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