1 /* $NetBSD: nubus.c,v 1.68 2021/08/07 16:18:57 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1995, 1996 Allen Briggs. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Allen Briggs. 17 * 4. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: nubus.c,v 1.68 2021/08/07 16:18:57 thorpej Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/malloc.h> 38 #include <sys/device.h> 39 #include <sys/buf.h> 40 #include <sys/conf.h> 41 42 #include <uvm/uvm_extern.h> 43 44 #include <machine/autoconf.h> 45 #include <machine/vmparam.h> 46 #include <machine/cpu.h> 47 #include <machine/pte.h> 48 #include <machine/viareg.h> 49 50 #include <mac68k/nubus/nubus.h> 51 52 #ifdef DEBUG 53 #define NDB_PROBE 0x1 54 #define NDB_FOLLOW 0x2 55 #define NDB_ARITH 0x4 56 static int nubus_debug = 0 /* | NDB_PROBE | NDB_FOLLOW | NDB_ARITH */ ; 57 #endif 58 59 static int nubus_print(void *, const char *); 60 static int nubus_match(device_t, cfdata_t, void *); 61 static void nubus_attach(device_t, device_t, void *); 62 static int nubus_video_resource(int); 63 64 static int nubus_probe_slot(bus_space_tag_t, bus_space_handle_t, int, 65 nubus_slot *); 66 static u_int32_t nubus_calc_CRC(bus_space_tag_t, bus_space_handle_t, 67 nubus_slot *); 68 69 static u_long nubus_adjust_ptr(u_int8_t, u_long, long); 70 static u_int8_t nubus_read_1(bus_space_tag_t, bus_space_handle_t, u_int8_t, 71 u_long); 72 #ifdef notyet 73 static u_int16_t nubus_read_2(bus_space_tag_t, bus_space_handle_t, u_int8_t, 74 u_long); 75 #endif 76 static u_int32_t nubus_read_4(bus_space_tag_t, bus_space_handle_t, u_int8_t, 77 u_long); 78 79 CFATTACH_DECL_NEW(nubus, sizeof(struct nubus_softc), 80 nubus_match, nubus_attach, NULL, NULL); 81 82 static int 83 nubus_match(device_t parent, cfdata_t cf, void *aux) 84 { 85 static int nubus_matched = 0; 86 87 /* Allow only one instance. */ 88 if (nubus_matched) 89 return (0); 90 91 nubus_matched = 1; 92 return (1); 93 } 94 95 static void 96 nubus_attach(device_t parent, device_t self, void *aux) 97 { 98 struct nubus_attach_args na_args; 99 struct mainbus_attach_args *mba; 100 bus_space_tag_t bst; 101 bus_space_handle_t bsh; 102 nubus_slot fmtblock; 103 nubus_dir dir; 104 nubus_dirent dirent; 105 nubus_type slottype; 106 u_long entry; 107 int i, rsrcid; 108 u_int8_t lanes; 109 110 mba = aux; 111 KASSERT(NULL != mba->mba_dmat); 112 113 printf("\n"); 114 115 for (i = NUBUS_MIN_SLOT; i <= NUBUS_MAX_SLOT; i++) { 116 na_args.slot = i; 117 na_args.na_tag = bst = mba->mba_bst; 118 na_args.na_dmat = mba->mba_dmat; 119 120 if (bus_space_map(bst, 121 NUBUS_SLOT2PA(na_args.slot), NBMEMSIZE, 0, &bsh)) { 122 #ifdef DEBUG 123 if (nubus_debug & NDB_PROBE) 124 printf("%s: failed to map slot %x, " 125 "address %p (in use?)\n", 126 device_xname(self), i, 127 (void *)NUBUS_SLOT2PA(i)); 128 #endif 129 continue; 130 } 131 132 if (nubus_probe_slot(bst, bsh, i, &fmtblock) <= 0) { 133 notfound: 134 bus_space_unmap(bst, bsh, NBMEMSIZE); 135 continue; 136 } 137 138 rsrcid = 0x80; 139 lanes = fmtblock.bytelanes; 140 141 nubus_get_main_dir(&fmtblock, &dir); 142 143 /* 144 * Get the resource for the first function on the card. 145 * This is assumed to be at resource ID 0x80. If we can 146 * not find this entry (as we can not on some video cards), 147 * check to see if we can get a different ID from the list 148 * of video resources given to us by the booter. If that 149 * doesn't work either, take the first resource following 150 * the board resource. 151 * If we only find a board resource, report that. 152 * There are cards that do not have anything else; their 153 * driver then has to match on the board resource and 154 * the card name. 155 */ 156 if (nubus_find_rsrc(bst, bsh, 157 &fmtblock, &dir, rsrcid, &dirent) <= 0) { 158 if ((rsrcid = nubus_video_resource(i)) == -1) { 159 int has_board_rsrc = 0; 160 161 /* 162 * Since nubus_find_rsrc failed, the directory 163 * is back at its base. 164 */ 165 entry = dir.curr_ent; 166 167 /* 168 * All nubus cards should have a board 169 * resource, but be sure that's what it 170 * is before we skip it, and note the fact. 171 */ 172 rsrcid = nubus_read_1(bst, bsh, 173 lanes, entry); 174 if (rsrcid == 0x1) { 175 has_board_rsrc = 1; 176 entry = nubus_adjust_ptr(lanes, 177 dir.curr_ent, 4); 178 } 179 rsrcid = nubus_read_1(bst, bsh, lanes, entry); 180 /* end of chain? */ 181 if (rsrcid == 0xff) { 182 if (!has_board_rsrc) 183 goto notfound; 184 else 185 rsrcid = 0x01; 186 } 187 #ifdef DEBUG 188 if (nubus_debug & NDB_FOLLOW) 189 printf("\tUsing rsrc 0x%x.\n", rsrcid); 190 #endif 191 } 192 /* 193 * Try to find the resource passed by the booter 194 * or the one we just tracked down. 195 */ 196 if (nubus_find_rsrc(bst, bsh, 197 &fmtblock, &dir, rsrcid, &dirent) <= 0) 198 goto notfound; 199 } 200 201 nubus_get_dir_from_rsrc(&fmtblock, &dirent, &dir); 202 203 if (nubus_find_rsrc(bst, bsh, 204 &fmtblock, &dir, NUBUS_RSRC_TYPE, &dirent) <= 0) 205 goto notfound; 206 207 if (nubus_get_ind_data(bst, bsh, &fmtblock, &dirent, 208 (void *)&slottype, sizeof(nubus_type)) <= 0) 209 goto notfound; 210 211 /* 212 * If this is a display card, try to pull out the correct 213 * display mode as passed by the booter. 214 */ 215 if (slottype.category == NUBUS_CATEGORY_DISPLAY) { 216 int r; 217 218 if ((r = nubus_video_resource(i)) != -1) { 219 220 nubus_get_main_dir(&fmtblock, &dir); 221 222 if (nubus_find_rsrc(bst, bsh, 223 &fmtblock, &dir, r, &dirent) <= 0) 224 goto notfound; 225 226 nubus_get_dir_from_rsrc(&fmtblock, 227 &dirent, &dir); 228 229 if (nubus_find_rsrc(bst, bsh, &fmtblock, &dir, 230 NUBUS_RSRC_TYPE, &dirent) <= 0) 231 goto notfound; 232 233 if (nubus_get_ind_data(bst, bsh, 234 &fmtblock, &dirent, (void *)&slottype, 235 sizeof(nubus_type)) <= 0) 236 goto notfound; 237 238 rsrcid = r; 239 } 240 } 241 242 na_args.slot = i; 243 na_args.rsrcid = rsrcid; 244 na_args.category = slottype.category; 245 na_args.type = slottype.type; 246 na_args.drsw = slottype.drsw; 247 na_args.drhw = slottype.drhw; 248 na_args.fmt = &fmtblock; 249 250 bus_space_unmap(bst, bsh, NBMEMSIZE); 251 252 config_found(self, &na_args, nubus_print, CFARGS_NONE); 253 } 254 255 enable_nubus_intr(); 256 } 257 258 static int 259 nubus_print(void *aux, const char *pnp) 260 { 261 struct nubus_attach_args *na = (struct nubus_attach_args *)aux; 262 bus_space_tag_t bst = na->na_tag; 263 bus_space_handle_t bsh; 264 265 if (pnp) { 266 aprint_normal("%s slot %x", pnp, na->slot); 267 if (bus_space_map(bst, 268 NUBUS_SLOT2PA(na->slot), NBMEMSIZE, 0, &bsh) == 0) { 269 aprint_normal(": %s", 270 nubus_get_card_name(bst, bsh, na->fmt)); 271 aprint_normal(" (Vendor: %s,", 272 nubus_get_vendor(bst, bsh, 273 na->fmt, NUBUS_RSRC_VEND_ID)); 274 aprint_normal(" Part: %s)", nubus_get_vendor(bst, bsh, 275 na->fmt, NUBUS_RSRC_VEND_PART)); 276 bus_space_unmap(bst, bsh, NBMEMSIZE); 277 } 278 #ifdef DIAGNOSTIC 279 else 280 aprint_normal(":"); 281 aprint_normal(" Type: %04x %04x %04x %04x", 282 na->category, na->type, na->drsw, na->drhw); 283 #endif 284 } else { 285 aprint_normal(" slot %x", na->slot); 286 } 287 return (UNCONF); 288 } 289 290 static int 291 nubus_video_resource(int slot) 292 { 293 extern u_int16_t mac68k_vrsrc_vec[]; 294 int i; 295 296 for (i = 0 ; i < 6 ; i++) 297 if ((mac68k_vrsrc_vec[i] & 0xff) == slot) 298 return ((mac68k_vrsrc_vec[i] >> 8) & 0xff); 299 return (-1); 300 } 301 302 /* 303 * Probe a given nubus slot. If a card is there and we can get the 304 * format block from its clutching decl. ROMs, fill the format block 305 * and return non-zero. If we can't find a card there with a valid 306 * decl. ROM, return 0. 307 * 308 * First, we check to see if we can access the memory at the tail 309 * end of the slot. If so, then we check for a bytelanes byte. We 310 * could probably just return a failure status if we bus error on 311 * the first try, but there really is little reason not to go ahead 312 * and check the other three locations in case there's a weird card 313 * out there. 314 * 315 * Checking for a card involves locating the "bytelanes" byte which 316 * tells us how to interpret the declaration ROM's data. The format 317 * block is at the top of the card's standard memory space and the 318 * bytelanes byte is at the end of that block. 319 * 320 * After some inspection of the bytelanes byte, it appears that it 321 * takes the form 0xXY where Y is a bitmask of the bytelanes in use 322 * and X is a bitmask of the lanes to ignore. Hence, (X ^ Y) == 0 323 * and (less obviously), Y will have the upper N bits clear if it is 324 * found N bytes from the last possible location. Both that and 325 * the exclusive-or check are made. 326 * 327 * If a valid 328 */ 329 static u_int8_t nbits[] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4}; 330 static int 331 nubus_probe_slot(bus_space_tag_t bst, bus_space_handle_t bsh, int slot, 332 nubus_slot *fmt) 333 { 334 u_long ofs, hdr; 335 int i, j, found, hdr_size; 336 u_int8_t lanes; 337 338 #ifdef DEBUG 339 if (nubus_debug & NDB_PROBE) 340 printf("probing slot %x\n", slot); 341 #endif 342 343 /* 344 * The idea behind this glorious work of art is to probe for only 345 * valid bytelanes values at appropriate locations (see DC&D p. 159 346 * for a list). Note the pattern: the first 8 values are at offset 347 * 0xffffff in the slot's space; the next 4 values at 0xfffffe; the 348 * next 2 values at 0xfffffd; and the last one at 0xfffffc. 349 * 350 * The nested loops implement an efficient search of this space, 351 * probing first for a valid address, then checking for each of the 352 * valid bytelanes values at that address. 353 */ 354 ofs = NBMEMSIZE; 355 lanes = 0xf; 356 357 for (j = 8, found = 0; j > 0 && !found; j >>= 1) { 358 ofs--; 359 for (i = j; i > 0; i--, lanes--) { 360 if (!mac68k_bus_space_probe(bst, bsh, ofs, 1)) { 361 lanes -= i; 362 break; 363 } 364 if (bus_space_read_1(bst, bsh, ofs) == 365 (((~lanes & 0xf) << 4) | lanes)) { 366 found = 1; 367 break; 368 } 369 } 370 } 371 372 if (!found) { 373 #ifdef DEBUG 374 if (nubus_debug & NDB_PROBE) 375 printf("bytelanes not found for slot %x\n", slot); 376 #endif 377 return 0; 378 } 379 380 fmt->bytelanes = lanes; 381 fmt->step = nbits[(lanes & 0x0f)]; 382 fmt->slot = slot; /* XXX redundant; get rid of this someday */ 383 384 #ifdef DEBUG 385 if (nubus_debug & NDB_PROBE) 386 printf("bytelanes of 0x%x found for slot 0x%x.\n", 387 fmt->bytelanes, slot); 388 #endif 389 390 /* 391 * Go ahead and attempt to load format header. 392 * First, we need to find the first byte beyond memory that 393 * would be valid. This is necessary for NUBUS_ROM_offset() 394 * to work. 395 */ 396 hdr = NBMEMSIZE; 397 hdr_size = 20; 398 399 i = 0x10 | (lanes & 0x0f); 400 while ((i & 1) == 0) { 401 hdr++; 402 i >>= 1; 403 } 404 fmt->top = hdr; 405 hdr = nubus_adjust_ptr(lanes, hdr, -hdr_size); 406 #ifdef DEBUG 407 if (nubus_debug & NDB_PROBE) 408 printf("fmt->top is 0x%lx, that minus 0x%x puts us at 0x%lx.\n", 409 fmt->top, hdr_size, hdr); 410 if (nubus_debug & NDB_ARITH) 411 for (i = 1 ; i < 8 ; i++) 412 printf("0x%lx - 0x%x = 0x%lx, + 0x%x = 0x%lx.\n", 413 hdr, i, nubus_adjust_ptr(lanes, hdr, -i), 414 i, nubus_adjust_ptr(lanes, hdr, i)); 415 #endif 416 417 fmt->directory_offset = 418 0xff000000 | nubus_read_4(bst, bsh, lanes, hdr); 419 hdr = nubus_adjust_ptr(lanes, hdr, 4); 420 fmt->length = nubus_read_4(bst, bsh, lanes, hdr); 421 hdr = nubus_adjust_ptr(lanes, hdr, 4); 422 fmt->crc = nubus_read_4(bst, bsh, lanes, hdr); 423 hdr = nubus_adjust_ptr(lanes, hdr, 4); 424 fmt->revision_level = nubus_read_1(bst, bsh, lanes, hdr); 425 hdr = nubus_adjust_ptr(lanes, hdr, 1); 426 fmt->format = nubus_read_1(bst, bsh, lanes, hdr); 427 hdr = nubus_adjust_ptr(lanes, hdr, 1); 428 fmt->test_pattern = nubus_read_4(bst, bsh, lanes, hdr); 429 430 #ifdef DEBUG 431 if (nubus_debug & NDB_PROBE) { 432 printf("Directory offset 0x%x\t", fmt->directory_offset); 433 printf("Length 0x%x\t", fmt->length); 434 printf("CRC 0x%x\n", fmt->crc); 435 printf("Revision level 0x%x\t", fmt->revision_level); 436 printf("Format 0x%x\t", fmt->format); 437 printf("Test Pattern 0x%x\n", fmt->test_pattern); 438 } 439 #endif 440 441 if ((fmt->directory_offset & 0x00ff0000) == 0) { 442 printf("Invalid looking directory offset (0x%x)!\n", 443 fmt->directory_offset); 444 return 0; 445 } 446 if (fmt->test_pattern != NUBUS_ROM_TEST_PATTERN) { 447 printf("Nubus--test pattern invalid:\n"); 448 printf(" slot 0x%x, bytelanes 0x%x?\n", fmt->slot, lanes); 449 printf(" read test 0x%x, compare with 0x%x.\n", 450 fmt->test_pattern, NUBUS_ROM_TEST_PATTERN); 451 return 0; 452 } 453 454 /* Perform CRC */ 455 if (fmt->crc != nubus_calc_CRC(bst, bsh, fmt)) { 456 printf("Nubus--crc check failed, slot 0x%x.\n", fmt->slot); 457 return 0; 458 } 459 460 return 1; 461 } 462 463 static u_int32_t 464 nubus_calc_CRC(bus_space_tag_t bst, bus_space_handle_t bsh, nubus_slot *fmt) 465 { 466 #if 0 467 u_long base, ptr, crc_loc; 468 u_int32_t sum; 469 u_int8_t lanes = fmt->bytelanes; 470 471 base = fmt->top; 472 crc_loc = NUBUS_ROM_offset(fmt, base, -12); 473 ptr = NUBUS_ROM_offset(fmt, base, -fmt->length); 474 475 sum = 0; 476 while (ptr < base) 477 roll #1, sum 478 if (ptr == crc_loc) { 479 roll #3, sum 480 ptr = nubus_adjust_ptr(lanes, ptr, 3); 481 } else { 482 sum += nubus_read_1(bst, bsh, lanes, ptr); 483 } 484 ptr = nubus_adjust_ptr(lanes, ptr, 1); 485 } 486 487 return sum; 488 #endif 489 return fmt->crc; 490 } 491 492 /* 493 * Compute byte offset on card, taking into account bytelanes. 494 * Base must be on a valid bytelane for this function to work. 495 * Return the new address. 496 * 497 * XXX -- There has GOT to be a better way to do this. 498 */ 499 static u_long 500 nubus_adjust_ptr(u_int8_t lanes, u_long base, long amt) 501 { 502 u_int8_t b, t; 503 504 if (!amt) 505 return base; 506 507 if (amt < 0) { 508 amt = -amt; 509 b = lanes; 510 t = (b << 4); 511 b <<= (3 - (base & 0x3)); 512 while (amt) { 513 b <<= 1; 514 if (b == t) 515 b = lanes; 516 if (b & 0x08) 517 amt--; 518 base--; 519 } 520 return base; 521 } 522 523 t = (lanes & 0xf) | 0x10; 524 b = t >> (base & 0x3); 525 while (amt) { 526 b >>= 1; 527 if (b == 1) 528 b = t; 529 if (b & 1) 530 amt--; 531 base++; 532 } 533 534 return base; 535 } 536 537 static u_int8_t 538 nubus_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, u_int8_t lanes, 539 u_long ofs) 540 { 541 return bus_space_read_1(bst, bsh, ofs); 542 } 543 544 #ifdef notyet 545 /* Nothing uses this, yet */ 546 static u_int16_t 547 nubus_read_2(bus_space_tag_t bst, bus_space_handle_t bsh, u_int8_t lanes, 548 u_long ofs) 549 { 550 u_int16_t s; 551 552 s = (nubus_read_1(bst, bsh, lanes, ofs) << 8); 553 ofs = nubus_adjust_ptr(lanes, ofs, 1); 554 s |= nubus_read_1(bst, bsh, lanes, ofs); 555 return s; 556 } 557 #endif 558 559 static u_int32_t 560 nubus_read_4(bus_space_tag_t bst, bus_space_handle_t bsh, u_int8_t lanes, 561 u_long ofs) 562 { 563 u_int32_t l; 564 int i; 565 566 l = 0; 567 for (i = 0; i < 4; i++) { 568 l = (l << 8) | nubus_read_1(bst, bsh, lanes, ofs); 569 ofs = nubus_adjust_ptr(lanes, ofs, 1); 570 } 571 return l; 572 } 573 574 void 575 nubus_get_main_dir(nubus_slot *fmt, nubus_dir *dir_return) 576 { 577 #ifdef DEBUG 578 if (nubus_debug & NDB_FOLLOW) 579 printf("nubus_get_main_dir(%p, %p)\n", 580 fmt, dir_return); 581 #endif 582 dir_return->dirbase = nubus_adjust_ptr(fmt->bytelanes, fmt->top, 583 fmt->directory_offset - 20); 584 dir_return->curr_ent = dir_return->dirbase; 585 } 586 587 void 588 nubus_get_dir_from_rsrc(nubus_slot *fmt, nubus_dirent *dirent, 589 nubus_dir *dir_return) 590 { 591 u_long loc; 592 593 #ifdef DEBUG 594 if (nubus_debug & NDB_FOLLOW) 595 printf("nubus_get_dir_from_rsrc(%p, %p, %p).\n", 596 fmt, dirent, dir_return); 597 #endif 598 if ((loc = dirent->offset) & 0x800000) { 599 loc |= 0xff000000; 600 } 601 dir_return->dirbase = 602 nubus_adjust_ptr(fmt->bytelanes, dirent->myloc, loc); 603 dir_return->curr_ent = dir_return->dirbase; 604 } 605 606 int 607 nubus_find_rsrc(bus_space_tag_t bst, bus_space_handle_t bsh, nubus_slot *fmt, 608 nubus_dir *dir, u_int8_t rsrcid, nubus_dirent *dirent_return) 609 { 610 u_long entry; 611 u_int8_t byte, lanes = fmt->bytelanes; 612 613 #ifdef DEBUG 614 if (nubus_debug & NDB_FOLLOW) 615 printf("nubus_find_rsrc(%p, %p, 0x%x, %p)\n", 616 fmt, dir, rsrcid, dirent_return); 617 #endif 618 if (fmt->test_pattern != NUBUS_ROM_TEST_PATTERN) 619 return -1; 620 621 entry = dir->curr_ent; 622 do { 623 byte = nubus_read_1(bst, bsh, lanes, entry); 624 #ifdef DEBUG 625 if (nubus_debug & NDB_FOLLOW) 626 printf("\tFound rsrc 0x%x.\n", byte); 627 #endif 628 if (byte == rsrcid) { 629 dirent_return->myloc = entry; 630 dirent_return->rsrc_id = rsrcid; 631 entry = nubus_read_4(bst, bsh, lanes, entry); 632 dirent_return->offset = (entry & 0x00ffffff); 633 return 1; 634 } 635 if (byte == 0xff) { 636 entry = dir->dirbase; 637 } else { 638 entry = nubus_adjust_ptr(lanes, entry, 4); 639 } 640 } while (entry != (u_long)dir->curr_ent); 641 return 0; 642 } 643 644 int 645 nubus_get_ind_data(bus_space_tag_t bst, bus_space_handle_t bsh, nubus_slot *fmt, 646 nubus_dirent *dirent, char *data_return, int nbytes) 647 { 648 u_long loc; 649 u_int8_t lanes = fmt->bytelanes; 650 651 #ifdef DEBUG 652 if (nubus_debug & NDB_FOLLOW) 653 printf("nubus_get_ind_data(%p, %p, %p, %d).\n", 654 fmt, dirent, data_return, nbytes); 655 #endif 656 if ((loc = dirent->offset) & 0x800000) { 657 loc |= 0xff000000; 658 } 659 loc = nubus_adjust_ptr(lanes, dirent->myloc, loc); 660 661 while (nbytes--) { 662 *data_return++ = nubus_read_1(bst, bsh, lanes, loc); 663 loc = nubus_adjust_ptr(lanes, loc, 1); 664 } 665 return 1; 666 } 667 668 int 669 nubus_get_c_string(bus_space_tag_t bst, bus_space_handle_t bsh, nubus_slot *fmt, 670 nubus_dirent *dirent, char *data_return, int max_bytes) 671 { 672 u_long loc; 673 u_int8_t lanes = fmt->bytelanes; 674 675 #ifdef DEBUG 676 if (nubus_debug & NDB_FOLLOW) 677 printf("nubus_get_c_string(%p, %p, %p, %d).\n", 678 fmt, dirent, data_return, max_bytes); 679 #endif 680 if ((loc = dirent->offset) & 0x800000) 681 loc |= 0xff000000; 682 683 loc = nubus_adjust_ptr(lanes, dirent->myloc, loc); 684 685 *data_return = '\0'; 686 while (max_bytes--) { 687 if ((*data_return++ = 688 nubus_read_1(bst, bsh, lanes, loc)) == 0) 689 return 1; 690 loc = nubus_adjust_ptr(lanes, loc, 1); 691 } 692 *(data_return-1) = '\0'; 693 return 0; 694 } 695 696 /* 697 * Get list of address ranges for an sMemory resource 698 * -> DC&D, p.171 699 */ 700 int 701 nubus_get_smem_addr_rangelist(bus_space_tag_t bst, bus_space_handle_t bsh, 702 nubus_slot *fmt, nubus_dirent *dirent, void *data_return) 703 { 704 u_long loc; 705 u_int8_t lanes = fmt->bytelanes; 706 long blocklen; 707 void *blocklist; 708 709 #ifdef DEBUG 710 if (nubus_debug & NDB_FOLLOW) 711 printf("nubus_get_smem_addr_rangelist(%p, %p, %p).\n", 712 fmt, dirent, data_return); 713 #endif 714 if ((loc = dirent->offset) & 0x800000) { 715 loc |= 0xff000000; 716 } 717 loc = nubus_adjust_ptr(lanes, dirent->myloc, loc); 718 719 /* Obtain the block length from the head of the list */ 720 blocklen = nubus_read_4(bst, bsh, lanes, loc); 721 722 /* 723 * malloc a block of (blocklen) bytes 724 * caller must recycle block after use 725 */ 726 blocklist = malloc(blocklen,M_TEMP,M_WAITOK); 727 728 /* read ((blocklen - 4) / 8) (length,offset) pairs into block */ 729 nubus_get_ind_data(bst, bsh, fmt, dirent, blocklist, blocklen); 730 #ifdef DEBUG 731 if (nubus_debug & NDB_FOLLOW) { 732 int ii; 733 nubus_smem_rangelist *rlist; 734 735 rlist = (nubus_smem_rangelist *)blocklist; 736 printf("\tblock@%p, len 0x0%X\n", rlist, rlist->length); 737 738 for (ii=0; ii < ((blocklen - 4) / 8); ii++) { 739 printf("\tRange %d: base addr 0x%X [0x%X]\n", ii, 740 rlist->range[ii].offset, rlist->range[ii].length); 741 } 742 } 743 #endif 744 *(void **)data_return = blocklist; 745 746 return 1; 747 } 748 749 static const char *huh = "???"; 750 751 const char * 752 nubus_get_vendor(bus_space_tag_t bst, bus_space_handle_t bsh, nubus_slot *fmt, 753 int rsrc) 754 { 755 static char str_ret[64]; 756 nubus_dir dir; 757 nubus_dirent ent; 758 759 #ifdef DEBUG 760 if (nubus_debug & NDB_FOLLOW) 761 printf("nubus_get_vendor(%p, 0x%x).\n", fmt, rsrc); 762 #endif 763 nubus_get_main_dir(fmt, &dir); 764 if (nubus_find_rsrc(bst, bsh, fmt, &dir, 1, &ent) <= 0) 765 return huh; 766 nubus_get_dir_from_rsrc(fmt, &ent, &dir); 767 768 if (nubus_find_rsrc(bst, bsh, fmt, &dir, NUBUS_RSRC_VENDORINFO, &ent) 769 <= 0) 770 return huh; 771 nubus_get_dir_from_rsrc(fmt, &ent, &dir); 772 773 if (nubus_find_rsrc(bst, bsh, fmt, &dir, rsrc, &ent) <= 0) 774 return huh; 775 776 nubus_get_c_string(bst, bsh, fmt, &ent, str_ret, 64); 777 778 return str_ret; 779 } 780 781 const char * 782 nubus_get_card_name(bus_space_tag_t bst, bus_space_handle_t bsh, 783 nubus_slot *fmt) 784 { 785 static char name_ret[64]; 786 nubus_dir dir; 787 nubus_dirent ent; 788 789 #ifdef DEBUG 790 if (nubus_debug & NDB_FOLLOW) 791 printf("nubus_get_card_name(%p).\n", fmt); 792 #endif 793 nubus_get_main_dir(fmt, &dir); 794 795 if (nubus_find_rsrc(bst, bsh, fmt, &dir, 1, &ent) <= 0) 796 return huh; 797 798 nubus_get_dir_from_rsrc(fmt, &ent, &dir); 799 800 if (nubus_find_rsrc(bst, bsh, fmt, &dir, NUBUS_RSRC_NAME, &ent) <= 0) 801 return huh; 802 803 nubus_get_c_string(bst, bsh, fmt, &ent, name_ret, 64); 804 805 return name_ret; 806 } 807 808 #ifdef DEBUG 809 void 810 nubus_scan_slot(bus_space_tag_t bst, int slotno) 811 { 812 int i=0, state=0; 813 char twirl[] = "-\\|/"; 814 bus_space_handle_t sc_bsh; 815 816 if (bus_space_map(bst, NUBUS_SLOT2PA(slotno), NBMEMSIZE, 0, &sc_bsh)) { 817 printf("nubus_scan_slot: failed to map slot %x\n", slotno); 818 return; 819 } 820 821 printf("Scanning slot %c for accessible regions:\n", 822 slotno == 9 ? '9' : slotno - 10 + 'A'); 823 for (i=0 ; i<NBMEMSIZE; i++) { 824 if (mac68k_bus_space_probe(bst, sc_bsh, i, 1)) { 825 if (state == 0) { 826 printf("\t0x%x-", i); 827 state = 1; 828 } 829 } else { 830 if (state) { 831 printf("0x%x\n", i); 832 state = 0; 833 } 834 } 835 if (i%100 == 0) { 836 printf("%c\b", twirl[(i/100)%4]); 837 } 838 } 839 if (state) { 840 printf("0x%x\n", i); 841 } 842 return; 843 } 844 #endif 845
Indexes created Sat Sep 20 22:09:52 GMT 2025