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, u32 flags) 229 { 230 acpi_status status; 231 u32 support_set, result, capbuf[3]; 232 233 /* do _OSC query for all possible controls */ 234 support_set = root->osc_support_set | (flags & OSC_PCI_SUPPORT_MASKS); 235 capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE; 236 capbuf[OSC_SUPPORT_TYPE] = support_set; 237 capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS; 238 239 status = acpi_pci_run_osc(root->device->handle, capbuf, &result); 240 if (ACPI_SUCCESS(status)) { 241 root->osc_support_set = support_set; 242 root->osc_control_qry = result; 243 root->osc_queried = 1; 244 } 245 return status; 246 } 247 248 static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags) 249 { 250 acpi_status status; 251 acpi_handle tmp; 252 253 status = acpi_get_handle(root->device->handle, "_OSC", &tmp); 254 if (ACPI_FAILURE(status)) 255 return status; 256 mutex_lock(&osc_lock); 257 status = acpi_pci_query_osc(root, flags); 258 mutex_unlock(&osc_lock); 259 return status; 260 } 261 262 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle) 263 { 264 struct acpi_pci_root *root; 265 266 list_for_each_entry(root, &acpi_pci_roots, node) { 267 if (root->device->handle == handle) 268 return root; 269 } 270 return NULL; 271 } 272 EXPORT_SYMBOL_GPL(acpi_pci_find_root); 273 274 struct acpi_handle_node { 275 struct list_head node; 276 acpi_handle handle; 277 }; 278 279 /** 280 * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev 281 * @handle: the handle in question 282 * 283 * Given an ACPI CA handle, the desired PCI device is located in the 284 * list of PCI devices. 285 * 286 * If the device is found, its reference count is increased and this 287 * function returns a pointer to its data structure. The caller must 288 * decrement the reference count by calling pci_dev_put(). 289 * If no device is found, %NULL is returned. 290 */ 291 struct pci_dev *acpi_get_pci_dev(acpi_handle handle) 292 { 293 int dev, fn; 294 unsigned long long adr; 295 acpi_status status; 296 acpi_handle phandle; 297 struct pci_bus *pbus; 298 struct pci_dev *pdev = NULL; 299 struct acpi_handle_node *node, *tmp; 300 struct acpi_pci_root *root; 301 LIST_HEAD(device_list); 302 303 /* 304 * Walk up the ACPI CA namespace until we reach a PCI root bridge. 305 */ 306 phandle = handle; 307 while (!acpi_is_root_bridge(phandle)) { 308 node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL); 309 if (!node) 310 goto out; 311 312 INIT_LIST_HEAD(&node->node); 313 node->handle = phandle; 314 list_add(&node->node, &device_list); 315 316 status = acpi_get_parent(phandle, &phandle); 317 if (ACPI_FAILURE(status)) 318 goto out; 319 } 320 321 root = acpi_pci_find_root(phandle); 322 if (!root) 323 goto out; 324 325 pbus = root->bus; 326 327 /* 328 * Now, walk back down the PCI device tree until we return to our 329 * original handle. Assumes that everything between the PCI root 330 * bridge and the device we're looking for must be a P2P bridge. 331 */ 332 list_for_each_entry(node, &device_list, node) { 333 acpi_handle hnd = node->handle; 334 status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr); 335 if (ACPI_FAILURE(status)) 336 goto out; 337 dev = (adr >> 16) & 0xffff; 338 fn = adr & 0xffff; 339 340 pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn)); 341 if (!pdev || hnd == handle) 342 break; 343 344 pbus = pdev->subordinate; 345 pci_dev_put(pdev); 346 347 /* 348 * This function may be called for a non-PCI device that has a 349 * PCI parent (eg. a disk under a PCI SATA controller). In that 350 * case pdev->subordinate will be NULL for the parent. 351 */ 352 if (!pbus) { 353 dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n"); 354 pdev = NULL; 355 break; 356 } 357 } 358 out: 359 list_for_each_entry_safe(node, tmp, &device_list, node) 360 kfree(node); 361 362 return pdev; 363 } 364 EXPORT_SYMBOL_GPL(acpi_get_pci_dev); 365 366 /** 367 * acpi_pci_osc_control_set - commit requested control to Firmware 368 * @handle: acpi_handle for the target ACPI object 369 * @flags: driver's requested control bits 370 * 371 * Attempt to take control from Firmware on requested control bits. 372 **/ 373 acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags) 374 { 375 acpi_status status; 376 u32 control_req, result, capbuf[3]; 377 acpi_handle tmp; 378 struct acpi_pci_root *root; 379 380 status = acpi_get_handle(handle, "_OSC", &tmp); 381 if (ACPI_FAILURE(status)) 382 return status; 383 384 control_req = (flags & OSC_PCI_CONTROL_MASKS); 385 if (!control_req) 386 return AE_TYPE; 387 388 root = acpi_pci_find_root(handle); 389 if (!root) 390 return AE_NOT_EXIST; 391 392 mutex_lock(&osc_lock); 393 /* No need to evaluate _OSC if the control was already granted. */ 394 if ((root->osc_control_set & control_req) == control_req) 395 goto out; 396 397 /* Need to query controls first before requesting them */ 398 if (!root->osc_queried) { 399 status = acpi_pci_query_osc(root, root->osc_support_set); 400 if (ACPI_FAILURE(status)) 401 goto out; 402 } 403 if ((root->osc_control_qry & control_req) != control_req) { 404 printk(KERN_DEBUG 405 "Firmware did not grant requested _OSC control\n"); 406 status = AE_SUPPORT; 407 goto out; 408 } 409 410 capbuf[OSC_QUERY_TYPE] = 0; 411 capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set; 412 capbuf[OSC_CONTROL_TYPE] = root->osc_control_set | control_req; 413 status = acpi_pci_run_osc(handle, capbuf, &result); 414 if (ACPI_SUCCESS(status)) 415 root->osc_control_set = result; 416 out: 417 mutex_unlock(&osc_lock); 418 return status; 419 } 420 EXPORT_SYMBOL(acpi_pci_osc_control_set); 421 422 static int __devinit acpi_pci_root_add(struct acpi_device *device) 423 { 424 unsigned long long segment, bus; 425 acpi_status status; 426 int result; 427 struct acpi_pci_root *root; 428 acpi_handle handle; 429 struct acpi_device *child; 430 u32 flags, base_flags; 431 432 root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL); 433 if (!root) 434 return -ENOMEM; 435 436 segment = 0; 437 status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL, 438 &segment); 439 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 440 printk(KERN_ERR PREFIX "can't evaluate _SEG\n"); 441 result = -ENODEV; 442 goto end; 443 } 444 445 /* Check _CRS first, then _BBN. If no _BBN, default to zero. */ 446 root->secondary.flags = IORESOURCE_BUS; 447 status = try_get_root_bridge_busnr(device->handle, &root->secondary); 448 if (ACPI_FAILURE(status)) { 449 /* 450 * We need both the start and end of the downstream bus range 451 * to interpret _CBA (MMCONFIG base address), so it really is 452 * supposed to be in _CRS. If we don't find it there, all we 453 * can do is assume [_BBN-0xFF] or [0-0xFF]. 454 */ 455 root->secondary.end = 0xFF; 456 printk(KERN_WARNING FW_BUG PREFIX 457 "no secondary bus range in _CRS\n"); 458 status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL, &bus); 459 if (ACPI_SUCCESS(status)) 460 root->secondary.start = bus; 461 else if (status == AE_NOT_FOUND) 462 root->secondary.start = 0; 463 else { 464 printk(KERN_ERR PREFIX "can't evaluate _BBN\n"); 465 result = -ENODEV; 466 goto end; 467 } 468 } 469 470 INIT_LIST_HEAD(&root->node); 471 root->device = device; 472 root->segment = segment & 0xFFFF; 473 strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME); 474 strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS); 475 device->driver_data = root; 476 477 /* 478 * All supported architectures that use ACPI have support for 479 * PCI domains, so we indicate this in _OSC support capabilities. 480 */ 481 flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT; 482 acpi_pci_osc_support(root, flags); 483 484 /* 485 * TBD: Need PCI interface for enumeration/configuration of roots. 486 */ 487 488 /* TBD: Locking */ 489 list_add_tail(&root->node, &acpi_pci_roots); 490 491 printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n", 492 acpi_device_name(device), acpi_device_bid(device), 493 root->segment, &root->secondary); 494 495 /* 496 * Scan the Root Bridge 497 * -------------------- 498 * Must do this prior to any attempt to bind the root device, as the 499 * PCI namespace does not get created until this call is made (and 500 * thus the root bridge's pci_dev does not exist). 501 */ 502 root->bus = pci_acpi_scan_root(root); 503 if (!root->bus) { 504 printk(KERN_ERR PREFIX 505 "Bus %04x:%02x not present in PCI namespace\n", 506 root->segment, (unsigned int)root->secondary.start); 507 result = -ENODEV; 508 goto end; 509 } 510 511 /* 512 * Attach ACPI-PCI Context 513 * ----------------------- 514 * Thus binding the ACPI and PCI devices. 515 */ 516 result = acpi_pci_bind_root(device); 517 if (result) 518 goto end; 519 520 /* 521 * PCI Routing Table 522 * ----------------- 523 * Evaluate and parse _PRT, if exists. 524 */ 525 status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle); 526 if (ACPI_SUCCESS(status)) 527 result = acpi_pci_irq_add_prt(device->handle, root->bus); 528 529 /* 530 * Scan and bind all _ADR-Based Devices 531 */ 532 list_for_each_entry(child, &device->children, node) 533 acpi_pci_bridge_scan(child); 534 535 /* Indicate support for various _OSC capabilities. */ 536 if (pci_ext_cfg_avail(root->bus->self)) 537 flags |= OSC_EXT_PCI_CONFIG_SUPPORT; 538 if (pcie_aspm_enabled()) 539 flags |= OSC_ACTIVE_STATE_PWR_SUPPORT | 540 OSC_CLOCK_PWR_CAPABILITY_SUPPORT; 541 if (pci_msi_enabled()) 542 flags |= OSC_MSI_SUPPORT; 543 if (flags != base_flags) 544 acpi_pci_osc_support(root, flags); 545 546 pci_acpi_add_bus_pm_notifier(device, root->bus); 547 if (device->wakeup.flags.run_wake) 548 device_set_run_wake(root->bus->bridge, true); 549 550 return 0; 551 552 end: 553 if (!list_empty(&root->node)) 554 list_del(&root->node); 555 kfree(root); 556 return result; 557 } 558 559 static int acpi_pci_root_start(struct acpi_device *device) 560 { 561 struct acpi_pci_root *root = acpi_driver_data(device); 562 563 pci_bus_add_devices(root->bus); 564 return 0; 565 } 566 567 static int acpi_pci_root_remove(struct acpi_device *device, int type) 568 { 569 struct acpi_pci_root *root = acpi_driver_data(device); 570 571 device_set_run_wake(root->bus->bridge, false); 572 pci_acpi_remove_bus_pm_notifier(device); 573 574 kfree(root); 575 return 0; 576 } 577 578 static int __init acpi_pci_root_init(void) 579 { 580 if (acpi_pci_disabled) 581 return 0; 582 583 pci_acpi_crs_quirks(); 584 if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0) 585 return -ENODEV; 586 587 return 0; 588 } 589 590 subsys_initcall(acpi_pci_root_init); 591