1 /* $NetBSD: podulebus.c,v 1.24 2009/03/15 22:18:35 cegger Exp $ */ 2 3 /* 4 * Copyright (c) 1994-1996 Mark Brinicombe. 5 * Copyright (c) 1994 Brini. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by Brini. 19 * 4. The name of the company nor the name of the author may be used to 20 * endorse or promote products derived from this software without specific 21 * prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY BRINI ``AS IS'' AND ANY EXPRESS OR IMPLIED 24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26 * IN NO EVENT SHALL BRINI OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 27 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 29 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * RiscBSD kernel project 36 * 37 * podulebus.c 38 * 39 * Podule probe and configuration routines 40 * 41 * Created : 07/11/94 42 */ 43 44 #include <sys/param.h> 45 46 __KERNEL_RCSID(0, "$NetBSD: podulebus.c,v 1.24 2009/03/15 22:18:35 cegger Exp $"); 47 48 #include <sys/systm.h> 49 #include <sys/kernel.h> 50 #include <sys/conf.h> 51 #include <sys/malloc.h> 52 #include <sys/device.h> 53 #include <uvm/uvm_extern.h> 54 #include <machine/io.h> 55 #include <arm/arm32/katelib.h> 56 #include <machine/intr.h> 57 #include <machine/bootconfig.h> 58 #include <machine/pmap.h> 59 #include <arm/iomd/iomdreg.h> 60 #include <arm/iomd/iomdvar.h> 61 #include <acorn32/podulebus/podulebus.h> 62 #include <dev/podulebus/podules.h> 63 #include <dev/podulebus/podule_data.h> 64 65 #include "locators.h" 66 67 /* Array of podule structures, one per possible podule */ 68 69 podule_t podules[MAX_PODULES + MAX_NETSLOTS]; 70 71 extern struct bus_space podulebus_bs_tag; 72 73 /* Declare prototypes */ 74 75 u_int poduleread(u_int, int); 76 int podulebusmatch(struct device *, struct cfdata *, void *); 77 void podulebusattach(struct device *, struct device *, void *); 78 int podulebusprint(void *, const char *); 79 int podulebussubmatch(struct device *, struct cfdata *, 80 const int *, void *); 81 void podulechunkdirectory(podule_t *); 82 void podulescan(struct device *); 83 84 /* 85 * int podulebusmatch(struct device *parent, void *match, void *aux) 86 * 87 * Probe for the podule bus. Currently all this does is return 1 to 88 * indicate that the podule bus was found. 89 */ 90 91 int 92 podulebusmatch(struct device *parent, struct cfdata *cf, void *aux) 93 { 94 switch (IOMD_ID) { 95 case RPC600_IOMD_ID: 96 case ARM7500_IOC_ID: 97 case ARM7500FE_IOC_ID: 98 return(1); 99 } 100 return (0); 101 } 102 103 104 int 105 podulebusprint(void *aux, const char *name) 106 { 107 struct podule_attach_args *pa = aux; 108 109 if (name) 110 aprint_normal("podule at %s", name); 111 if (pa->pa_podule->slottype == SLOT_POD) 112 aprint_normal(" slot %d", pa->pa_podule_number); 113 else if (pa->pa_podule->slottype == SLOT_NET) 114 aprint_normal(" [ netslot %d ]", 115 pa->pa_podule_number - MAX_PODULES); 116 #ifdef DIAGNOSTIC 117 else 118 panic("Invalid slot type"); 119 #endif 120 121 return (UNCONF); 122 } 123 124 125 int 126 podulebussubmatch(struct device *parent, struct cfdata *cf, const int *ldesc, void *aux) 127 { 128 struct podule_attach_args *pa = aux; 129 130 /* Return priority 0 or 1 for wildcarded podule */ 131 132 if (cf->cf_loc[PODULEBUSCF_SLOT] == PODULEBUSCF_SLOT_DEFAULT) 133 return(config_match(parent, cf, aux)); 134 135 /* Return higher priority if we match the specific podule */ 136 137 else if (cf->cf_loc[PODULEBUSCF_SLOT] == pa->pa_podule_number) 138 return(config_match(parent, cf, aux) * 8); 139 140 /* Fail */ 141 return(0); 142 } 143 144 145 #if 0 146 void 147 dump_podule(podule_t *podule) 148 { 149 printf("podule%d: ", podule->podulenum); 150 printf("flags0=%02x ", podule->flags0); 151 printf("flags1=%02x ", podule->flags1); 152 printf("reserved=%02x ", podule->reserved); 153 printf("product=%02x ", podule->product); 154 printf("manufacturer=%02x ", podule->manufacturer); 155 printf("country=%02x ", podule->country); 156 printf("irq_addr=%08x ", podule->irq_addr); 157 printf("irq_mask=%02x ", podule->irq_mask); 158 printf("fiq_addr=%08x ", podule->fiq_addr); 159 printf("fiq_mask=%02x ", podule->fiq_mask); 160 printf("fast_base=%08x ", podule->fast_base); 161 printf("medium_base=%08x ", podule->medium_base); 162 printf("slow_base=%08x ", podule->slow_base); 163 printf("sync_base=%08x ", podule->sync_base); 164 printf("mod_base=%08x ", podule->mod_base); 165 printf("easi_base=%08x ", podule->easi_base); 166 printf("attached=%d ", podule->attached); 167 printf("slottype=%d ", podule->slottype); 168 printf("podulenum=%d ", podule->podulenum); 169 printf("description=%s ", podule->description); 170 printf("\n"); 171 } 172 #endif 173 174 void 175 podulechunkdirectory(podule_t *podule) 176 { 177 u_int address; 178 u_int id; 179 u_int size; 180 u_int addr; 181 int loop; 182 int done_f5; 183 184 done_f5 = 0; 185 address = 0x40; 186 187 do { 188 id = podule->read_rom(podule->sync_base, address); 189 size = podule->read_rom(podule->sync_base, address + 4); 190 size |= (podule->read_rom(podule->sync_base, address + 8) << 8); 191 size |= (podule->read_rom(podule->sync_base, address + 12) << 16); 192 if (id == 0xf5) { 193 addr = podule->read_rom(podule->sync_base, address + 16); 194 addr |= (podule->read_rom(podule->sync_base, address + 20) << 8); 195 addr |= (podule->read_rom(podule->sync_base, address + 24) << 16); 196 addr |= (podule->read_rom(podule->sync_base, address + 28) << 24); 197 if (addr < 0x800 && done_f5 == 0) { 198 done_f5 = 1; 199 for (loop = 0; loop < size; ++loop) { 200 if (loop < PODULE_DESCRIPTION_LENGTH) { 201 podule->description[loop] = 202 podule->read_rom(podule->sync_base, (addr + loop)*4); 203 podule->description[loop + 1] = 0; 204 } 205 } 206 } 207 } 208 #ifdef DEBUG_CHUNK_DIR 209 if (id == 0xf5 || id == 0xf1 || id == 0xf2 || id == 0xf3 || id == 0xf4 || id == 0xf6) { 210 addr = podule->read_rom(podule->sync_base, address + 16); 211 addr |= (podule->read_rom(podule->sync_base, address + 20) << 8); 212 addr |= (podule->read_rom(podule->sync_base, address + 24) << 16); 213 addr |= (podule->read_rom(podule->sync_base, address + 28) << 24); 214 printf("<%04x.%04x.%04x.%04x>", id, address, addr, size); 215 if (addr < 0x800) { 216 for (loop = 0; loop < size; ++loop) { 217 printf("%c", podule->read_rom(podule->sync_base, (addr + loop)*4)); 218 } 219 printf("\\n\n"); 220 } 221 } 222 #endif 223 address += 32; 224 } while (id != 0 && address < 0x800); 225 } 226 227 228 void 229 poduleexamine(podule_t *podule, struct device *dev, int slottype) 230 { 231 struct manufacturer_description *man_desc; 232 struct podule_description *pod_desc; 233 234 /* Test to see if the podule is present */ 235 236 if ((podule->flags0 & 0x02) == 0x00) { 237 podule->slottype = slottype; 238 if (slottype == SLOT_NET) 239 printf("netslot%d at %s : ", podule->podulenum - MAX_PODULES, 240 dev->dv_xname); 241 else 242 printf("podule%d at %s : ", podule->podulenum, 243 dev->dv_xname); 244 245 /* Is it Acorn conformant ? */ 246 247 if (podule->flags0 & 0x80) 248 printf("Non-Acorn conformant expansion card\n"); 249 else { 250 int id; 251 252 /* Is it a simple podule ? */ 253 254 id = (podule->flags0 >> 3) & 0x0f; 255 if (id != 0) 256 printf("Simple expansion card <%x>\n", id); 257 else { 258 /* Scan the chunk directory if present for tags we use */ 259 if (podule->flags1 & PODULE_FLAGS_CD) 260 podulechunkdirectory(podule); 261 262 /* Do we know this manufacturer ? */ 263 man_desc = known_manufacturers; 264 while (man_desc->description) { 265 if (man_desc->manufacturer_id == 266 podule->manufacturer) 267 break; 268 ++man_desc; 269 } 270 if (!man_desc->description) 271 printf("man=%04x : ", podule->manufacturer); 272 else 273 printf("%s : ", man_desc->description); 274 275 /* Do we know this product ? */ 276 277 pod_desc = known_podules; 278 while (pod_desc->description) { 279 if (pod_desc->product_id == podule->product) 280 break; 281 ++pod_desc; 282 } 283 if (!pod_desc->description) 284 printf("prod=%04x : ", 285 podule->product); 286 else 287 printf("%s : ", pod_desc->description); 288 printf("%s\n", podule->description); 289 } 290 } 291 } 292 } 293 294 295 u_int 296 poduleread(u_int address, int offset) 297 { 298 299 return(ReadByte(address + offset)); 300 } 301 302 void 303 podulescan(struct device *dev) 304 { 305 int loop; 306 podule_t *podule; 307 u_char *address; 308 u_int offset = 0; 309 310 /* Loop round all the podules */ 311 312 for (loop = 0; loop < MAX_PODULES; ++loop, offset += SIMPLE_PODULE_SIZE) { 313 podule = &podules[loop]; 314 podule->podulenum = loop; 315 podule->attached = 0; 316 podule->slottype = SLOT_NONE; 317 podule->interrupt = IRQ_PODULE; 318 podule->read_rom = poduleread; 319 podule->dma_channel = -1; 320 podule->dma_interrupt = -1; 321 podule->description[0] = 0; 322 323 if (loop == 4) offset += PODULE_GAP; 324 address = ((u_char *)SYNC_PODULE_BASE) + offset; 325 326 if ((address[0] & 0x02) == 0x00) { 327 podule->fast_base = FAST_PODULE_BASE + offset; 328 podule->medium_base = MEDIUM_PODULE_BASE + offset; 329 podule->slow_base = SLOW_PODULE_BASE + offset; 330 podule->sync_base = SYNC_PODULE_BASE + offset; 331 podule->mod_base = MOD_PODULE_BASE + offset; 332 podule->easi_base = EASI_BASE + loop * EASI_SIZE; 333 } else { 334 address = ((u_char *)EASI_BASE) + loop * EASI_SIZE; 335 if ((address[0] & 0x02) != 0x00) 336 continue; 337 338 podule->fast_base = 0; 339 podule->medium_base = 0; 340 podule->slow_base = 0; 341 podule->sync_base = 0; 342 podule->mod_base = 0; 343 podule->easi_base = EASI_BASE + loop * EASI_SIZE; 344 } 345 346 /* XXX - Really needs to be linked to a DMA manager */ 347 if (IOMD_ID == RPC600_IOMD_ID) { 348 switch (loop) { 349 case 0: 350 podule->dma_channel = 2; 351 podule->dma_interrupt = IRQ_DMACH2; 352 break; 353 case 1: 354 podule->dma_channel = 3; 355 podule->dma_interrupt = IRQ_DMACH3; 356 break; 357 } 358 } 359 360 /* Get information from the podule header */ 361 362 podule->flags0 = address[0]; 363 if ((podule->flags0 & 0x78) == 0) { 364 podule->flags1 = address[4]; 365 podule->reserved = address[8]; 366 podule->product = address[12] + (address[16] << 8); 367 podule->manufacturer = address[20] + (address[24] << 8); 368 podule->country = address[28]; 369 if (podule->flags1 & PODULE_FLAGS_IS) { 370 podule->irq_addr = address[52] + (address[56] << 8) + (address[60] << 16); 371 podule->irq_addr += podule->slow_base; 372 podule->irq_mask = address[48]; 373 if (podule->irq_mask == 0) 374 podule->irq_mask = 0x01; 375 podule->fiq_addr = address[36] + (address[40] << 8) + (address[44] << 16); 376 podule->fiq_addr += podule->slow_base; 377 podule->fiq_mask = address[32]; 378 if (podule->fiq_mask == 0) 379 podule->fiq_mask = 0x04; 380 } else { 381 podule->irq_addr = podule->slow_base; 382 podule->irq_mask = 0x01; 383 podule->fiq_addr = podule->slow_base; 384 podule->fiq_mask = 0x04; 385 } 386 } 387 388 poduleexamine(podule, dev, SLOT_POD); 389 } 390 } 391 392 393 /* 394 * void podulebusattach(struct device *parent, struct device *dev, void *aux) 395 * 396 * Attach podulebus. 397 * This probes all the podules and sets up the podules array with 398 * information found in the podule headers. 399 * After identifing all the podules, all the children of the podulebus 400 * are probed and attached. 401 */ 402 403 void 404 podulebusattach(struct device *parent, struct device *self, void *aux) 405 { 406 int loop; 407 struct podule_attach_args pa; 408 #if 0 409 int easi_time; 410 int bit; 411 #endif 412 unsigned int value; 413 char argstring[20]; 414 415 #if 0 416 easi_time = IOMD_READ_BYTE(IOMD_ECTCR); 417 printf(": easi timings="); 418 for (bit = 0x01; bit < 0x100; bit = bit << 1) 419 if (easi_time & bit) 420 printf("C"); 421 else 422 printf("A"); 423 #endif 424 printf("\n"); 425 426 427 #if 0 /* XXXJRT */ 428 /* Ok we need to map in the podulebus */ 429 /* with the new pmap mappings have to be done when the L1 tables 430 * are built during initarm 431 */ 432 /* Map the FAST and SYNC simple podules */ 433 pmap_map_section((vm_offset_t)pmap_kernel()->pm_pdir, 434 SYNC_PODULE_BASE & 0xfff00000, SYNC_PODULE_HW_BASE & 0xfff00000, 435 VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE); 436 cpu_tlb_flushD(); 437 /* Now map the EASI space */ 438 439 for (loop = 0; loop < MAX_PODULES; ++loop) { 440 int loop1; 441 442 for (loop1 = loop * EASI_SIZE; loop1 < ((loop + 1) * EASI_SIZE); 443 loop1 += L1_S_SIZE) 444 pmap_map_section((vm_offset_t)pmap_kernel()->pm_pdir, 445 EASI_BASE + loop1, EASI_HW_BASE + loop1, 446 VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE); 447 } 448 cpu_tlb_flushD(); 449 #endif 450 /* 451 * The MEDIUM and SLOW simple podules and the module space will have been 452 * mapped when the IOMD and COMBO we mapped in for the RPC 453 */ 454 455 /* Find out what hardware is bolted on */ 456 457 podulescan(self); 458 netslotscan(self); 459 460 /* Look for drivers to attach */ 461 462 for (loop = 0; loop < MAX_PODULES+MAX_NETSLOTS; ++loop) { 463 #if 1 464 /* Provide backwards compat for a while */ 465 sprintf(argstring, "podule%d.disable", loop); 466 if (get_bootconf_option(boot_args, argstring, 467 BOOTOPT_TYPE_BOOLEAN, &value)) { 468 if (value) { 469 if (podules[loop].slottype != SLOT_NONE) 470 printf("podule%d: Disabled\n", loop); 471 continue; 472 } 473 } 474 #endif 475 sprintf(argstring, "podule%d=", loop); 476 if (get_bootconf_option(boot_args, argstring, 477 BOOTOPT_TYPE_HEXINT, &value)) { 478 /* Override the ID */ 479 podules[loop].manufacturer = value >> 16; 480 podules[loop].product = value & 0xffff; 481 /* Any old description is now wrong */ 482 podules[loop].description[0] = 0; 483 if (value != 0xffff) { 484 printf("podule%d: ID overriden man=%04x prod=%04x\n", 485 loop, podules[loop].manufacturer, 486 podules[loop].product); 487 podules[loop].slottype = SLOT_POD; 488 pa.pa_podule_number = loop; 489 pa.pa_ih = pa.pa_podule_number; 490 pa.pa_podule = &podules[loop]; 491 pa.pa_iot = &podulebus_bs_tag; 492 config_found_sm_loc(self, "podulebus", NULL, &pa, 493 podulebusprint, podulebussubmatch); 494 continue; 495 } 496 if (value == 0xffff) { 497 printf("podule%d: Disabled\n", loop); 498 continue; 499 } 500 } 501 502 if (podules[loop].slottype != SLOT_NONE) { 503 pa.pa_podule_number = loop; 504 pa.pa_ih = pa.pa_podule_number; 505 pa.pa_podule = &podules[loop]; 506 pa.pa_iot = &podulebus_bs_tag; 507 config_found_sm_loc(self, "podulebus", NULL, &pa, 508 podulebusprint, podulebussubmatch); 509 } 510 } 511 } 512 513 514 CFATTACH_DECL(podulebus, sizeof(struct device), 515 podulebusmatch, podulebusattach, NULL, NULL); 516 517 /* Useful functions that drivers may share */ 518 519 /* 520 * Match a podule structure with the specified parameters 521 * Returns 0 if the match failed 522 * The required_slot is not used at the moment. 523 */ 524 525 int 526 matchpodule(struct podule_attach_args *pa, int manufacturer, int product, int required_slot) 527 { 528 if (pa->pa_podule->attached) 529 panic("podulebus: Podule already attached"); 530 531 if (IS_PODULE(pa, manufacturer, product)) 532 return(1); 533 534 return(0); 535 } 536 537 void * 538 podulebus_irq_establish(podulebus_intr_handle_t ih, 539 int ipl, int (*func)(void *), void *arg, struct evcnt *ev) 540 { 541 542 /* XXX We don't actually use the evcnt supplied, just its name. */ 543 return intr_claim(podules[ih].interrupt, ipl, ev->ev_group, func, 544 arg); 545 } 546 547 /* 548 * Generate a bus_space_tag_t with the specified address-bus shift. 549 */ 550 void 551 podulebus_shift_tag(bus_space_tag_t tag, u_int shift, bus_space_tag_t *tagp) 552 { 553 554 /* 555 * For the podulebus, the bus tag cookie is the shift to apply 556 * to registers, so duplicate the bus space tag and change the 557 * cookie. 558 */ 559 560 /* XXX never freed, but podules are never detached anyway. */ 561 *tagp = malloc(sizeof(struct bus_space), M_DEVBUF, M_WAITOK); 562 **tagp = *tag; 563 (*tagp)->bs_cookie = (void *)shift; 564 } 565 566 int 567 podulebus_initloader(struct podulebus_attach_args *pa) 568 { 569 570 /* No loader support at present on arm32, so always fail. */ 571 return -1; 572 } 573 574 int 575 podloader_readbyte(struct podulebus_attach_args *pa, u_int addr) 576 { 577 578 panic("podloader_readbyte"); 579 } 580 581 void 582 podloader_writebyte(struct podulebus_attach_args *pa, u_int addr, int val) 583 { 584 585 panic("podloader_writebyte"); 586 } 587 588 void 589 podloader_reset(struct podulebus_attach_args *pa) 590 { 591 592 panic("podloader_reset"); 593 } 594 595 int 596 podloader_callloader(struct podulebus_attach_args *pa, u_int r0, u_int r1) 597 { 598 599 panic("podloader_callloader"); 600 } 601 602 /* End of podulebus.c */ 603