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