1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * ACPI PCI HotPlug glue functions to ACPI CA subsystem 4 * 5 * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com) 6 * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com) 7 * Copyright (C) 2002,2003 NEC Corporation 8 * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com) 9 * Copyright (C) 2003-2005 Hewlett Packard 10 * Copyright (C) 2005 Rajesh Shah (rajesh.shah@intel.com) 11 * Copyright (C) 2005 Intel Corporation 12 * 13 * All rights reserved. 14 * 15 * Send feedback to <kristen.c.accardi@intel.com> 16 * 17 */ 18 19 /* 20 * Lifetime rules for pci_dev: 21 * - The one in acpiphp_bridge has its refcount elevated by pci_get_slot() 22 * when the bridge is scanned and it loses a refcount when the bridge 23 * is removed. 24 * - When a P2P bridge is present, we elevate the refcount on the subordinate 25 * bus. It loses the refcount when the the driver unloads. 26 */ 27 28 #define pr_fmt(fmt) "acpiphp_glue: " fmt 29 30 #include <linux/module.h> 31 32 #include <linux/kernel.h> 33 #include <linux/pci.h> 34 #include <linux/pci_hotplug.h> 35 #include <linux/pci-acpi.h> 36 #include <linux/pm_runtime.h> 37 #include <linux/mutex.h> 38 #include <linux/slab.h> 39 #include <linux/acpi.h> 40 41 #include "../pci.h" 42 #include "acpiphp.h" 43 44 static LIST_HEAD(bridge_list); 45 static DEFINE_MUTEX(bridge_mutex); 46 47 static int acpiphp_hotplug_notify(struct acpi_device *adev, u32 type); 48 static void acpiphp_post_dock_fixup(struct acpi_device *adev); 49 static void acpiphp_sanitize_bus(struct pci_bus *bus); 50 static void hotplug_event(u32 type, struct acpiphp_context *context); 51 static void free_bridge(struct kref *kref); 52 53 /** 54 * acpiphp_init_context - Create hotplug context and grab a reference to it. 55 * @adev: ACPI device object to create the context for. 56 * 57 * Call under acpi_hp_context_lock. 58 */ 59 static struct acpiphp_context *acpiphp_init_context(struct acpi_device *adev) 60 { 61 struct acpiphp_context *context; 62 63 context = kzalloc(sizeof(*context), GFP_KERNEL); 64 if (!context) 65 return NULL; 66 67 context->refcount = 1; 68 context->hp.notify = acpiphp_hotplug_notify; 69 context->hp.fixup = acpiphp_post_dock_fixup; 70 acpi_set_hp_context(adev, &context->hp); 71 return context; 72 } 73 74 /** 75 * acpiphp_get_context - Get hotplug context and grab a reference to it. 76 * @adev: ACPI device object to get the context for. 77 * 78 * Call under acpi_hp_context_lock. 79 */ 80 static struct acpiphp_context *acpiphp_get_context(struct acpi_device *adev) 81 { 82 struct acpiphp_context *context; 83 84 if (!adev->hp) 85 return NULL; 86 87 context = to_acpiphp_context(adev->hp); 88 context->refcount++; 89 return context; 90 } 91 92 /** 93 * acpiphp_put_context - Drop a reference to ACPI hotplug context. 94 * @context: ACPI hotplug context to drop a reference to. 95 * 96 * The context object is removed if there are no more references to it. 97 * 98 * Call under acpi_hp_context_lock. 99 */ 100 static void acpiphp_put_context(struct acpiphp_context *context) 101 { 102 if (--context->refcount) 103 return; 104 105 WARN_ON(context->bridge); 106 context->hp.self->hp = NULL; 107 kfree(context); 108 } 109 110 static inline void get_bridge(struct acpiphp_bridge *bridge) 111 { 112 kref_get(&bridge->ref); 113 } 114 115 static inline void put_bridge(struct acpiphp_bridge *bridge) 116 { 117 kref_put(&bridge->ref, free_bridge); 118 } 119 120 static struct acpiphp_context *acpiphp_grab_context(struct acpi_device *adev) 121 { 122 struct acpiphp_context *context; 123 124 acpi_lock_hp_context(); 125 context = acpiphp_get_context(adev); 126 if (!context || context->func.parent->is_going_away) { 127 acpi_unlock_hp_context(); 128 return NULL; 129 } 130 get_bridge(context->func.parent); 131 acpiphp_put_context(context); 132 acpi_unlock_hp_context(); 133 return context; 134 } 135 136 static void acpiphp_let_context_go(struct acpiphp_context *context) 137 { 138 put_bridge(context->func.parent); 139 } 140 141 static void free_bridge(struct kref *kref) 142 { 143 struct acpiphp_context *context; 144 struct acpiphp_bridge *bridge; 145 struct acpiphp_slot *slot, *next; 146 struct acpiphp_func *func, *tmp; 147 148 acpi_lock_hp_context(); 149 150 bridge = container_of(kref, struct acpiphp_bridge, ref); 151 152 list_for_each_entry_safe(slot, next, &bridge->slots, node) { 153 list_for_each_entry_safe(func, tmp, &slot->funcs, sibling) 154 acpiphp_put_context(func_to_context(func)); 155 156 kfree(slot); 157 } 158 159 context = bridge->context; 160 /* Root bridges will not have hotplug context. */ 161 if (context) { 162 /* Release the reference taken by acpiphp_enumerate_slots(). */ 163 put_bridge(context->func.parent); 164 context->bridge = NULL; 165 acpiphp_put_context(context); 166 } 167 168 put_device(&bridge->pci_bus->dev); 169 pci_dev_put(bridge->pci_dev); 170 kfree(bridge); 171 172 acpi_unlock_hp_context(); 173 } 174 175 /** 176 * acpiphp_post_dock_fixup - Post-dock fixups for PCI devices. 177 * @adev: ACPI device object corresponding to a PCI device. 178 * 179 * TBD - figure out a way to only call fixups for systems that require them. 180 */ 181 static void acpiphp_post_dock_fixup(struct acpi_device *adev) 182 { 183 struct acpiphp_context *context = acpiphp_grab_context(adev); 184 struct pci_bus *bus; 185 u32 buses; 186 187 if (!context) 188 return; 189 190 bus = context->func.slot->bus; 191 if (!bus->self) 192 goto out; 193 194 /* fixup bad _DCK function that rewrites 195 * secondary bridge on slot 196 */ 197 pci_read_config_dword(bus->self, PCI_PRIMARY_BUS, &buses); 198 199 if (((buses >> 8) & 0xff) != bus->busn_res.start) { 200 buses = (buses & 0xff000000) 201 | ((unsigned int)(bus->primary) << 0) 202 | ((unsigned int)(bus->busn_res.start) << 8) 203 | ((unsigned int)(bus->busn_res.end) << 16); 204 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses); 205 } 206 207 out: 208 acpiphp_let_context_go(context); 209 } 210 211 /** 212 * acpiphp_add_context - Add ACPIPHP context to an ACPI device object. 213 * @handle: ACPI handle of the object to add a context to. 214 * @lvl: Not used. 215 * @data: The object's parent ACPIPHP bridge. 216 * @rv: Not used. 217 */ 218 static acpi_status acpiphp_add_context(acpi_handle handle, u32 lvl, void *data, 219 void **rv) 220 { 221 struct acpiphp_bridge *bridge = data; 222 struct acpiphp_context *context; 223 struct acpi_device *adev; 224 struct acpiphp_slot *slot; 225 struct acpiphp_func *newfunc; 226 acpi_status status = AE_OK; 227 unsigned long long adr; 228 int device, function; 229 struct pci_bus *pbus = bridge->pci_bus; 230 struct pci_dev *pdev = bridge->pci_dev; 231 u32 val; 232 233 status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr); 234 if (ACPI_FAILURE(status)) { 235 if (status != AE_NOT_FOUND) 236 acpi_handle_warn(handle, 237 "can't evaluate _ADR (%#x)\n", status); 238 return AE_OK; 239 } 240 if (acpi_bus_get_device(handle, &adev)) 241 return AE_OK; 242 243 device = (adr >> 16) & 0xffff; 244 function = adr & 0xffff; 245 246 acpi_lock_hp_context(); 247 context = acpiphp_init_context(adev); 248 if (!context) { 249 acpi_unlock_hp_context(); 250 acpi_handle_err(handle, "No hotplug context\n"); 251 return AE_NOT_EXIST; 252 } 253 newfunc = &context->func; 254 newfunc->function = function; 255 newfunc->parent = bridge; 256 acpi_unlock_hp_context(); 257 258 /* 259 * If this is a dock device, its _EJ0 should be executed by the dock 260 * notify handler after calling _DCK. 261 */ 262 if (!is_dock_device(adev) && acpi_has_method(handle, "_EJ0")) 263 newfunc->flags = FUNC_HAS_EJ0; 264 265 if (acpi_has_method(handle, "_STA")) 266 newfunc->flags |= FUNC_HAS_STA; 267 268 /* search for objects that share the same slot */ 269 list_for_each_entry(slot, &bridge->slots, node) 270 if (slot->device == device) 271 goto slot_found; 272 273 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); 274 if (!slot) { 275 acpi_lock_hp_context(); 276 acpiphp_put_context(context); 277 acpi_unlock_hp_context(); 278 return AE_NO_MEMORY; 279 } 280 281 slot->bus = bridge->pci_bus; 282 slot->device = device; 283 INIT_LIST_HEAD(&slot->funcs); 284 285 list_add_tail(&slot->node, &bridge->slots); 286 287 /* 288 * Expose slots to user space for functions that have _EJ0 or _RMV or 289 * are located in dock stations. Do not expose them for devices handled 290 * by the native PCIe hotplug (PCIeHP), becuase that code is supposed to 291 * expose slots to user space in those cases. 292 */ 293 if ((acpi_pci_check_ejectable(pbus, handle) || is_dock_device(adev)) 294 && !(pdev && pdev->is_hotplug_bridge && pciehp_is_native(pdev))) { 295 unsigned long long sun; 296 int retval; 297 298 bridge->nr_slots++; 299 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun); 300 if (ACPI_FAILURE(status)) 301 sun = bridge->nr_slots; 302 303 pr_debug("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n", 304 sun, pci_domain_nr(pbus), pbus->number, device); 305 306 retval = acpiphp_register_hotplug_slot(slot, sun); 307 if (retval) { 308 slot->slot = NULL; 309 bridge->nr_slots--; 310 if (retval == -EBUSY) 311 pr_warn("Slot %llu already registered by another hotplug driver\n", sun); 312 else 313 pr_warn("acpiphp_register_hotplug_slot failed (err code = 0x%x)\n", retval); 314 } 315 /* Even if the slot registration fails, we can still use it. */ 316 } 317 318 slot_found: 319 newfunc->slot = slot; 320 list_add_tail(&newfunc->sibling, &slot->funcs); 321 322 if (pci_bus_read_dev_vendor_id(pbus, PCI_DEVFN(device, function), 323 &val, 60*1000)) 324 slot->flags |= SLOT_ENABLED; 325 326 return AE_OK; 327 } 328 329 static void cleanup_bridge(struct acpiphp_bridge *bridge) 330 { 331 struct acpiphp_slot *slot; 332 struct acpiphp_func *func; 333 334 list_for_each_entry(slot, &bridge->slots, node) { 335 list_for_each_entry(func, &slot->funcs, sibling) { 336 struct acpi_device *adev = func_to_acpi_device(func); 337 338 acpi_lock_hp_context(); 339 adev->hp->notify = NULL; 340 adev->hp->fixup = NULL; 341 acpi_unlock_hp_context(); 342 } 343 slot->flags |= SLOT_IS_GOING_AWAY; 344 if (slot->slot) 345 acpiphp_unregister_hotplug_slot(slot); 346 } 347 348 mutex_lock(&bridge_mutex); 349 list_del(&bridge->list); 350 mutex_unlock(&bridge_mutex); 351 352 acpi_lock_hp_context(); 353 bridge->is_going_away = true; 354 acpi_unlock_hp_context(); 355 } 356 357 /** 358 * acpiphp_max_busnr - return the highest reserved bus number under the given bus. 359 * @bus: bus to start search with 360 */ 361 static unsigned char acpiphp_max_busnr(struct pci_bus *bus) 362 { 363 struct pci_bus *tmp; 364 unsigned char max, n; 365 366 /* 367 * pci_bus_max_busnr will return the highest 368 * reserved busnr for all these children. 369 * that is equivalent to the bus->subordinate 370 * value. We don't want to use the parent's 371 * bus->subordinate value because it could have 372 * padding in it. 373 */ 374 max = bus->busn_res.start; 375 376 list_for_each_entry(tmp, &bus->children, node) { 377 n = pci_bus_max_busnr(tmp); 378 if (n > max) 379 max = n; 380 } 381 return max; 382 } 383 384 static void acpiphp_set_acpi_region(struct acpiphp_slot *slot) 385 { 386 struct acpiphp_func *func; 387 union acpi_object params[2]; 388 struct acpi_object_list arg_list; 389 390 list_for_each_entry(func, &slot->funcs, sibling) { 391 arg_list.count = 2; 392 arg_list.pointer = params; 393 params[0].type = ACPI_TYPE_INTEGER; 394 params[0].integer.value = ACPI_ADR_SPACE_PCI_CONFIG; 395 params[1].type = ACPI_TYPE_INTEGER; 396 params[1].integer.value = 1; 397 /* _REG is optional, we don't care about if there is failure */ 398 acpi_evaluate_object(func_to_handle(func), "_REG", &arg_list, 399 NULL); 400 } 401 } 402 403 static void check_hotplug_bridge(struct acpiphp_slot *slot, struct pci_dev *dev) 404 { 405 struct acpiphp_func *func; 406 407 /* quirk, or pcie could set it already */ 408 if (dev->is_hotplug_bridge) 409 return; 410 411 list_for_each_entry(func, &slot->funcs, sibling) { 412 if (PCI_FUNC(dev->devfn) == func->function) { 413 dev->is_hotplug_bridge = 1; 414 break; 415 } 416 } 417 } 418 419 static int acpiphp_rescan_slot(struct acpiphp_slot *slot) 420 { 421 struct acpiphp_func *func; 422 423 list_for_each_entry(func, &slot->funcs, sibling) { 424 struct acpi_device *adev = func_to_acpi_device(func); 425 426 acpi_bus_scan(adev->handle); 427 if (acpi_device_enumerated(adev)) 428 acpi_device_set_power(adev, ACPI_STATE_D0); 429 } 430 return pci_scan_slot(slot->bus, PCI_DEVFN(slot->device, 0)); 431 } 432 433 /** 434 * enable_slot - enable, configure a slot 435 * @slot: slot to be enabled 436 * 437 * This function should be called per *physical slot*, 438 * not per each slot object in ACPI namespace. 439 */ 440 static void enable_slot(struct acpiphp_slot *slot) 441 { 442 struct pci_dev *dev; 443 struct pci_bus *bus = slot->bus; 444 struct acpiphp_func *func; 445 int max, pass; 446 LIST_HEAD(add_list); 447 448 acpiphp_rescan_slot(slot); 449 max = acpiphp_max_busnr(bus); 450 for (pass = 0; pass < 2; pass++) { 451 for_each_pci_bridge(dev, bus) { 452 if (PCI_SLOT(dev->devfn) != slot->device) 453 continue; 454 455 max = pci_scan_bridge(bus, dev, max, pass); 456 if (pass && dev->subordinate) { 457 check_hotplug_bridge(slot, dev); 458 pcibios_resource_survey_bus(dev->subordinate); 459 __pci_bus_size_bridges(dev->subordinate, &add_list); 460 } 461 } 462 } 463 __pci_bus_assign_resources(bus, &add_list, NULL); 464 465 acpiphp_sanitize_bus(bus); 466 pcie_bus_configure_settings(bus); 467 acpiphp_set_acpi_region(slot); 468 469 list_for_each_entry(dev, &bus->devices, bus_list) { 470 /* Assume that newly added devices are powered on already. */ 471 if (!dev->is_added) 472 dev->current_state = PCI_D0; 473 } 474 475 pci_bus_add_devices(bus); 476 477 slot->flags |= SLOT_ENABLED; 478 list_for_each_entry(func, &slot->funcs, sibling) { 479 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 480 func->function)); 481 if (!dev) { 482 /* Do not set SLOT_ENABLED flag if some funcs 483 are not added. */ 484 slot->flags &= (~SLOT_ENABLED); 485 continue; 486 } 487 } 488 } 489 490 /** 491 * disable_slot - disable a slot 492 * @slot: ACPI PHP slot 493 */ 494 static void disable_slot(struct acpiphp_slot *slot) 495 { 496 struct pci_bus *bus = slot->bus; 497 struct pci_dev *dev, *prev; 498 struct acpiphp_func *func; 499 500 /* 501 * enable_slot() enumerates all functions in this device via 502 * pci_scan_slot(), whether they have associated ACPI hotplug 503 * methods (_EJ0, etc.) or not. Therefore, we remove all functions 504 * here. 505 */ 506 list_for_each_entry_safe_reverse(dev, prev, &bus->devices, bus_list) 507 if (PCI_SLOT(dev->devfn) == slot->device) 508 pci_stop_and_remove_bus_device(dev); 509 510 list_for_each_entry(func, &slot->funcs, sibling) 511 acpi_bus_trim(func_to_acpi_device(func)); 512 513 slot->flags &= (~SLOT_ENABLED); 514 } 515 516 static bool slot_no_hotplug(struct acpiphp_slot *slot) 517 { 518 struct pci_bus *bus = slot->bus; 519 struct pci_dev *dev; 520 521 list_for_each_entry(dev, &bus->devices, bus_list) { 522 if (PCI_SLOT(dev->devfn) == slot->device && dev->ignore_hotplug) 523 return true; 524 } 525 return false; 526 } 527 528 /** 529 * get_slot_status - get ACPI slot status 530 * @slot: ACPI PHP slot 531 * 532 * If a slot has _STA for each function and if any one of them 533 * returned non-zero status, return it. 534 * 535 * If a slot doesn't have _STA and if any one of its functions' 536 * configuration space is configured, return 0x0f as a _STA. 537 * 538 * Otherwise return 0. 539 */ 540 static unsigned int get_slot_status(struct acpiphp_slot *slot) 541 { 542 unsigned long long sta = 0; 543 struct acpiphp_func *func; 544 545 list_for_each_entry(func, &slot->funcs, sibling) { 546 if (func->flags & FUNC_HAS_STA) { 547 acpi_status status; 548 549 status = acpi_evaluate_integer(func_to_handle(func), 550 "_STA", NULL, &sta); 551 if (ACPI_SUCCESS(status) && sta) 552 break; 553 } else { 554 u32 dvid; 555 556 pci_bus_read_config_dword(slot->bus, 557 PCI_DEVFN(slot->device, 558 func->function), 559 PCI_VENDOR_ID, &dvid); 560 if (dvid != 0xffffffff) { 561 sta = ACPI_STA_ALL; 562 break; 563 } 564 } 565 } 566 567 return (unsigned int)sta; 568 } 569 570 static inline bool device_status_valid(unsigned int sta) 571 { 572 /* 573 * ACPI spec says that _STA may return bit 0 clear with bit 3 set 574 * if the device is valid but does not require a device driver to be 575 * loaded (Section 6.3.7 of ACPI 5.0A). 576 */ 577 unsigned int mask = ACPI_STA_DEVICE_ENABLED | ACPI_STA_DEVICE_FUNCTIONING; 578 return (sta & mask) == mask; 579 } 580 581 /** 582 * trim_stale_devices - remove PCI devices that are not responding. 583 * @dev: PCI device to start walking the hierarchy from. 584 */ 585 static void trim_stale_devices(struct pci_dev *dev) 586 { 587 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 588 struct pci_bus *bus = dev->subordinate; 589 bool alive = dev->ignore_hotplug; 590 591 if (adev) { 592 acpi_status status; 593 unsigned long long sta; 594 595 status = acpi_evaluate_integer(adev->handle, "_STA", NULL, &sta); 596 alive = alive || (ACPI_SUCCESS(status) && device_status_valid(sta)); 597 } 598 if (!alive) 599 alive = pci_device_is_present(dev); 600 601 if (!alive) { 602 pci_stop_and_remove_bus_device(dev); 603 if (adev) 604 acpi_bus_trim(adev); 605 } else if (bus) { 606 struct pci_dev *child, *tmp; 607 608 /* The device is a bridge. so check the bus below it. */ 609 pm_runtime_get_sync(&dev->dev); 610 list_for_each_entry_safe_reverse(child, tmp, &bus->devices, bus_list) 611 trim_stale_devices(child); 612 613 pm_runtime_put(&dev->dev); 614 } 615 } 616 617 /** 618 * acpiphp_check_bridge - re-enumerate devices 619 * @bridge: where to begin re-enumeration 620 * 621 * Iterate over all slots under this bridge and make sure that if a 622 * card is present they are enabled, and if not they are disabled. 623 */ 624 static void acpiphp_check_bridge(struct acpiphp_bridge *bridge) 625 { 626 struct acpiphp_slot *slot; 627 628 /* Bail out if the bridge is going away. */ 629 if (bridge->is_going_away) 630 return; 631 632 if (bridge->pci_dev) 633 pm_runtime_get_sync(&bridge->pci_dev->dev); 634 635 list_for_each_entry(slot, &bridge->slots, node) { 636 struct pci_bus *bus = slot->bus; 637 struct pci_dev *dev, *tmp; 638 639 if (slot_no_hotplug(slot)) { 640 ; /* do nothing */ 641 } else if (device_status_valid(get_slot_status(slot))) { 642 /* remove stale devices if any */ 643 list_for_each_entry_safe_reverse(dev, tmp, 644 &bus->devices, bus_list) 645 if (PCI_SLOT(dev->devfn) == slot->device) 646 trim_stale_devices(dev); 647 648 /* configure all functions */ 649 enable_slot(slot); 650 } else { 651 disable_slot(slot); 652 } 653 } 654 655 if (bridge->pci_dev) 656 pm_runtime_put(&bridge->pci_dev->dev); 657 } 658 659 /* 660 * Remove devices for which we could not assign resources, call 661 * arch specific code to fix-up the bus 662 */ 663 static void acpiphp_sanitize_bus(struct pci_bus *bus) 664 { 665 struct pci_dev *dev, *tmp; 666 int i; 667 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; 668 669 list_for_each_entry_safe_reverse(dev, tmp, &bus->devices, bus_list) { 670 for (i = 0; i < PCI_BRIDGE_RESOURCES; i++) { 671 struct resource *res = &dev->resource[i]; 672 if ((res->flags & type_mask) && !res->start && 673 res->end) { 674 /* Could not assign a required resources 675 * for this device, remove it */ 676 pci_stop_and_remove_bus_device(dev); 677 break; 678 } 679 } 680 } 681 } 682 683 /* 684 * ACPI event handlers 685 */ 686 687 void acpiphp_check_host_bridge(struct acpi_device *adev) 688 { 689 struct acpiphp_bridge *bridge = NULL; 690 691 acpi_lock_hp_context(); 692 if (adev->hp) { 693 bridge = to_acpiphp_root_context(adev->hp)->root_bridge; 694 if (bridge) 695 get_bridge(bridge); 696 } 697 acpi_unlock_hp_context(); 698 if (bridge) { 699 pci_lock_rescan_remove(); 700 701 acpiphp_check_bridge(bridge); 702 703 pci_unlock_rescan_remove(); 704 put_bridge(bridge); 705 } 706 } 707 708 static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot); 709 710 static void hotplug_event(u32 type, struct acpiphp_context *context) 711 { 712 acpi_handle handle = context->hp.self->handle; 713 struct acpiphp_func *func = &context->func; 714 struct acpiphp_slot *slot = func->slot; 715 struct acpiphp_bridge *bridge; 716 717 acpi_lock_hp_context(); 718 bridge = context->bridge; 719 if (bridge) 720 get_bridge(bridge); 721 722 acpi_unlock_hp_context(); 723 724 pci_lock_rescan_remove(); 725 726 switch (type) { 727 case ACPI_NOTIFY_BUS_CHECK: 728 /* bus re-enumerate */ 729 acpi_handle_debug(handle, "Bus check in %s()\n", __func__); 730 if (bridge) 731 acpiphp_check_bridge(bridge); 732 else if (!(slot->flags & SLOT_IS_GOING_AWAY)) 733 enable_slot(slot); 734 735 break; 736 737 case ACPI_NOTIFY_DEVICE_CHECK: 738 /* device check */ 739 acpi_handle_debug(handle, "Device check in %s()\n", __func__); 740 if (bridge) { 741 acpiphp_check_bridge(bridge); 742 } else if (!(slot->flags & SLOT_IS_GOING_AWAY)) { 743 /* 744 * Check if anything has changed in the slot and rescan 745 * from the parent if that's the case. 746 */ 747 if (acpiphp_rescan_slot(slot)) 748 acpiphp_check_bridge(func->parent); 749 } 750 break; 751 752 case ACPI_NOTIFY_EJECT_REQUEST: 753 /* request device eject */ 754 acpi_handle_debug(handle, "Eject request in %s()\n", __func__); 755 acpiphp_disable_and_eject_slot(slot); 756 break; 757 } 758 759 pci_unlock_rescan_remove(); 760 if (bridge) 761 put_bridge(bridge); 762 } 763 764 static int acpiphp_hotplug_notify(struct acpi_device *adev, u32 type) 765 { 766 struct acpiphp_context *context; 767 768 context = acpiphp_grab_context(adev); 769 if (!context) 770 return -ENODATA; 771 772 hotplug_event(type, context); 773 acpiphp_let_context_go(context); 774 return 0; 775 } 776 777 /** 778 * acpiphp_enumerate_slots - Enumerate PCI slots for a given bus. 779 * @bus: PCI bus to enumerate the slots for. 780 * 781 * A "slot" is an object associated with a PCI device number. All functions 782 * (PCI devices) with the same bus and device number belong to the same slot. 783 */ 784 void acpiphp_enumerate_slots(struct pci_bus *bus) 785 { 786 struct acpiphp_bridge *bridge; 787 struct acpi_device *adev; 788 acpi_handle handle; 789 acpi_status status; 790 791 if (acpiphp_disabled) 792 return; 793 794 adev = ACPI_COMPANION(bus->bridge); 795 if (!adev) 796 return; 797 798 handle = adev->handle; 799 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 800 if (!bridge) 801 return; 802 803 INIT_LIST_HEAD(&bridge->slots); 804 kref_init(&bridge->ref); 805 bridge->pci_dev = pci_dev_get(bus->self); 806 bridge->pci_bus = bus; 807 808 /* 809 * Grab a ref to the subordinate PCI bus in case the bus is 810 * removed via PCI core logical hotplug. The ref pins the bus 811 * (which we access during module unload). 812 */ 813 get_device(&bus->dev); 814 815 acpi_lock_hp_context(); 816 if (pci_is_root_bus(bridge->pci_bus)) { 817 struct acpiphp_root_context *root_context; 818 819 root_context = kzalloc(sizeof(*root_context), GFP_KERNEL); 820 if (!root_context) 821 goto err; 822 823 root_context->root_bridge = bridge; 824 acpi_set_hp_context(adev, &root_context->hp); 825 } else { 826 struct acpiphp_context *context; 827 828 /* 829 * This bridge should have been registered as a hotplug function 830 * under its parent, so the context should be there, unless the 831 * parent is going to be handled by pciehp, in which case this 832 * bridge is not interesting to us either. 833 */ 834 context = acpiphp_get_context(adev); 835 if (!context) 836 goto err; 837 838 bridge->context = context; 839 context->bridge = bridge; 840 /* Get a reference to the parent bridge. */ 841 get_bridge(context->func.parent); 842 } 843 acpi_unlock_hp_context(); 844 845 /* Must be added to the list prior to calling acpiphp_add_context(). */ 846 mutex_lock(&bridge_mutex); 847 list_add(&bridge->list, &bridge_list); 848 mutex_unlock(&bridge_mutex); 849 850 /* register all slot objects under this bridge */ 851 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 852 acpiphp_add_context, NULL, bridge, NULL); 853 if (ACPI_FAILURE(status)) { 854 acpi_handle_err(handle, "failed to register slots\n"); 855 cleanup_bridge(bridge); 856 put_bridge(bridge); 857 } 858 return; 859 860 err: 861 acpi_unlock_hp_context(); 862 put_device(&bus->dev); 863 pci_dev_put(bridge->pci_dev); 864 kfree(bridge); 865 } 866 867 static void acpiphp_drop_bridge(struct acpiphp_bridge *bridge) 868 { 869 if (pci_is_root_bus(bridge->pci_bus)) { 870 struct acpiphp_root_context *root_context; 871 struct acpi_device *adev; 872 873 acpi_lock_hp_context(); 874 adev = ACPI_COMPANION(bridge->pci_bus->bridge); 875 root_context = to_acpiphp_root_context(adev->hp); 876 adev->hp = NULL; 877 acpi_unlock_hp_context(); 878 kfree(root_context); 879 } 880 cleanup_bridge(bridge); 881 put_bridge(bridge); 882 } 883 884 /** 885 * acpiphp_remove_slots - Remove slot objects associated with a given bus. 886 * @bus: PCI bus to remove the slot objects for. 887 */ 888 void acpiphp_remove_slots(struct pci_bus *bus) 889 { 890 struct acpiphp_bridge *bridge; 891 892 if (acpiphp_disabled) 893 return; 894 895 mutex_lock(&bridge_mutex); 896 list_for_each_entry(bridge, &bridge_list, list) 897 if (bridge->pci_bus == bus) { 898 mutex_unlock(&bridge_mutex); 899 acpiphp_drop_bridge(bridge); 900 return; 901 } 902 903 mutex_unlock(&bridge_mutex); 904 } 905 906 /** 907 * acpiphp_enable_slot - power on slot 908 * @slot: ACPI PHP slot 909 */ 910 int acpiphp_enable_slot(struct acpiphp_slot *slot) 911 { 912 pci_lock_rescan_remove(); 913 914 if (slot->flags & SLOT_IS_GOING_AWAY) { 915 pci_unlock_rescan_remove(); 916 return -ENODEV; 917 } 918 919 /* configure all functions */ 920 if (!(slot->flags & SLOT_ENABLED)) 921 enable_slot(slot); 922 923 pci_unlock_rescan_remove(); 924 return 0; 925 } 926 927 /** 928 * acpiphp_disable_and_eject_slot - power off and eject slot 929 * @slot: ACPI PHP slot 930 */ 931 static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot) 932 { 933 struct acpiphp_func *func; 934 935 if (slot->flags & SLOT_IS_GOING_AWAY) 936 return -ENODEV; 937 938 /* unconfigure all functions */ 939 disable_slot(slot); 940 941 list_for_each_entry(func, &slot->funcs, sibling) 942 if (func->flags & FUNC_HAS_EJ0) { 943 acpi_handle handle = func_to_handle(func); 944 945 if (ACPI_FAILURE(acpi_evaluate_ej0(handle))) 946 acpi_handle_err(handle, "_EJ0 failed\n"); 947 948 break; 949 } 950 951 return 0; 952 } 953 954 int acpiphp_disable_slot(struct acpiphp_slot *slot) 955 { 956 int ret; 957 958 /* 959 * Acquire acpi_scan_lock to ensure that the execution of _EJ0 in 960 * acpiphp_disable_and_eject_slot() will be synchronized properly. 961 */ 962 acpi_scan_lock_acquire(); 963 pci_lock_rescan_remove(); 964 ret = acpiphp_disable_and_eject_slot(slot); 965 pci_unlock_rescan_remove(); 966 acpi_scan_lock_release(); 967 return ret; 968 } 969 970 /* 971 * slot enabled: 1 972 * slot disabled: 0 973 */ 974 u8 acpiphp_get_power_status(struct acpiphp_slot *slot) 975 { 976 return (slot->flags & SLOT_ENABLED); 977 } 978 979 /* 980 * latch open: 1 981 * latch closed: 0 982 */ 983 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot) 984 { 985 return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI); 986 } 987 988 /* 989 * adapter presence : 1 990 * absence : 0 991 */ 992 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) 993 { 994 return !!get_slot_status(slot); 995 } 996