acpi_mcfg.c revision 1.12
1 /* $NetBSD: acpi_mcfg.c,v 1.12 2018/11/02 15:01:18 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (C) 2015 NONAKA Kimihiro <nonaka (at) NetBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "opt_pci.h" 29 30 #include <sys/cdefs.h> 31 __KERNEL_RCSID(0, "$NetBSD: acpi_mcfg.c,v 1.12 2018/11/02 15:01:18 jmcneill Exp $"); 32 33 #include <sys/param.h> 34 #include <sys/device.h> 35 #include <sys/kmem.h> 36 #include <sys/systm.h> 37 #include <sys/extent.h> 38 39 #include <dev/pci/pcireg.h> 40 #include <dev/pci/pcivar.h> 41 #include <dev/pci/pciconf.h> 42 #include <dev/pci/pcidevs.h> 43 44 #include <dev/acpi/acpireg.h> 45 #include <dev/acpi/acpivar.h> 46 #include <dev/acpi/acpi_mcfg.h> 47 48 #include "locators.h" 49 50 #define _COMPONENT ACPI_RESOURCE_COMPONENT 51 ACPI_MODULE_NAME ("acpi_mcfg") 52 53 #define EXTCONF_OFFSET(d, f, r) ((((d) * 8 + (f)) * PCI_EXTCONF_SIZE) + (r)) 54 55 #define PCIDEV_SET_VALID(mb, d, f) ((mb)->valid_devs[(d)] |= __BIT((f))) 56 #define PCIDEV_SET_INVALID(mb, d, f) ((mb)->valid_devs[(d)] &= ~__BIT((f))) 57 #define PCIDEV_IS_VALID(mb, d, f) ((mb)->valid_devs[(d)] & __BIT((f))) 58 59 #define EXTCONF_SET_VALID(mb, d, f) ((mb)->valid_extconf[(d)] |= __BIT((f))) 60 #define EXTCONF_SET_INVALID(mb, d, f) ((mb)->valid_extconf[(d)] &= ~__BIT((f))) 61 #define EXTCONF_IS_VALID(mb, d, f) ((mb)->valid_extconf[(d)] & __BIT((f))) 62 63 struct mcfg_segment { 64 uint64_t ms_address; /* Base address */ 65 int ms_segment; /* Segment # */ 66 int ms_bus_start; /* Start bus # */ 67 int ms_bus_end; /* End bus # */ 68 bus_space_tag_t ms_bst; 69 struct mcfg_bus { 70 bus_space_handle_t bsh[32][8]; 71 uint8_t valid_devs[32]; 72 uint8_t valid_extconf[32]; 73 int valid_ndevs; 74 pcitag_t last_probed; 75 } *ms_bus; 76 }; 77 78 static struct mcfg_segment *mcfg_segs; 79 static int mcfg_nsegs; 80 static ACPI_TABLE_MCFG *mcfg; 81 static int mcfg_inited; 82 static struct acpi_softc *acpi_sc; 83 84 static const struct acpimcfg_ops mcfg_default_ops = { 85 .ao_validate = acpimcfg_default_validate, 86 87 .ao_read = acpimcfg_default_read, 88 .ao_write = acpimcfg_default_write, 89 }; 90 static const struct acpimcfg_ops *mcfg_ops = &mcfg_default_ops; 91 92 /* 93 * default operations. 94 */ 95 bool 96 acpimcfg_default_validate(uint64_t address, int bus_start, int *bus_end) 97 { 98 99 /* Always Ok */ 100 return true; 101 } 102 103 uint32_t 104 acpimcfg_default_read(bus_space_tag_t bst, bus_space_handle_t bsh, 105 bus_addr_t addr) 106 { 107 108 return bus_space_read_4(bst, bsh, addr); 109 } 110 111 void 112 acpimcfg_default_write(bus_space_tag_t bst, bus_space_handle_t bsh, 113 bus_addr_t addr, uint32_t data) 114 { 115 116 bus_space_write_4(bst, bsh, addr, data); 117 } 118 119 120 /* 121 * Check MCFG memory region at system resource 122 */ 123 struct acpimcfg_memrange { 124 const char *hid; 125 uint64_t address; 126 int bus_start; 127 int bus_end; 128 bool found; 129 }; 130 131 static ACPI_STATUS 132 acpimcfg_parse_callback(ACPI_RESOURCE *res, void *ctx) 133 { 134 struct acpimcfg_memrange *mr = ctx; 135 const char *type; 136 uint64_t size, mapaddr, mapsize; 137 int n; 138 139 switch (res->Type) { 140 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 141 type = "FIXED_MEMORY32"; 142 mapaddr = res->Data.FixedMemory32.Address; 143 mapsize = res->Data.FixedMemory32.AddressLength; 144 break; 145 146 case ACPI_RESOURCE_TYPE_ADDRESS32: 147 /* XXX Only fixed size supported for now */ 148 if (res->Data.Address32.Address.AddressLength == 0 || 149 res->Data.Address32.ProducerConsumer != ACPI_CONSUMER) 150 goto out; 151 152 if (res->Data.Address32.ResourceType != ACPI_MEMORY_RANGE) 153 goto out; 154 155 if (res->Data.Address32.MinAddressFixed != ACPI_ADDRESS_FIXED || 156 res->Data.Address32.MaxAddressFixed != ACPI_ADDRESS_FIXED) 157 goto out; 158 159 type = "ADDRESS32"; 160 mapaddr = res->Data.Address32.Address.Minimum; 161 mapsize = res->Data.Address32.Address.AddressLength; 162 break; 163 164 #ifdef _LP64 165 case ACPI_RESOURCE_TYPE_ADDRESS64: 166 /* XXX Only fixed size supported for now */ 167 if (res->Data.Address64.Address.AddressLength == 0 || 168 res->Data.Address64.ProducerConsumer != ACPI_CONSUMER) 169 goto out; 170 171 if (res->Data.Address64.ResourceType != ACPI_MEMORY_RANGE) 172 goto out; 173 174 if (res->Data.Address64.MinAddressFixed != ACPI_ADDRESS_FIXED || 175 res->Data.Address64.MaxAddressFixed != ACPI_ADDRESS_FIXED) 176 goto out; 177 178 type = "ADDRESS64"; 179 mapaddr = res->Data.Address64.Address.Minimum; 180 mapsize = res->Data.Address64.Address.AddressLength; 181 break; 182 #endif 183 184 default: 185 out: 186 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: %s: Type=%d\n", 187 mr->hid, res->Type); 188 return_ACPI_STATUS(AE_OK); 189 } 190 191 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: %s: Type=%d(%s), " 192 "Address=0x%016" PRIx64 ", Length=0x%016" PRIx64 "\n", 193 mr->hid, res->Type, type, mapaddr, mapsize); 194 195 if (mr->address < mapaddr || mr->address >= mapaddr + mapsize) 196 return_ACPI_STATUS(AE_OK); 197 198 size = (mr->bus_end - mr->bus_start + 1) * ACPIMCFG_SIZE_PER_BUS; 199 200 /* full map */ 201 if (mr->address + size <= mapaddr + mapsize) { 202 mr->found = true; 203 return_ACPI_STATUS(AE_CTRL_TERMINATE); 204 } 205 206 /* partial map */ 207 n = (mapsize - (mr->address - mapaddr)) / ACPIMCFG_SIZE_PER_BUS; 208 /* bus_start == bus_end is not allowed. */ 209 if (n > 1) { 210 mr->bus_end = mr->bus_start + n - 1; 211 mr->found = true; 212 return_ACPI_STATUS(AE_CTRL_TERMINATE); 213 } 214 215 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: bus %d-%d, " 216 "address 0x%016" PRIx64 ": invalid size: request 0x%016" PRIx64 217 ", actual 0x%016" PRIx64 "\n", 218 mr->bus_start, mr->bus_end, mr->address, size, mapsize); 219 220 return_ACPI_STATUS(AE_OK); 221 } 222 223 static ACPI_STATUS 224 acpimcfg_check_system_resource(ACPI_HANDLE handle, UINT32 level, void *ctx, 225 void **retval) 226 { 227 struct acpimcfg_memrange *mr = ctx; 228 ACPI_STATUS status; 229 230 status = AcpiWalkResources(handle, "_CRS", acpimcfg_parse_callback, mr); 231 if (ACPI_FAILURE(status)) 232 return_ACPI_STATUS(status); 233 234 if (mr->found) 235 return_ACPI_STATUS(AE_CTRL_TERMINATE); 236 237 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: %s: bus %d-%d, " 238 "address 0x%016" PRIx64 ": no valid region\n", mr->hid, 239 mr->bus_start, mr->bus_end, mr->address); 240 241 return_ACPI_STATUS(AE_OK); 242 } 243 244 static bool 245 acpimcfg_find_system_resource(uint64_t address, int bus_start, int *bus_end) 246 { 247 static const char *system_resource_hid[] = { 248 "PNP0C01", /* System Board */ 249 "PNP0C02" /* General ID for reserving resources */ 250 }; 251 struct acpimcfg_memrange mr; 252 ACPI_STATUS status; 253 int i; 254 255 mr.address = address; 256 mr.bus_start = bus_start; 257 mr.bus_end = *bus_end; 258 mr.found = false; 259 260 for (i = 0; i < __arraycount(system_resource_hid); i++) { 261 mr.hid = system_resource_hid[i]; 262 status = AcpiGetDevices(__UNCONST(system_resource_hid[i]), 263 acpimcfg_check_system_resource, &mr, NULL); 264 if (ACPI_FAILURE(status)) 265 continue; 266 if (mr.found) { 267 *bus_end = mr.bus_end; 268 return true; 269 } 270 } 271 return false; 272 } 273 274 275 /* 276 * ACPI MCFG 277 */ 278 void 279 acpimcfg_probe(struct acpi_softc *sc) 280 { 281 ACPI_MCFG_ALLOCATION *ama; 282 ACPI_STATUS status; 283 uint32_t offset; 284 int i, nsegs; 285 286 if (acpi_sc != NULL) 287 panic("acpi_sc != NULL"); 288 acpi_sc = sc; 289 290 status = AcpiGetTable(ACPI_SIG_MCFG, 0, (ACPI_TABLE_HEADER **)&mcfg); 291 if (ACPI_FAILURE(status)) { 292 mcfg = NULL; 293 return; 294 } 295 296 nsegs = 0; 297 offset = sizeof(ACPI_TABLE_MCFG); 298 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, mcfg, offset); 299 for (i = 0; offset + sizeof(ACPI_MCFG_ALLOCATION) <= 300 mcfg->Header.Length; i++) { 301 aprint_debug_dev(sc->sc_dev, 302 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 "\n", 303 ama->PciSegment, ama->StartBusNumber, ama->EndBusNumber, 304 ama->Address); 305 nsegs++; 306 offset += sizeof(ACPI_MCFG_ALLOCATION); 307 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, mcfg, offset); 308 } 309 if (nsegs == 0) { 310 mcfg = NULL; 311 return; 312 } 313 314 mcfg_segs = kmem_zalloc(sizeof(*mcfg_segs) * nsegs, KM_SLEEP); 315 mcfg_nsegs = nsegs; 316 } 317 318 int 319 acpimcfg_init(bus_space_tag_t memt, const struct acpimcfg_ops *ops) 320 { 321 ACPI_MCFG_ALLOCATION *ama; 322 struct mcfg_segment *seg; 323 uint32_t offset; 324 int i, n, nsegs, bus_end; 325 326 if (mcfg == NULL) 327 return ENXIO; 328 329 if (mcfg_inited) 330 return 0; 331 332 if (ops != NULL) 333 mcfg_ops = ops; 334 335 nsegs = 0; 336 offset = sizeof(ACPI_TABLE_MCFG); 337 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, mcfg, offset); 338 for (i = 0; offset < mcfg->Header.Length; i++) { 339 #ifndef _LP64 340 if (ama->Address >= 0x100000000ULL) { 341 aprint_debug_dev(acpi_sc->sc_dev, 342 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 343 ": ignore (64bit address)\n", ama->PciSegment, 344 ama->StartBusNumber, ama->EndBusNumber, 345 ama->Address); 346 goto next; 347 } 348 #endif 349 /* 350 * Some (broken?) BIOSen have an MCFG table for an empty 351 * bus range. Ignore those tables. 352 */ 353 if (ama->StartBusNumber == ama->EndBusNumber) { 354 aprint_debug_dev(acpi_sc->sc_dev, 355 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 356 ": ignore (bus %d == %d)\n", ama->PciSegment, 357 ama->StartBusNumber, ama->EndBusNumber, 358 ama->Address, ama->StartBusNumber, 359 ama->EndBusNumber); 360 goto next; 361 } 362 if (ama->StartBusNumber > ama->EndBusNumber) { 363 aprint_debug_dev(acpi_sc->sc_dev, 364 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 365 ": ignore (bus %d > %d)\n", ama->PciSegment, 366 ama->StartBusNumber, ama->EndBusNumber, 367 ama->Address, ama->StartBusNumber, 368 ama->EndBusNumber); 369 goto next; 370 } 371 372 /* Validate MCFG memory range */ 373 bus_end = ama->EndBusNumber; 374 if (mcfg_ops->ao_validate != NULL && 375 !mcfg_ops->ao_validate(ama->Address, ama->StartBusNumber, 376 &bus_end)) { 377 if (!acpimcfg_find_system_resource( ama->Address, 378 ama->StartBusNumber, &bus_end)) { 379 aprint_debug_dev(acpi_sc->sc_dev, 380 "MCFG: segment %d, bus %d-%d, " 381 "address 0x%016" PRIx64 382 ": ignore (invalid address)\n", 383 ama->PciSegment, 384 ama->StartBusNumber, ama->EndBusNumber, 385 ama->Address); 386 goto next; 387 } 388 } 389 if (ama->EndBusNumber != bus_end) { 390 aprint_debug_dev(acpi_sc->sc_dev, 391 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 392 " -> bus %d-%d\n", ama->PciSegment, 393 ama->StartBusNumber, ama->EndBusNumber, 394 ama->Address, ama->StartBusNumber, bus_end); 395 } 396 397 if (ama->PciSegment != 0) { 398 aprint_debug_dev(acpi_sc->sc_dev, 399 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 400 ": ignore (non PCI segment 0)\n", ama->PciSegment, 401 ama->StartBusNumber, bus_end, ama->Address); 402 goto next; 403 } 404 405 seg = &mcfg_segs[nsegs++]; 406 seg->ms_address = ama->Address; 407 seg->ms_segment = ama->PciSegment; 408 seg->ms_bus_start = ama->StartBusNumber; 409 seg->ms_bus_end = bus_end; 410 seg->ms_bst = memt; 411 n = seg->ms_bus_end - seg->ms_bus_start + 1; 412 seg->ms_bus = kmem_zalloc(sizeof(*seg->ms_bus) * n, KM_SLEEP); 413 414 next: 415 offset += sizeof(ACPI_MCFG_ALLOCATION); 416 ama = ACPI_ADD_PTR(ACPI_MCFG_ALLOCATION, mcfg, offset); 417 } 418 if (nsegs == 0) 419 return ENOENT; 420 421 for (i = 0; i < nsegs; i++) { 422 seg = &mcfg_segs[i]; 423 aprint_verbose_dev(acpi_sc->sc_dev, 424 "MCFG: segment %d, bus %d-%d, address 0x%016" PRIx64 "\n", 425 seg->ms_segment, seg->ms_bus_start, seg->ms_bus_end, 426 seg->ms_address); 427 } 428 429 /* Update # of segment */ 430 mcfg_nsegs = nsegs; 431 mcfg_inited = true; 432 433 return 0; 434 } 435 436 static int 437 acpimcfg_ext_conf_is_aliased(pci_chipset_tag_t pc, pcitag_t tag) 438 { 439 pcireg_t id; 440 int i; 441 442 id = pci_conf_read(pc, tag, PCI_ID_REG); 443 for (i = PCI_CONF_SIZE; i < PCI_EXTCONF_SIZE; i += PCI_CONF_SIZE) { 444 if (pci_conf_read(pc, tag, i) != id) 445 return false; 446 } 447 return true; 448 } 449 450 static struct mcfg_segment * 451 acpimcfg_get_segment(pci_chipset_tag_t pc, int bus) 452 { 453 struct mcfg_segment *seg; 454 u_int segment; 455 int i; 456 457 #ifdef __HAVE_PCI_GET_SEGMENT 458 segment = pci_get_segment(pc); 459 #else 460 segment = 0; 461 #endif 462 463 for (i = 0; i < mcfg_nsegs; i++) { 464 seg = &mcfg_segs[i]; 465 if (segment == seg->ms_segment && 466 bus >= seg->ms_bus_start && bus <= seg->ms_bus_end) 467 return seg; 468 } 469 return NULL; 470 } 471 472 static int 473 acpimcfg_device_probe(const struct pci_attach_args *pa) 474 { 475 pci_chipset_tag_t pc = pa->pa_pc; 476 struct mcfg_segment *seg; 477 struct mcfg_bus *mb; 478 pcitag_t tag; 479 pcireg_t reg; 480 int bus = pa->pa_bus; 481 int dev = pa->pa_device; 482 int func = pa->pa_function; 483 int last_dev, last_func, end_func; 484 int alias = 0; 485 const struct pci_quirkdata *qd; 486 bool force_hasextcnf = false; 487 bool force_noextcnf = false; 488 int i, j; 489 490 seg = acpimcfg_get_segment(pc, bus); 491 if (seg == NULL) 492 return 0; 493 494 mb = &seg->ms_bus[bus - seg->ms_bus_start]; 495 tag = pci_make_tag(pc, bus, dev, func); 496 497 /* Mark invalid between last probed device to probed device. */ 498 pci_decompose_tag(pc, mb->last_probed, NULL, &last_dev, &last_func); 499 if (dev != 0 || func != 0) { 500 for (i = last_dev; i <= dev; i++) { 501 end_func = (i == dev) ? func : 8; 502 for (j = last_func; j < end_func; j++) { 503 if (i == last_dev && j == last_func) 504 continue; 505 PCIDEV_SET_INVALID(mb, i, j); 506 } 507 last_func = 0; 508 } 509 } 510 mb->last_probed = tag; 511 512 reg = pci_conf_read(pc, tag, PCI_ID_REG); 513 qd = pci_lookup_quirkdata(PCI_VENDOR(reg), PCI_PRODUCT(reg)); 514 if (qd != NULL && (qd->quirks & PCI_QUIRK_HASEXTCNF) != 0) 515 force_hasextcnf = true; 516 if (qd != NULL && (qd->quirks & PCI_QUIRK_NOEXTCNF) != 0) 517 force_noextcnf = true; 518 519 /* Probe extended configuration space. */ 520 if ((!force_hasextcnf) && ((force_noextcnf) || 521 ((reg = pci_conf_read(pc, tag, PCI_CONF_SIZE)) == (pcireg_t)-1) 522 || (reg == 0) 523 || (alias = acpimcfg_ext_conf_is_aliased(pc, tag)))) { 524 aprint_debug_dev(acpi_sc->sc_dev, 525 "MCFG: %03d:%02d:%d: invalid config space " 526 "(cfg[0x%03x]=0x%08x, alias=%s)\n", bus, dev, func, 527 PCI_CONF_SIZE, reg, alias ? "true" : "false"); 528 EXTCONF_SET_INVALID(mb, dev, func); 529 } 530 531 aprint_debug_dev(acpi_sc->sc_dev, 532 "MCFG: %03d:%02d:%d: Ok (cfg[0x%03x]=0x%08x extconf=%c)\n", 533 bus, dev, func, PCI_CONF_SIZE, reg, 534 EXTCONF_IS_VALID(mb, dev, func) ? 'Y' : 'N'); 535 mb->valid_ndevs++; 536 537 return 0; 538 } 539 540 static void 541 acpimcfg_scan_bus(struct pci_softc *sc, pci_chipset_tag_t pc, int bus) 542 { 543 static const int wildcard[PCICF_NLOCS] = { 544 PCICF_DEV_DEFAULT, PCICF_FUNCTION_DEFAULT 545 }; 546 547 sc->sc_bus = bus; /* XXX */ 548 sc->sc_pc = pc; 549 550 pci_enumerate_bus(sc, wildcard, acpimcfg_device_probe, NULL); 551 } 552 553 int 554 acpimcfg_map_bus(device_t self, pci_chipset_tag_t pc, int bus) 555 { 556 struct pci_softc *sc = device_private(self); 557 struct mcfg_segment *seg = NULL; 558 struct mcfg_bus *mb; 559 bus_space_handle_t bsh; 560 bus_addr_t baddr; 561 pcitag_t tag; 562 pcireg_t reg; 563 bool is_e7520_mch; 564 int boff; 565 int last_dev, last_func; 566 int i, j; 567 int error; 568 569 if (!mcfg_inited) 570 return ENXIO; 571 572 seg = acpimcfg_get_segment(pc, bus); 573 if (seg == NULL) 574 return ENOENT; 575 576 boff = bus - seg->ms_bus_start; 577 if (seg->ms_bus[boff].valid_ndevs > 0) 578 return 0; 579 580 mb = &seg->ms_bus[boff]; 581 baddr = seg->ms_address + (boff * ACPIMCFG_SIZE_PER_BUS); 582 583 /* Map extended configration space of all dev/func. */ 584 error = bus_space_map(seg->ms_bst, baddr, ACPIMCFG_SIZE_PER_BUS, 0, 585 &bsh); 586 if (error != 0) 587 return error; 588 for (i = 0; i < 32; i++) { 589 for (j = 0; j < 8; j++) { 590 error = bus_space_subregion(seg->ms_bst, bsh, 591 EXTCONF_OFFSET(i, j, 0), PCI_EXTCONF_SIZE, 592 &mb->bsh[i][j]); 593 if (error != 0) 594 break; 595 } 596 } 597 if (error != 0) 598 return error; 599 600 aprint_debug("\n"); 601 602 /* Probe extended configuration space of all devices. */ 603 memset(mb->valid_devs, 0xff, sizeof(mb->valid_devs)); 604 memset(mb->valid_extconf, 0xff, sizeof(mb->valid_extconf)); 605 mb->valid_ndevs = 0; 606 mb->last_probed = pci_make_tag(pc, bus, 0, 0); 607 608 /* 609 * On an Intel E7520 we have to temporarily disable 610 * Enhanced Config Access error detection and reporting 611 * by setting the appropriate error mask in HI_ERRMASK register. 612 * 613 * See "Intel E7520 Memory Controller Hub (MCH) Datasheet", 614 * Document 303006-002, pg. 82 615 */ 616 tag = pci_make_tag(pc, 0, 0, 1); 617 reg = pci_conf_read(pc, tag, PCI_ID_REG); 618 is_e7520_mch = (reg == 619 PCI_ID_CODE(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_E7525_MCHER)); 620 if (is_e7520_mch) { 621 reg = pci_conf_read(pc, tag, 0x54); 622 pci_conf_write(pc, tag, 0x54, reg | 0x20); 623 } 624 625 acpimcfg_scan_bus(sc, pc, bus); 626 627 if (is_e7520_mch) { 628 pci_conf_write(pc, tag, 0x54, reg); 629 } 630 631 /* Unmap configuration space of all dev/func. */ 632 bus_space_unmap(seg->ms_bst, bsh, ACPIMCFG_SIZE_PER_BUS); 633 memset(mb->bsh, 0, sizeof(mb->bsh)); 634 635 if (mb->valid_ndevs == 0) { 636 aprint_debug_dev(acpi_sc->sc_dev, 637 "MCFG: bus %d: no valid devices.\n", bus); 638 memset(mb->valid_devs, 0, sizeof(mb->valid_devs)); 639 goto out; 640 } 641 642 /* Mark invalid on remaining all devices. */ 643 pci_decompose_tag(pc, mb->last_probed, NULL, &last_dev, &last_func); 644 for (i = last_dev; i < 32; i++) { 645 for (j = last_func; j < 8; j++) { 646 if (i == last_dev && j == last_func) { 647 /* Don't mark invalid to last probed device. */ 648 continue; 649 } 650 PCIDEV_SET_INVALID(mb, i, j); 651 } 652 last_func = 0; 653 } 654 655 /* Map configuration space per dev/func. */ 656 for (i = 0; i < 32; i++) { 657 for (j = 0; j < 8; j++) { 658 if (!PCIDEV_IS_VALID(mb, i, j)) 659 continue; 660 error = bus_space_map(seg->ms_bst, 661 baddr + EXTCONF_OFFSET(i, j, 0), PCI_EXTCONF_SIZE, 662 0, &mb->bsh[i][j]); 663 if (error != 0) { 664 /* Unmap all handles when map failed. */ 665 do { 666 while (--j >= 0) { 667 if (!PCIDEV_IS_VALID(mb, i, j)) 668 continue; 669 bus_space_unmap(seg->ms_bst, 670 mb->bsh[i][j], 671 PCI_EXTCONF_SIZE); 672 } 673 j = 8; 674 } while (--i >= 0); 675 memset(mb->valid_devs, 0, 676 sizeof(mb->valid_devs)); 677 goto out; 678 } 679 } 680 } 681 682 aprint_debug_dev(acpi_sc->sc_dev, "MCFG: bus %d: valid devices\n", bus); 683 for (i = 0; i < 32; i++) { 684 for (j = 0; j < 8; j++) { 685 if (PCIDEV_IS_VALID(mb, i, j)) { 686 aprint_debug_dev(acpi_sc->sc_dev, 687 "MCFG: %03d:%02d:%d\n", bus, i, j); 688 } 689 } 690 } 691 692 error = 0; 693 out: 694 aprint_debug_dev(acpi_sc->sc_dev, "%s done", __func__); 695 696 return error; 697 } 698 699 #ifdef PCI_NETBSD_CONFIGURE 700 struct acpimcfg_resource { 701 struct extent *ioext; 702 struct extent *memext; 703 struct extent *pmemext; 704 }; 705 706 static ACPI_STATUS 707 acpimcfg_configure_bus_cb(ACPI_RESOURCE *res, void *ctx) 708 { 709 struct acpimcfg_resource *pcires = ctx; 710 struct extent *ex; 711 const char *s; 712 int error; 713 714 if (res->Type != ACPI_RESOURCE_TYPE_ADDRESS32 && 715 res->Type != ACPI_RESOURCE_TYPE_ADDRESS64) 716 return AE_OK; 717 718 if (res->Data.Address.ProducerConsumer != ACPI_PRODUCER) 719 return AE_OK; 720 721 if (res->Data.Address.ResourceType != ACPI_MEMORY_RANGE && 722 res->Data.Address.ResourceType != ACPI_IO_RANGE) 723 return AE_OK; 724 725 if (res->Data.Address.ResourceType == ACPI_MEMORY_RANGE && 726 res->Data.Address.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY) { 727 if (pcires->pmemext == NULL) { 728 pcires->pmemext = extent_create("pcipmem", 0, ULONG_MAX, 729 NULL, 0, EX_WAITOK); 730 error = extent_alloc_region(pcires->pmemext, 0, ULONG_MAX, 731 EX_WAITOK); 732 if (error) { 733 extent_destroy(pcires->pmemext); 734 pcires->pmemext = NULL; 735 return AE_NO_MEMORY; 736 } 737 } 738 ex = pcires->pmemext; 739 s = "prefetchable"; 740 } else if (res->Data.Address.ResourceType == ACPI_MEMORY_RANGE && 741 res->Data.Address.Info.Mem.Caching != ACPI_PREFETCHABLE_MEMORY) { 742 if (pcires->memext == NULL) { 743 pcires->memext = extent_create("pcimem", 0, ULONG_MAX, 744 NULL, 0, EX_WAITOK); 745 error = extent_alloc_region(pcires->memext, 0, ULONG_MAX, 746 EX_WAITOK); 747 if (error) { 748 extent_destroy(pcires->memext); 749 pcires->memext = NULL; 750 return AE_NO_MEMORY; 751 } 752 } 753 ex = pcires->memext; 754 s = "non-prefetchable"; 755 } else if (res->Data.Address.ResourceType == ACPI_IO_RANGE) { 756 if (pcires->ioext == NULL) { 757 pcires->ioext = extent_create("pciio", 0, ULONG_MAX, 758 NULL, 0, EX_WAITOK); 759 error = extent_alloc_region(pcires->ioext, 0, ULONG_MAX, 760 EX_WAITOK); 761 if (error) { 762 extent_destroy(pcires->ioext); 763 pcires->ioext = NULL; 764 return AE_NO_MEMORY; 765 } 766 } 767 ex = pcires->ioext; 768 s = "i/o"; 769 770 } 771 772 switch (res->Type) { 773 case ACPI_RESOURCE_TYPE_ADDRESS16: 774 aprint_debug( 775 "MCFG: range 0x%04" PRIx16 " size %#" PRIx16 " (16-bit %s)\n", 776 res->Data.Address16.Address.Minimum, 777 res->Data.Address16.Address.AddressLength, 778 s); 779 error = extent_free(ex, res->Data.Address16.Address.Minimum, 780 res->Data.Address16.Address.AddressLength, EX_WAITOK); 781 if (error) 782 return AE_NO_MEMORY; 783 break; 784 case ACPI_RESOURCE_TYPE_ADDRESS32: 785 aprint_debug( 786 "MCFG: range 0x%08" PRIx32 " size %#" PRIx32 " (32-bit %s)\n", 787 res->Data.Address32.Address.Minimum, 788 res->Data.Address32.Address.AddressLength, 789 s); 790 error = extent_free(ex, res->Data.Address32.Address.Minimum, 791 res->Data.Address32.Address.AddressLength, EX_WAITOK); 792 if (error) 793 return AE_NO_MEMORY; 794 break; 795 case ACPI_RESOURCE_TYPE_ADDRESS64: 796 aprint_debug( 797 "MCFG: range 0x%016" PRIx64 " size %#" PRIx64 " (64-bit %s)\n", 798 res->Data.Address64.Address.Minimum, 799 res->Data.Address64.Address.AddressLength, 800 s); 801 error = extent_free(ex, res->Data.Address64.Address.Minimum, 802 res->Data.Address64.Address.AddressLength, EX_WAITOK); 803 if (error) 804 return AE_NO_MEMORY; 805 break; 806 } 807 808 return AE_OK; 809 } 810 811 int 812 acpimcfg_configure_bus(device_t self, pci_chipset_tag_t pc, ACPI_HANDLE handle, 813 int bus, int cacheline_size) 814 { 815 struct acpimcfg_resource res; 816 struct mcfg_segment *seg; 817 struct mcfg_bus *mb; 818 bus_space_handle_t bsh[256]; 819 bool bsh_mapped[256]; 820 int error, boff, b, d, f; 821 bus_addr_t baddr; 822 ACPI_STATUS rv; 823 824 seg = acpimcfg_get_segment(pc, bus); 825 if (seg == NULL) 826 return ENOENT; 827 828 /* 829 * Map config space for all possible busses and mark them valid during 830 * configuration so pci_configure_bus can access them through our chipset 831 * tag with acpimcfg_conf_read/write below. 832 */ 833 memset(bsh_mapped, 0, sizeof(bsh_mapped)); 834 for (b = seg->ms_bus_start; b <= seg->ms_bus_end; b++) { 835 boff = b - seg->ms_bus_start; 836 mb = &seg->ms_bus[boff]; 837 baddr = seg->ms_address + (boff * ACPIMCFG_SIZE_PER_BUS); 838 839 /* Map extended configration space of all dev/func. */ 840 error = bus_space_map(seg->ms_bst, baddr, ACPIMCFG_SIZE_PER_BUS, 0, 841 &bsh[b]); 842 if (error != 0) 843 goto cleanup; 844 bsh_mapped[b] = true; 845 for (d = 0; d < 32; d++) { 846 for (f = 0; f < 8; f++) { 847 error = bus_space_subregion(seg->ms_bst, bsh[b], 848 EXTCONF_OFFSET(d, f, 0), PCI_EXTCONF_SIZE, 849 &mb->bsh[d][f]); 850 if (error != 0) 851 break; 852 } 853 } 854 if (error != 0) 855 goto cleanup; 856 857 memset(mb->valid_devs, 0xff, sizeof(mb->valid_devs)); 858 } 859 860 memset(&res, 0, sizeof(res)); 861 rv = AcpiWalkResources(handle, "_CRS", acpimcfg_configure_bus_cb, &res); 862 if (ACPI_FAILURE(rv)) { 863 error = ENXIO; 864 goto cleanup; 865 } 866 867 error = pci_configure_bus(pc, res.ioext, res.memext, res.pmemext, bus, 868 cacheline_size); 869 870 cleanup: 871 /* 872 * Unmap config space for the segment's busses. Valid devices will be 873 * re-mapped later on by acpimcfg_map_bus. 874 */ 875 for (b = seg->ms_bus_start; b <= seg->ms_bus_end; b++) { 876 boff = b - seg->ms_bus_start; 877 mb = &seg->ms_bus[boff]; 878 memset(mb->valid_devs, 0, sizeof(mb->valid_devs)); 879 880 if (bsh_mapped[b]) 881 bus_space_unmap(seg->ms_bst, bsh[b], ACPIMCFG_SIZE_PER_BUS); 882 } 883 884 if (res.ioext) 885 extent_destroy(res.ioext); 886 if (res.memext) 887 extent_destroy(res.memext); 888 if (res.pmemext) 889 extent_destroy(res.pmemext); 890 891 return error; 892 } 893 #else 894 int 895 acpimcfg_configure_bus(device_t self, pci_chipset_tag_t pc, ACPI_HANDLE handle, 896 int bus, int cacheline_size) 897 { 898 return ENXIO; 899 } 900 #endif 901 902 int 903 acpimcfg_conf_read(pci_chipset_tag_t pc, pcitag_t tag, int reg, pcireg_t *data) 904 { 905 struct mcfg_segment *seg = NULL; 906 struct mcfg_bus *mb; 907 int bus, dev, func; 908 909 KASSERT(reg < PCI_EXTCONF_SIZE); 910 KASSERT((reg & 3) == 0); 911 912 if (!mcfg_inited) { 913 *data = -1; 914 return ENXIO; 915 } 916 917 pci_decompose_tag(pc, tag, &bus, &dev, &func); 918 919 seg = acpimcfg_get_segment(pc, bus); 920 if (seg == NULL) { 921 *data = -1; 922 return ERANGE; 923 } 924 925 mb = &seg->ms_bus[bus - seg->ms_bus_start]; 926 if (!PCIDEV_IS_VALID(mb, dev, func)) { 927 *data = -1; 928 return EINVAL; 929 } 930 if (!EXTCONF_IS_VALID(mb, dev, func) && reg >= PCI_CONF_SIZE) { 931 *data = -1; 932 return EINVAL; 933 } 934 935 *data = mcfg_ops->ao_read(seg->ms_bst, mb->bsh[dev][func], reg); 936 return 0; 937 } 938 939 int 940 acpimcfg_conf_write(pci_chipset_tag_t pc, pcitag_t tag, int reg, pcireg_t data) 941 { 942 struct mcfg_segment *seg = NULL; 943 struct mcfg_bus *mb; 944 int bus, dev, func; 945 946 KASSERT(reg < PCI_EXTCONF_SIZE); 947 KASSERT((reg & 3) == 0); 948 949 if (!mcfg_inited) 950 return ENXIO; 951 952 pci_decompose_tag(pc, tag, &bus, &dev, &func); 953 954 seg = acpimcfg_get_segment(pc, bus); 955 if (seg == NULL) 956 return ERANGE; 957 958 mb = &seg->ms_bus[bus - seg->ms_bus_start]; 959 if (!PCIDEV_IS_VALID(mb, dev, func)) 960 return EINVAL; 961 if (!EXTCONF_IS_VALID(mb, dev, func) && reg >= PCI_CONF_SIZE) 962 return EINVAL; 963 964 mcfg_ops->ao_write(seg->ms_bst, mb->bsh[dev][func], reg, data); 965 return 0; 966 } 967
Indexes created Mon Sep 22 21:09:42 GMT 2025