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