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