1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2015-2016 Landon Fuller <landon@landonf.org> 5 * Copyright (c) 2017 The FreeBSD Foundation 6 * All rights reserved. 7 * 8 * Portions of this software were developed by Landon Fuller 9 * under sponsorship from the FreeBSD Foundation. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 19 * redistribution must be conditioned upon including a substantially 20 * similar Disclaimer requirement for further binary redistribution. 21 * 22 * NO WARRANTY 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 26 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 27 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 28 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 31 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 33 * THE POSSIBILITY OF SUCH DAMAGES. 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include <sys/param.h> 40 #include <sys/bus.h> 41 #include <sys/refcount.h> 42 #include <sys/systm.h> 43 44 #include <machine/bus.h> 45 #include <sys/rman.h> 46 #include <machine/resource.h> 47 48 #include <dev/bhnd/siba/sibareg.h> 49 50 #include <dev/bhnd/cores/chipc/chipcreg.h> 51 52 #include "nvram/bhnd_nvram.h" 53 54 #include "bhnd_chipc_if.h" 55 56 #include "bhnd_nvram_if.h" 57 #include "bhnd_nvram_map.h" 58 59 #include "bhndreg.h" 60 #include "bhndvar.h" 61 #include "bhnd_private.h" 62 63 static void bhnd_service_registry_free_entry( 64 struct bhnd_service_entry *entry); 65 66 static int compare_ascending_probe_order(const void *lhs, const void *rhs); 67 static int compare_descending_probe_order(const void *lhs, 68 const void *rhs); 69 70 /* BHND core device description table. */ 71 static const struct bhnd_core_desc { 72 uint16_t vendor; 73 uint16_t device; 74 bhnd_devclass_t class; 75 const char *desc; 76 } bhnd_core_descs[] = { 77 #define BHND_CDESC(_mfg, _cid, _cls, _desc) \ 78 { BHND_MFGID_ ## _mfg, BHND_COREID_ ## _cid, \ 79 BHND_DEVCLASS_ ## _cls, _desc } 80 81 BHND_CDESC(BCM, CC, CC, "ChipCommon I/O Controller"), 82 BHND_CDESC(BCM, ILINE20, OTHER, "iLine20 HPNA"), 83 BHND_CDESC(BCM, SRAM, RAM, "SRAM"), 84 BHND_CDESC(BCM, SDRAM, RAM, "SDRAM"), 85 BHND_CDESC(BCM, PCI, PCI, "PCI Bridge"), 86 BHND_CDESC(BCM, MIPS, CPU, "BMIPS CPU"), 87 BHND_CDESC(BCM, ENET, ENET_MAC, "Fast Ethernet MAC"), 88 BHND_CDESC(BCM, V90_CODEC, SOFTMODEM, "V.90 SoftModem Codec"), 89 BHND_CDESC(BCM, USB, USB_DUAL, "USB 1.1 Device/Host Controller"), 90 BHND_CDESC(BCM, ADSL, OTHER, "ADSL Core"), 91 BHND_CDESC(BCM, ILINE100, OTHER, "iLine100 HPNA"), 92 BHND_CDESC(BCM, IPSEC, OTHER, "IPsec Accelerator"), 93 BHND_CDESC(BCM, UTOPIA, OTHER, "UTOPIA ATM Core"), 94 BHND_CDESC(BCM, PCMCIA, PCCARD, "PCMCIA Bridge"), 95 BHND_CDESC(BCM, SOCRAM, RAM, "Internal Memory"), 96 BHND_CDESC(BCM, MEMC, MEMC, "MEMC SDRAM Controller"), 97 BHND_CDESC(BCM, OFDM, OTHER, "OFDM PHY"), 98 BHND_CDESC(BCM, EXTIF, OTHER, "External Interface"), 99 BHND_CDESC(BCM, D11, WLAN, "802.11 MAC/PHY/Radio"), 100 BHND_CDESC(BCM, APHY, WLAN_PHY, "802.11a PHY"), 101 BHND_CDESC(BCM, BPHY, WLAN_PHY, "802.11b PHY"), 102 BHND_CDESC(BCM, GPHY, WLAN_PHY, "802.11g PHY"), 103 BHND_CDESC(BCM, MIPS33, CPU, "BMIPS33 CPU"), 104 BHND_CDESC(BCM, USB11H, USB_HOST, "USB 1.1 Host Controller"), 105 BHND_CDESC(BCM, USB11D, USB_DEV, "USB 1.1 Device Controller"), 106 BHND_CDESC(BCM, USB20H, USB_HOST, "USB 2.0 Host Controller"), 107 BHND_CDESC(BCM, USB20D, USB_DEV, "USB 2.0 Device Controller"), 108 BHND_CDESC(BCM, SDIOH, OTHER, "SDIO Host Controller"), 109 BHND_CDESC(BCM, ROBO, OTHER, "RoboSwitch"), 110 BHND_CDESC(BCM, ATA100, OTHER, "Parallel ATA Controller"), 111 BHND_CDESC(BCM, SATAXOR, OTHER, "SATA DMA/XOR Controller"), 112 BHND_CDESC(BCM, GIGETH, ENET_MAC, "Gigabit Ethernet MAC"), 113 BHND_CDESC(BCM, PCIE, PCIE, "PCIe Bridge"), 114 BHND_CDESC(BCM, NPHY, WLAN_PHY, "802.11n 2x2 PHY"), 115 BHND_CDESC(BCM, SRAMC, MEMC, "SRAM Controller"), 116 BHND_CDESC(BCM, MINIMAC, OTHER, "MINI MAC/PHY"), 117 BHND_CDESC(BCM, ARM11, CPU, "ARM1176 CPU"), 118 BHND_CDESC(BCM, ARM7S, CPU, "ARM7TDMI-S CPU"), 119 BHND_CDESC(BCM, LPPHY, WLAN_PHY, "802.11a/b/g PHY"), 120 BHND_CDESC(BCM, PMU, PMU, "PMU"), 121 BHND_CDESC(BCM, SSNPHY, WLAN_PHY, "802.11n Single-Stream PHY"), 122 BHND_CDESC(BCM, SDIOD, OTHER, "SDIO Device Core"), 123 BHND_CDESC(BCM, ARMCM3, CPU, "ARM Cortex-M3 CPU"), 124 BHND_CDESC(BCM, HTPHY, WLAN_PHY, "802.11n 4x4 PHY"), 125 BHND_CDESC(MIPS,MIPS74K, CPU, "MIPS74k CPU"), 126 BHND_CDESC(BCM, GMAC, ENET_MAC, "Gigabit MAC core"), 127 BHND_CDESC(BCM, DMEMC, MEMC, "DDR1/DDR2 Memory Controller"), 128 BHND_CDESC(BCM, PCIERC, OTHER, "PCIe Root Complex"), 129 BHND_CDESC(BCM, OCP, SOC_BRIDGE, "OCP to OCP Bridge"), 130 BHND_CDESC(BCM, SC, OTHER, "Shared Common Core"), 131 BHND_CDESC(BCM, AHB, SOC_BRIDGE, "OCP to AHB Bridge"), 132 BHND_CDESC(BCM, SPIH, OTHER, "SPI Host Controller"), 133 BHND_CDESC(BCM, I2S, OTHER, "I2S Digital Audio Interface"), 134 BHND_CDESC(BCM, DMEMS, MEMC, "SDR/DDR1 Memory Controller"), 135 BHND_CDESC(BCM, UBUS_SHIM, OTHER, "BCM6362/UBUS WLAN SHIM"), 136 BHND_CDESC(BCM, PCIE2, PCIE, "PCIe Bridge (Gen2)"), 137 138 BHND_CDESC(ARM, APB_BRIDGE, SOC_BRIDGE, "BP135 AMBA3 AXI to APB Bridge"), 139 BHND_CDESC(ARM, PL301, SOC_ROUTER, "PL301 AMBA3 Interconnect"), 140 BHND_CDESC(ARM, EROM, EROM, "PL366 Device Enumeration ROM"), 141 BHND_CDESC(ARM, OOB_ROUTER, OTHER, "PL367 OOB Interrupt Router"), 142 BHND_CDESC(ARM, AXI_UNMAPPED, OTHER, "Unmapped Address Ranges"), 143 144 BHND_CDESC(BCM, 4706_CC, CC, "ChipCommon I/O Controller"), 145 BHND_CDESC(BCM, NS_PCIE2, PCIE, "PCIe Bridge (Gen2)"), 146 BHND_CDESC(BCM, NS_DMA, OTHER, "DMA engine"), 147 BHND_CDESC(BCM, NS_SDIO, OTHER, "SDIO 3.0 Host Controller"), 148 BHND_CDESC(BCM, NS_USB20H, USB_HOST, "USB 2.0 Host Controller"), 149 BHND_CDESC(BCM, NS_USB30H, USB_HOST, "USB 3.0 Host Controller"), 150 BHND_CDESC(BCM, NS_A9JTAG, OTHER, "ARM Cortex A9 JTAG Interface"), 151 BHND_CDESC(BCM, NS_DDR23_MEMC, MEMC, "Denali DDR2/DD3 Memory Controller"), 152 BHND_CDESC(BCM, NS_ROM, NVRAM, "System ROM"), 153 BHND_CDESC(BCM, NS_NAND, NVRAM, "NAND Flash Controller"), 154 BHND_CDESC(BCM, NS_QSPI, NVRAM, "QSPI Flash Controller"), 155 BHND_CDESC(BCM, NS_CC_B, CC_B, "ChipCommon B Auxiliary I/O Controller"), 156 BHND_CDESC(BCM, 4706_SOCRAM, RAM, "Internal Memory"), 157 BHND_CDESC(BCM, IHOST_ARMCA9, CPU, "ARM Cortex A9 CPU"), 158 BHND_CDESC(BCM, 4706_GMAC_CMN, ENET, "Gigabit MAC (Common)"), 159 BHND_CDESC(BCM, 4706_GMAC, ENET_MAC, "Gigabit MAC"), 160 BHND_CDESC(BCM, AMEMC, MEMC, "Denali DDR1/DDR2 Memory Controller"), 161 #undef BHND_CDESC 162 163 /* Derived from inspection of the BCM4331 cores that provide PrimeCell 164 * IDs. Due to lack of documentation, the surmised device name/purpose 165 * provided here may be incorrect. */ 166 { BHND_MFGID_ARM, BHND_PRIMEID_EROM, BHND_DEVCLASS_OTHER, 167 "PL364 Device Enumeration ROM" }, 168 { BHND_MFGID_ARM, BHND_PRIMEID_SWRAP, BHND_DEVCLASS_OTHER, 169 "PL368 Device Management Interface" }, 170 { BHND_MFGID_ARM, BHND_PRIMEID_MWRAP, BHND_DEVCLASS_OTHER, 171 "PL369 Device Management Interface" }, 172 { 0, 0, 0, NULL } 173 }; 174 175 static const struct bhnd_device_quirk bhnd_chipc_clkctl_quirks[]; 176 static const struct bhnd_device_quirk bhnd_pcmcia_clkctl_quirks[]; 177 178 /** 179 * Device table entries for core-specific CLKCTL quirk lookup. 180 */ 181 static const struct bhnd_device bhnd_clkctl_devices[] = { 182 BHND_DEVICE(BCM, CC, NULL, bhnd_chipc_clkctl_quirks), 183 BHND_DEVICE(BCM, PCMCIA, NULL, bhnd_pcmcia_clkctl_quirks), 184 BHND_DEVICE_END, 185 }; 186 187 /** ChipCommon CLKCTL quirks */ 188 static const struct bhnd_device_quirk bhnd_chipc_clkctl_quirks[] = { 189 /* HTAVAIL/ALPAVAIL are bitswapped in chipc's CLKCTL */ 190 BHND_CHIP_QUIRK(4328, HWREV_ANY, BHND_CLKCTL_QUIRK_CCS0), 191 BHND_CHIP_QUIRK(5354, HWREV_ANY, BHND_CLKCTL_QUIRK_CCS0), 192 BHND_DEVICE_QUIRK_END 193 }; 194 195 /** PCMCIA CLKCTL quirks */ 196 static const struct bhnd_device_quirk bhnd_pcmcia_clkctl_quirks[] = { 197 /* HTAVAIL/ALPAVAIL are bitswapped in pcmcia's CLKCTL */ 198 BHND_CHIP_QUIRK(4328, HWREV_ANY, BHND_CLKCTL_QUIRK_CCS0), 199 BHND_CHIP_QUIRK(5354, HWREV_ANY, BHND_CLKCTL_QUIRK_CCS0), 200 BHND_DEVICE_QUIRK_END 201 }; 202 203 /** 204 * Return the name for a given JEP106 manufacturer ID. 205 * 206 * @param vendor A JEP106 Manufacturer ID, including the non-standard ARM 4-bit 207 * JEP106 continuation code. 208 */ 209 const char * 210 bhnd_vendor_name(uint16_t vendor) 211 { 212 switch (vendor) { 213 case BHND_MFGID_ARM: 214 return "ARM"; 215 case BHND_MFGID_BCM: 216 return "Broadcom"; 217 case BHND_MFGID_MIPS: 218 return "MIPS"; 219 default: 220 return "unknown"; 221 } 222 } 223 224 /** 225 * Return the name of a port type. 226 * 227 * @param port_type The port type to look up. 228 */ 229 const char * 230 bhnd_port_type_name(bhnd_port_type port_type) 231 { 232 switch (port_type) { 233 case BHND_PORT_DEVICE: 234 return ("device"); 235 case BHND_PORT_BRIDGE: 236 return ("bridge"); 237 case BHND_PORT_AGENT: 238 return ("agent"); 239 default: 240 return "unknown"; 241 } 242 } 243 244 /** 245 * Return the name of an NVRAM source. 246 * 247 * @param nvram_src The NVRAM source type to look up. 248 */ 249 const char * 250 bhnd_nvram_src_name(bhnd_nvram_src nvram_src) 251 { 252 switch (nvram_src) { 253 case BHND_NVRAM_SRC_FLASH: 254 return ("flash"); 255 case BHND_NVRAM_SRC_OTP: 256 return ("OTP"); 257 case BHND_NVRAM_SRC_SPROM: 258 return ("SPROM"); 259 case BHND_NVRAM_SRC_UNKNOWN: 260 return ("none"); 261 default: 262 return ("unknown"); 263 } 264 } 265 266 static const struct bhnd_core_desc * 267 bhnd_find_core_desc(uint16_t vendor, uint16_t device) 268 { 269 for (u_int i = 0; bhnd_core_descs[i].desc != NULL; i++) { 270 if (bhnd_core_descs[i].vendor != vendor) 271 continue; 272 273 if (bhnd_core_descs[i].device != device) 274 continue; 275 276 return (&bhnd_core_descs[i]); 277 } 278 279 return (NULL); 280 } 281 282 /** 283 * Return a human-readable name for a BHND core. 284 * 285 * @param vendor The core designer's JEDEC-106 Manufacturer ID. 286 * @param device The core identifier. 287 */ 288 const char * 289 bhnd_find_core_name(uint16_t vendor, uint16_t device) 290 { 291 const struct bhnd_core_desc *desc; 292 293 if ((desc = bhnd_find_core_desc(vendor, device)) == NULL) 294 return ("unknown"); 295 296 return desc->desc; 297 } 298 299 /** 300 * Return the device class for a BHND core. 301 * 302 * @param vendor The core designer's JEDEC-106 Manufacturer ID. 303 * @param device The core identifier. 304 */ 305 bhnd_devclass_t 306 bhnd_find_core_class(uint16_t vendor, uint16_t device) 307 { 308 const struct bhnd_core_desc *desc; 309 310 if ((desc = bhnd_find_core_desc(vendor, device)) == NULL) 311 return (BHND_DEVCLASS_OTHER); 312 313 return desc->class; 314 } 315 316 /** 317 * Return a human-readable name for a BHND core. 318 * 319 * @param ci The core's info record. 320 */ 321 const char * 322 bhnd_core_name(const struct bhnd_core_info *ci) 323 { 324 return bhnd_find_core_name(ci->vendor, ci->device); 325 } 326 327 /** 328 * Return the device class for a BHND core. 329 * 330 * @param ci The core's info record. 331 */ 332 bhnd_devclass_t 333 bhnd_core_class(const struct bhnd_core_info *ci) 334 { 335 return bhnd_find_core_class(ci->vendor, ci->device); 336 } 337 338 /** 339 * Write a human readable name representation of the given 340 * BHND_CHIPID_* constant to @p buffer. 341 * 342 * @param buffer Output buffer, or NULL to compute the required size. 343 * @param size Capacity of @p buffer, in bytes. 344 * @param chip_id Chip ID to be formatted. 345 * 346 * @return The required number of bytes on success, or a negative integer on 347 * failure. No more than @p size-1 characters be written, with the @p size'th 348 * set to '\0'. 349 * 350 * @sa BHND_CHIPID_MAX_NAMELEN 351 */ 352 int 353 bhnd_format_chip_id(char *buffer, size_t size, uint16_t chip_id) 354 { 355 /* All hex formatted IDs are within the range of 0x4000-0x9C3F (40000-1) */ 356 if (chip_id >= 0x4000 && chip_id <= 0x9C3F) 357 return (snprintf(buffer, size, "BCM%hX", chip_id)); 358 else 359 return (snprintf(buffer, size, "BCM%hu", chip_id)); 360 } 361 362 /** 363 * Return a core info record populated from a bhnd-attached @p dev. 364 * 365 * @param dev A bhnd device. 366 * 367 * @return A core info record for @p dev. 368 */ 369 struct bhnd_core_info 370 bhnd_get_core_info(device_t dev) { 371 return (struct bhnd_core_info) { 372 .vendor = bhnd_get_vendor(dev), 373 .device = bhnd_get_device(dev), 374 .hwrev = bhnd_get_hwrev(dev), 375 .core_idx = bhnd_get_core_index(dev), 376 .unit = bhnd_get_core_unit(dev) 377 }; 378 } 379 380 /** 381 * Find a @p class child device with @p unit on @p bus. 382 * 383 * @param bus The bhnd-compatible bus to be searched. 384 * @param class The device class to match on. 385 * @param unit The core unit number; specify -1 to return the first match 386 * regardless of unit number. 387 * 388 * @retval device_t if a matching child device is found. 389 * @retval NULL if no matching child device is found. 390 */ 391 device_t 392 bhnd_bus_find_child(device_t bus, bhnd_devclass_t class, int unit) 393 { 394 struct bhnd_core_match md = { 395 BHND_MATCH_CORE_CLASS(class), 396 BHND_MATCH_CORE_UNIT(unit) 397 }; 398 399 if (unit == -1) 400 md.m.match.core_unit = 0; 401 402 return bhnd_bus_match_child(bus, &md); 403 } 404 405 /** 406 * Find the first child device on @p bus that matches @p desc. 407 * 408 * @param bus The bhnd-compatible bus to be searched. 409 * @param desc A match descriptor. 410 * 411 * @retval device_t if a matching child device is found. 412 * @retval NULL if no matching child device is found. 413 */ 414 device_t 415 bhnd_bus_match_child(device_t bus, const struct bhnd_core_match *desc) 416 { 417 device_t *devlistp; 418 device_t match; 419 int devcnt; 420 int error; 421 422 error = device_get_children(bus, &devlistp, &devcnt); 423 if (error != 0) 424 return (NULL); 425 426 match = NULL; 427 for (int i = 0; i < devcnt; i++) { 428 struct bhnd_core_info ci = bhnd_get_core_info(devlistp[i]); 429 430 if (bhnd_core_matches(&ci, desc)) { 431 match = devlistp[i]; 432 goto done; 433 } 434 } 435 436 done: 437 free(devlistp, M_TEMP); 438 return match; 439 } 440 441 /** 442 * Retrieve an ordered list of all device instances currently connected to 443 * @p bus, returning a pointer to the array in @p devlistp and the count 444 * in @p ndevs. 445 * 446 * The memory allocated for the table must be freed via 447 * bhnd_bus_free_children(). 448 * 449 * @param bus The bhnd-compatible bus to be queried. 450 * @param[out] devlist The array of devices. 451 * @param[out] devcount The number of devices in @p devlistp 452 * @param order The order in which devices will be returned 453 * in @p devlist. 454 * 455 * @retval 0 success 456 * @retval non-zero if an error occurs, a regular unix error code will 457 * be returned. 458 */ 459 int 460 bhnd_bus_get_children(device_t bus, device_t **devlist, int *devcount, 461 bhnd_device_order order) 462 { 463 int error; 464 465 /* Fetch device array */ 466 if ((error = device_get_children(bus, devlist, devcount))) 467 return (error); 468 469 /* Perform requested sorting */ 470 if ((error = bhnd_sort_devices(*devlist, *devcount, order))) { 471 bhnd_bus_free_children(*devlist); 472 return (error); 473 } 474 475 return (0); 476 } 477 478 /** 479 * Free any memory allocated in a previous call to bhnd_bus_get_children(). 480 * 481 * @param devlist The device array returned by bhnd_bus_get_children(). 482 */ 483 void 484 bhnd_bus_free_children(device_t *devlist) 485 { 486 free(devlist, M_TEMP); 487 } 488 489 /** 490 * Perform in-place sorting of an array of bhnd device instances. 491 * 492 * @param devlist An array of bhnd devices. 493 * @param devcount The number of devices in @p devs. 494 * @param order The sort order to be used. 495 * 496 * @retval 0 success 497 * @retval EINVAL if the sort order is unknown. 498 */ 499 int 500 bhnd_sort_devices(device_t *devlist, size_t devcount, bhnd_device_order order) 501 { 502 int (*compare)(const void *, const void *); 503 504 switch (order) { 505 case BHND_DEVICE_ORDER_ATTACH: 506 compare = compare_ascending_probe_order; 507 break; 508 case BHND_DEVICE_ORDER_DETACH: 509 compare = compare_descending_probe_order; 510 break; 511 default: 512 printf("unknown sort order: %d\n", order); 513 return (EINVAL); 514 } 515 516 qsort(devlist, devcount, sizeof(*devlist), compare); 517 return (0); 518 } 519 520 /* 521 * Ascending comparison of bhnd device's probe order. 522 */ 523 static int 524 compare_ascending_probe_order(const void *lhs, const void *rhs) 525 { 526 device_t ldev, rdev; 527 int lorder, rorder; 528 529 ldev = (*(const device_t *) lhs); 530 rdev = (*(const device_t *) rhs); 531 532 lorder = BHND_BUS_GET_PROBE_ORDER(device_get_parent(ldev), ldev); 533 rorder = BHND_BUS_GET_PROBE_ORDER(device_get_parent(rdev), rdev); 534 535 if (lorder < rorder) { 536 return (-1); 537 } else if (lorder > rorder) { 538 return (1); 539 } else { 540 return (0); 541 } 542 } 543 544 /* 545 * Descending comparison of bhnd device's probe order. 546 */ 547 static int 548 compare_descending_probe_order(const void *lhs, const void *rhs) 549 { 550 return (compare_ascending_probe_order(rhs, lhs)); 551 } 552 553 /** 554 * Call device_probe_and_attach() for each of the bhnd bus device's 555 * children, in bhnd attach order. 556 * 557 * @param bus The bhnd-compatible bus for which all children should be probed 558 * and attached. 559 */ 560 int 561 bhnd_bus_probe_children(device_t bus) 562 { 563 device_t *devs; 564 int ndevs; 565 int error; 566 567 /* Fetch children in attach order */ 568 error = bhnd_bus_get_children(bus, &devs, &ndevs, 569 BHND_DEVICE_ORDER_ATTACH); 570 if (error) 571 return (error); 572 573 /* Probe and attach all children */ 574 for (int i = 0; i < ndevs; i++) { 575 device_t child = devs[i]; 576 device_probe_and_attach(child); 577 } 578 579 bhnd_bus_free_children(devs); 580 581 return (0); 582 } 583 584 /** 585 * Walk up the bhnd device hierarchy to locate the root device 586 * to which the bhndb bridge is attached. 587 * 588 * This can be used from within bhnd host bridge drivers to locate the 589 * actual upstream host device. 590 * 591 * @param dev A bhnd device. 592 * @param bus_class The expected bus (e.g. "pci") to which the bridge root 593 * should be attached. 594 * 595 * @retval device_t if a matching parent device is found. 596 * @retval NULL if @p dev is not attached via a bhndb bus. 597 * @retval NULL if no parent device is attached via @p bus_class. 598 */ 599 device_t 600 bhnd_find_bridge_root(device_t dev, devclass_t bus_class) 601 { 602 devclass_t bhndb_class; 603 device_t parent; 604 605 KASSERT(device_get_devclass(device_get_parent(dev)) == 606 devclass_find("bhnd"), 607 ("%s not a bhnd device", device_get_nameunit(dev))); 608 609 bhndb_class = devclass_find("bhndb"); 610 611 /* Walk the device tree until we hit a bridge */ 612 parent = dev; 613 while ((parent = device_get_parent(parent)) != NULL) { 614 if (device_get_devclass(parent) == bhndb_class) 615 break; 616 } 617 618 /* No bridge? */ 619 if (parent == NULL) 620 return (NULL); 621 622 /* Search for a parent attached to the expected bus class */ 623 while ((parent = device_get_parent(parent)) != NULL) { 624 device_t bus; 625 626 bus = device_get_parent(parent); 627 if (bus != NULL && device_get_devclass(bus) == bus_class) 628 return (parent); 629 } 630 631 /* Not found */ 632 return (NULL); 633 } 634 635 /** 636 * Find the first core in @p cores that matches @p desc. 637 * 638 * @param cores The table to search. 639 * @param num_cores The length of @p cores. 640 * @param desc A match descriptor. 641 * 642 * @retval bhnd_core_info if a matching core is found. 643 * @retval NULL if no matching core is found. 644 */ 645 const struct bhnd_core_info * 646 bhnd_match_core(const struct bhnd_core_info *cores, u_int num_cores, 647 const struct bhnd_core_match *desc) 648 { 649 for (u_int i = 0; i < num_cores; i++) { 650 if (bhnd_core_matches(&cores[i], desc)) 651 return &cores[i]; 652 } 653 654 return (NULL); 655 } 656 657 /** 658 * Find the first core in @p cores with the given @p class. 659 * 660 * @param cores The table to search. 661 * @param num_cores The length of @p cores. 662 * @param class The device class to match on. 663 * 664 * @retval non-NULL if a matching core is found. 665 * @retval NULL if no matching core is found. 666 */ 667 const struct bhnd_core_info * 668 bhnd_find_core(const struct bhnd_core_info *cores, u_int num_cores, 669 bhnd_devclass_t class) 670 { 671 struct bhnd_core_match md = { 672 BHND_MATCH_CORE_CLASS(class) 673 }; 674 675 return bhnd_match_core(cores, num_cores, &md); 676 } 677 678 /** 679 * Create an equality match descriptor for @p core. 680 * 681 * @param core The core info to be matched on. 682 * 683 * @return an equality match descriptor for @p core. 684 */ 685 struct bhnd_core_match 686 bhnd_core_get_match_desc(const struct bhnd_core_info *core) 687 { 688 return ((struct bhnd_core_match) { 689 BHND_MATCH_CORE_VENDOR(core->vendor), 690 BHND_MATCH_CORE_ID(core->device), 691 BHND_MATCH_CORE_REV(HWREV_EQ(core->hwrev)), 692 BHND_MATCH_CORE_CLASS(bhnd_core_class(core)), 693 BHND_MATCH_CORE_IDX(core->core_idx), 694 BHND_MATCH_CORE_UNIT(core->unit) 695 }); 696 } 697 698 /** 699 * Return true if the @p lhs is equal to @p rhs. 700 * 701 * @param lhs The first bhnd core descriptor to compare. 702 * @param rhs The second bhnd core descriptor to compare. 703 * 704 * @retval true if @p lhs is equal to @p rhs 705 * @retval false if @p lhs is not equal to @p rhs 706 */ 707 bool 708 bhnd_cores_equal(const struct bhnd_core_info *lhs, 709 const struct bhnd_core_info *rhs) 710 { 711 struct bhnd_core_match md; 712 713 /* Use an equality match descriptor to perform the comparison */ 714 md = bhnd_core_get_match_desc(rhs); 715 return (bhnd_core_matches(lhs, &md)); 716 } 717 718 /** 719 * Return true if the @p core matches @p desc. 720 * 721 * @param core A bhnd core descriptor. 722 * @param desc A match descriptor to compare against @p core. 723 * 724 * @retval true if @p core matches @p match. 725 * @retval false if @p core does not match @p match. 726 */ 727 bool 728 bhnd_core_matches(const struct bhnd_core_info *core, 729 const struct bhnd_core_match *desc) 730 { 731 if (desc->m.match.core_vendor && desc->core_vendor != core->vendor) 732 return (false); 733 734 if (desc->m.match.core_id && desc->core_id != core->device) 735 return (false); 736 737 if (desc->m.match.core_unit && desc->core_unit != core->unit) 738 return (false); 739 740 if (desc->m.match.core_rev && 741 !bhnd_hwrev_matches(core->hwrev, &desc->core_rev)) 742 return (false); 743 744 if (desc->m.match.core_idx && desc->core_idx != core->core_idx) 745 return (false); 746 747 if (desc->m.match.core_class && 748 desc->core_class != bhnd_core_class(core)) 749 return (false); 750 751 return true; 752 } 753 754 /** 755 * Return true if the @p chip matches @p desc. 756 * 757 * @param chip A bhnd chip identifier. 758 * @param desc A match descriptor to compare against @p chip. 759 * 760 * @retval true if @p chip matches @p match. 761 * @retval false if @p chip does not match @p match. 762 */ 763 bool 764 bhnd_chip_matches(const struct bhnd_chipid *chip, 765 const struct bhnd_chip_match *desc) 766 { 767 if (desc->m.match.chip_id && chip->chip_id != desc->chip_id) 768 return (false); 769 770 if (desc->m.match.chip_pkg && chip->chip_pkg != desc->chip_pkg) 771 return (false); 772 773 if (desc->m.match.chip_rev && 774 !bhnd_hwrev_matches(chip->chip_rev, &desc->chip_rev)) 775 return (false); 776 777 if (desc->m.match.chip_type && chip->chip_type != desc->chip_type) 778 return (false); 779 780 return (true); 781 } 782 783 /** 784 * Return true if the @p board matches @p desc. 785 * 786 * @param board The bhnd board info. 787 * @param desc A match descriptor to compare against @p board. 788 * 789 * @retval true if @p chip matches @p match. 790 * @retval false if @p chip does not match @p match. 791 */ 792 bool 793 bhnd_board_matches(const struct bhnd_board_info *board, 794 const struct bhnd_board_match *desc) 795 { 796 if (desc->m.match.board_srom_rev && 797 !bhnd_hwrev_matches(board->board_srom_rev, &desc->board_srom_rev)) 798 return (false); 799 800 if (desc->m.match.board_vendor && 801 board->board_vendor != desc->board_vendor) 802 return (false); 803 804 if (desc->m.match.board_type && board->board_type != desc->board_type) 805 return (false); 806 807 if (desc->m.match.board_devid && 808 board->board_devid != desc->board_devid) 809 return (false); 810 811 if (desc->m.match.board_rev && 812 !bhnd_hwrev_matches(board->board_rev, &desc->board_rev)) 813 return (false); 814 815 return (true); 816 } 817 818 /** 819 * Return true if the @p hwrev matches @p desc. 820 * 821 * @param hwrev A bhnd hardware revision. 822 * @param desc A match descriptor to compare against @p core. 823 * 824 * @retval true if @p hwrev matches @p match. 825 * @retval false if @p hwrev does not match @p match. 826 */ 827 bool 828 bhnd_hwrev_matches(uint16_t hwrev, const struct bhnd_hwrev_match *desc) 829 { 830 if (desc->start != BHND_HWREV_INVALID && 831 desc->start > hwrev) 832 return false; 833 834 if (desc->end != BHND_HWREV_INVALID && 835 desc->end < hwrev) 836 return false; 837 838 return true; 839 } 840 841 /** 842 * Return true if the @p dev matches @p desc. 843 * 844 * @param dev A bhnd device. 845 * @param desc A match descriptor to compare against @p dev. 846 * 847 * @retval true if @p dev matches @p match. 848 * @retval false if @p dev does not match @p match. 849 */ 850 bool 851 bhnd_device_matches(device_t dev, const struct bhnd_device_match *desc) 852 { 853 struct bhnd_core_info core; 854 const struct bhnd_chipid *chip; 855 struct bhnd_board_info board; 856 device_t parent; 857 int error; 858 859 /* Construct individual match descriptors */ 860 struct bhnd_core_match m_core = { _BHND_CORE_MATCH_COPY(desc) }; 861 struct bhnd_chip_match m_chip = { _BHND_CHIP_MATCH_COPY(desc) }; 862 struct bhnd_board_match m_board = { _BHND_BOARD_MATCH_COPY(desc) }; 863 864 /* Fetch and match core info */ 865 if (m_core.m.match_flags) { 866 /* Only applicable to bhnd-attached cores */ 867 parent = device_get_parent(dev); 868 if (device_get_devclass(parent) != devclass_find("bhnd")) { 869 device_printf(dev, "attempting to match core " 870 "attributes against non-core device\n"); 871 return (false); 872 } 873 874 core = bhnd_get_core_info(dev); 875 if (!bhnd_core_matches(&core, &m_core)) 876 return (false); 877 } 878 879 /* Fetch and match chip info */ 880 if (m_chip.m.match_flags) { 881 chip = bhnd_get_chipid(dev); 882 883 if (!bhnd_chip_matches(chip, &m_chip)) 884 return (false); 885 } 886 887 /* Fetch and match board info. 888 * 889 * This is not available until after NVRAM is up; earlier device 890 * matches should not include board requirements */ 891 if (m_board.m.match_flags) { 892 if ((error = bhnd_read_board_info(dev, &board))) { 893 device_printf(dev, "failed to read required board info " 894 "during device matching: %d\n", error); 895 return (false); 896 } 897 898 if (!bhnd_board_matches(&board, &m_board)) 899 return (false); 900 } 901 902 /* All matched */ 903 return (true); 904 } 905 906 /** 907 * Search @p table for an entry matching @p dev. 908 * 909 * @param dev A bhnd device to match against @p table. 910 * @param table The device table to search. 911 * @param entry_size The @p table entry size, in bytes. 912 * 913 * @retval non-NULL the first matching device, if any. 914 * @retval NULL if no matching device is found in @p table. 915 */ 916 const struct bhnd_device * 917 bhnd_device_lookup(device_t dev, const struct bhnd_device *table, 918 size_t entry_size) 919 { 920 const struct bhnd_device *entry; 921 device_t hostb, parent; 922 bhnd_attach_type attach_type; 923 uint32_t dflags; 924 925 parent = device_get_parent(dev); 926 hostb = bhnd_bus_find_hostb_device(parent); 927 attach_type = bhnd_get_attach_type(dev); 928 929 for (entry = table; !BHND_DEVICE_IS_END(entry); entry = 930 (const struct bhnd_device *) ((const char *) entry + entry_size)) 931 { 932 /* match core info */ 933 if (!bhnd_device_matches(dev, &entry->core)) 934 continue; 935 936 /* match device flags */ 937 dflags = entry->device_flags; 938 939 /* hostb implies BHND_ATTACH_ADAPTER requirement */ 940 if (dflags & BHND_DF_HOSTB) 941 dflags |= BHND_DF_ADAPTER; 942 943 if (dflags & BHND_DF_ADAPTER) 944 if (attach_type != BHND_ATTACH_ADAPTER) 945 continue; 946 947 if (dflags & BHND_DF_HOSTB) 948 if (dev != hostb) 949 continue; 950 951 if (dflags & BHND_DF_SOC) 952 if (attach_type != BHND_ATTACH_NATIVE) 953 continue; 954 955 /* device found */ 956 return (entry); 957 } 958 959 /* not found */ 960 return (NULL); 961 } 962 963 /** 964 * Scan the device @p table for all quirk flags applicable to @p dev. 965 * 966 * @param dev A bhnd device to match against @p table. 967 * @param table The device table to search. 968 * @param entry_size The @p table entry size, in bytes. 969 * 970 * @return all matching quirk flags. 971 */ 972 uint32_t 973 bhnd_device_quirks(device_t dev, const struct bhnd_device *table, 974 size_t entry_size) 975 { 976 const struct bhnd_device *dent; 977 const struct bhnd_device_quirk *qent, *qtable; 978 uint32_t quirks; 979 980 /* Locate the device entry */ 981 if ((dent = bhnd_device_lookup(dev, table, entry_size)) == NULL) 982 return (0); 983 984 /* Quirks table is optional */ 985 qtable = dent->quirks_table; 986 if (qtable == NULL) 987 return (0); 988 989 /* Collect matching device quirk entries */ 990 quirks = 0; 991 for (qent = qtable; !BHND_DEVICE_QUIRK_IS_END(qent); qent++) { 992 if (bhnd_device_matches(dev, &qent->desc)) 993 quirks |= qent->quirks; 994 } 995 996 return (quirks); 997 } 998 999 /** 1000 * Allocate bhnd(4) resources defined in @p rs from a parent bus. 1001 * 1002 * @param dev The device requesting ownership of the resources. 1003 * @param rs A standard bus resource specification. This will be updated 1004 * with the allocated resource's RIDs. 1005 * @param res On success, the allocated bhnd resources. 1006 * 1007 * @retval 0 success 1008 * @retval non-zero if allocation of any non-RF_OPTIONAL resource fails, 1009 * all allocated resources will be released and a regular 1010 * unix error code will be returned. 1011 */ 1012 int 1013 bhnd_alloc_resources(device_t dev, struct resource_spec *rs, 1014 struct bhnd_resource **res) 1015 { 1016 /* Initialize output array */ 1017 for (u_int i = 0; rs[i].type != -1; i++) 1018 res[i] = NULL; 1019 1020 for (u_int i = 0; rs[i].type != -1; i++) { 1021 res[i] = bhnd_alloc_resource_any(dev, rs[i].type, &rs[i].rid, 1022 rs[i].flags); 1023 1024 /* Clean up all allocations on failure */ 1025 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) { 1026 bhnd_release_resources(dev, rs, res); 1027 return (ENXIO); 1028 } 1029 } 1030 1031 return (0); 1032 } 1033 1034 /** 1035 * Release bhnd(4) resources defined in @p rs from a parent bus. 1036 * 1037 * @param dev The device that owns the resources. 1038 * @param rs A standard bus resource specification previously initialized 1039 * by @p bhnd_alloc_resources. 1040 * @param res The bhnd resources to be released. 1041 */ 1042 void 1043 bhnd_release_resources(device_t dev, const struct resource_spec *rs, 1044 struct bhnd_resource **res) 1045 { 1046 for (u_int i = 0; rs[i].type != -1; i++) { 1047 if (res[i] == NULL) 1048 continue; 1049 1050 bhnd_release_resource(dev, rs[i].type, rs[i].rid, res[i]); 1051 res[i] = NULL; 1052 } 1053 } 1054 1055 /** 1056 * Allocate and return a new per-core PMU clock control/status (clkctl) 1057 * instance for @p dev. 1058 * 1059 * @param dev The bhnd(4) core device mapped by @p r. 1060 * @param pmu_dev The bhnd(4) PMU device, implmenting the bhnd_pmu_if 1061 * interface. The caller is responsible for ensuring that 1062 * this reference remains valid for the lifetime of the 1063 * returned clkctl instance. 1064 * @param r A resource mapping the core's clock control register 1065 * (see BHND_CLK_CTL_ST). The caller is responsible for 1066 * ensuring that this resource remains valid for the 1067 * lifetime of the returned clkctl instance. 1068 * @param offset The offset to the clock control register within @p r. 1069 * @param max_latency The PMU's maximum state transition latency in 1070 * microseconds; this upper bound will be used to busy-wait 1071 * on PMU state transitions. 1072 * 1073 * @retval non-NULL success 1074 * @retval NULL if allocation fails. 1075 * 1076 */ 1077 struct bhnd_core_clkctl * 1078 bhnd_alloc_core_clkctl(device_t dev, device_t pmu_dev, struct bhnd_resource *r, 1079 bus_size_t offset, u_int max_latency) 1080 { 1081 struct bhnd_core_clkctl *clkctl; 1082 1083 clkctl = malloc(sizeof(*clkctl), M_BHND, M_ZERO | M_NOWAIT); 1084 if (clkctl == NULL) 1085 return (NULL); 1086 1087 clkctl->cc_dev = dev; 1088 clkctl->cc_pmu_dev = pmu_dev; 1089 clkctl->cc_res = r; 1090 clkctl->cc_res_offset = offset; 1091 clkctl->cc_max_latency = max_latency; 1092 clkctl->cc_quirks = bhnd_device_quirks(dev, bhnd_clkctl_devices, 1093 sizeof(bhnd_clkctl_devices[0])); 1094 1095 BHND_CLKCTL_LOCK_INIT(clkctl); 1096 1097 return (clkctl); 1098 } 1099 1100 /** 1101 * Free a clkctl instance previously allocated via bhnd_alloc_core_clkctl(). 1102 * 1103 * @param clkctl The clkctl instance to be freed. 1104 */ 1105 void 1106 bhnd_free_core_clkctl(struct bhnd_core_clkctl *clkctl) 1107 { 1108 BHND_CLKCTL_LOCK_DESTROY(clkctl); 1109 1110 free(clkctl, M_BHND); 1111 } 1112 1113 /** 1114 * Wait for the per-core clock status to be equal to @p value after 1115 * applying @p mask, timing out after the maximum transition latency is reached. 1116 * 1117 * @param clkctl Per-core clkctl state to be queryied. 1118 * @param value Value to wait for. 1119 * @param mask Mask to apply prior to value comparison. 1120 * 1121 * @retval 0 success 1122 * @retval ETIMEDOUT if the PMU's maximum transition delay is reached before 1123 * the clock status matches @p value and @p mask. 1124 */ 1125 int 1126 bhnd_core_clkctl_wait(struct bhnd_core_clkctl *clkctl, uint32_t value, 1127 uint32_t mask) 1128 { 1129 uint32_t clkst; 1130 1131 BHND_CLKCTL_LOCK_ASSERT(clkctl, MA_OWNED); 1132 1133 /* Bitswapped HTAVAIL/ALPAVAIL work-around */ 1134 if (clkctl->cc_quirks & BHND_CLKCTL_QUIRK_CCS0) { 1135 uint32_t fmask, fval; 1136 1137 fmask = mask & ~(BHND_CCS_HTAVAIL | BHND_CCS_ALPAVAIL); 1138 fval = value & ~(BHND_CCS_HTAVAIL | BHND_CCS_ALPAVAIL); 1139 1140 if (mask & BHND_CCS_HTAVAIL) 1141 fmask |= BHND_CCS0_HTAVAIL; 1142 if (value & BHND_CCS_HTAVAIL) 1143 fval |= BHND_CCS0_HTAVAIL; 1144 1145 if (mask & BHND_CCS_ALPAVAIL) 1146 fmask |= BHND_CCS0_ALPAVAIL; 1147 if (value & BHND_CCS_ALPAVAIL) 1148 fval |= BHND_CCS0_ALPAVAIL; 1149 1150 mask = fmask; 1151 value = fval; 1152 } 1153 1154 for (u_int i = 0; i < clkctl->cc_max_latency; i += 10) { 1155 clkst = bhnd_bus_read_4(clkctl->cc_res, clkctl->cc_res_offset); 1156 if ((clkst & mask) == (value & mask)) 1157 return (0); 1158 1159 DELAY(10); 1160 } 1161 1162 device_printf(clkctl->cc_dev, "clkst wait timeout (value=%#x, " 1163 "mask=%#x)\n", value, mask); 1164 1165 return (ETIMEDOUT); 1166 } 1167 1168 /** 1169 * Read an NVRAM variable's NUL-terminated string value. 1170 * 1171 * @param dev A bhnd bus child device. 1172 * @param name The NVRAM variable name. 1173 * @param[out] buf A buffer large enough to hold @p len bytes. On 1174 * success, the NUL-terminated string value will be 1175 * written to this buffer. This argment may be NULL if 1176 * the value is not desired. 1177 * @param len The maximum capacity of @p buf. 1178 * @param[out] rlen On success, will be set to the actual size of 1179 * the requested value (including NUL termination). This 1180 * argment may be NULL if the size is not desired. 1181 * 1182 * @retval 0 success 1183 * @retval ENOENT The requested variable was not found. 1184 * @retval ENODEV No valid NVRAM source could be found. 1185 * @retval ENOMEM If @p buf is non-NULL and a buffer of @p len is too 1186 * small to hold the requested value. 1187 * @retval EFTYPE If the variable data cannot be coerced to a valid 1188 * string representation. 1189 * @retval ERANGE If value coercion would overflow @p type. 1190 * @retval non-zero If reading @p name otherwise fails, a regular unix 1191 * error code will be returned. 1192 */ 1193 int 1194 bhnd_nvram_getvar_str(device_t dev, const char *name, char *buf, size_t len, 1195 size_t *rlen) 1196 { 1197 size_t larg; 1198 int error; 1199 1200 larg = len; 1201 error = bhnd_nvram_getvar(dev, name, buf, &larg, 1202 BHND_NVRAM_TYPE_STRING); 1203 if (rlen != NULL) 1204 *rlen = larg; 1205 1206 return (error); 1207 } 1208 1209 /** 1210 * Read an NVRAM variable's unsigned integer value. 1211 * 1212 * @param dev A bhnd bus child device. 1213 * @param name The NVRAM variable name. 1214 * @param[out] value On success, the requested value will be written 1215 * to this pointer. 1216 * @param width The output integer type width (1, 2, or 1217 * 4 bytes). 1218 * 1219 * @retval 0 success 1220 * @retval ENOENT The requested variable was not found. 1221 * @retval ENODEV No valid NVRAM source could be found. 1222 * @retval EFTYPE If the variable data cannot be coerced to a 1223 * a valid unsigned integer representation. 1224 * @retval ERANGE If value coercion would overflow (or underflow) an 1225 * unsigned representation of the given @p width. 1226 * @retval non-zero If reading @p name otherwise fails, a regular unix 1227 * error code will be returned. 1228 */ 1229 int 1230 bhnd_nvram_getvar_uint(device_t dev, const char *name, void *value, int width) 1231 { 1232 bhnd_nvram_type type; 1233 size_t len; 1234 1235 switch (width) { 1236 case 1: 1237 type = BHND_NVRAM_TYPE_UINT8; 1238 break; 1239 case 2: 1240 type = BHND_NVRAM_TYPE_UINT16; 1241 break; 1242 case 4: 1243 type = BHND_NVRAM_TYPE_UINT32; 1244 break; 1245 default: 1246 device_printf(dev, "unsupported NVRAM integer width: %d\n", 1247 width); 1248 return (EINVAL); 1249 } 1250 1251 len = width; 1252 return (bhnd_nvram_getvar(dev, name, value, &len, type)); 1253 } 1254 1255 /** 1256 * Read an NVRAM variable's unsigned 8-bit integer value. 1257 * 1258 * @param dev A bhnd bus child device. 1259 * @param name The NVRAM variable name. 1260 * @param[out] value On success, the requested value will be written 1261 * to this pointer. 1262 * 1263 * @retval 0 success 1264 * @retval ENOENT The requested variable was not found. 1265 * @retval ENODEV No valid NVRAM source could be found. 1266 * @retval EFTYPE If the variable data cannot be coerced to a 1267 * a valid unsigned integer representation. 1268 * @retval ERANGE If value coercion would overflow (or underflow) uint8_t. 1269 * @retval non-zero If reading @p name otherwise fails, a regular unix 1270 * error code will be returned. 1271 */ 1272 int 1273 bhnd_nvram_getvar_uint8(device_t dev, const char *name, uint8_t *value) 1274 { 1275 return (bhnd_nvram_getvar_uint(dev, name, value, sizeof(*value))); 1276 } 1277 1278 /** 1279 * Read an NVRAM variable's unsigned 16-bit integer value. 1280 * 1281 * @param dev A bhnd bus child device. 1282 * @param name The NVRAM variable name. 1283 * @param[out] value On success, the requested value will be written 1284 * to this pointer. 1285 * 1286 * @retval 0 success 1287 * @retval ENOENT The requested variable was not found. 1288 * @retval ENODEV No valid NVRAM source could be found. 1289 * @retval EFTYPE If the variable data cannot be coerced to a 1290 * a valid unsigned integer representation. 1291 * @retval ERANGE If value coercion would overflow (or underflow) 1292 * uint16_t. 1293 * @retval non-zero If reading @p name otherwise fails, a regular unix 1294 * error code will be returned. 1295 */ 1296 int 1297 bhnd_nvram_getvar_uint16(device_t dev, const char *name, uint16_t *value) 1298 { 1299 return (bhnd_nvram_getvar_uint(dev, name, value, sizeof(*value))); 1300 } 1301 1302 /** 1303 * Read an NVRAM variable's unsigned 32-bit integer value. 1304 * 1305 * @param dev A bhnd bus child device. 1306 * @param name The NVRAM variable name. 1307 * @param[out] value On success, the requested value will be written 1308 * to this pointer. 1309 * 1310 * @retval 0 success 1311 * @retval ENOENT The requested variable was not found. 1312 * @retval ENODEV No valid NVRAM source could be found. 1313 * @retval EFTYPE If the variable data cannot be coerced to a 1314 * a valid unsigned integer representation. 1315 * @retval ERANGE If value coercion would overflow (or underflow) 1316 * uint32_t. 1317 * @retval non-zero If reading @p name otherwise fails, a regular unix 1318 * error code will be returned. 1319 */ 1320 int 1321 bhnd_nvram_getvar_uint32(device_t dev, const char *name, uint32_t *value) 1322 { 1323 return (bhnd_nvram_getvar_uint(dev, name, value, sizeof(*value))); 1324 } 1325 1326 /** 1327 * Read an NVRAM variable's signed integer value. 1328 * 1329 * @param dev A bhnd bus child device. 1330 * @param name The NVRAM variable name. 1331 * @param[out] value On success, the requested value will be written 1332 * to this pointer. 1333 * @param width The output integer type width (1, 2, or 1334 * 4 bytes). 1335 * 1336 * @retval 0 success 1337 * @retval ENOENT The requested variable was not found. 1338 * @retval ENODEV No valid NVRAM source could be found. 1339 * @retval EFTYPE If the variable data cannot be coerced to a 1340 * a valid integer representation. 1341 * @retval ERANGE If value coercion would overflow (or underflow) an 1342 * signed representation of the given @p width. 1343 * @retval non-zero If reading @p name otherwise fails, a regular unix 1344 * error code will be returned. 1345 */ 1346 int 1347 bhnd_nvram_getvar_int(device_t dev, const char *name, void *value, int width) 1348 { 1349 bhnd_nvram_type type; 1350 size_t len; 1351 1352 switch (width) { 1353 case 1: 1354 type = BHND_NVRAM_TYPE_INT8; 1355 break; 1356 case 2: 1357 type = BHND_NVRAM_TYPE_INT16; 1358 break; 1359 case 4: 1360 type = BHND_NVRAM_TYPE_INT32; 1361 break; 1362 default: 1363 device_printf(dev, "unsupported NVRAM integer width: %d\n", 1364 width); 1365 return (EINVAL); 1366 } 1367 1368 len = width; 1369 return (bhnd_nvram_getvar(dev, name, value, &len, type)); 1370 } 1371 1372 /** 1373 * Read an NVRAM variable's signed 8-bit integer value. 1374 * 1375 * @param dev A bhnd bus child device. 1376 * @param name The NVRAM variable name. 1377 * @param[out] value On success, the requested value will be written 1378 * to this pointer. 1379 * 1380 * @retval 0 success 1381 * @retval ENOENT The requested variable was not found. 1382 * @retval ENODEV No valid NVRAM source could be found. 1383 * @retval EFTYPE If the variable data cannot be coerced to a 1384 * a valid integer representation. 1385 * @retval ERANGE If value coercion would overflow (or underflow) int8_t. 1386 * @retval non-zero If reading @p name otherwise fails, a regular unix 1387 * error code will be returned. 1388 */ 1389 int 1390 bhnd_nvram_getvar_int8(device_t dev, const char *name, int8_t *value) 1391 { 1392 return (bhnd_nvram_getvar_int(dev, name, value, sizeof(*value))); 1393 } 1394 1395 /** 1396 * Read an NVRAM variable's signed 16-bit integer value. 1397 * 1398 * @param dev A bhnd bus child device. 1399 * @param name The NVRAM variable name. 1400 * @param[out] value On success, the requested value will be written 1401 * to this pointer. 1402 * 1403 * @retval 0 success 1404 * @retval ENOENT The requested variable was not found. 1405 * @retval ENODEV No valid NVRAM source could be found. 1406 * @retval EFTYPE If the variable data cannot be coerced to a 1407 * a valid integer representation. 1408 * @retval ERANGE If value coercion would overflow (or underflow) 1409 * int16_t. 1410 * @retval non-zero If reading @p name otherwise fails, a regular unix 1411 * error code will be returned. 1412 */ 1413 int 1414 bhnd_nvram_getvar_int16(device_t dev, const char *name, int16_t *value) 1415 { 1416 return (bhnd_nvram_getvar_int(dev, name, value, sizeof(*value))); 1417 } 1418 1419 /** 1420 * Read an NVRAM variable's signed 32-bit integer value. 1421 * 1422 * @param dev A bhnd bus child device. 1423 * @param name The NVRAM variable name. 1424 * @param[out] value On success, the requested value will be written 1425 * to this pointer. 1426 * 1427 * @retval 0 success 1428 * @retval ENOENT The requested variable was not found. 1429 * @retval ENODEV No valid NVRAM source could be found. 1430 * @retval EFTYPE If the variable data cannot be coerced to a 1431 * a valid integer representation. 1432 * @retval ERANGE If value coercion would overflow (or underflow) 1433 * int32_t. 1434 * @retval non-zero If reading @p name otherwise fails, a regular unix 1435 * error code will be returned. 1436 */ 1437 int 1438 bhnd_nvram_getvar_int32(device_t dev, const char *name, int32_t *value) 1439 { 1440 return (bhnd_nvram_getvar_int(dev, name, value, sizeof(*value))); 1441 } 1442 1443 /** 1444 * Read an NVRAM variable's array value. 1445 * 1446 * @param dev A bhnd bus child device. 1447 * @param name The NVRAM variable name. 1448 * @param[out] buf A buffer large enough to hold @p size bytes. 1449 * On success, the requested value will be written 1450 * to this buffer. 1451 * @param[in,out] size The required number of bytes to write to 1452 * @p buf. 1453 * @param type The desired array element data representation. 1454 * 1455 * @retval 0 success 1456 * @retval ENOENT The requested variable was not found. 1457 * @retval ENODEV No valid NVRAM source could be found. 1458 * @retval ENXIO If less than @p size bytes are available. 1459 * @retval ENOMEM If a buffer of @p size is too small to hold the 1460 * requested value. 1461 * @retval EFTYPE If the variable data cannot be coerced to a 1462 * a valid instance of @p type. 1463 * @retval ERANGE If value coercion would overflow (or underflow) a 1464 * representation of @p type. 1465 * @retval non-zero If reading @p name otherwise fails, a regular unix 1466 * error code will be returned. 1467 */ 1468 int 1469 bhnd_nvram_getvar_array(device_t dev, const char *name, void *buf, size_t size, 1470 bhnd_nvram_type type) 1471 { 1472 size_t nbytes; 1473 int error; 1474 1475 /* Attempt read */ 1476 nbytes = size; 1477 if ((error = bhnd_nvram_getvar(dev, name, buf, &nbytes, type))) 1478 return (error); 1479 1480 /* Verify that the expected number of bytes were fetched */ 1481 if (nbytes < size) 1482 return (ENXIO); 1483 1484 return (0); 1485 } 1486 1487 /** 1488 * Initialize a service provider registry. 1489 * 1490 * @param bsr The service registry to initialize. 1491 * 1492 * @retval 0 success 1493 * @retval non-zero if an error occurs initializing the service registry, 1494 * a regular unix error code will be returned. 1495 1496 */ 1497 int 1498 bhnd_service_registry_init(struct bhnd_service_registry *bsr) 1499 { 1500 STAILQ_INIT(&bsr->entries); 1501 mtx_init(&bsr->lock, "bhnd_service_registry lock", NULL, MTX_DEF); 1502 1503 return (0); 1504 } 1505 1506 /** 1507 * Release all resources held by @p bsr. 1508 * 1509 * @param bsr A service registry instance previously successfully 1510 * initialized via bhnd_service_registry_init(). 1511 * 1512 * @retval 0 success 1513 * @retval EBUSY if active references to service providers registered 1514 * with @p bsr exist. 1515 */ 1516 int 1517 bhnd_service_registry_fini(struct bhnd_service_registry *bsr) 1518 { 1519 struct bhnd_service_entry *entry, *enext; 1520 1521 /* Remove everthing we can */ 1522 mtx_lock(&bsr->lock); 1523 STAILQ_FOREACH_SAFE(entry, &bsr->entries, link, enext) { 1524 if (entry->refs > 0) 1525 continue; 1526 1527 STAILQ_REMOVE(&bsr->entries, entry, bhnd_service_entry, link); 1528 free(entry, M_BHND); 1529 } 1530 1531 if (!STAILQ_EMPTY(&bsr->entries)) { 1532 mtx_unlock(&bsr->lock); 1533 return (EBUSY); 1534 } 1535 mtx_unlock(&bsr->lock); 1536 1537 mtx_destroy(&bsr->lock); 1538 return (0); 1539 } 1540 1541 /** 1542 * Register a @p provider for the given @p service. 1543 * 1544 * @param bsr Service registry to be modified. 1545 * @param provider Service provider to register. 1546 * @param service Service for which @p provider will be registered. 1547 * @param flags Service provider flags (see BHND_SPF_*). 1548 * 1549 * @retval 0 success 1550 * @retval EEXIST if an entry for @p service already exists. 1551 * @retval EINVAL if @p service is BHND_SERVICE_ANY. 1552 * @retval non-zero if registering @p provider otherwise fails, a regular 1553 * unix error code will be returned. 1554 */ 1555 int 1556 bhnd_service_registry_add(struct bhnd_service_registry *bsr, device_t provider, 1557 bhnd_service_t service, uint32_t flags) 1558 { 1559 struct bhnd_service_entry *entry; 1560 1561 if (service == BHND_SERVICE_ANY) 1562 return (EINVAL); 1563 1564 mtx_lock(&bsr->lock); 1565 1566 /* Is a service provider already registered? */ 1567 STAILQ_FOREACH(entry, &bsr->entries, link) { 1568 if (entry->service == service) { 1569 mtx_unlock(&bsr->lock); 1570 return (EEXIST); 1571 } 1572 } 1573 1574 /* Initialize and insert our new entry */ 1575 entry = malloc(sizeof(*entry), M_BHND, M_NOWAIT); 1576 if (entry == NULL) { 1577 mtx_unlock(&bsr->lock); 1578 return (ENOMEM); 1579 } 1580 1581 entry->provider = provider; 1582 entry->service = service; 1583 entry->flags = flags; 1584 refcount_init(&entry->refs, 0); 1585 1586 STAILQ_INSERT_HEAD(&bsr->entries, entry, link); 1587 1588 mtx_unlock(&bsr->lock); 1589 return (0); 1590 } 1591 1592 /** 1593 * Free an unreferenced registry entry. 1594 * 1595 * @param entry The entry to be deallocated. 1596 */ 1597 static void 1598 bhnd_service_registry_free_entry(struct bhnd_service_entry *entry) 1599 { 1600 KASSERT(entry->refs == 0, ("provider has active references")); 1601 free(entry, M_BHND); 1602 } 1603 1604 /** 1605 * Attempt to remove the @p service provider registration for @p provider. 1606 * 1607 * @param bsr The service registry to be modified. 1608 * @param provider The service provider to be deregistered. 1609 * @param service The service for which @p provider will be deregistered, 1610 * or BHND_SERVICE_ANY to remove all service 1611 * registrations for @p provider. 1612 * 1613 * @retval 0 success 1614 * @retval EBUSY if active references to @p provider exist; see 1615 * bhnd_service_registry_retain() and 1616 * bhnd_service_registry_release(). 1617 */ 1618 int 1619 bhnd_service_registry_remove(struct bhnd_service_registry *bsr, 1620 device_t provider, bhnd_service_t service) 1621 { 1622 struct bhnd_service_entry *entry, *enext; 1623 1624 mtx_lock(&bsr->lock); 1625 1626 #define BHND_PROV_MATCH(_e) \ 1627 ((_e)->provider == provider && \ 1628 (service == BHND_SERVICE_ANY || (_e)->service == service)) 1629 1630 /* Validate matching provider entries before making any 1631 * modifications */ 1632 STAILQ_FOREACH(entry, &bsr->entries, link) { 1633 /* Skip non-matching entries */ 1634 if (!BHND_PROV_MATCH(entry)) 1635 continue; 1636 1637 /* Entry is in use? */ 1638 if (entry->refs > 0) { 1639 mtx_unlock(&bsr->lock); 1640 return (EBUSY); 1641 } 1642 } 1643 1644 /* We can now safely remove matching entries */ 1645 STAILQ_FOREACH_SAFE(entry, &bsr->entries, link, enext) { 1646 /* Skip non-matching entries */ 1647 if (!BHND_PROV_MATCH(entry)) 1648 continue; 1649 1650 /* Remove from list */ 1651 STAILQ_REMOVE(&bsr->entries, entry, bhnd_service_entry, link); 1652 1653 /* Free provider entry */ 1654 bhnd_service_registry_free_entry(entry); 1655 } 1656 #undef BHND_PROV_MATCH 1657 1658 mtx_unlock(&bsr->lock); 1659 return (0); 1660 } 1661 1662 /** 1663 * Retain and return a reference to a registered @p service provider, if any. 1664 * 1665 * @param bsr The service registry to be queried. 1666 * @param service The service for which a provider should be returned. 1667 * 1668 * On success, the caller assumes ownership the returned provider, and 1669 * is responsible for releasing this reference via 1670 * bhnd_service_registry_release(). 1671 * 1672 * @retval device_t success 1673 * @retval NULL if no provider is registered for @p service. 1674 */ 1675 device_t 1676 bhnd_service_registry_retain(struct bhnd_service_registry *bsr, 1677 bhnd_service_t service) 1678 { 1679 struct bhnd_service_entry *entry; 1680 1681 mtx_lock(&bsr->lock); 1682 STAILQ_FOREACH(entry, &bsr->entries, link) { 1683 if (entry->service != service) 1684 continue; 1685 1686 /* With a live refcount, entry is gauranteed to remain alive 1687 * after we release our lock */ 1688 refcount_acquire(&entry->refs); 1689 1690 mtx_unlock(&bsr->lock); 1691 return (entry->provider); 1692 } 1693 mtx_unlock(&bsr->lock); 1694 1695 /* Not found */ 1696 return (NULL); 1697 } 1698 1699 /** 1700 * Release a reference to a service provider previously returned by 1701 * bhnd_service_registry_retain(). 1702 * 1703 * If this is the last reference to an inherited service provider registration 1704 * (see BHND_SPF_INHERITED), the registration will also be removed, and 1705 * true will be returned. 1706 * 1707 * @param bsr The service registry from which @p provider 1708 * was returned. 1709 * @param provider The provider to be released. 1710 * @param service The service for which @p provider was previously 1711 * retained. 1712 * @retval true The inherited service provider registration was removed; 1713 * the caller should release its own reference to the 1714 * provider. 1715 * @retval false The service provider was not inherited, or active 1716 * references to the provider remain. 1717 * 1718 * @see BHND_SPF_INHERITED 1719 */ 1720 bool 1721 bhnd_service_registry_release(struct bhnd_service_registry *bsr, 1722 device_t provider, bhnd_service_t service) 1723 { 1724 struct bhnd_service_entry *entry; 1725 1726 /* Exclusive lock, as we need to prevent any new references to the 1727 * entry from being taken if it's to be removed */ 1728 mtx_lock(&bsr->lock); 1729 STAILQ_FOREACH(entry, &bsr->entries, link) { 1730 bool removed; 1731 1732 if (entry->provider != provider) 1733 continue; 1734 1735 if (entry->service != service) 1736 continue; 1737 1738 if (refcount_release(&entry->refs) && 1739 (entry->flags & BHND_SPF_INHERITED)) 1740 { 1741 /* If an inherited entry is no longer actively 1742 * referenced, remove the local registration and inform 1743 * the caller. */ 1744 STAILQ_REMOVE(&bsr->entries, entry, bhnd_service_entry, 1745 link); 1746 bhnd_service_registry_free_entry(entry); 1747 removed = true; 1748 } else { 1749 removed = false; 1750 } 1751 1752 mtx_unlock(&bsr->lock); 1753 return (removed); 1754 } 1755 1756 /* Caller owns a reference, but no such provider is registered? */ 1757 panic("invalid service provider reference"); 1758 } 1759 1760 /** 1761 * Using the bhnd(4) bus-level core information and a custom core name, 1762 * populate @p dev's device description. 1763 * 1764 * @param dev A bhnd-bus attached device. 1765 * @param dev_name The core's name (e.g. "SDIO Device Core"). 1766 */ 1767 void 1768 bhnd_set_custom_core_desc(device_t dev, const char *dev_name) 1769 { 1770 const char *vendor_name; 1771 char *desc; 1772 1773 vendor_name = bhnd_get_vendor_name(dev); 1774 asprintf(&desc, M_BHND, "%s %s, rev %hhu", vendor_name, dev_name, 1775 bhnd_get_hwrev(dev)); 1776 1777 if (desc != NULL) { 1778 device_set_desc_copy(dev, desc); 1779 free(desc, M_BHND); 1780 } else { 1781 device_set_desc(dev, dev_name); 1782 } 1783 } 1784 1785 /** 1786 * Using the bhnd(4) bus-level core information, populate @p dev's device 1787 * description. 1788 * 1789 * @param dev A bhnd-bus attached device. 1790 */ 1791 void 1792 bhnd_set_default_core_desc(device_t dev) 1793 { 1794 bhnd_set_custom_core_desc(dev, bhnd_get_device_name(dev)); 1795 } 1796 1797 /** 1798 * Using the bhnd @p chip_id, populate the bhnd(4) bus @p dev's device 1799 * description. 1800 * 1801 * @param dev A bhnd-bus attached device. 1802 * @param chip_id The chip identification. 1803 */ 1804 void 1805 bhnd_set_default_bus_desc(device_t dev, const struct bhnd_chipid *chip_id) 1806 { 1807 const char *bus_name; 1808 char *desc; 1809 char chip_name[BHND_CHIPID_MAX_NAMELEN]; 1810 1811 /* Determine chip type's bus name */ 1812 switch (chip_id->chip_type) { 1813 case BHND_CHIPTYPE_SIBA: 1814 bus_name = "SIBA bus"; 1815 break; 1816 case BHND_CHIPTYPE_BCMA: 1817 case BHND_CHIPTYPE_BCMA_ALT: 1818 bus_name = "BCMA bus"; 1819 break; 1820 case BHND_CHIPTYPE_UBUS: 1821 bus_name = "UBUS bus"; 1822 break; 1823 default: 1824 bus_name = "Unknown Type"; 1825 break; 1826 } 1827 1828 /* Format chip name */ 1829 bhnd_format_chip_id(chip_name, sizeof(chip_name), 1830 chip_id->chip_id); 1831 1832 /* Format and set device description */ 1833 asprintf(&desc, M_BHND, "%s %s", chip_name, bus_name); 1834 if (desc != NULL) { 1835 device_set_desc_copy(dev, desc); 1836 free(desc, M_BHND); 1837 } else { 1838 device_set_desc(dev, bus_name); 1839 } 1840 1841 } 1842 1843 /** 1844 * Helper function for implementing BHND_BUS_REGISTER_PROVIDER(). 1845 * 1846 * This implementation delegates the request to the BHND_BUS_REGISTER_PROVIDER() 1847 * method on the parent of @p dev. If no parent exists, the implementation 1848 * will return an error. 1849 */ 1850 int 1851 bhnd_bus_generic_register_provider(device_t dev, device_t child, 1852 device_t provider, bhnd_service_t service) 1853 { 1854 device_t parent = device_get_parent(dev); 1855 1856 if (parent != NULL) { 1857 return (BHND_BUS_REGISTER_PROVIDER(parent, child, 1858 provider, service)); 1859 } 1860 1861 return (ENXIO); 1862 } 1863 1864 /** 1865 * Helper function for implementing BHND_BUS_DEREGISTER_PROVIDER(). 1866 * 1867 * This implementation delegates the request to the 1868 * BHND_BUS_DEREGISTER_PROVIDER() method on the parent of @p dev. If no parent 1869 * exists, the implementation will panic. 1870 */ 1871 int 1872 bhnd_bus_generic_deregister_provider(device_t dev, device_t child, 1873 device_t provider, bhnd_service_t service) 1874 { 1875 device_t parent = device_get_parent(dev); 1876 1877 if (parent != NULL) { 1878 return (BHND_BUS_DEREGISTER_PROVIDER(parent, child, 1879 provider, service)); 1880 } 1881 1882 panic("missing BHND_BUS_DEREGISTER_PROVIDER()"); 1883 } 1884 1885 /** 1886 * Helper function for implementing BHND_BUS_RETAIN_PROVIDER(). 1887 * 1888 * This implementation delegates the request to the 1889 * BHND_BUS_DEREGISTER_PROVIDER() method on the parent of @p dev. If no parent 1890 * exists, the implementation will return NULL. 1891 */ 1892 device_t 1893 bhnd_bus_generic_retain_provider(device_t dev, device_t child, 1894 bhnd_service_t service) 1895 { 1896 device_t parent = device_get_parent(dev); 1897 1898 if (parent != NULL) { 1899 return (BHND_BUS_RETAIN_PROVIDER(parent, child, 1900 service)); 1901 } 1902 1903 return (NULL); 1904 } 1905 1906 /** 1907 * Helper function for implementing BHND_BUS_RELEASE_PROVIDER(). 1908 * 1909 * This implementation delegates the request to the 1910 * BHND_BUS_DEREGISTER_PROVIDER() method on the parent of @p dev. If no parent 1911 * exists, the implementation will panic. 1912 */ 1913 void 1914 bhnd_bus_generic_release_provider(device_t dev, device_t child, 1915 device_t provider, bhnd_service_t service) 1916 { 1917 device_t parent = device_get_parent(dev); 1918 1919 if (parent != NULL) { 1920 return (BHND_BUS_RELEASE_PROVIDER(parent, child, 1921 provider, service)); 1922 } 1923 1924 panic("missing BHND_BUS_RELEASE_PROVIDER()"); 1925 } 1926 1927 /** 1928 * Helper function for implementing BHND_BUS_REGISTER_PROVIDER(). 1929 * 1930 * This implementation uses the bhnd_service_registry_add() function to 1931 * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find 1932 * a suitable service registry to edit. 1933 */ 1934 int 1935 bhnd_bus_generic_sr_register_provider(device_t dev, device_t child, 1936 device_t provider, bhnd_service_t service) 1937 { 1938 struct bhnd_service_registry *bsr; 1939 1940 bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child); 1941 1942 KASSERT(bsr != NULL, ("NULL service registry")); 1943 1944 return (bhnd_service_registry_add(bsr, provider, service, 0)); 1945 } 1946 1947 /** 1948 * Helper function for implementing BHND_BUS_DEREGISTER_PROVIDER(). 1949 * 1950 * This implementation uses the bhnd_service_registry_remove() function to 1951 * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find 1952 * a suitable service registry to edit. 1953 */ 1954 int 1955 bhnd_bus_generic_sr_deregister_provider(device_t dev, device_t child, 1956 device_t provider, bhnd_service_t service) 1957 { 1958 struct bhnd_service_registry *bsr; 1959 1960 bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child); 1961 1962 KASSERT(bsr != NULL, ("NULL service registry")); 1963 1964 return (bhnd_service_registry_remove(bsr, provider, service)); 1965 } 1966 1967 /** 1968 * Helper function for implementing BHND_BUS_RETAIN_PROVIDER(). 1969 * 1970 * This implementation uses the bhnd_service_registry_retain() function to 1971 * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find 1972 * a suitable service registry. 1973 * 1974 * If a local provider for the service is not available, and a parent device is 1975 * available, this implementation will attempt to fetch and locally register 1976 * a service provider reference from the parent of @p dev. 1977 */ 1978 device_t 1979 bhnd_bus_generic_sr_retain_provider(device_t dev, device_t child, 1980 bhnd_service_t service) 1981 { 1982 struct bhnd_service_registry *bsr; 1983 device_t parent, provider; 1984 int error; 1985 1986 bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child); 1987 KASSERT(bsr != NULL, ("NULL service registry")); 1988 1989 /* 1990 * Attempt to fetch a service provider reference from either the local 1991 * service registry, or if not found, from our parent. 1992 * 1993 * If we fetch a provider from our parent, we register the provider 1994 * with the local service registry to prevent conflicting local 1995 * registrations from being added. 1996 */ 1997 while (1) { 1998 /* Check the local service registry first */ 1999 provider = bhnd_service_registry_retain(bsr, service); 2000 if (provider != NULL) 2001 return (provider); 2002 2003 /* Otherwise, try to delegate to our parent (if any) */ 2004 if ((parent = device_get_parent(dev)) == NULL) 2005 return (NULL); 2006 2007 provider = BHND_BUS_RETAIN_PROVIDER(parent, dev, service); 2008 if (provider == NULL) 2009 return (NULL); 2010 2011 /* Register the inherited service registration with the local 2012 * registry */ 2013 error = bhnd_service_registry_add(bsr, provider, service, 2014 BHND_SPF_INHERITED); 2015 if (error) { 2016 BHND_BUS_RELEASE_PROVIDER(parent, dev, provider, 2017 service); 2018 if (error == EEXIST) { 2019 /* A valid service provider was registered 2020 * concurrently; retry fetching from the local 2021 * registry */ 2022 continue; 2023 } 2024 2025 device_printf(dev, "failed to register service " 2026 "provider: %d\n", error); 2027 return (NULL); 2028 } 2029 } 2030 } 2031 2032 /** 2033 * Helper function for implementing BHND_BUS_RELEASE_PROVIDER(). 2034 * 2035 * This implementation uses the bhnd_service_registry_release() function to 2036 * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find 2037 * a suitable service registry. 2038 */ 2039 void 2040 bhnd_bus_generic_sr_release_provider(device_t dev, device_t child, 2041 device_t provider, bhnd_service_t service) 2042 { 2043 struct bhnd_service_registry *bsr; 2044 2045 bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child); 2046 KASSERT(bsr != NULL, ("NULL service registry")); 2047 2048 /* Release the provider reference; if the refcount hits zero on an 2049 * inherited reference, true will be returned, and we need to drop 2050 * our own bus reference to the provider */ 2051 if (!bhnd_service_registry_release(bsr, provider, service)) 2052 return; 2053 2054 /* Drop our reference to the borrowed provider */ 2055 BHND_BUS_RELEASE_PROVIDER(device_get_parent(dev), dev, provider, 2056 service); 2057 } 2058 2059 /** 2060 * Helper function for implementing BHND_BUS_IS_HW_DISABLED(). 2061 * 2062 * If a parent device is available, this implementation delegates the 2063 * request to the BHND_BUS_IS_HW_DISABLED() method on the parent of @p dev. 2064 * 2065 * If no parent device is available (i.e. on a the bus root), the hardware 2066 * is assumed to be usable and false is returned. 2067 */ 2068 bool 2069 bhnd_bus_generic_is_hw_disabled(device_t dev, device_t child) 2070 { 2071 if (device_get_parent(dev) != NULL) 2072 return (BHND_BUS_IS_HW_DISABLED(device_get_parent(dev), child)); 2073 2074 return (false); 2075 } 2076 2077 /** 2078 * Helper function for implementing BHND_BUS_GET_CHIPID(). 2079 * 2080 * This implementation delegates the request to the BHND_BUS_GET_CHIPID() 2081 * method on the parent of @p dev. If no parent exists, the implementation 2082 * will panic. 2083 */ 2084 const struct bhnd_chipid * 2085 bhnd_bus_generic_get_chipid(device_t dev, device_t child) 2086 { 2087 if (device_get_parent(dev) != NULL) 2088 return (BHND_BUS_GET_CHIPID(device_get_parent(dev), child)); 2089 2090 panic("missing BHND_BUS_GET_CHIPID()"); 2091 } 2092 2093 /** 2094 * Helper function for implementing BHND_BUS_GET_DMA_TRANSLATION(). 2095 * 2096 * If a parent device is available, this implementation delegates the 2097 * request to the BHND_BUS_GET_DMA_TRANSLATION() method on the parent of @p dev. 2098 * 2099 * If no parent device is available, this implementation will panic. 2100 */ 2101 int 2102 bhnd_bus_generic_get_dma_translation(device_t dev, device_t child, u_int width, 2103 uint32_t flags, bus_dma_tag_t *dmat, 2104 struct bhnd_dma_translation *translation) 2105 { 2106 if (device_get_parent(dev) != NULL) { 2107 return (BHND_BUS_GET_DMA_TRANSLATION(device_get_parent(dev), 2108 child, width, flags, dmat, translation)); 2109 } 2110 2111 panic("missing BHND_BUS_GET_DMA_TRANSLATION()"); 2112 } 2113 2114 /* nvram board_info population macros for bhnd_bus_generic_read_board_info() */ 2115 #define BHND_GV(_dest, _name) \ 2116 bhnd_nvram_getvar_uint(child, BHND_NVAR_ ## _name, &_dest, \ 2117 sizeof(_dest)) 2118 2119 #define REQ_BHND_GV(_dest, _name) do { \ 2120 if ((error = BHND_GV(_dest, _name))) { \ 2121 device_printf(dev, \ 2122 "error reading " __STRING(_name) ": %d\n", error); \ 2123 return (error); \ 2124 } \ 2125 } while(0) 2126 2127 #define OPT_BHND_GV(_dest, _name, _default) do { \ 2128 if ((error = BHND_GV(_dest, _name))) { \ 2129 if (error != ENOENT) { \ 2130 device_printf(dev, \ 2131 "error reading " \ 2132 __STRING(_name) ": %d\n", error); \ 2133 return (error); \ 2134 } \ 2135 _dest = _default; \ 2136 } \ 2137 } while(0) 2138 2139 /** 2140 * Helper function for implementing BHND_BUS_READ_BOARDINFO(). 2141 * 2142 * This implementation populates @p info with information from NVRAM, 2143 * defaulting board_vendor and board_type fields to 0 if the 2144 * requested variables cannot be found. 2145 * 2146 * This behavior is correct for most SoCs, but must be overridden on 2147 * bridged (PCI, PCMCIA, etc) devices to produce a complete bhnd_board_info 2148 * result. 2149 */ 2150 int 2151 bhnd_bus_generic_read_board_info(device_t dev, device_t child, 2152 struct bhnd_board_info *info) 2153 { 2154 int error; 2155 2156 OPT_BHND_GV(info->board_vendor, BOARDVENDOR, 0); 2157 OPT_BHND_GV(info->board_type, BOARDTYPE, 0); /* srom >= 2 */ 2158 OPT_BHND_GV(info->board_devid, DEVID, 0); /* srom >= 8 */ 2159 REQ_BHND_GV(info->board_rev, BOARDREV); 2160 OPT_BHND_GV(info->board_srom_rev,SROMREV, 0); /* missing in 2161 some SoC 2162 NVRAM */ 2163 REQ_BHND_GV(info->board_flags, BOARDFLAGS); 2164 OPT_BHND_GV(info->board_flags2, BOARDFLAGS2, 0); /* srom >= 4 */ 2165 OPT_BHND_GV(info->board_flags3, BOARDFLAGS3, 0); /* srom >= 11 */ 2166 2167 return (0); 2168 } 2169 2170 #undef BHND_GV 2171 #undef BHND_GV_REQ 2172 #undef BHND_GV_OPT 2173 2174 /** 2175 * Helper function for implementing BHND_BUS_GET_NVRAM_VAR(). 2176 * 2177 * This implementation searches @p dev for a usable NVRAM child device. 2178 * 2179 * If no usable child device is found on @p dev, the request is delegated to 2180 * the BHND_BUS_GET_NVRAM_VAR() method on the parent of @p dev. 2181 */ 2182 int 2183 bhnd_bus_generic_get_nvram_var(device_t dev, device_t child, const char *name, 2184 void *buf, size_t *size, bhnd_nvram_type type) 2185 { 2186 device_t nvram; 2187 device_t parent; 2188 2189 bus_topo_assert(); 2190 2191 /* Look for a directly-attached NVRAM child */ 2192 if ((nvram = device_find_child(dev, "bhnd_nvram", -1)) != NULL) 2193 return BHND_NVRAM_GETVAR(nvram, name, buf, size, type); 2194 2195 /* Try to delegate to parent */ 2196 if ((parent = device_get_parent(dev)) == NULL) 2197 return (ENODEV); 2198 2199 return (BHND_BUS_GET_NVRAM_VAR(device_get_parent(dev), child, 2200 name, buf, size, type)); 2201 } 2202 2203 /** 2204 * Helper function for implementing BHND_BUS_ALLOC_RESOURCE(). 2205 * 2206 * This implementation of BHND_BUS_ALLOC_RESOURCE() delegates allocation 2207 * of the underlying resource to BUS_ALLOC_RESOURCE(), and activation 2208 * to @p dev's BHND_BUS_ACTIVATE_RESOURCE(). 2209 */ 2210 struct bhnd_resource * 2211 bhnd_bus_generic_alloc_resource(device_t dev, device_t child, int type, 2212 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, 2213 u_int flags) 2214 { 2215 struct bhnd_resource *br; 2216 struct resource *res; 2217 int error; 2218 2219 br = NULL; 2220 res = NULL; 2221 2222 /* Allocate the real bus resource (without activating it) */ 2223 res = BUS_ALLOC_RESOURCE(dev, child, type, rid, start, end, count, 2224 (flags & ~RF_ACTIVE)); 2225 if (res == NULL) 2226 return (NULL); 2227 2228 /* Allocate our bhnd resource wrapper. */ 2229 br = malloc(sizeof(struct bhnd_resource), M_BHND, M_NOWAIT); 2230 if (br == NULL) 2231 goto failed; 2232 2233 br->direct = false; 2234 br->res = res; 2235 2236 /* Attempt activation */ 2237 if (flags & RF_ACTIVE) { 2238 error = BHND_BUS_ACTIVATE_RESOURCE(dev, child, type, *rid, br); 2239 if (error) 2240 goto failed; 2241 } 2242 2243 return (br); 2244 2245 failed: 2246 if (res != NULL) 2247 BUS_RELEASE_RESOURCE(dev, child, type, *rid, res); 2248 2249 free(br, M_BHND); 2250 return (NULL); 2251 } 2252 2253 /** 2254 * Helper function for implementing BHND_BUS_RELEASE_RESOURCE(). 2255 * 2256 * This implementation of BHND_BUS_RELEASE_RESOURCE() delegates release of 2257 * the backing resource to BUS_RELEASE_RESOURCE(). 2258 */ 2259 int 2260 bhnd_bus_generic_release_resource(device_t dev, device_t child, int type, 2261 int rid, struct bhnd_resource *r) 2262 { 2263 int error; 2264 2265 if ((error = BUS_RELEASE_RESOURCE(dev, child, type, rid, r->res))) 2266 return (error); 2267 2268 free(r, M_BHND); 2269 return (0); 2270 } 2271 2272 /** 2273 * Helper function for implementing BHND_BUS_ACTIVATE_RESOURCE(). 2274 * 2275 * This implementation of BHND_BUS_ACTIVATE_RESOURCE() first calls the 2276 * BHND_BUS_ACTIVATE_RESOURCE() method of the parent of @p dev. 2277 * 2278 * If this fails, and if @p dev is the direct parent of @p child, standard 2279 * resource activation is attempted via bus_activate_resource(). This enables 2280 * direct use of the bhnd(4) resource APIs on devices that may not be attached 2281 * to a parent bhnd bus or bridge. 2282 */ 2283 int 2284 bhnd_bus_generic_activate_resource(device_t dev, device_t child, int type, 2285 int rid, struct bhnd_resource *r) 2286 { 2287 int error; 2288 bool passthrough; 2289 2290 passthrough = (device_get_parent(child) != dev); 2291 2292 /* Try to delegate to the parent */ 2293 if (device_get_parent(dev) != NULL) { 2294 error = BHND_BUS_ACTIVATE_RESOURCE(device_get_parent(dev), 2295 child, type, rid, r); 2296 } else { 2297 error = ENODEV; 2298 } 2299 2300 /* If bhnd(4) activation has failed and we're the child's direct 2301 * parent, try falling back on standard resource activation. 2302 */ 2303 if (error && !passthrough) { 2304 error = bus_activate_resource(child, type, rid, r->res); 2305 if (!error) 2306 r->direct = true; 2307 } 2308 2309 return (error); 2310 } 2311 2312 /** 2313 * Helper function for implementing BHND_BUS_DEACTIVATE_RESOURCE(). 2314 * 2315 * This implementation of BHND_BUS_ACTIVATE_RESOURCE() simply calls the 2316 * BHND_BUS_ACTIVATE_RESOURCE() method of the parent of @p dev. 2317 */ 2318 int 2319 bhnd_bus_generic_deactivate_resource(device_t dev, device_t child, 2320 int type, int rid, struct bhnd_resource *r) 2321 { 2322 if (device_get_parent(dev) != NULL) 2323 return (BHND_BUS_DEACTIVATE_RESOURCE(device_get_parent(dev), 2324 child, type, rid, r)); 2325 2326 return (EINVAL); 2327 } 2328 2329 /** 2330 * Helper function for implementing BHND_BUS_GET_INTR_DOMAIN(). 2331 * 2332 * This implementation simply returns the address of nearest bhnd(4) bus, 2333 * which may be @p dev; this behavior may be incompatible with FDT/OFW targets. 2334 */ 2335 uintptr_t 2336 bhnd_bus_generic_get_intr_domain(device_t dev, device_t child, bool self) 2337 { 2338 return ((uintptr_t)dev); 2339 } 2340