dio.c revision 1.28
1 /* $NetBSD: dio.c,v 1.28 2005/01/02 12:03:12 tsutsui Exp $ */ 2 3 /*- 4 * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Autoconfiguration and mapping support for the DIO bus. 41 */ 42 43 #include <sys/cdefs.h> 44 __KERNEL_RCSID(0, "$NetBSD: dio.c,v 1.28 2005/01/02 12:03:12 tsutsui Exp $"); 45 46 #define _HP300_INTR_H_PRIVATE 47 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/kernel.h> 51 #include <sys/device.h> 52 53 #include <machine/bus.h> 54 55 #include <uvm/uvm_extern.h> 56 57 #include <machine/autoconf.h> 58 #include <machine/cpu.h> 59 #include <machine/hp300spu.h> 60 61 #include <hp300/dev/dmavar.h> 62 63 #include <hp300/dev/dioreg.h> 64 #include <hp300/dev/diovar.h> 65 66 #include <hp300/dev/diodevs.h> 67 #include <hp300/dev/diodevs_data.h> 68 69 #include "locators.h" 70 #define diocf_scode cf_loc[DIOCF_SCODE] 71 72 struct dio_softc { 73 struct device sc_dev; 74 struct bus_space_tag sc_tag; 75 }; 76 77 static int dio_scodesize(struct dio_attach_args *); 78 static const char *dio_devinfo(struct dio_attach_args *, char *, size_t); 79 80 static int diomatch(struct device *, struct cfdata *, void *); 81 static void dioattach(struct device *, struct device *, void *); 82 static int dioprint(void *, const char *); 83 static int diosubmatch(struct device *, struct cfdata *, void *); 84 85 CFATTACH_DECL(dio, sizeof(struct dio_softc), 86 diomatch, dioattach, NULL, NULL); 87 88 static int 89 diomatch(struct device *parent, struct cfdata *match, void *aux) 90 { 91 static int dio_matched = 0; 92 93 /* Allow only one instance. */ 94 if (dio_matched) 95 return (0); 96 97 dio_matched = 1; 98 return (1); 99 } 100 101 static void 102 dioattach(struct device *parent, struct device *self, void *aux) 103 { 104 struct dio_softc *sc = (struct dio_softc *)self; 105 struct dio_attach_args da; 106 caddr_t pa, va; 107 bus_space_tag_t bst = &sc->sc_tag; 108 int scode, scmax, scodesize; 109 110 printf("\n"); 111 112 memset(bst, 0, sizeof(struct bus_space_tag)); 113 bst->bustype = HP300_BUS_SPACE_DIO; 114 115 scmax = DIO_SCMAX(machineid); 116 117 for (scode = 0; scode < scmax; ) { 118 if (DIO_INHOLE(scode)) { 119 scode++; 120 continue; 121 } 122 123 /* 124 * Temporarily map the space corresponding to 125 * the current select code unless: 126 */ 127 pa = dio_scodetopa(scode); 128 va = iomap(pa, PAGE_SIZE); 129 if (va == NULL) { 130 printf("%s: can't map scode %d\n", 131 self->dv_xname, scode); 132 scode++; 133 continue; 134 } 135 136 /* Check for hardware. */ 137 if (badaddr(va)) { 138 iounmap(va, PAGE_SIZE); 139 scode++; 140 continue; 141 } 142 143 /* Fill out attach args. */ 144 memset(&da, 0, sizeof(da)); 145 da.da_bst = bst; 146 da.da_scode = scode; 147 148 da.da_id = DIO_ID(va); 149 if (DIO_ISFRAMEBUFFER(da.da_id)) 150 da.da_secid = DIO_SECID(va); 151 da.da_addr = (bus_addr_t)dio_scodetopa(scode); 152 da.da_size = DIO_SIZE(scode, va); 153 scodesize = dio_scodesize(&da); 154 if (DIO_ISDIO(scode)) 155 da.da_size *= scodesize; 156 da.da_ipl = DIO_IPL(va); 157 158 /* No longer need the device to be mapped. */ 159 iounmap(va, PAGE_SIZE); 160 161 /* Attach matching device. */ 162 config_found_sm(self, &da, dioprint, diosubmatch); 163 scode += scodesize; 164 } 165 } 166 167 static int 168 diosubmatch(struct device *parent, struct cfdata *cf, void *aux) 169 { 170 struct dio_attach_args *da = aux; 171 172 if (cf->diocf_scode != DIOCF_SCODE_DEFAULT && 173 cf->diocf_scode != da->da_scode) 174 return (0); 175 176 return (config_match(parent, cf, aux)); 177 } 178 179 static int 180 dioprint(void *aux, const char *pnp) 181 { 182 struct dio_attach_args *da = aux; 183 char buf[128]; 184 185 if (pnp) 186 aprint_normal("%s at %s", 187 dio_devinfo(da, buf, sizeof(buf)), pnp); 188 aprint_normal(" scode %d ipl %d", da->da_scode, da->da_ipl); 189 return (UNCONF); 190 } 191 192 /* 193 * Convert a select code to a system physical address. 194 */ 195 void * 196 dio_scodetopa(int scode) 197 { 198 u_long rval; 199 200 if (DIO_ISDIO(scode)) 201 rval = DIO_BASE + (scode * DIO_DEVSIZE); 202 else if (DIO_ISDIOII(scode)) 203 rval = DIOII_BASE + ((scode - DIOII_SCBASE) * DIOII_DEVSIZE); 204 else 205 rval = 0; 206 207 return ((void *)rval); 208 } 209 210 /* 211 * Return the select code size for this device, defaulting to 1 212 * if we don't know what kind of device we have. 213 */ 214 static int 215 dio_scodesize(struct dio_attach_args *da) 216 { 217 int i; 218 219 /* 220 * Find the dio_devdata matchind the primary id. 221 * If we're a framebuffer, we also check the secondary id. 222 */ 223 for (i = 0; i < DIO_NDEVICES; i++) { 224 if (da->da_id == dio_devdatas[i].dd_id) { 225 if (DIO_ISFRAMEBUFFER(da->da_id)) { 226 if (da->da_secid == dio_devdatas[i].dd_secid) { 227 goto foundit; 228 } 229 } else { 230 foundit: 231 return (dio_devdatas[i].dd_nscode); 232 } 233 } 234 } 235 236 /* 237 * Device is unknown. Print a warning and assume a default. 238 */ 239 printf("WARNING: select code size unknown for id = 0x%x secid = 0x%x\n", 240 da->da_id, da->da_secid); 241 return (1); 242 } 243 244 /* 245 * Return a reasonable description of a DIO device. 246 */ 247 static const char * 248 dio_devinfo(struct dio_attach_args *da, char *buf, size_t buflen) 249 { 250 #ifdef DIOVERBOSE 251 int i; 252 #endif 253 254 memset(buf, 0, buflen); 255 256 #ifdef DIOVERBOSE 257 /* 258 * Find the description matching our primary id. 259 * If we're a framebuffer, we also check the secondary id. 260 */ 261 for (i = 0; i < DIO_NDEVICES; i++) { 262 if (da->da_id == dio_devdescs[i].dd_id) { 263 if (DIO_ISFRAMEBUFFER(da->da_id)) { 264 if (da->da_secid == dio_devdescs[i].dd_secid) { 265 goto foundit; 266 } 267 } else { 268 foundit: 269 sprintf(buf, "%s", dio_devdescs[i].dd_desc); 270 return (buf); 271 } 272 } 273 } 274 #endif /* DIOVERBOSE */ 275 276 /* 277 * Device is unknown. Construct something reasonable. 278 */ 279 sprintf(buf, "device id = 0x%x secid = 0x%x", 280 da->da_id, da->da_secid); 281 return (buf); 282 } 283 284 /* 285 * Establish an interrupt handler for a DIO device. 286 */ 287 void * 288 dio_intr_establish(int (*func)(void *), void *arg, int ipl, int priority) 289 { 290 void *ih; 291 292 ih = intr_establish(func, arg, ipl, priority); 293 294 if (priority == IPL_BIO) 295 dmacomputeipl(); 296 297 return (ih); 298 } 299 300 /* 301 * Remove an interrupt handler for a DIO device. 302 */ 303 void 304 dio_intr_disestablish(void *arg) 305 { 306 struct hp300_intrhand *ih = arg; 307 int priority = ih->ih_priority; 308 309 intr_disestablish(arg); 310 311 if (priority == IPL_BIO) 312 dmacomputeipl(); 313 } 314 315 /* 316 * DIO specific bus_space(9) support functions. 317 */ 318 static uint8_t dio_bus_space_read_oddbyte_1(bus_space_tag_t, 319 bus_space_handle_t, bus_size_t); 320 static void dio_bus_space_write_oddbyte_1(bus_space_tag_t, 321 bus_space_handle_t, bus_size_t, uint8_t); 322 323 static void dio_bus_space_read_multi_oddbyte_1(bus_space_tag_t, 324 bus_space_handle_t, bus_size_t, uint8_t *, bus_size_t); 325 static void dio_bus_space_write_multi_oddbyte_1(bus_space_tag_t, 326 bus_space_handle_t, bus_size_t, const uint8_t *, bus_size_t); 327 328 static void dio_bus_space_read_region_oddbyte_1(bus_space_tag_t, 329 bus_space_handle_t, bus_size_t, uint8_t *, bus_size_t); 330 static void dio_bus_space_write_region_oddbyte_1(bus_space_tag_t, 331 bus_space_handle_t, bus_size_t, const uint8_t *, bus_size_t); 332 333 static void dio_bus_space_set_multi_oddbyte_1(bus_space_tag_t, 334 bus_space_handle_t, bus_size_t, uint8_t, bus_size_t); 335 336 static void dio_bus_space_set_region_oddbyte_1(bus_space_tag_t, 337 bus_space_handle_t, bus_size_t, uint8_t, bus_size_t); 338 339 /* 340 * dio_set_bus_space_oddbyte(): 341 * Override bus_space functions in bus_space_tag_t 342 * for devices which have odd byte address space. 343 */ 344 void 345 dio_set_bus_space_oddbyte(bus_space_tag_t bst) 346 { 347 348 /* XXX only 1-byte functions for now */ 349 bst->bsr1 = dio_bus_space_read_oddbyte_1; 350 bst->bsw1 = dio_bus_space_write_oddbyte_1; 351 352 bst->bsrm1 = dio_bus_space_read_multi_oddbyte_1; 353 bst->bswm1 = dio_bus_space_write_multi_oddbyte_1; 354 355 bst->bsrr1 = dio_bus_space_read_region_oddbyte_1; 356 bst->bswr1 = dio_bus_space_write_region_oddbyte_1; 357 358 bst->bssm1 = dio_bus_space_set_multi_oddbyte_1; 359 360 bst->bssr1 = dio_bus_space_set_region_oddbyte_1; 361 } 362 363 static uint8_t 364 dio_bus_space_read_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 365 bus_size_t offset) 366 { 367 368 return *(volatile uint8_t *)(bsh + (offset << 1) + 1); 369 } 370 371 static void 372 dio_bus_space_write_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 373 bus_size_t offset, uint8_t val) 374 { 375 376 *(volatile uint8_t *)(bsh + (offset << 1) + 1) = val; 377 } 378 379 static void 380 dio_bus_space_read_multi_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 381 bus_size_t offset, uint8_t *addr, bus_size_t len) 382 { 383 384 __asm __volatile ( 385 " movl %0,%%a0 ;\n" 386 " movl %1,%%a1 ;\n" 387 " movl %2,%%d0 ;\n" 388 "1: movb %%a0@,%%a1@+ ;\n" 389 " subql #1,%%d0 ;\n" 390 " jne 1b" 391 : 392 : "r" (bsh + (offset << 1) + 1), "g" (addr), "g" (len) 393 : "%a0","%a1","%d0"); 394 } 395 396 static void 397 dio_bus_space_write_multi_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 398 bus_size_t offset, const uint8_t *addr, bus_size_t len) 399 { 400 401 __asm __volatile ( 402 " movl %0,%%a0 ;\n" 403 " movl %1,%%a1 ;\n" 404 " movl %2,%%d0 ;\n" 405 "1: movb %%a1@+,%%a0@ ;\n" 406 " subql #1,%%d0 ;\n" 407 " jne 1b" 408 : 409 : "r" (bsh + (offset << 1) + 1), "g" (addr), "g" (len) 410 : "%a0","%a1","%d0"); 411 } 412 413 static void 414 dio_bus_space_read_region_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 415 bus_size_t offset, uint8_t *addr, bus_size_t len) 416 { 417 __asm __volatile ( 418 " movl %0,%%a0 ;\n" 419 " movl %1,%%a1 ;\n" 420 " movl %2,%%d0 ;\n" 421 "1: movb %%a0@,%%a1@+ ;\n" 422 " addql #2,%%a0 ;\n" 423 " subql #1,%%d0 ;\n" 424 " jne 1b" 425 : 426 : "r" (bsh + (offset << 1) + 1), "g" (addr), "g" (len) 427 : "%a0","%a1","%d0"); 428 } 429 430 static void 431 dio_bus_space_write_region_oddbyte_1(bus_space_tag_t bst, 432 bus_space_handle_t bsh, bus_size_t offset, const uint8_t *addr, 433 bus_size_t len) 434 { 435 436 __asm __volatile ( 437 " movl %0,%%a0 ;\n" 438 " movl %1,%%a1 ;\n" 439 " movl %2,%%d0 ;\n" 440 "1: movb %%a1@+,%%a0@ ;\n" 441 " addql #2,%%a0 ;\n" 442 " subql #1,%%d0 ;\n" 443 " jne 1b" 444 : 445 : "r" (bsh + (offset << 1) + 1), "g" (addr), "g" (len) 446 : "%a0","%a1","%d0"); 447 } 448 449 static void 450 dio_bus_space_set_multi_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 451 bus_size_t offset, uint8_t val, bus_size_t count) 452 { 453 __asm __volatile ( 454 " movl %0,%%a0 ;\n" 455 " movl %1,%%d1 ;\n" 456 " movl %2,%%d0 ;\n" 457 "1: movb %%d1,%%a0@ ;\n" 458 " subql #1,%%d0 ;\n" 459 " jne 1b" 460 : 461 : "r" (bsh + (offset << 1) + 1), "g" (val), "g" (count) 462 : "%a0","%d0","%d1"); 463 } 464 465 static void 466 dio_bus_space_set_region_oddbyte_1(bus_space_tag_t bst, bus_space_handle_t bsh, 467 bus_size_t offset, uint8_t val, bus_size_t count) 468 { 469 470 __asm __volatile ( 471 " movl %0,%%a0 ;\n" 472 " movl %1,%%d1 ;\n" 473 " movl %2,%%d0 ;\n" 474 "1: movb %%d1,%%a0@ ;\n" 475 " addql #2,%%a0 ;\n" 476 " subql #1,%%d0 ;\n" 477 " jne 1b" 478 : 479 : "r" (bsh + (offset << 1) + 1), "g" (val), "g" (count) 480 : "%a0","%d0","%d1"); 481 } 482
Indexes created Wed Sep 24 05:09:52 GMT 2025