1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2016 Landon Fuller <landonf@FreeBSD.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/kobj.h> 42 43 #include <machine/bus.h> 44 #include <sys/rman.h> 45 #include <machine/resource.h> 46 47 #include <dev/bhnd/bhndreg.h> 48 #include <dev/bhnd/bhndvar.h> 49 50 #include <dev/bhnd/bhnd_erom.h> 51 #include <dev/bhnd/bhnd_eromvar.h> 52 53 #include <dev/bhnd/cores/chipc/chipcreg.h> 54 55 static int bhnd_erom_iores_map(struct bhnd_erom_io *eio, bhnd_addr_t addr, 56 bhnd_size_t size); 57 static int bhnd_erom_iores_tell(struct bhnd_erom_io *eio, 58 bhnd_addr_t *addr, bhnd_size_t *size); 59 static uint32_t bhnd_erom_iores_read(struct bhnd_erom_io *eio, 60 bhnd_size_t offset, u_int width); 61 static void bhnd_erom_iores_fini(struct bhnd_erom_io *eio); 62 63 static int bhnd_erom_iobus_map(struct bhnd_erom_io *eio, bhnd_addr_t addr, 64 bhnd_size_t size); 65 static int bhnd_erom_iobus_tell(struct bhnd_erom_io *eio, 66 bhnd_addr_t *addr, bhnd_size_t *size); 67 static uint32_t bhnd_erom_iobus_read(struct bhnd_erom_io *eio, 68 bhnd_size_t offset, u_int width); 69 70 /** 71 * An implementation of bhnd_erom_io that manages mappings via 72 * bhnd_alloc_resource() and bhnd_release_resource(). 73 */ 74 struct bhnd_erom_iores { 75 struct bhnd_erom_io eio; 76 device_t owner; /**< device from which we'll allocate resources */ 77 int owner_rid; /**< rid to use when allocating new mappings */ 78 struct bhnd_resource *mapped; /**< current mapping, or NULL */ 79 int mapped_rid; /**< resource ID of current mapping, or -1 */ 80 }; 81 82 /** 83 * Fetch the device enumeration parser class from all bhnd(4)-compatible drivers 84 * registered for @p bus_devclass, probe @p eio for supporting parser classes, 85 * and return the best available supporting enumeration parser class. 86 * 87 * @param bus_devclass The bus device class to be queried for 88 * bhnd(4)-compatible drivers. 89 * @param eio An erom bus I/O instance, configured with a 90 * mapping of the first bus core. 91 * @param hint Identification hint used to identify the device. 92 * If the chipset supports standard chip 93 * identification registers within the first core, 94 * this parameter should be NULL. 95 * @param[out] cid On success, the probed chip identifier. 96 * 97 * @retval non-NULL on success, the best available EROM class. 98 * @retval NULL if no erom class returned a successful probe result for 99 * @p eio. 100 */ 101 bhnd_erom_class_t * 102 bhnd_erom_probe_driver_classes(devclass_t bus_devclass, 103 struct bhnd_erom_io *eio, const struct bhnd_chipid *hint, 104 struct bhnd_chipid *cid) 105 { 106 driver_t **drivers; 107 int drv_count; 108 bhnd_erom_class_t *erom_cls; 109 int error, prio, result; 110 111 erom_cls = NULL; 112 prio = 0; 113 114 /* Fetch all available drivers */ 115 error = devclass_get_drivers(bus_devclass, &drivers, &drv_count); 116 if (error) { 117 printf("error fetching bhnd(4) drivers for %s: %d\n", 118 devclass_get_name(bus_devclass), error); 119 return (NULL); 120 } 121 122 /* Enumerate the drivers looking for the best available EROM class */ 123 for (int i = 0; i < drv_count; i++) { 124 struct bhnd_chipid pcid; 125 bhnd_erom_class_t *cls; 126 127 /* The default implementation of BHND_BUS_GET_EROM_CLASS() 128 * returns NULL if unimplemented; this should always be safe 129 * to call on arbitrary drivers */ 130 cls = bhnd_driver_get_erom_class(drivers[i]); 131 if (cls == NULL) 132 continue; 133 134 kobj_class_compile(cls); 135 136 /* Probe the bus */ 137 result = bhnd_erom_probe(cls, eio, hint, &pcid); 138 139 /* The parser did not match if an error was returned */ 140 if (result > 0) 141 continue; 142 143 /* Check for a new highest priority match */ 144 if (erom_cls == NULL || result > prio) { 145 prio = result; 146 147 *cid = pcid; 148 erom_cls = cls; 149 } 150 151 /* Terminate immediately on BUS_PROBE_SPECIFIC */ 152 if (result == BUS_PROBE_SPECIFIC) 153 break; 154 } 155 156 free(drivers, M_TEMP); 157 return (erom_cls); 158 } 159 160 /** 161 * Allocate and return a new device enumeration table parser. 162 * 163 * @param cls The parser class for which an instance will be 164 * allocated. 165 * @param eio The bus I/O callbacks to use when reading the device 166 * enumeration table. 167 * @param cid The device's chip identifier. 168 * 169 * @retval non-NULL success 170 * @retval NULL if an error occurred allocating or initializing the 171 * EROM parser. 172 */ 173 bhnd_erom_t * 174 bhnd_erom_alloc(bhnd_erom_class_t *cls, const struct bhnd_chipid *cid, 175 struct bhnd_erom_io *eio) 176 { 177 bhnd_erom_t *erom; 178 int error; 179 180 erom = (bhnd_erom_t *)kobj_create((kobj_class_t)cls, M_BHND, 181 M_WAITOK|M_ZERO); 182 183 if ((error = BHND_EROM_INIT(erom, cid, eio))) { 184 printf("error initializing %s parser at %#jx: %d\n", cls->name, 185 (uintmax_t)cid->enum_addr, error); 186 187 kobj_delete((kobj_t)erom, M_BHND); 188 return (NULL); 189 } 190 191 return (erom); 192 } 193 194 /** 195 * Perform static initialization of a device enumeration table parser. 196 * 197 * This may be used to initialize a caller-allocated erom instance state 198 * during early boot, prior to malloc availability. 199 * 200 * @param cls The parser class for which an instance will be 201 * allocated. 202 * @param erom The erom parser instance to initialize. 203 * @param esize The total available number of bytes allocated for 204 * @p erom. If this is less than is required by @p cls, 205 * ENOMEM will be returned. 206 * @param cid The device's chip identifier. 207 * @param eio The bus I/O callbacks to use when reading the device 208 * enumeration table. 209 * 210 * @retval 0 success 211 * @retval ENOMEM if @p esize is smaller than required by @p cls. 212 * @retval non-zero if an error occurs initializing the EROM parser, 213 * a regular unix error code will be returned. 214 */ 215 int 216 bhnd_erom_init_static(bhnd_erom_class_t *cls, bhnd_erom_t *erom, size_t esize, 217 const struct bhnd_chipid *cid, struct bhnd_erom_io *eio) 218 { 219 kobj_class_t kcls; 220 221 kcls = (kobj_class_t)cls; 222 223 /* Verify allocation size */ 224 if (kcls->size > esize) 225 return (ENOMEM); 226 227 /* Perform instance initialization */ 228 kobj_init_static((kobj_t)erom, kcls); 229 return (BHND_EROM_INIT(erom, cid, eio)); 230 } 231 232 /** 233 * Release any resources held by a @p erom parser previously 234 * initialized via bhnd_erom_init_static(). 235 * 236 * @param erom An erom parser instance previously initialized via 237 * bhnd_erom_init_static(). 238 */ 239 void 240 bhnd_erom_fini_static(bhnd_erom_t *erom) 241 { 242 return (BHND_EROM_FINI(erom)); 243 } 244 245 /** 246 * Release all resources held by a @p erom parser previously 247 * allocated via bhnd_erom_alloc(). 248 * 249 * @param erom An erom parser instance previously allocated via 250 * bhnd_erom_alloc(). 251 */ 252 void 253 bhnd_erom_free(bhnd_erom_t *erom) 254 { 255 BHND_EROM_FINI(erom); 256 kobj_delete((kobj_t)erom, M_BHND); 257 } 258 259 /** 260 * Read the chip identification registers mapped by @p eio, popuating @p cid 261 * with the parsed result 262 * 263 * @param eio A bus I/O instance, configured with a mapping 264 * of the ChipCommon core. 265 * @param[out] cid On success, the parsed chip identification. 266 * 267 * @warning 268 * On early siba(4) devices, the ChipCommon core does not provide 269 * a valid CHIPC_ID_NUMCORE field. On these ChipCommon revisions 270 * (see CHIPC_NCORES_MIN_HWREV()), this function will parse and return 271 * an invalid `ncores` value. 272 */ 273 int 274 bhnd_erom_read_chipid(struct bhnd_erom_io *eio, struct bhnd_chipid *cid) 275 { 276 bhnd_addr_t cc_addr; 277 bhnd_size_t cc_size; 278 uint32_t idreg, cc_caps; 279 int error; 280 281 /* Fetch ChipCommon address */ 282 if ((error = bhnd_erom_io_tell(eio, &cc_addr, &cc_size))) 283 return (error); 284 285 /* Read chip identifier */ 286 idreg = bhnd_erom_io_read(eio, CHIPC_ID, 4); 287 288 /* Extract the basic chip info */ 289 cid->chip_id = CHIPC_GET_BITS(idreg, CHIPC_ID_CHIP); 290 cid->chip_pkg = CHIPC_GET_BITS(idreg, CHIPC_ID_PKG); 291 cid->chip_rev = CHIPC_GET_BITS(idreg, CHIPC_ID_REV); 292 cid->chip_type = CHIPC_GET_BITS(idreg, CHIPC_ID_BUS); 293 cid->ncores = CHIPC_GET_BITS(idreg, CHIPC_ID_NUMCORE); 294 295 /* Populate EROM address */ 296 if (BHND_CHIPTYPE_HAS_EROM(cid->chip_type)) { 297 cid->enum_addr = bhnd_erom_io_read(eio, CHIPC_EROMPTR, 4); 298 } else { 299 cid->enum_addr = cc_addr; 300 } 301 302 /* Populate capability flags */ 303 cc_caps = bhnd_erom_io_read(eio, CHIPC_CAPABILITIES, 4); 304 cid->chip_caps = 0x0; 305 306 if (cc_caps & CHIPC_CAP_BKPLN64) 307 cid->chip_caps |= BHND_CAP_BP64; 308 309 if (cc_caps & CHIPC_CAP_PMU) 310 cid->chip_caps |= BHND_CAP_PMU; 311 312 return (0); 313 } 314 315 /** 316 * Attempt to map @p size bytes at @p addr, replacing any existing 317 * @p eio mapping. 318 * 319 * @param eio I/O instance state. 320 * @param addr The address to be mapped. 321 * @param size The number of bytes to be mapped at @p addr. 322 * 323 * @retval 0 success 324 * @retval non-zero if mapping @p addr otherwise fails, a regular 325 * unix error code should be returned. 326 */ 327 int 328 bhnd_erom_io_map(struct bhnd_erom_io *eio, bhnd_addr_t addr, bhnd_size_t size) 329 { 330 return (eio->map(eio, addr, size)); 331 } 332 333 /** 334 * Return the address range mapped by @p eio, if any. 335 * 336 * @param eio I/O instance state. 337 * @param[out] addr The address mapped by @p eio. 338 * @param[out] size The number of bytes mapped at @p addr. 339 * 340 * @retval 0 success 341 * @retval ENXIO if @p eio has no mapping. 342 */ 343 int 344 bhnd_erom_io_tell(struct bhnd_erom_io *eio, bhnd_addr_t *addr, 345 bhnd_size_t *size) 346 { 347 return (eio->tell(eio, addr, size)); 348 } 349 350 /** 351 * Read a 1, 2, or 4 byte data item from @p eio, at the given @p offset 352 * relative to @p eio's current mapping. 353 * 354 * @param eio erom I/O callbacks 355 * @param offset read offset. 356 * @param width item width (1, 2, or 4 bytes). 357 */ 358 uint32_t 359 bhnd_erom_io_read(struct bhnd_erom_io *eio, bhnd_size_t offset, u_int width) 360 { 361 return (eio->read(eio, offset, width)); 362 } 363 364 /** 365 * Free all resources held by @p eio. 366 */ 367 void 368 bhnd_erom_io_fini(struct bhnd_erom_io *eio) 369 { 370 if (eio->fini != NULL) 371 return (eio->fini(eio)); 372 } 373 374 /** 375 * Allocate, initialize, and return a new I/O instance that will perform 376 * mapping by allocating SYS_RES_MEMORY resources from @p dev using @p rid. 377 * 378 * @param dev The device to pass to bhnd_alloc_resource() and 379 * bhnd_release_resource() functions. 380 * @param rid The resource ID to be used when allocating memory resources. 381 */ 382 struct bhnd_erom_io * 383 bhnd_erom_iores_new(device_t dev, int rid) 384 { 385 struct bhnd_erom_iores *iores; 386 387 iores = malloc(sizeof(*iores), M_BHND, M_WAITOK | M_ZERO); 388 iores->eio.map = bhnd_erom_iores_map; 389 iores->eio.tell = bhnd_erom_iores_tell; 390 iores->eio.read = bhnd_erom_iores_read; 391 iores->eio.fini = bhnd_erom_iores_fini; 392 393 iores->owner = dev; 394 iores->owner_rid = rid; 395 iores->mapped = NULL; 396 iores->mapped_rid = -1; 397 398 return (&iores->eio); 399 } 400 401 static int 402 bhnd_erom_iores_map(struct bhnd_erom_io *eio, bhnd_addr_t addr, 403 bhnd_size_t size) 404 { 405 struct bhnd_erom_iores *iores; 406 407 iores = (struct bhnd_erom_iores *)eio; 408 409 /* Sanity check the addr/size */ 410 if (size == 0) 411 return (EINVAL); 412 413 if (BHND_ADDR_MAX - size < addr) 414 return (EINVAL); /* would overflow */ 415 416 /* Check for an existing mapping */ 417 if (iores->mapped) { 418 /* If already mapped, nothing else to do */ 419 if (rman_get_start(iores->mapped->res) == addr && 420 rman_get_size(iores->mapped->res) == size) 421 { 422 return (0); 423 } 424 425 /* Otherwise, we need to drop the existing mapping */ 426 bhnd_release_resource(iores->owner, SYS_RES_MEMORY, 427 iores->mapped_rid, iores->mapped); 428 iores->mapped = NULL; 429 iores->mapped_rid = -1; 430 } 431 432 /* Try to allocate the new mapping */ 433 iores->mapped_rid = iores->owner_rid; 434 iores->mapped = bhnd_alloc_resource(iores->owner, SYS_RES_MEMORY, 435 &iores->mapped_rid, addr, addr+size-1, size, 436 RF_ACTIVE|RF_SHAREABLE); 437 if (iores->mapped == NULL) { 438 iores->mapped_rid = -1; 439 return (ENXIO); 440 } 441 442 return (0); 443 } 444 445 static int 446 bhnd_erom_iores_tell(struct bhnd_erom_io *eio, bhnd_addr_t *addr, 447 bhnd_size_t *size) 448 { 449 struct bhnd_erom_iores *iores = (struct bhnd_erom_iores *)eio; 450 451 if (iores->mapped == NULL) 452 return (ENXIO); 453 454 *addr = rman_get_start(iores->mapped->res); 455 *size = rman_get_size(iores->mapped->res); 456 457 return (0); 458 } 459 460 static uint32_t 461 bhnd_erom_iores_read(struct bhnd_erom_io *eio, bhnd_size_t offset, u_int width) 462 { 463 struct bhnd_erom_iores *iores = (struct bhnd_erom_iores *)eio; 464 465 if (iores->mapped == NULL) 466 panic("read with invalid mapping"); 467 468 switch (width) { 469 case 1: 470 return (bhnd_bus_read_1(iores->mapped, offset)); 471 case 2: 472 return (bhnd_bus_read_2(iores->mapped, offset)); 473 case 4: 474 return (bhnd_bus_read_4(iores->mapped, offset)); 475 default: 476 panic("invalid width %u", width); 477 } 478 } 479 480 static void 481 bhnd_erom_iores_fini(struct bhnd_erom_io *eio) 482 { 483 struct bhnd_erom_iores *iores = (struct bhnd_erom_iores *)eio; 484 485 /* Release any mapping */ 486 if (iores->mapped) { 487 bhnd_release_resource(iores->owner, SYS_RES_MEMORY, 488 iores->mapped_rid, iores->mapped); 489 iores->mapped = NULL; 490 iores->mapped_rid = -1; 491 } 492 493 free(eio, M_BHND); 494 } 495 496 /** 497 * Initialize an I/O instance that will perform mapping directly from the 498 * given bus space tag and handle. 499 * 500 * @param iobus The I/O instance to be initialized. 501 * @param addr The base address mapped by @p bsh. 502 * @param size The total size mapped by @p bsh. 503 * @param bst Bus space tag for @p bsh. 504 * @param bsh Bus space handle mapping the full bus enumeration space. 505 * 506 * @retval 0 success 507 * @retval non-zero if initializing @p iobus otherwise fails, a regular 508 * unix error code will be returned. 509 */ 510 int 511 bhnd_erom_iobus_init(struct bhnd_erom_iobus *iobus, bhnd_addr_t addr, 512 bhnd_size_t size, bus_space_tag_t bst, bus_space_handle_t bsh) 513 { 514 iobus->eio.map = bhnd_erom_iobus_map; 515 iobus->eio.tell = bhnd_erom_iobus_tell; 516 iobus->eio.read = bhnd_erom_iobus_read; 517 iobus->eio.fini = NULL; 518 519 iobus->addr = addr; 520 iobus->size = size; 521 iobus->bst = bst; 522 iobus->bsh = bsh; 523 iobus->mapped = false; 524 525 return (0); 526 } 527 528 static int 529 bhnd_erom_iobus_map(struct bhnd_erom_io *eio, bhnd_addr_t addr, 530 bhnd_size_t size) 531 { 532 struct bhnd_erom_iobus *iobus = (struct bhnd_erom_iobus *)eio; 533 534 /* Sanity check the addr/size */ 535 if (size == 0) 536 return (EINVAL); 537 538 /* addr+size must not overflow */ 539 if (BHND_ADDR_MAX - size < addr) 540 return (EINVAL); 541 542 /* addr/size must fit within our bus tag's mapping */ 543 if (addr < iobus->addr || size > iobus->size) 544 return (ENXIO); 545 546 if (iobus->size - (addr - iobus->addr) < size) 547 return (ENXIO); 548 549 /* The new addr offset and size must be representible as a bus_size_t */ 550 if ((addr - iobus->addr) > BUS_SPACE_MAXSIZE) 551 return (ENXIO); 552 553 if (size > BUS_SPACE_MAXSIZE) 554 return (ENXIO); 555 556 iobus->offset = addr - iobus->addr; 557 iobus->limit = size; 558 iobus->mapped = true; 559 560 return (0); 561 } 562 563 static int 564 bhnd_erom_iobus_tell(struct bhnd_erom_io *eio, bhnd_addr_t *addr, 565 bhnd_size_t *size) 566 { 567 struct bhnd_erom_iobus *iobus = (struct bhnd_erom_iobus *)eio; 568 569 if (!iobus->mapped) 570 return (ENXIO); 571 572 *addr = iobus->addr + iobus->offset; 573 *size = iobus->limit; 574 575 return (0); 576 } 577 578 static uint32_t 579 bhnd_erom_iobus_read(struct bhnd_erom_io *eio, bhnd_size_t offset, u_int width) 580 { 581 struct bhnd_erom_iobus *iobus = (struct bhnd_erom_iobus *)eio; 582 583 if (!iobus->mapped) 584 panic("no active mapping"); 585 586 if (iobus->limit < width || iobus->limit - width < offset) 587 panic("invalid offset %#jx", offset); 588 589 switch (width) { 590 case 1: 591 return (bus_space_read_1(iobus->bst, iobus->bsh, 592 iobus->offset + offset)); 593 case 2: 594 return (bus_space_read_2(iobus->bst, iobus->bsh, 595 iobus->offset + offset)); 596 case 4: 597 return (bus_space_read_4(iobus->bst, iobus->bsh, 598 iobus->offset + offset)); 599 default: 600 panic("invalid width %u", width); 601 } 602 } 603