1 /* 2 * pci_root.c - ACPI PCI Root Bridge Driver ($Revision: 40 $) 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or (at 12 * your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write to the Free Software Foundation, Inc., 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26 #include <linux/kernel.h> 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <linux/types.h> 30 #include <linux/proc_fs.h> 31 #include <linux/spinlock.h> 32 #include <linux/pm.h> 33 #include <linux/pm_runtime.h> 34 #include <linux/pci.h> 35 #include <linux/pci-acpi.h> 36 #include <linux/acpi.h> 37 #include <linux/slab.h> 38 #include <acpi/acpi_bus.h> 39 #include <acpi/acpi_drivers.h> 40 41 #define PREFIX "ACPI: " 42 43 #define _COMPONENT ACPI_PCI_COMPONENT 44 ACPI_MODULE_NAME("pci_root"); 45 #define ACPI_PCI_ROOT_CLASS "pci_bridge" 46 #define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge" 47 static int acpi_pci_root_add(struct acpi_device *device); 48 static int acpi_pci_root_remove(struct acpi_device *device, int type); 49 static int acpi_pci_root_start(struct acpi_device *device); 50 51 static const struct acpi_device_id root_device_ids[] = { 52 {"PNP0A03", 0}, 53 {"", 0}, 54 }; 55 MODULE_DEVICE_TABLE(acpi, root_device_ids); 56 57 static struct acpi_driver acpi_pci_root_driver = { 58 .name = "pci_root", 59 .class = ACPI_PCI_ROOT_CLASS, 60 .ids = root_device_ids, 61 .ops = { 62 .add = acpi_pci_root_add, 63 .remove = acpi_pci_root_remove, 64 .start = acpi_pci_root_start, 65 }, 66 }; 67 68 static LIST_HEAD(acpi_pci_roots); 69 70 static struct acpi_pci_driver *sub_driver; 71 static DEFINE_MUTEX(osc_lock); 72 73 int acpi_pci_register_driver(struct acpi_pci_driver *driver) 74 { 75 int n = 0; 76 struct acpi_pci_root *root; 77 78 struct acpi_pci_driver **pptr = &sub_driver; 79 while (*pptr) 80 pptr = &(*pptr)->next; 81 *pptr = driver; 82 83 if (!driver->add) 84 return 0; 85 86 list_for_each_entry(root, &acpi_pci_roots, node) { 87 driver->add(root->device->handle); 88 n++; 89 } 90 91 return n; 92 } 93 94 EXPORT_SYMBOL(acpi_pci_register_driver); 95 96 void acpi_pci_unregister_driver(struct acpi_pci_driver *driver) 97 { 98 struct acpi_pci_root *root; 99 100 struct acpi_pci_driver **pptr = &sub_driver; 101 while (*pptr) { 102 if (*pptr == driver) 103 break; 104 pptr = &(*pptr)->next; 105 } 106 BUG_ON(!*pptr); 107 *pptr = (*pptr)->next; 108 109 if (!driver->remove) 110 return; 111 112 list_for_each_entry(root, &acpi_pci_roots, node) 113 driver->remove(root->device->handle); 114 } 115 116 EXPORT_SYMBOL(acpi_pci_unregister_driver); 117 118 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus) 119 { 120 struct acpi_pci_root *root; 121 122 list_for_each_entry(root, &acpi_pci_roots, node) 123 if ((root->segment == (u16) seg) && 124 (root->secondary.start == (u16) bus)) 125 return root->device->handle; 126 return NULL; 127 } 128 129 EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle); 130 131 /** 132 * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge 133 * @handle - the ACPI CA node in question. 134 * 135 * Note: we could make this API take a struct acpi_device * instead, but 136 * for now, it's more convenient to operate on an acpi_handle. 137 */ 138 int acpi_is_root_bridge(acpi_handle handle) 139 { 140 int ret; 141 struct acpi_device *device; 142 143 ret = acpi_bus_get_device(handle, &device); 144 if (ret) 145 return 0; 146 147 ret = acpi_match_device_ids(device, root_device_ids); 148 if (ret) 149 return 0; 150 else 151 return 1; 152 } 153 EXPORT_SYMBOL_GPL(acpi_is_root_bridge); 154 155 static acpi_status 156 get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data) 157 { 158 struct resource *res = data; 159 struct acpi_resource_address64 address; 160 161 if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 && 162 resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 && 163 resource->type != ACPI_RESOURCE_TYPE_ADDRESS64) 164 return AE_OK; 165 166 acpi_resource_to_address64(resource, &address); 167 if ((address.address_length > 0) && 168 (address.resource_type == ACPI_BUS_NUMBER_RANGE)) { 169 res->start = address.minimum; 170 res->end = address.minimum + address.address_length - 1; 171 } 172 173 return AE_OK; 174 } 175 176 static acpi_status try_get_root_bridge_busnr(acpi_handle handle, 177 struct resource *res) 178 { 179 acpi_status status; 180 181 res->start = -1; 182 status = 183 acpi_walk_resources(handle, METHOD_NAME__CRS, 184 get_root_bridge_busnr_callback, res); 185 if (ACPI_FAILURE(status)) 186 return status; 187 if (res->start == -1) 188 return AE_ERROR; 189 return AE_OK; 190 } 191 192 static void acpi_pci_bridge_scan(struct acpi_device *device) 193 { 194 int status; 195 struct acpi_device *child = NULL; 196 197 if (device->flags.bus_address) 198 if (device->parent && device->parent->ops.bind) { 199 status = device->parent->ops.bind(device); 200 if (!status) { 201 list_for_each_entry(child, &device->children, node) 202 acpi_pci_bridge_scan(child); 203 } 204 } 205 } 206 207 static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766"; 208 209 static acpi_status acpi_pci_run_osc(acpi_handle handle, 210 const u32 *capbuf, u32 *retval) 211 { 212 struct acpi_osc_context context = { 213 .uuid_str = pci_osc_uuid_str, 214 .rev = 1, 215 .cap.length = 12, 216 .cap.pointer = (void *)capbuf, 217 }; 218 acpi_status status; 219 220 status = acpi_run_osc(handle, &context); 221 if (ACPI_SUCCESS(status)) { 222 *retval = *((u32 *)(context.ret.pointer + 8)); 223 kfree(context.ret.pointer); 224 } 225 return status; 226 } 227 228 static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, 229 u32 support, 230 u32 *control) 231 { 232 acpi_status status; 233 u32 result, capbuf[3]; 234 235 support &= OSC_PCI_SUPPORT_MASKS; 236 support |= root->osc_support_set; 237 238 capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE; 239 capbuf[OSC_SUPPORT_TYPE] = support; 240 if (control) { 241 *control &= OSC_PCI_CONTROL_MASKS; 242 capbuf[OSC_CONTROL_TYPE] = *control | root->osc_control_set; 243 } else { 244 /* Run _OSC query for all possible controls. */ 245 capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS; 246 } 247 248 status = acpi_pci_run_osc(root->device->handle, capbuf, &result); 249 if (ACPI_SUCCESS(status)) { 250 root->osc_support_set = support; 251 if (control) 252 *control = result; 253 } 254 return status; 255 } 256 257 static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags) 258 { 259 acpi_status status; 260 acpi_handle tmp; 261 262 status = acpi_get_handle(root->device->handle, "_OSC", &tmp); 263 if (ACPI_FAILURE(status)) 264 return status; 265 mutex_lock(&osc_lock); 266 status = acpi_pci_query_osc(root, flags, NULL); 267 mutex_unlock(&osc_lock); 268 return status; 269 } 270 271 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle) 272 { 273 struct acpi_pci_root *root; 274 275 list_for_each_entry(root, &acpi_pci_roots, node) { 276 if (root->device->handle == handle) 277 return root; 278 } 279 return NULL; 280 } 281 EXPORT_SYMBOL_GPL(acpi_pci_find_root); 282 283 struct acpi_handle_node { 284 struct list_head node; 285 acpi_handle handle; 286 }; 287 288 /** 289 * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev 290 * @handle: the handle in question 291 * 292 * Given an ACPI CA handle, the desired PCI device is located in the 293 * list of PCI devices. 294 * 295 * If the device is found, its reference count is increased and this 296 * function returns a pointer to its data structure. The caller must 297 * decrement the reference count by calling pci_dev_put(). 298 * If no device is found, %NULL is returned. 299 */ 300 struct pci_dev *acpi_get_pci_dev(acpi_handle handle) 301 { 302 int dev, fn; 303 unsigned long long adr; 304 acpi_status status; 305 acpi_handle phandle; 306 struct pci_bus *pbus; 307 struct pci_dev *pdev = NULL; 308 struct acpi_handle_node *node, *tmp; 309 struct acpi_pci_root *root; 310 LIST_HEAD(device_list); 311 312 /* 313 * Walk up the ACPI CA namespace until we reach a PCI root bridge. 314 */ 315 phandle = handle; 316 while (!acpi_is_root_bridge(phandle)) { 317 node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL); 318 if (!node) 319 goto out; 320 321 INIT_LIST_HEAD(&node->node); 322 node->handle = phandle; 323 list_add(&node->node, &device_list); 324 325 status = acpi_get_parent(phandle, &phandle); 326 if (ACPI_FAILURE(status)) 327 goto out; 328 } 329 330 root = acpi_pci_find_root(phandle); 331 if (!root) 332 goto out; 333 334 pbus = root->bus; 335 336 /* 337 * Now, walk back down the PCI device tree until we return to our 338 * original handle. Assumes that everything between the PCI root 339 * bridge and the device we're looking for must be a P2P bridge. 340 */ 341 list_for_each_entry(node, &device_list, node) { 342 acpi_handle hnd = node->handle; 343 status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr); 344 if (ACPI_FAILURE(status)) 345 goto out; 346 dev = (adr >> 16) & 0xffff; 347 fn = adr & 0xffff; 348 349 pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn)); 350 if (!pdev || hnd == handle) 351 break; 352 353 pbus = pdev->subordinate; 354 pci_dev_put(pdev); 355 356 /* 357 * This function may be called for a non-PCI device that has a 358 * PCI parent (eg. a disk under a PCI SATA controller). In that 359 * case pdev->subordinate will be NULL for the parent. 360 */ 361 if (!pbus) { 362 dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n"); 363 pdev = NULL; 364 break; 365 } 366 } 367 out: 368 list_for_each_entry_safe(node, tmp, &device_list, node) 369 kfree(node); 370 371 return pdev; 372 } 373 EXPORT_SYMBOL_GPL(acpi_get_pci_dev); 374 375 /** 376 * acpi_pci_osc_control_set - Request control of PCI root _OSC features. 377 * @handle: ACPI handle of a PCI root bridge (or PCIe Root Complex). 378 * @mask: Mask of _OSC bits to request control of, place to store control mask. 379 * @req: Mask of _OSC bits the control of is essential to the caller. 380 * 381 * Run _OSC query for @mask and if that is successful, compare the returned 382 * mask of control bits with @req. If all of the @req bits are set in the 383 * returned mask, run _OSC request for it. 384 * 385 * The variable at the @mask address may be modified regardless of whether or 386 * not the function returns success. On success it will contain the mask of 387 * _OSC bits the BIOS has granted control of, but its contents are meaningless 388 * on failure. 389 **/ 390 acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req) 391 { 392 struct acpi_pci_root *root; 393 acpi_status status; 394 u32 ctrl, capbuf[3]; 395 acpi_handle tmp; 396 397 if (!mask) 398 return AE_BAD_PARAMETER; 399 400 ctrl = *mask & OSC_PCI_CONTROL_MASKS; 401 if ((ctrl & req) != req) 402 return AE_TYPE; 403 404 root = acpi_pci_find_root(handle); 405 if (!root) 406 return AE_NOT_EXIST; 407 408 status = acpi_get_handle(handle, "_OSC", &tmp); 409 if (ACPI_FAILURE(status)) 410 return status; 411 412 mutex_lock(&osc_lock); 413 414 *mask = ctrl | root->osc_control_set; 415 /* No need to evaluate _OSC if the control was already granted. */ 416 if ((root->osc_control_set & ctrl) == ctrl) 417 goto out; 418 419 /* Need to check the available controls bits before requesting them. */ 420 while (*mask) { 421 status = acpi_pci_query_osc(root, root->osc_support_set, mask); 422 if (ACPI_FAILURE(status)) 423 goto out; 424 if (ctrl == *mask) 425 break; 426 ctrl = *mask; 427 } 428 429 if ((ctrl & req) != req) { 430 status = AE_SUPPORT; 431 goto out; 432 } 433 434 capbuf[OSC_QUERY_TYPE] = 0; 435 capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set; 436 capbuf[OSC_CONTROL_TYPE] = ctrl; 437 status = acpi_pci_run_osc(handle, capbuf, mask); 438 if (ACPI_SUCCESS(status)) 439 root->osc_control_set = *mask; 440 out: 441 mutex_unlock(&osc_lock); 442 return status; 443 } 444 EXPORT_SYMBOL(acpi_pci_osc_control_set); 445 446 static int __devinit acpi_pci_root_add(struct acpi_device *device) 447 { 448 unsigned long long segment, bus; 449 acpi_status status; 450 int result; 451 struct acpi_pci_root *root; 452 acpi_handle handle; 453 struct acpi_device *child; 454 u32 flags, base_flags; 455 456 root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL); 457 if (!root) 458 return -ENOMEM; 459 460 segment = 0; 461 status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL, 462 &segment); 463 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 464 printk(KERN_ERR PREFIX "can't evaluate _SEG\n"); 465 result = -ENODEV; 466 goto end; 467 } 468 469 /* Check _CRS first, then _BBN. If no _BBN, default to zero. */ 470 root->secondary.flags = IORESOURCE_BUS; 471 status = try_get_root_bridge_busnr(device->handle, &root->secondary); 472 if (ACPI_FAILURE(status)) { 473 /* 474 * We need both the start and end of the downstream bus range 475 * to interpret _CBA (MMCONFIG base address), so it really is 476 * supposed to be in _CRS. If we don't find it there, all we 477 * can do is assume [_BBN-0xFF] or [0-0xFF]. 478 */ 479 root->secondary.end = 0xFF; 480 printk(KERN_WARNING FW_BUG PREFIX 481 "no secondary bus range in _CRS\n"); 482 status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL, &bus); 483 if (ACPI_SUCCESS(status)) 484 root->secondary.start = bus; 485 else if (status == AE_NOT_FOUND) 486 root->secondary.start = 0; 487 else { 488 printk(KERN_ERR PREFIX "can't evaluate _BBN\n"); 489 result = -ENODEV; 490 goto end; 491 } 492 } 493 494 INIT_LIST_HEAD(&root->node); 495 root->device = device; 496 root->segment = segment & 0xFFFF; 497 strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME); 498 strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS); 499 device->driver_data = root; 500 501 /* 502 * All supported architectures that use ACPI have support for 503 * PCI domains, so we indicate this in _OSC support capabilities. 504 */ 505 flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT; 506 acpi_pci_osc_support(root, flags); 507 508 /* 509 * TBD: Need PCI interface for enumeration/configuration of roots. 510 */ 511 512 /* TBD: Locking */ 513 list_add_tail(&root->node, &acpi_pci_roots); 514 515 printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n", 516 acpi_device_name(device), acpi_device_bid(device), 517 root->segment, &root->secondary); 518 519 /* 520 * Scan the Root Bridge 521 * -------------------- 522 * Must do this prior to any attempt to bind the root device, as the 523 * PCI namespace does not get created until this call is made (and 524 * thus the root bridge's pci_dev does not exist). 525 */ 526 root->bus = pci_acpi_scan_root(root); 527 if (!root->bus) { 528 printk(KERN_ERR PREFIX 529 "Bus %04x:%02x not present in PCI namespace\n", 530 root->segment, (unsigned int)root->secondary.start); 531 result = -ENODEV; 532 goto end; 533 } 534 535 /* 536 * Attach ACPI-PCI Context 537 * ----------------------- 538 * Thus binding the ACPI and PCI devices. 539 */ 540 result = acpi_pci_bind_root(device); 541 if (result) 542 goto end; 543 544 /* 545 * PCI Routing Table 546 * ----------------- 547 * Evaluate and parse _PRT, if exists. 548 */ 549 status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle); 550 if (ACPI_SUCCESS(status)) 551 result = acpi_pci_irq_add_prt(device->handle, root->bus); 552 553 /* 554 * Scan and bind all _ADR-Based Devices 555 */ 556 list_for_each_entry(child, &device->children, node) 557 acpi_pci_bridge_scan(child); 558 559 /* Indicate support for various _OSC capabilities. */ 560 if (pci_ext_cfg_avail(root->bus->self)) 561 flags |= OSC_EXT_PCI_CONFIG_SUPPORT; 562 if (pcie_aspm_enabled()) 563 flags |= OSC_ACTIVE_STATE_PWR_SUPPORT | 564 OSC_CLOCK_PWR_CAPABILITY_SUPPORT; 565 if (pci_msi_enabled()) 566 flags |= OSC_MSI_SUPPORT; 567 if (flags != base_flags) 568 acpi_pci_osc_support(root, flags); 569 570 pci_acpi_add_bus_pm_notifier(device, root->bus); 571 if (device->wakeup.flags.run_wake) 572 device_set_run_wake(root->bus->bridge, true); 573 574 return 0; 575 576 end: 577 if (!list_empty(&root->node)) 578 list_del(&root->node); 579 kfree(root); 580 return result; 581 } 582 583 static int acpi_pci_root_start(struct acpi_device *device) 584 { 585 struct acpi_pci_root *root = acpi_driver_data(device); 586 587 pci_bus_add_devices(root->bus); 588 return 0; 589 } 590 591 static int acpi_pci_root_remove(struct acpi_device *device, int type) 592 { 593 struct acpi_pci_root *root = acpi_driver_data(device); 594 595 device_set_run_wake(root->bus->bridge, false); 596 pci_acpi_remove_bus_pm_notifier(device); 597 598 kfree(root); 599 return 0; 600 } 601 602 static int __init acpi_pci_root_init(void) 603 { 604 if (acpi_pci_disabled) 605 return 0; 606 607 pci_acpi_crs_quirks(); 608 if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0) 609 return -ENODEV; 610 611 return 0; 612 } 613 614 subsys_initcall(acpi_pci_root_init); 615