1 /*- 2 * Copyright (c) 2015 Landon Fuller <landon@landonf.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13 * redistribution must be conditioned upon including a substantially 14 * similar Disclaimer requirement for further binary redistribution. 15 * 16 * NO WARRANTY 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 20 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 21 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 22 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 27 * THE POSSIBILITY OF SUCH DAMAGES. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 #include <sys/bus.h> 35 #include <sys/kernel.h> 36 #include <sys/limits.h> 37 #include <sys/systm.h> 38 39 #include <machine/bus.h> 40 #include <machine/resource.h> 41 42 #include <dev/bhnd/cores/chipc/chipcreg.h> 43 44 #include "bcma_eromreg.h" 45 #include "bcma_eromvar.h" 46 47 /* 48 * BCMA Enumeration ROM (EROM) Table 49 * 50 * Provides auto-discovery of BCMA cores on Broadcom's HND SoC. 51 * 52 * The EROM core address can be found at BCMA_CC_EROM_ADDR within the 53 * ChipCommon registers. The table itself is comprised of 32-bit 54 * type-tagged entries, organized into an array of variable-length 55 * core descriptor records. 56 * 57 * The final core descriptor is followed by a 32-bit BCMA_EROM_TABLE_EOF (0xF) 58 * marker. 59 */ 60 61 struct bcma_erom_io; 62 63 static const char *bcma_erom_entry_type_name (uint8_t entry); 64 65 static uint32_t bcma_eio_read4(struct bcma_erom_io *io, 66 bus_size_t offset); 67 68 static int bcma_erom_read32(struct bcma_erom *erom, 69 uint32_t *entry); 70 static int bcma_erom_skip32(struct bcma_erom *erom); 71 72 static int bcma_erom_skip_core(struct bcma_erom *erom); 73 static int bcma_erom_skip_mport(struct bcma_erom *erom); 74 static int bcma_erom_skip_sport_region(struct bcma_erom *erom); 75 76 static int bcma_erom_seek_next(struct bcma_erom *erom, 77 uint8_t etype); 78 static int bcma_erom_region_to_port_type(struct bcma_erom *erom, 79 uint8_t region_type, bhnd_port_type *port_type); 80 81 82 static int bcma_erom_peek32(struct bcma_erom *erom, 83 uint32_t *entry); 84 85 static bus_size_t bcma_erom_tell(struct bcma_erom *erom); 86 static void bcma_erom_seek(struct bcma_erom *erom, 87 bus_size_t offset); 88 static void bcma_erom_reset(struct bcma_erom *erom); 89 90 static int bcma_erom_seek_matching_core(struct bcma_erom *sc, 91 const struct bhnd_core_match *desc, 92 struct bhnd_core_info *core); 93 94 static int bcma_erom_parse_core(struct bcma_erom *erom, 95 struct bcma_erom_core *core); 96 97 static int bcma_erom_parse_mport(struct bcma_erom *erom, 98 struct bcma_erom_mport *mport); 99 100 static int bcma_erom_parse_sport_region(struct bcma_erom *erom, 101 struct bcma_erom_sport_region *region); 102 103 static void bcma_erom_to_core_info(const struct bcma_erom_core *core, 104 u_int core_idx, int core_unit, 105 struct bhnd_core_info *info); 106 107 /** 108 * BCMA EROM generic I/O context 109 */ 110 struct bcma_erom_io { 111 struct bhnd_resource *res; /**< memory resource, or NULL if initialized 112 with bus space tag and handle */ 113 int rid; /**< memory resource id, or -1 */ 114 115 bus_space_tag_t bst; /**< bus space tag, if any */ 116 bus_space_handle_t bsh; /**< bus space handle, if any */ 117 118 bus_size_t start; /**< base read offset */ 119 }; 120 121 /** 122 * BCMA EROM per-instance state. 123 */ 124 struct bcma_erom { 125 struct bhnd_erom obj; 126 device_t dev; /**< parent device, or NULL if none. */ 127 struct bcma_erom_io io; /**< I/O context */ 128 bus_size_t offset; /**< current read offset */ 129 }; 130 131 #define EROM_LOG(erom, fmt, ...) do { \ 132 if (erom->dev != NULL) { \ 133 device_printf(erom->dev, "erom[0x%llx]: " fmt, \ 134 (unsigned long long) (erom->offset), ##__VA_ARGS__);\ 135 } else { \ 136 printf("erom[0x%llx]: " fmt, \ 137 (unsigned long long) (erom->offset), ##__VA_ARGS__);\ 138 } \ 139 } while(0) 140 141 /** Return the type name for an EROM entry */ 142 static const char * 143 bcma_erom_entry_type_name (uint8_t entry) 144 { 145 switch (BCMA_EROM_GET_ATTR(entry, ENTRY_TYPE)) { 146 case BCMA_EROM_ENTRY_TYPE_CORE: 147 return "core"; 148 case BCMA_EROM_ENTRY_TYPE_MPORT: 149 return "mport"; 150 case BCMA_EROM_ENTRY_TYPE_REGION: 151 return "region"; 152 default: 153 return "unknown"; 154 } 155 } 156 157 158 /** 159 * Read a 32-bit value from an EROM I/O context. 160 * 161 * @param io EROM I/O context. 162 * @param offset Read offset. 163 */ 164 static uint32_t 165 bcma_eio_read4(struct bcma_erom_io *io, bus_size_t offset) 166 { 167 bus_size_t read_off; 168 169 read_off = io->start + offset; 170 if (io->res != NULL) 171 return (bhnd_bus_read_4(io->res, read_off)); 172 else 173 return (bus_space_read_4(io->bst, io->bsh, read_off)); 174 } 175 176 /* Initialize bcma_erom resource I/O context */ 177 static void 178 bcma_eio_init(struct bcma_erom_io *io, struct bhnd_resource *res, int rid, 179 bus_size_t offset) 180 { 181 io->res = res; 182 io->rid = rid; 183 io->start = offset; 184 } 185 186 /* Initialize bcma_erom bus space I/O context */ 187 static void 188 bcma_eio_init_static(struct bcma_erom_io *io, bus_space_tag_t bst, 189 bus_space_handle_t bsh, bus_size_t offset) 190 { 191 io->res = NULL; 192 io->rid = -1; 193 io->bst = bst; 194 io->bsh = bsh; 195 io->start = offset; 196 } 197 198 /* BCMA implementation of BHND_EROM_INIT() */ 199 static int 200 bcma_erom_init(bhnd_erom_t *erom, const struct bhnd_chipid *cid, 201 device_t parent, int rid) 202 { 203 struct bcma_erom *sc; 204 struct bhnd_resource *res; 205 206 sc = (struct bcma_erom *)erom; 207 sc->dev = parent; 208 sc->offset = 0; 209 210 res = bhnd_alloc_resource(parent, SYS_RES_MEMORY, &rid, cid->enum_addr, 211 cid->enum_addr + BCMA_EROM_TABLE_SIZE - 1, BCMA_EROM_TABLE_SIZE, 212 RF_ACTIVE|RF_SHAREABLE); 213 214 if (res == NULL) 215 return (ENOMEM); 216 217 bcma_eio_init(&sc->io, res, rid, BCMA_EROM_TABLE_START); 218 219 return (0); 220 } 221 222 /* BCMA implementation of BHND_EROM_INIT_STATIC() */ 223 static int 224 bcma_erom_init_static(bhnd_erom_t *erom, const struct bhnd_chipid *cid, 225 bus_space_tag_t bst, bus_space_handle_t bsh) 226 { 227 struct bcma_erom *sc; 228 229 sc = (struct bcma_erom *)erom; 230 sc->dev = NULL; 231 sc->offset = 0; 232 233 bcma_eio_init_static(&sc->io, bst, bsh, BCMA_EROM_TABLE_START); 234 235 return (0); 236 } 237 238 /* Common implementation of BHND_EROM_PROBE/BHND_EROM_PROBE_STATIC */ 239 static int 240 bcma_erom_probe_common(struct bcma_erom_io *io, const struct bhnd_chipid *hint, 241 struct bhnd_chipid *cid) 242 { 243 uint32_t idreg, eromptr; 244 245 /* Hints aren't supported; all BCMA devices have a ChipCommon 246 * core */ 247 if (hint != NULL) 248 return (EINVAL); 249 250 /* Confirm CHIPC_EROMPTR availability */ 251 idreg = bcma_eio_read4(io, CHIPC_ID); 252 if (!BHND_CHIPTYPE_HAS_EROM(CHIPC_GET_BITS(idreg, CHIPC_ID_BUS))) 253 return (ENXIO); 254 255 /* Fetch EROM address */ 256 eromptr = bcma_eio_read4(io, CHIPC_EROMPTR); 257 258 /* Parse chip identifier */ 259 *cid = bhnd_parse_chipid(idreg, eromptr); 260 261 /* Verify chip type */ 262 switch (cid->chip_type) { 263 case BHND_CHIPTYPE_BCMA: 264 return (BUS_PROBE_DEFAULT); 265 266 case BHND_CHIPTYPE_BCMA_ALT: 267 case BHND_CHIPTYPE_UBUS: 268 return (BUS_PROBE_GENERIC); 269 270 default: 271 return (ENXIO); 272 } 273 } 274 275 static int 276 bcma_erom_probe(bhnd_erom_class_t *cls, struct bhnd_resource *res, 277 bus_size_t offset, const struct bhnd_chipid *hint, struct bhnd_chipid *cid) 278 { 279 struct bcma_erom_io io; 280 281 bcma_eio_init(&io, res, rman_get_rid(res->res), 282 offset + BCMA_EROM_TABLE_START); 283 284 return (bcma_erom_probe_common(&io, hint, cid)); 285 } 286 287 static int 288 bcma_erom_probe_static(bhnd_erom_class_t *cls, bus_space_tag_t bst, 289 bus_space_handle_t bsh, bus_addr_t paddr, const struct bhnd_chipid *hint, 290 struct bhnd_chipid *cid) 291 { 292 struct bcma_erom_io io; 293 294 bcma_eio_init_static(&io, bst, bsh, BCMA_EROM_TABLE_START); 295 return (bcma_erom_probe_common(&io, hint, cid)); 296 } 297 298 299 static void 300 bcma_erom_fini(bhnd_erom_t *erom) 301 { 302 struct bcma_erom *sc = (struct bcma_erom *)erom; 303 304 if (sc->io.res != NULL) { 305 bhnd_release_resource(sc->dev, SYS_RES_MEMORY, sc->io.rid, 306 sc->io.res); 307 308 sc->io.res = NULL; 309 sc->io.rid = -1; 310 } 311 } 312 313 static int 314 bcma_erom_lookup_core(bhnd_erom_t *erom, const struct bhnd_core_match *desc, 315 struct bhnd_core_info *core) 316 { 317 struct bcma_erom *sc = (struct bcma_erom *)erom; 318 319 /* Search for the first matching core */ 320 return (bcma_erom_seek_matching_core(sc, desc, core)); 321 } 322 323 static int 324 bcma_erom_lookup_core_addr(bhnd_erom_t *erom, const struct bhnd_core_match *desc, 325 bhnd_port_type port_type, u_int port_num, u_int region_num, 326 struct bhnd_core_info *core, bhnd_addr_t *addr, bhnd_size_t *size) 327 { 328 struct bcma_erom *sc; 329 struct bcma_erom_core ec; 330 uint32_t entry; 331 uint8_t region_port, region_type; 332 bool found; 333 int error; 334 335 sc = (struct bcma_erom *)erom; 336 337 /* Seek to the first matching core and provide the core info 338 * to the caller */ 339 if ((error = bcma_erom_seek_matching_core(sc, desc, core))) 340 return (error); 341 342 if ((error = bcma_erom_parse_core(sc, &ec))) 343 return (error); 344 345 /* Skip master ports */ 346 for (u_long i = 0; i < ec.num_mport; i++) { 347 if ((error = bcma_erom_skip_mport(sc))) 348 return (error); 349 } 350 351 /* Seek to the region block for the given port type */ 352 found = false; 353 while (1) { 354 bhnd_port_type p_type; 355 uint8_t r_type; 356 357 if ((error = bcma_erom_peek32(sc, &entry))) 358 return (error); 359 360 if (!BCMA_EROM_ENTRY_IS(entry, REGION)) 361 return (ENOENT); 362 363 /* Expected region type? */ 364 r_type = BCMA_EROM_GET_ATTR(entry, REGION_TYPE); 365 error = bcma_erom_region_to_port_type(sc, r_type, &p_type); 366 if (error) 367 return (error); 368 369 if (p_type == port_type) { 370 found = true; 371 break; 372 } 373 374 /* Skip to next entry */ 375 if ((error = bcma_erom_skip_sport_region(sc))) 376 return (error); 377 } 378 379 if (!found) 380 return (ENOENT); 381 382 /* Found the appropriate port type block; now find the region records 383 * for the given port number */ 384 found = false; 385 for (u_int i = 0; i <= port_num; i++) { 386 bhnd_port_type p_type; 387 388 if ((error = bcma_erom_peek32(sc, &entry))) 389 return (error); 390 391 if (!BCMA_EROM_ENTRY_IS(entry, REGION)) 392 return (ENOENT); 393 394 /* Fetch the type/port of the first region entry */ 395 region_type = BCMA_EROM_GET_ATTR(entry, REGION_TYPE); 396 region_port = BCMA_EROM_GET_ATTR(entry, REGION_PORT); 397 398 /* Have we found the region entries for the desired port? */ 399 if (i == port_num) { 400 error = bcma_erom_region_to_port_type(sc, region_type, 401 &p_type); 402 if (error) 403 return (error); 404 405 if (p_type == port_type) 406 found = true; 407 408 break; 409 } 410 411 /* Otherwise, seek to next block of region records */ 412 while (1) { 413 uint8_t next_type, next_port; 414 415 if ((error = bcma_erom_skip_sport_region(sc))) 416 return (error); 417 418 if ((error = bcma_erom_peek32(sc, &entry))) 419 return (error); 420 421 if (!BCMA_EROM_ENTRY_IS(entry, REGION)) 422 return (ENOENT); 423 424 next_type = BCMA_EROM_GET_ATTR(entry, REGION_TYPE); 425 next_port = BCMA_EROM_GET_ATTR(entry, REGION_PORT); 426 427 if (next_type != region_type || 428 next_port != region_port) 429 break; 430 } 431 } 432 433 if (!found) 434 return (ENOENT); 435 436 /* Finally, search for the requested region number */ 437 for (u_int i = 0; i <= region_num; i++) { 438 struct bcma_erom_sport_region region; 439 uint8_t next_port, next_type; 440 441 if ((error = bcma_erom_peek32(sc, &entry))) 442 return (error); 443 444 if (!BCMA_EROM_ENTRY_IS(entry, REGION)) 445 return (ENOENT); 446 447 /* Check for the end of the region block */ 448 next_type = BCMA_EROM_GET_ATTR(entry, REGION_TYPE); 449 next_port = BCMA_EROM_GET_ATTR(entry, REGION_PORT); 450 451 if (next_type != region_type || 452 next_port != region_port) 453 break; 454 455 /* Parse the region */ 456 if ((error = bcma_erom_parse_sport_region(sc, ®ion))) 457 return (error); 458 459 /* Is this our target region_num? */ 460 if (i == region_num) { 461 /* Found */ 462 *addr = region.base_addr; 463 *size = region.size; 464 return (0); 465 } 466 } 467 468 /* Not found */ 469 return (ENOENT); 470 }; 471 472 static int 473 bcma_erom_get_core_table(bhnd_erom_t *erom, struct bhnd_core_info **cores, 474 u_int *num_cores) 475 { 476 struct bcma_erom *sc; 477 struct bhnd_core_info *buffer; 478 bus_size_t initial_offset; 479 u_int count; 480 int error; 481 482 sc = (struct bcma_erom *)erom; 483 484 buffer = NULL; 485 initial_offset = bcma_erom_tell(sc); 486 487 /* Determine the core count */ 488 bcma_erom_reset(sc); 489 for (count = 0, error = 0; !error; count++) { 490 struct bcma_erom_core core; 491 492 /* Seek to the first readable core entry */ 493 error = bcma_erom_seek_next(sc, BCMA_EROM_ENTRY_TYPE_CORE); 494 if (error == ENOENT) 495 break; 496 else if (error) 497 goto cleanup; 498 499 /* Read past the core descriptor */ 500 if ((error = bcma_erom_parse_core(sc, &core))) 501 goto cleanup; 502 } 503 504 /* Allocate our output buffer */ 505 buffer = malloc(sizeof(struct bhnd_core_info) * count, M_BHND, 506 M_NOWAIT); 507 if (buffer == NULL) { 508 error = ENOMEM; 509 goto cleanup; 510 } 511 512 /* Parse all core descriptors */ 513 bcma_erom_reset(sc); 514 for (u_int i = 0; i < count; i++) { 515 struct bcma_erom_core core; 516 int unit; 517 518 /* Parse the core */ 519 error = bcma_erom_seek_next(sc, BCMA_EROM_ENTRY_TYPE_CORE); 520 if (error) 521 goto cleanup; 522 523 error = bcma_erom_parse_core(sc, &core); 524 if (error) 525 goto cleanup; 526 527 /* Determine the unit number */ 528 unit = 0; 529 for (u_int j = 0; j < i; j++) { 530 if (buffer[i].vendor == buffer[j].vendor && 531 buffer[i].device == buffer[j].device) 532 unit++; 533 } 534 535 /* Convert to a bhnd info record */ 536 bcma_erom_to_core_info(&core, i, unit, &buffer[i]); 537 } 538 539 cleanup: 540 if (!error) { 541 *cores = buffer; 542 *num_cores = count; 543 } else { 544 if (buffer != NULL) 545 free(buffer, M_BHND); 546 } 547 548 /* Restore the initial position */ 549 bcma_erom_seek(sc, initial_offset); 550 return (error); 551 } 552 553 static void 554 bcma_erom_free_core_table(bhnd_erom_t *erom, struct bhnd_core_info *cores) 555 { 556 free(cores, M_BHND); 557 } 558 559 /** 560 * Return the current read position. 561 */ 562 static bus_size_t 563 bcma_erom_tell(struct bcma_erom *erom) 564 { 565 return (erom->offset); 566 } 567 568 /** 569 * Seek to an absolute read position. 570 */ 571 static void 572 bcma_erom_seek(struct bcma_erom *erom, bus_size_t offset) 573 { 574 erom->offset = offset; 575 } 576 577 /** 578 * Read a 32-bit entry value from the EROM table without advancing the 579 * read position. 580 * 581 * @param erom EROM read state. 582 * @param entry Will contain the read result on success. 583 * @retval 0 success 584 * @retval ENOENT The end of the EROM table was reached. 585 * @retval non-zero The read could not be completed. 586 */ 587 static int 588 bcma_erom_peek32(struct bcma_erom *erom, uint32_t *entry) 589 { 590 if (erom->offset >= (BCMA_EROM_TABLE_SIZE - sizeof(uint32_t))) { 591 EROM_LOG(erom, "BCMA EROM table missing terminating EOF\n"); 592 return (EINVAL); 593 } 594 595 *entry = bcma_eio_read4(&erom->io, erom->offset); 596 return (0); 597 } 598 599 /** 600 * Read a 32-bit entry value from the EROM table. 601 * 602 * @param erom EROM read state. 603 * @param entry Will contain the read result on success. 604 * @retval 0 success 605 * @retval ENOENT The end of the EROM table was reached. 606 * @retval non-zero The read could not be completed. 607 */ 608 static int 609 bcma_erom_read32(struct bcma_erom *erom, uint32_t *entry) 610 { 611 int error; 612 613 if ((error = bcma_erom_peek32(erom, entry)) == 0) 614 erom->offset += 4; 615 616 return (error); 617 } 618 619 /** 620 * Read and discard 32-bit entry value from the EROM table. 621 * 622 * @param erom EROM read state. 623 * @retval 0 success 624 * @retval ENOENT The end of the EROM table was reached. 625 * @retval non-zero The read could not be completed. 626 */ 627 static int 628 bcma_erom_skip32(struct bcma_erom *erom) 629 { 630 uint32_t entry; 631 632 return bcma_erom_read32(erom, &entry); 633 } 634 635 /** 636 * Read and discard a core descriptor from the EROM table. 637 * 638 * @param erom EROM read state. 639 * @retval 0 success 640 * @retval ENOENT The end of the EROM table was reached. 641 * @retval non-zero The read could not be completed. 642 */ 643 static int 644 bcma_erom_skip_core(struct bcma_erom *erom) 645 { 646 struct bcma_erom_core core; 647 return (bcma_erom_parse_core(erom, &core)); 648 } 649 650 /** 651 * Read and discard a master port descriptor from the EROM table. 652 * 653 * @param erom EROM read state. 654 * @retval 0 success 655 * @retval ENOENT The end of the EROM table was reached. 656 * @retval non-zero The read could not be completed. 657 */ 658 static int 659 bcma_erom_skip_mport(struct bcma_erom *erom) 660 { 661 struct bcma_erom_mport mp; 662 return (bcma_erom_parse_mport(erom, &mp)); 663 } 664 665 /** 666 * Read and discard a port region descriptor from the EROM table. 667 * 668 * @param erom EROM read state. 669 * @retval 0 success 670 * @retval ENOENT The end of the EROM table was reached. 671 * @retval non-zero The read could not be completed. 672 */ 673 static int 674 bcma_erom_skip_sport_region(struct bcma_erom *erom) 675 { 676 struct bcma_erom_sport_region r; 677 return (bcma_erom_parse_sport_region(erom, &r)); 678 } 679 680 /** 681 * Seek to the next entry matching the given EROM entry type. 682 * 683 * @param erom EROM read state. 684 * @param etype One of BCMA_EROM_ENTRY_TYPE_CORE, 685 * BCMA_EROM_ENTRY_TYPE_MPORT, or BCMA_EROM_ENTRY_TYPE_REGION. 686 * @retval 0 success 687 * @retval ENOENT The end of the EROM table was reached. 688 * @retval non-zero Reading or parsing the descriptor failed. 689 */ 690 static int 691 bcma_erom_seek_next(struct bcma_erom *erom, uint8_t etype) 692 { 693 uint32_t entry; 694 int error; 695 696 /* Iterate until we hit an entry matching the requested type. */ 697 while (!(error = bcma_erom_peek32(erom, &entry))) { 698 /* Handle EOF */ 699 if (entry == BCMA_EROM_TABLE_EOF) 700 return (ENOENT); 701 702 /* Invalid entry */ 703 if (!BCMA_EROM_GET_ATTR(entry, ENTRY_ISVALID)) 704 return (EINVAL); 705 706 /* Entry type matches? */ 707 if (BCMA_EROM_GET_ATTR(entry, ENTRY_TYPE) == etype) 708 return (0); 709 710 /* Skip non-matching entry types. */ 711 switch (BCMA_EROM_GET_ATTR(entry, ENTRY_TYPE)) { 712 case BCMA_EROM_ENTRY_TYPE_CORE: 713 if ((error = bcma_erom_skip_core(erom))) 714 return (error); 715 716 break; 717 718 case BCMA_EROM_ENTRY_TYPE_MPORT: 719 if ((error = bcma_erom_skip_mport(erom))) 720 return (error); 721 722 break; 723 724 case BCMA_EROM_ENTRY_TYPE_REGION: 725 if ((error = bcma_erom_skip_sport_region(erom))) 726 return (error); 727 break; 728 729 default: 730 /* Unknown entry type! */ 731 return (EINVAL); 732 } 733 } 734 735 return (error); 736 } 737 738 /** 739 * Return the read position to the start of the EROM table. 740 * 741 * @param erom EROM read state. 742 */ 743 static void 744 bcma_erom_reset(struct bcma_erom *erom) 745 { 746 erom->offset = 0; 747 } 748 749 /** 750 * Seek to the first core entry matching @p desc. 751 * 752 * @param erom EROM read state. 753 * @param desc The core match descriptor. 754 * @param[out] core On success, the matching core info. If the core info 755 * is not desired, a NULL pointer may be provided. 756 * @retval 0 success 757 * @retval ENOENT The end of the EROM table was reached before @p index was 758 * found. 759 * @retval non-zero Reading or parsing failed. 760 */ 761 static int 762 bcma_erom_seek_matching_core(struct bcma_erom *sc, 763 const struct bhnd_core_match *desc, struct bhnd_core_info *core) 764 { 765 struct bhnd_core_match imatch; 766 bus_size_t core_offset, next_offset; 767 int error; 768 769 /* Seek to table start. */ 770 bcma_erom_reset(sc); 771 772 /* We can't determine a core's unit number during the initial scan. */ 773 imatch = *desc; 774 imatch.m.match.core_unit = 0; 775 776 /* Locate the first matching core */ 777 for (u_int i = 0; i < UINT_MAX; i++) { 778 struct bcma_erom_core ec; 779 struct bhnd_core_info ci; 780 781 /* Seek to the next core */ 782 error = bcma_erom_seek_next(sc, BCMA_EROM_ENTRY_TYPE_CORE); 783 if (error) 784 return (error); 785 786 /* Save the core offset */ 787 core_offset = bcma_erom_tell(sc); 788 789 /* Parse the core */ 790 if ((error = bcma_erom_parse_core(sc, &ec))) 791 return (error); 792 793 bcma_erom_to_core_info(&ec, i, 0, &ci); 794 795 /* Check for initial match */ 796 if (!bhnd_core_matches(&ci, &imatch)) 797 continue; 798 799 /* Re-scan preceding cores to determine the unit number. */ 800 next_offset = bcma_erom_tell(sc); 801 bcma_erom_reset(sc); 802 for (u_int j = 0; j < i; j++) { 803 /* Parse the core */ 804 error = bcma_erom_seek_next(sc, 805 BCMA_EROM_ENTRY_TYPE_CORE); 806 if (error) 807 return (error); 808 809 if ((error = bcma_erom_parse_core(sc, &ec))) 810 return (error); 811 812 /* Bump the unit number? */ 813 if (ec.vendor == ci.vendor && ec.device == ci.device) 814 ci.unit++; 815 } 816 817 /* Check for full match against now-valid unit number */ 818 if (!bhnd_core_matches(&ci, desc)) { 819 /* Reposition to allow reading the next core */ 820 bcma_erom_seek(sc, next_offset); 821 continue; 822 } 823 824 /* Found; seek to the core's initial offset and provide 825 * the core info to the caller */ 826 bcma_erom_seek(sc, core_offset); 827 if (core != NULL) 828 *core = ci; 829 830 return (0); 831 } 832 833 /* Not found, or a parse error occured */ 834 return (error); 835 } 836 837 /** 838 * Read the next core descriptor from the EROM table. 839 * 840 * @param erom EROM read state. 841 * @param[out] core On success, will be populated with the parsed core 842 * descriptor data. 843 * @retval 0 success 844 * @retval ENOENT The end of the EROM table was reached. 845 * @retval non-zero Reading or parsing the core descriptor failed. 846 */ 847 static int 848 bcma_erom_parse_core(struct bcma_erom *erom, struct bcma_erom_core *core) 849 { 850 uint32_t entry; 851 int error; 852 853 /* Parse CoreDescA */ 854 if ((error = bcma_erom_read32(erom, &entry))) 855 return (error); 856 857 /* Handle EOF */ 858 if (entry == BCMA_EROM_TABLE_EOF) 859 return (ENOENT); 860 861 if (!BCMA_EROM_ENTRY_IS(entry, CORE)) { 862 EROM_LOG(erom, "Unexpected EROM entry 0x%x (type=%s)\n", 863 entry, bcma_erom_entry_type_name(entry)); 864 865 return (EINVAL); 866 } 867 868 core->vendor = BCMA_EROM_GET_ATTR(entry, COREA_DESIGNER); 869 core->device = BCMA_EROM_GET_ATTR(entry, COREA_ID); 870 871 /* Parse CoreDescB */ 872 if ((error = bcma_erom_read32(erom, &entry))) 873 return (error); 874 875 if (!BCMA_EROM_ENTRY_IS(entry, CORE)) { 876 return (EINVAL); 877 } 878 879 core->rev = BCMA_EROM_GET_ATTR(entry, COREB_REV); 880 core->num_mport = BCMA_EROM_GET_ATTR(entry, COREB_NUM_MP); 881 core->num_dport = BCMA_EROM_GET_ATTR(entry, COREB_NUM_DP); 882 core->num_mwrap = BCMA_EROM_GET_ATTR(entry, COREB_NUM_WMP); 883 core->num_swrap = BCMA_EROM_GET_ATTR(entry, COREB_NUM_WSP); 884 885 return (0); 886 } 887 888 /** 889 * Read the next master port descriptor from the EROM table. 890 * 891 * @param erom EROM read state. 892 * @param[out] mport On success, will be populated with the parsed 893 * descriptor data. 894 * @retval 0 success 895 * @retval non-zero Reading or parsing the descriptor failed. 896 */ 897 static int 898 bcma_erom_parse_mport(struct bcma_erom *erom, struct bcma_erom_mport *mport) 899 { 900 uint32_t entry; 901 int error; 902 903 /* Parse the master port descriptor */ 904 if ((error = bcma_erom_read32(erom, &entry))) 905 return (error); 906 907 if (!BCMA_EROM_ENTRY_IS(entry, MPORT)) 908 return (EINVAL); 909 910 mport->port_vid = BCMA_EROM_GET_ATTR(entry, MPORT_ID); 911 mport->port_num = BCMA_EROM_GET_ATTR(entry, MPORT_NUM); 912 913 return (0); 914 } 915 916 /** 917 * Read the next slave port region descriptor from the EROM table. 918 * 919 * @param erom EROM read state. 920 * @param[out] mport On success, will be populated with the parsed 921 * descriptor data. 922 * @retval 0 success 923 * @retval ENOENT The end of the region descriptor table was reached. 924 * @retval non-zero Reading or parsing the descriptor failed. 925 */ 926 static int 927 bcma_erom_parse_sport_region(struct bcma_erom *erom, 928 struct bcma_erom_sport_region *region) 929 { 930 uint32_t entry; 931 uint8_t size_type; 932 int error; 933 934 /* Peek at the region descriptor */ 935 if (bcma_erom_peek32(erom, &entry)) 936 return (EINVAL); 937 938 /* A non-region entry signals the end of the region table */ 939 if (!BCMA_EROM_ENTRY_IS(entry, REGION)) { 940 return (ENOENT); 941 } else { 942 bcma_erom_skip32(erom); 943 } 944 945 region->base_addr = BCMA_EROM_GET_ATTR(entry, REGION_BASE); 946 region->region_type = BCMA_EROM_GET_ATTR(entry, REGION_TYPE); 947 region->region_port = BCMA_EROM_GET_ATTR(entry, REGION_PORT); 948 size_type = BCMA_EROM_GET_ATTR(entry, REGION_SIZE); 949 950 /* If region address is 64-bit, fetch the high bits. */ 951 if (BCMA_EROM_GET_ATTR(entry, REGION_64BIT)) { 952 if ((error = bcma_erom_read32(erom, &entry))) 953 return (error); 954 955 region->base_addr |= ((bhnd_addr_t) entry << 32); 956 } 957 958 /* Parse the region size; it's either encoded as the binary logarithm 959 * of the number of 4K pages (i.e. log2 n), or its encoded as a 960 * 32-bit/64-bit literal value directly following the current entry. */ 961 if (size_type == BCMA_EROM_REGION_SIZE_OTHER) { 962 if ((error = bcma_erom_read32(erom, &entry))) 963 return (error); 964 965 region->size = BCMA_EROM_GET_ATTR(entry, RSIZE_VAL); 966 967 if (BCMA_EROM_GET_ATTR(entry, RSIZE_64BIT)) { 968 if ((error = bcma_erom_read32(erom, &entry))) 969 return (error); 970 region->size |= ((bhnd_size_t) entry << 32); 971 } 972 } else { 973 region->size = BCMA_EROM_REGION_SIZE_BASE << size_type; 974 } 975 976 /* Verify that addr+size does not overflow. */ 977 if (region->size != 0 && 978 BHND_ADDR_MAX - (region->size - 1) < region->base_addr) 979 { 980 EROM_LOG(erom, "%s%u: invalid address map %llx:%llx\n", 981 bcma_erom_entry_type_name(region->region_type), 982 region->region_port, 983 (unsigned long long) region->base_addr, 984 (unsigned long long) region->size); 985 986 return (EINVAL); 987 } 988 989 return (0); 990 } 991 992 /** 993 * Convert a bcma_erom_core record to its bhnd_core_info representation. 994 * 995 * @param core EROM core record to convert. 996 * @param core_idx The core index of @p core. 997 * @param core_unit The core unit of @p core. 998 * @param[out] info The populated bhnd_core_info representation. 999 */ 1000 static void 1001 bcma_erom_to_core_info(const struct bcma_erom_core *core, u_int core_idx, 1002 int core_unit, struct bhnd_core_info *info) 1003 { 1004 info->vendor = core->vendor; 1005 info->device = core->device; 1006 info->hwrev = core->rev; 1007 info->core_idx = core_idx; 1008 info->unit = core_unit; 1009 } 1010 1011 /** 1012 * Map an EROM region type to its corresponding port type. 1013 * 1014 * @param region_type Region type value. 1015 * @param[out] port_type On success, the corresponding port type. 1016 */ 1017 static int 1018 bcma_erom_region_to_port_type(struct bcma_erom *erom, uint8_t region_type, 1019 bhnd_port_type *port_type) 1020 { 1021 switch (region_type) { 1022 case BCMA_EROM_REGION_TYPE_DEVICE: 1023 *port_type = BHND_PORT_DEVICE; 1024 return (0); 1025 case BCMA_EROM_REGION_TYPE_BRIDGE: 1026 *port_type = BHND_PORT_BRIDGE; 1027 return (0); 1028 case BCMA_EROM_REGION_TYPE_MWRAP: 1029 case BCMA_EROM_REGION_TYPE_SWRAP: 1030 *port_type = BHND_PORT_AGENT; 1031 return (0); 1032 default: 1033 EROM_LOG(erom, "unsupported region type %hhx\n", 1034 region_type); 1035 return (EINVAL); 1036 } 1037 } 1038 1039 /** 1040 * Register all MMIO region descriptors for the given slave port. 1041 * 1042 * @param erom EROM read state. 1043 * @param corecfg Core info to be populated with the scanned port regions. 1044 * @param port_num Port index for which regions will be parsed. 1045 * @param region_type The region type to be parsed. 1046 * @param[out] offset The offset at which to perform parsing. On success, this 1047 * will be updated to point to the next EROM table entry. 1048 */ 1049 static int 1050 bcma_erom_corecfg_fill_port_regions(struct bcma_erom *erom, 1051 struct bcma_corecfg *corecfg, bcma_pid_t port_num, 1052 uint8_t region_type) 1053 { 1054 struct bcma_sport *sport; 1055 struct bcma_sport_list *sports; 1056 bus_size_t entry_offset; 1057 int error; 1058 bhnd_port_type port_type; 1059 1060 error = 0; 1061 1062 /* Determine the port type for this region type. */ 1063 error = bcma_erom_region_to_port_type(erom, region_type, &port_type); 1064 if (error) 1065 return (error); 1066 1067 /* Fetch the list to be populated */ 1068 sports = bcma_corecfg_get_port_list(corecfg, port_type); 1069 1070 /* Allocate a new port descriptor */ 1071 sport = bcma_alloc_sport(port_num, port_type); 1072 if (sport == NULL) 1073 return (ENOMEM); 1074 1075 /* Read all address regions defined for this port */ 1076 for (bcma_rmid_t region_num = 0;; region_num++) { 1077 struct bcma_map *map; 1078 struct bcma_erom_sport_region spr; 1079 1080 /* No valid port definition should come anywhere near 1081 * BCMA_RMID_MAX. */ 1082 if (region_num == BCMA_RMID_MAX) { 1083 EROM_LOG(erom, "core%u %s%u: region count reached " 1084 "upper limit of %u\n", 1085 corecfg->core_info.core_idx, 1086 bhnd_port_type_name(port_type), 1087 port_num, BCMA_RMID_MAX); 1088 1089 error = EINVAL; 1090 goto cleanup; 1091 } 1092 1093 /* Parse the next region entry. */ 1094 entry_offset = bcma_erom_tell(erom); 1095 error = bcma_erom_parse_sport_region(erom, &spr); 1096 if (error && error != ENOENT) { 1097 EROM_LOG(erom, "core%u %s%u.%u: invalid slave port " 1098 "address region\n", 1099 corecfg->core_info.core_idx, 1100 bhnd_port_type_name(port_type), 1101 port_num, region_num); 1102 goto cleanup; 1103 } 1104 1105 /* ENOENT signals no further region entries */ 1106 if (error == ENOENT) { 1107 /* No further entries */ 1108 error = 0; 1109 break; 1110 } 1111 1112 /* A region or type mismatch also signals no further region 1113 * entries */ 1114 if (spr.region_port != port_num || 1115 spr.region_type != region_type) 1116 { 1117 /* We don't want to consume this entry */ 1118 bcma_erom_seek(erom, entry_offset); 1119 1120 error = 0; 1121 goto cleanup; 1122 } 1123 1124 /* 1125 * Create the map entry. 1126 */ 1127 map = malloc(sizeof(struct bcma_map), M_BHND, M_NOWAIT); 1128 if (map == NULL) { 1129 error = ENOMEM; 1130 goto cleanup; 1131 } 1132 1133 map->m_region_num = region_num; 1134 map->m_base = spr.base_addr; 1135 map->m_size = spr.size; 1136 map->m_rid = -1; 1137 1138 /* Add the region map to the port */ 1139 STAILQ_INSERT_TAIL(&sport->sp_maps, map, m_link); 1140 sport->sp_num_maps++; 1141 } 1142 1143 cleanup: 1144 /* Append the new port descriptor on success, or deallocate the 1145 * partially parsed descriptor on failure. */ 1146 if (error == 0) { 1147 STAILQ_INSERT_TAIL(sports, sport, sp_link); 1148 } else if (sport != NULL) { 1149 bcma_free_sport(sport); 1150 } 1151 1152 return error; 1153 } 1154 1155 /** 1156 * Parse the next core entry from the EROM table and produce a bcma_corecfg 1157 * to be owned by the caller. 1158 * 1159 * @param erom A bcma EROM instance. 1160 * @param[out] result On success, the core's device info. The caller inherits 1161 * ownership of this allocation. 1162 * 1163 * @return If successful, returns 0. If the end of the EROM table is hit, 1164 * ENOENT will be returned. On error, returns a non-zero error value. 1165 */ 1166 int 1167 bcma_erom_next_corecfg(struct bcma_erom *erom, struct bcma_corecfg **result) 1168 { 1169 struct bcma_corecfg *cfg; 1170 struct bcma_erom_core core; 1171 uint8_t first_region_type; 1172 bus_size_t initial_offset; 1173 u_int core_index; 1174 int core_unit; 1175 int error; 1176 1177 cfg = NULL; 1178 initial_offset = bcma_erom_tell(erom); 1179 1180 /* Parse the next core entry */ 1181 if ((error = bcma_erom_parse_core(erom, &core))) 1182 return (error); 1183 1184 /* Determine the core's index and unit numbers */ 1185 bcma_erom_reset(erom); 1186 core_unit = 0; 1187 core_index = 0; 1188 for (; bcma_erom_tell(erom) != initial_offset; core_index++) { 1189 struct bcma_erom_core prev_core; 1190 1191 /* Parse next core */ 1192 error = bcma_erom_seek_next(erom, BCMA_EROM_ENTRY_TYPE_CORE); 1193 if (error) 1194 return (error); 1195 1196 if ((error = bcma_erom_parse_core(erom, &prev_core))) 1197 return (error); 1198 1199 /* Is earlier unit? */ 1200 if (core.vendor == prev_core.vendor && 1201 core.device == prev_core.device) 1202 { 1203 core_unit++; 1204 } 1205 1206 /* Seek to next core */ 1207 error = bcma_erom_seek_next(erom, BCMA_EROM_ENTRY_TYPE_CORE); 1208 if (error) 1209 return (error); 1210 } 1211 1212 /* We already parsed the core descriptor */ 1213 if ((error = bcma_erom_skip_core(erom))) 1214 return (error); 1215 1216 /* Allocate our corecfg */ 1217 cfg = bcma_alloc_corecfg(core_index, core_unit, core.vendor, 1218 core.device, core.rev); 1219 if (cfg == NULL) 1220 return (ENOMEM); 1221 1222 /* These are 5-bit values in the EROM table, and should never be able 1223 * to overflow BCMA_PID_MAX. */ 1224 KASSERT(core.num_mport <= BCMA_PID_MAX, ("unsupported mport count")); 1225 KASSERT(core.num_dport <= BCMA_PID_MAX, ("unsupported dport count")); 1226 KASSERT(core.num_mwrap + core.num_swrap <= BCMA_PID_MAX, 1227 ("unsupported wport count")); 1228 1229 if (bootverbose) { 1230 EROM_LOG(erom, 1231 "core%u: %s %s (cid=%hx, rev=%hu, unit=%d)\n", 1232 core_index, 1233 bhnd_vendor_name(core.vendor), 1234 bhnd_find_core_name(core.vendor, core.device), 1235 core.device, core.rev, core_unit); 1236 } 1237 1238 cfg->num_master_ports = core.num_mport; 1239 cfg->num_dev_ports = 0; /* determined below */ 1240 cfg->num_bridge_ports = 0; /* determined blow */ 1241 cfg->num_wrapper_ports = core.num_mwrap + core.num_swrap; 1242 1243 /* Parse Master Port Descriptors */ 1244 for (uint8_t i = 0; i < core.num_mport; i++) { 1245 struct bcma_mport *mport; 1246 struct bcma_erom_mport mpd; 1247 1248 /* Parse the master port descriptor */ 1249 error = bcma_erom_parse_mport(erom, &mpd); 1250 if (error) 1251 goto failed; 1252 1253 /* Initialize a new bus mport structure */ 1254 mport = malloc(sizeof(struct bcma_mport), M_BHND, M_NOWAIT); 1255 if (mport == NULL) { 1256 error = ENOMEM; 1257 goto failed; 1258 } 1259 1260 mport->mp_vid = mpd.port_vid; 1261 mport->mp_num = mpd.port_num; 1262 1263 /* Update dinfo */ 1264 STAILQ_INSERT_TAIL(&cfg->master_ports, mport, mp_link); 1265 } 1266 1267 1268 /* 1269 * Determine whether this is a bridge device; if so, we can 1270 * expect the first sequence of address region descriptors to 1271 * be of EROM_REGION_TYPE_BRIDGE instead of 1272 * BCMA_EROM_REGION_TYPE_DEVICE. 1273 * 1274 * It's unclear whether this is the correct mechanism by which we 1275 * should detect/handle bridge devices, but this approach matches 1276 * that of (some of) Broadcom's published drivers. 1277 */ 1278 if (core.num_dport > 0) { 1279 uint32_t entry; 1280 1281 if ((error = bcma_erom_peek32(erom, &entry))) 1282 goto failed; 1283 1284 if (BCMA_EROM_ENTRY_IS(entry, REGION) && 1285 BCMA_EROM_GET_ATTR(entry, REGION_TYPE) == BCMA_EROM_REGION_TYPE_BRIDGE) 1286 { 1287 first_region_type = BCMA_EROM_REGION_TYPE_BRIDGE; 1288 cfg->num_dev_ports = 0; 1289 cfg->num_bridge_ports = core.num_dport; 1290 } else { 1291 first_region_type = BCMA_EROM_REGION_TYPE_DEVICE; 1292 cfg->num_dev_ports = core.num_dport; 1293 cfg->num_bridge_ports = 0; 1294 } 1295 } 1296 1297 /* Device/bridge port descriptors */ 1298 for (uint8_t sp_num = 0; sp_num < core.num_dport; sp_num++) { 1299 error = bcma_erom_corecfg_fill_port_regions(erom, cfg, sp_num, 1300 first_region_type); 1301 1302 if (error) 1303 goto failed; 1304 } 1305 1306 /* Wrapper (aka device management) descriptors (for master ports). */ 1307 for (uint8_t sp_num = 0; sp_num < core.num_mwrap; sp_num++) { 1308 error = bcma_erom_corecfg_fill_port_regions(erom, cfg, sp_num, 1309 BCMA_EROM_REGION_TYPE_MWRAP); 1310 1311 if (error) 1312 goto failed; 1313 } 1314 1315 1316 /* Wrapper (aka device management) descriptors (for slave ports). */ 1317 for (uint8_t i = 0; i < core.num_swrap; i++) { 1318 /* Slave wrapper ports are not numbered distinctly from master 1319 * wrapper ports. */ 1320 1321 /* 1322 * Broadcom DDR1/DDR2 Memory Controller 1323 * (cid=82e, rev=1, unit=0, d/mw/sw = 2/0/1 ) -> 1324 * bhnd0: erom[0xdc]: core6 agent0.0: mismatch got: 0x1 (0x2) 1325 * 1326 * ARM BP135 AMBA3 AXI to APB Bridge 1327 * (cid=135, rev=0, unit=0, d/mw/sw = 1/0/1 ) -> 1328 * bhnd0: erom[0x124]: core9 agent1.0: mismatch got: 0x0 (0x2) 1329 * 1330 * core.num_mwrap 1331 * ===> 1332 * (core.num_mwrap > 0) ? 1333 * core.num_mwrap : 1334 * ((core.vendor == BHND_MFGID_BCM) ? 1 : 0) 1335 */ 1336 uint8_t sp_num; 1337 sp_num = (core.num_mwrap > 0) ? 1338 core.num_mwrap : 1339 ((core.vendor == BHND_MFGID_BCM) ? 1 : 0) + i; 1340 error = bcma_erom_corecfg_fill_port_regions(erom, cfg, sp_num, 1341 BCMA_EROM_REGION_TYPE_SWRAP); 1342 1343 if (error) 1344 goto failed; 1345 } 1346 1347 /* 1348 * Seek to the next core entry (if any), skipping any dangling/invalid 1349 * region entries. 1350 * 1351 * On the BCM4706, the EROM entry for the memory controller core 1352 * (0x4bf/0x52E) contains a dangling/unused slave wrapper port region 1353 * descriptor. 1354 */ 1355 if ((error = bcma_erom_seek_next(erom, BCMA_EROM_ENTRY_TYPE_CORE))) { 1356 if (error != ENOENT) 1357 goto failed; 1358 } 1359 1360 *result = cfg; 1361 return (0); 1362 1363 failed: 1364 if (cfg != NULL) 1365 bcma_free_corecfg(cfg); 1366 1367 return error; 1368 } 1369 1370 static int 1371 bcma_erom_dump(bhnd_erom_t *erom) 1372 { 1373 struct bcma_erom *sc; 1374 uint32_t entry; 1375 int error; 1376 1377 sc = (struct bcma_erom *)erom; 1378 1379 bcma_erom_reset(sc); 1380 1381 while (!(error = bcma_erom_read32(sc, &entry))) { 1382 /* Handle EOF */ 1383 if (entry == BCMA_EROM_TABLE_EOF) { 1384 EROM_LOG(sc, "EOF\n"); 1385 return (0); 1386 } 1387 1388 /* Invalid entry */ 1389 if (!BCMA_EROM_GET_ATTR(entry, ENTRY_ISVALID)) { 1390 EROM_LOG(sc, "invalid EROM entry %#x\n", entry); 1391 return (EINVAL); 1392 } 1393 1394 switch (BCMA_EROM_GET_ATTR(entry, ENTRY_TYPE)) { 1395 case BCMA_EROM_ENTRY_TYPE_CORE: { 1396 /* CoreDescA */ 1397 EROM_LOG(sc, "coreA (0x%x)\n", entry); 1398 EROM_LOG(sc, "\tdesigner:\t0x%x\n", 1399 BCMA_EROM_GET_ATTR(entry, COREA_DESIGNER)); 1400 EROM_LOG(sc, "\tid:\t\t0x%x\n", 1401 BCMA_EROM_GET_ATTR(entry, COREA_ID)); 1402 EROM_LOG(sc, "\tclass:\t\t0x%x\n", 1403 BCMA_EROM_GET_ATTR(entry, COREA_CLASS)); 1404 1405 /* CoreDescB */ 1406 if ((error = bcma_erom_read32(sc, &entry))) { 1407 EROM_LOG(sc, "error reading CoreDescB: %d\n", 1408 error); 1409 return (error); 1410 } 1411 1412 if (!BCMA_EROM_ENTRY_IS(entry, CORE)) { 1413 EROM_LOG(sc, "invalid core descriptor; found " 1414 "unexpected entry %#x (type=%s)\n", 1415 entry, bcma_erom_entry_type_name(entry)); 1416 return (EINVAL); 1417 } 1418 1419 EROM_LOG(sc, "coreB (0x%x)\n", entry); 1420 EROM_LOG(sc, "\trev:\t0x%x\n", 1421 BCMA_EROM_GET_ATTR(entry, COREB_REV)); 1422 EROM_LOG(sc, "\tnummp:\t0x%x\n", 1423 BCMA_EROM_GET_ATTR(entry, COREB_NUM_MP)); 1424 EROM_LOG(sc, "\tnumdp:\t0x%x\n", 1425 BCMA_EROM_GET_ATTR(entry, COREB_NUM_DP)); 1426 EROM_LOG(sc, "\tnumwmp:\t0x%x\n", 1427 BCMA_EROM_GET_ATTR(entry, COREB_NUM_WMP)); 1428 EROM_LOG(sc, "\tnumwsp:\t0x%x\n", 1429 BCMA_EROM_GET_ATTR(entry, COREB_NUM_WMP)); 1430 1431 break; 1432 } 1433 case BCMA_EROM_ENTRY_TYPE_MPORT: 1434 EROM_LOG(sc, "\tmport 0x%x\n", entry); 1435 EROM_LOG(sc, "\t\tport:\t0x%x\n", 1436 BCMA_EROM_GET_ATTR(entry, MPORT_NUM)); 1437 EROM_LOG(sc, "\t\tid:\t\t0x%x\n", 1438 BCMA_EROM_GET_ATTR(entry, MPORT_ID)); 1439 break; 1440 1441 case BCMA_EROM_ENTRY_TYPE_REGION: { 1442 bool addr64; 1443 uint8_t size_type; 1444 1445 addr64 = (BCMA_EROM_GET_ATTR(entry, REGION_64BIT) != 0); 1446 size_type = BCMA_EROM_GET_ATTR(entry, REGION_SIZE); 1447 1448 EROM_LOG(sc, "\tregion 0x%x:\n", entry); 1449 EROM_LOG(sc, "\t\t%s:\t0x%x\n", 1450 addr64 ? "baselo" : "base", 1451 BCMA_EROM_GET_ATTR(entry, REGION_BASE)); 1452 EROM_LOG(sc, "\t\tport:\t0x%x\n", 1453 BCMA_EROM_GET_ATTR(entry, REGION_PORT)); 1454 EROM_LOG(sc, "\t\ttype:\t0x%x\n", 1455 BCMA_EROM_GET_ATTR(entry, REGION_TYPE)); 1456 EROM_LOG(sc, "\t\tsztype:\t0x%hhx\n", size_type); 1457 1458 /* Read the base address high bits */ 1459 if (addr64) { 1460 if ((error = bcma_erom_read32(sc, &entry))) { 1461 EROM_LOG(sc, "error reading region " 1462 "base address high bits %d\n", 1463 error); 1464 return (error); 1465 } 1466 1467 EROM_LOG(sc, "\t\tbasehi:\t0x%x\n", entry); 1468 } 1469 1470 /* Read extended size descriptor */ 1471 if (size_type == BCMA_EROM_REGION_SIZE_OTHER) { 1472 bool size64; 1473 1474 if ((error = bcma_erom_read32(sc, &entry))) { 1475 EROM_LOG(sc, "error reading region " 1476 "size descriptor %d\n", 1477 error); 1478 return (error); 1479 } 1480 1481 if (BCMA_EROM_GET_ATTR(entry, RSIZE_64BIT)) 1482 size64 = true; 1483 else 1484 size64 = false; 1485 1486 EROM_LOG(sc, "\t\t%s:\t0x%x\n", 1487 size64 ? "sizelo" : "size", 1488 BCMA_EROM_GET_ATTR(entry, RSIZE_VAL)); 1489 1490 if (size64) { 1491 error = bcma_erom_read32(sc, &entry); 1492 if (error) { 1493 EROM_LOG(sc, "error reading " 1494 "region size high bits: " 1495 "%d\n", error); 1496 return (error); 1497 } 1498 1499 EROM_LOG(sc, "\t\tsizehi:\t0x%x\n", 1500 entry); 1501 } 1502 } 1503 break; 1504 } 1505 1506 default: 1507 EROM_LOG(sc, "unknown EROM entry 0x%x (type=%s)\n", 1508 entry, bcma_erom_entry_type_name(entry)); 1509 return (EINVAL); 1510 } 1511 } 1512 1513 if (error == ENOENT) 1514 EROM_LOG(sc, "BCMA EROM table missing terminating EOF\n"); 1515 else if (error) 1516 EROM_LOG(sc, "EROM read failed: %d\n", error); 1517 1518 return (error); 1519 } 1520 1521 static kobj_method_t bcma_erom_methods[] = { 1522 KOBJMETHOD(bhnd_erom_probe, bcma_erom_probe), 1523 KOBJMETHOD(bhnd_erom_probe_static, bcma_erom_probe_static), 1524 KOBJMETHOD(bhnd_erom_init, bcma_erom_init), 1525 KOBJMETHOD(bhnd_erom_init_static, bcma_erom_init_static), 1526 KOBJMETHOD(bhnd_erom_fini, bcma_erom_fini), 1527 KOBJMETHOD(bhnd_erom_get_core_table, bcma_erom_get_core_table), 1528 KOBJMETHOD(bhnd_erom_free_core_table, bcma_erom_free_core_table), 1529 KOBJMETHOD(bhnd_erom_lookup_core, bcma_erom_lookup_core), 1530 KOBJMETHOD(bhnd_erom_lookup_core_addr, bcma_erom_lookup_core_addr), 1531 KOBJMETHOD(bhnd_erom_dump, bcma_erom_dump), 1532 1533 KOBJMETHOD_END 1534 }; 1535 1536 BHND_EROM_DEFINE_CLASS(bcma_erom, bcma_erom_parser, bcma_erom_methods, sizeof(struct bcma_erom)); 1537