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