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