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_func has its refcount elevated by pci_get_slot() 36 * when the driver is loaded or when an insertion event occurs. It loses 37 * a refcount when its ejected or the driver unloads. 38 * - The one in acpiphp_bridge has its refcount elevated by pci_get_slot() 39 * when the bridge is scanned and it loses a refcount when the bridge 40 * is removed. 41 */ 42 43 #include <linux/init.h> 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/mutex.h> 50 51 #include "../pci.h" 52 #include "acpiphp.h" 53 54 static LIST_HEAD(bridge_list); 55 static LIST_HEAD(ioapic_list); 56 static DEFINE_SPINLOCK(ioapic_list_lock); 57 58 #define MY_NAME "acpiphp_glue" 59 60 static void handle_hotplug_event_bridge (acpi_handle, u32, void *); 61 static void acpiphp_sanitize_bus(struct pci_bus *bus); 62 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus); 63 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context); 64 65 66 /* 67 * initialization & terminatation routines 68 */ 69 70 /** 71 * is_ejectable - determine if a slot is ejectable 72 * @handle: handle to acpi namespace 73 * 74 * Ejectable slot should satisfy at least these conditions: 75 * 76 * 1. has _ADR method 77 * 2. has _EJ0 method 78 * 79 * optionally 80 * 81 * 1. has _STA method 82 * 2. has _PS0 method 83 * 3. has _PS3 method 84 * 4. .. 85 * 86 */ 87 static int is_ejectable(acpi_handle handle) 88 { 89 acpi_status status; 90 acpi_handle tmp; 91 92 status = acpi_get_handle(handle, "_ADR", &tmp); 93 if (ACPI_FAILURE(status)) { 94 return 0; 95 } 96 97 status = acpi_get_handle(handle, "_EJ0", &tmp); 98 if (ACPI_FAILURE(status)) { 99 return 0; 100 } 101 102 return 1; 103 } 104 105 106 /* callback routine to check the existence of ejectable slots */ 107 static acpi_status 108 is_ejectable_slot(acpi_handle handle, u32 lvl, void *context, void **rv) 109 { 110 int *count = (int *)context; 111 112 if (is_ejectable(handle)) { 113 (*count)++; 114 /* only one ejectable slot is enough */ 115 return AE_CTRL_TERMINATE; 116 } else { 117 return AE_OK; 118 } 119 } 120 121 /* callback routine to check for the existance of a pci dock device */ 122 static acpi_status 123 is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv) 124 { 125 int *count = (int *)context; 126 127 if (is_dock_device(handle)) { 128 (*count)++; 129 return AE_CTRL_TERMINATE; 130 } else { 131 return AE_OK; 132 } 133 } 134 135 136 137 138 /* 139 * the _DCK method can do funny things... and sometimes not 140 * hah-hah funny. 141 * 142 * TBD - figure out a way to only call fixups for 143 * systems that require them. 144 */ 145 static int post_dock_fixups(struct notifier_block *nb, unsigned long val, 146 void *v) 147 { 148 struct acpiphp_func *func = container_of(nb, struct acpiphp_func, nb); 149 struct pci_bus *bus = func->slot->bridge->pci_bus; 150 u32 buses; 151 152 if (!bus->self) 153 return NOTIFY_OK; 154 155 /* fixup bad _DCK function that rewrites 156 * secondary bridge on slot 157 */ 158 pci_read_config_dword(bus->self, 159 PCI_PRIMARY_BUS, 160 &buses); 161 162 if (((buses >> 8) & 0xff) != bus->secondary) { 163 buses = (buses & 0xff000000) 164 | ((unsigned int)(bus->primary) << 0) 165 | ((unsigned int)(bus->secondary) << 8) 166 | ((unsigned int)(bus->subordinate) << 16); 167 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses); 168 } 169 return NOTIFY_OK; 170 } 171 172 173 174 175 /* callback routine to register each ACPI PCI slot object */ 176 static acpi_status 177 register_slot(acpi_handle handle, u32 lvl, void *context, void **rv) 178 { 179 struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context; 180 struct acpiphp_slot *slot; 181 struct acpiphp_func *newfunc; 182 acpi_handle tmp; 183 acpi_status status = AE_OK; 184 unsigned long adr, sun; 185 int device, function, retval; 186 187 status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr); 188 189 if (ACPI_FAILURE(status)) 190 return AE_OK; 191 192 status = acpi_get_handle(handle, "_EJ0", &tmp); 193 194 if (ACPI_FAILURE(status) && !(is_dock_device(handle))) 195 return AE_OK; 196 197 device = (adr >> 16) & 0xffff; 198 function = adr & 0xffff; 199 200 newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL); 201 if (!newfunc) 202 return AE_NO_MEMORY; 203 204 INIT_LIST_HEAD(&newfunc->sibling); 205 newfunc->handle = handle; 206 newfunc->function = function; 207 if (ACPI_SUCCESS(status)) 208 newfunc->flags = FUNC_HAS_EJ0; 209 210 if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp))) 211 newfunc->flags |= FUNC_HAS_STA; 212 213 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp))) 214 newfunc->flags |= FUNC_HAS_PS0; 215 216 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp))) 217 newfunc->flags |= FUNC_HAS_PS3; 218 219 if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp))) 220 newfunc->flags |= FUNC_HAS_DCK; 221 222 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun); 223 if (ACPI_FAILURE(status)) { 224 /* 225 * use the count of the number of slots we've found 226 * for the number of the slot 227 */ 228 sun = bridge->nr_slots+1; 229 } 230 231 /* search for objects that share the same slot */ 232 for (slot = bridge->slots; slot; slot = slot->next) 233 if (slot->device == device) { 234 if (slot->sun != sun) 235 warn("sibling found, but _SUN doesn't match!\n"); 236 break; 237 } 238 239 if (!slot) { 240 slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); 241 if (!slot) { 242 kfree(newfunc); 243 return AE_NO_MEMORY; 244 } 245 246 slot->bridge = bridge; 247 slot->device = device; 248 slot->sun = sun; 249 INIT_LIST_HEAD(&slot->funcs); 250 mutex_init(&slot->crit_sect); 251 252 slot->next = bridge->slots; 253 bridge->slots = slot; 254 255 bridge->nr_slots++; 256 257 dbg("found ACPI PCI Hotplug slot %d at PCI %04x:%02x:%02x\n", 258 slot->sun, pci_domain_nr(bridge->pci_bus), 259 bridge->pci_bus->number, slot->device); 260 retval = acpiphp_register_hotplug_slot(slot); 261 if (retval) { 262 warn("acpiphp_register_hotplug_slot failed(err code = 0x%x)\n", retval); 263 goto err_exit; 264 } 265 } 266 267 newfunc->slot = slot; 268 list_add_tail(&newfunc->sibling, &slot->funcs); 269 270 /* associate corresponding pci_dev */ 271 newfunc->pci_dev = pci_get_slot(bridge->pci_bus, 272 PCI_DEVFN(device, function)); 273 if (newfunc->pci_dev) { 274 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON); 275 } 276 277 if (is_dock_device(handle)) { 278 /* we don't want to call this device's _EJ0 279 * because we want the dock notify handler 280 * to call it after it calls _DCK 281 */ 282 newfunc->flags &= ~FUNC_HAS_EJ0; 283 if (register_hotplug_dock_device(handle, 284 handle_hotplug_event_func, newfunc)) 285 dbg("failed to register dock device\n"); 286 287 /* we need to be notified when dock events happen 288 * outside of the hotplug operation, since we may 289 * need to do fixups before we can hotplug. 290 */ 291 newfunc->nb.notifier_call = post_dock_fixups; 292 if (register_dock_notifier(&newfunc->nb)) 293 dbg("failed to register a dock notifier"); 294 } 295 296 /* install notify handler */ 297 if (!(newfunc->flags & FUNC_HAS_DCK)) { 298 status = acpi_install_notify_handler(handle, 299 ACPI_SYSTEM_NOTIFY, 300 handle_hotplug_event_func, 301 newfunc); 302 303 if (ACPI_FAILURE(status)) 304 err("failed to register interrupt notify handler\n"); 305 } else 306 status = AE_OK; 307 308 return status; 309 310 err_exit: 311 bridge->nr_slots--; 312 bridge->slots = slot->next; 313 kfree(slot); 314 kfree(newfunc); 315 316 return AE_OK; 317 } 318 319 320 /* see if it's worth looking at this bridge */ 321 static int detect_ejectable_slots(acpi_handle *bridge_handle) 322 { 323 acpi_status status; 324 int count; 325 326 count = 0; 327 328 /* only check slots defined directly below bridge object */ 329 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, (u32)1, 330 is_ejectable_slot, (void *)&count, NULL); 331 332 /* 333 * we also need to add this bridge if there is a dock bridge or 334 * other pci device on a dock station (removable) 335 */ 336 if (!count) 337 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, 338 (u32)1, is_pci_dock_device, (void *)&count, 339 NULL); 340 341 return count; 342 } 343 344 345 /* decode ACPI 2.0 _HPP hot plug parameters */ 346 static void decode_hpp(struct acpiphp_bridge *bridge) 347 { 348 acpi_status status; 349 350 status = acpi_get_hp_params_from_firmware(bridge->pci_bus, &bridge->hpp); 351 if (ACPI_FAILURE(status) || 352 !bridge->hpp.t0 || (bridge->hpp.t0->revision > 1)) { 353 /* use default numbers */ 354 printk(KERN_WARNING 355 "%s: Could not get hotplug parameters. Use defaults\n", 356 __FUNCTION__); 357 bridge->hpp.t0 = &bridge->hpp.type0_data; 358 bridge->hpp.t0->revision = 0; 359 bridge->hpp.t0->cache_line_size = 0x10; 360 bridge->hpp.t0->latency_timer = 0x40; 361 bridge->hpp.t0->enable_serr = 0; 362 bridge->hpp.t0->enable_perr = 0; 363 } 364 } 365 366 367 368 /* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */ 369 static void init_bridge_misc(struct acpiphp_bridge *bridge) 370 { 371 acpi_status status; 372 373 /* decode ACPI 2.0 _HPP (hot plug parameters) */ 374 decode_hpp(bridge); 375 376 /* must be added to the list prior to calling register_slot */ 377 list_add(&bridge->list, &bridge_list); 378 379 /* register all slot objects under this bridge */ 380 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1, 381 register_slot, bridge, NULL); 382 if (ACPI_FAILURE(status)) { 383 list_del(&bridge->list); 384 return; 385 } 386 387 /* install notify handler */ 388 if (bridge->type != BRIDGE_TYPE_HOST) { 389 if ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func) { 390 status = acpi_remove_notify_handler(bridge->func->handle, 391 ACPI_SYSTEM_NOTIFY, 392 handle_hotplug_event_func); 393 if (ACPI_FAILURE(status)) 394 err("failed to remove notify handler\n"); 395 } 396 status = acpi_install_notify_handler(bridge->handle, 397 ACPI_SYSTEM_NOTIFY, 398 handle_hotplug_event_bridge, 399 bridge); 400 401 if (ACPI_FAILURE(status)) { 402 err("failed to register interrupt notify handler\n"); 403 } 404 } 405 } 406 407 408 /* find acpiphp_func from acpiphp_bridge */ 409 static struct acpiphp_func *acpiphp_bridge_handle_to_function(acpi_handle handle) 410 { 411 struct list_head *node, *l; 412 struct acpiphp_bridge *bridge; 413 struct acpiphp_slot *slot; 414 struct acpiphp_func *func; 415 416 list_for_each(node, &bridge_list) { 417 bridge = list_entry(node, struct acpiphp_bridge, list); 418 for (slot = bridge->slots; slot; slot = slot->next) { 419 list_for_each(l, &slot->funcs) { 420 func = list_entry(l, struct acpiphp_func, 421 sibling); 422 if (func->handle == handle) 423 return func; 424 } 425 } 426 } 427 428 return NULL; 429 } 430 431 432 static inline void config_p2p_bridge_flags(struct acpiphp_bridge *bridge) 433 { 434 acpi_handle dummy_handle; 435 436 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 437 "_STA", &dummy_handle))) 438 bridge->flags |= BRIDGE_HAS_STA; 439 440 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 441 "_EJ0", &dummy_handle))) 442 bridge->flags |= BRIDGE_HAS_EJ0; 443 444 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 445 "_PS0", &dummy_handle))) 446 bridge->flags |= BRIDGE_HAS_PS0; 447 448 if (ACPI_SUCCESS(acpi_get_handle(bridge->handle, 449 "_PS3", &dummy_handle))) 450 bridge->flags |= BRIDGE_HAS_PS3; 451 452 /* is this ejectable p2p bridge? */ 453 if (bridge->flags & BRIDGE_HAS_EJ0) { 454 struct acpiphp_func *func; 455 456 dbg("found ejectable p2p bridge\n"); 457 458 /* make link between PCI bridge and PCI function */ 459 func = acpiphp_bridge_handle_to_function(bridge->handle); 460 if (!func) 461 return; 462 bridge->func = func; 463 func->bridge = bridge; 464 } 465 } 466 467 468 /* allocate and initialize host bridge data structure */ 469 static void add_host_bridge(acpi_handle *handle, struct pci_bus *pci_bus) 470 { 471 struct acpiphp_bridge *bridge; 472 473 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 474 if (bridge == NULL) 475 return; 476 477 bridge->type = BRIDGE_TYPE_HOST; 478 bridge->handle = handle; 479 480 bridge->pci_bus = pci_bus; 481 482 spin_lock_init(&bridge->res_lock); 483 484 init_bridge_misc(bridge); 485 } 486 487 488 /* allocate and initialize PCI-to-PCI bridge data structure */ 489 static void add_p2p_bridge(acpi_handle *handle, struct pci_dev *pci_dev) 490 { 491 struct acpiphp_bridge *bridge; 492 493 bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 494 if (bridge == NULL) { 495 err("out of memory\n"); 496 return; 497 } 498 499 bridge->type = BRIDGE_TYPE_P2P; 500 bridge->handle = handle; 501 config_p2p_bridge_flags(bridge); 502 503 bridge->pci_dev = pci_dev_get(pci_dev); 504 bridge->pci_bus = pci_dev->subordinate; 505 if (!bridge->pci_bus) { 506 err("This is not a PCI-to-PCI bridge!\n"); 507 goto err; 508 } 509 510 spin_lock_init(&bridge->res_lock); 511 512 init_bridge_misc(bridge); 513 return; 514 err: 515 pci_dev_put(pci_dev); 516 kfree(bridge); 517 return; 518 } 519 520 521 /* callback routine to find P2P bridges */ 522 static acpi_status 523 find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) 524 { 525 acpi_status status; 526 acpi_handle dummy_handle; 527 unsigned long tmp; 528 int device, function; 529 struct pci_dev *dev; 530 struct pci_bus *pci_bus = context; 531 532 status = acpi_get_handle(handle, "_ADR", &dummy_handle); 533 if (ACPI_FAILURE(status)) 534 return AE_OK; /* continue */ 535 536 status = acpi_evaluate_integer(handle, "_ADR", NULL, &tmp); 537 if (ACPI_FAILURE(status)) { 538 dbg("%s: _ADR evaluation failure\n", __FUNCTION__); 539 return AE_OK; 540 } 541 542 device = (tmp >> 16) & 0xffff; 543 function = tmp & 0xffff; 544 545 dev = pci_get_slot(pci_bus, PCI_DEVFN(device, function)); 546 547 if (!dev || !dev->subordinate) 548 goto out; 549 550 /* check if this bridge has ejectable slots */ 551 if ((detect_ejectable_slots(handle) > 0)) { 552 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev)); 553 add_p2p_bridge(handle, dev); 554 } 555 556 /* search P2P bridges under this p2p bridge */ 557 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 558 find_p2p_bridge, dev->subordinate, NULL); 559 if (ACPI_FAILURE(status)) 560 warn("find_p2p_bridge failed (error code = 0x%x)\n", status); 561 562 out: 563 pci_dev_put(dev); 564 return AE_OK; 565 } 566 567 568 /* find hot-pluggable slots, and then find P2P bridge */ 569 static int add_bridge(acpi_handle handle) 570 { 571 acpi_status status; 572 unsigned long tmp; 573 int seg, bus; 574 acpi_handle dummy_handle; 575 struct pci_bus *pci_bus; 576 577 /* if the bridge doesn't have _STA, we assume it is always there */ 578 status = acpi_get_handle(handle, "_STA", &dummy_handle); 579 if (ACPI_SUCCESS(status)) { 580 status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp); 581 if (ACPI_FAILURE(status)) { 582 dbg("%s: _STA evaluation failure\n", __FUNCTION__); 583 return 0; 584 } 585 if ((tmp & ACPI_STA_FUNCTIONING) == 0) 586 /* don't register this object */ 587 return 0; 588 } 589 590 /* get PCI segment number */ 591 status = acpi_evaluate_integer(handle, "_SEG", NULL, &tmp); 592 593 seg = ACPI_SUCCESS(status) ? tmp : 0; 594 595 /* get PCI bus number */ 596 status = acpi_evaluate_integer(handle, "_BBN", NULL, &tmp); 597 598 if (ACPI_SUCCESS(status)) { 599 bus = tmp; 600 } else { 601 warn("can't get bus number, assuming 0\n"); 602 bus = 0; 603 } 604 605 pci_bus = pci_find_bus(seg, bus); 606 if (!pci_bus) { 607 err("Can't find bus %04x:%02x\n", seg, bus); 608 return 0; 609 } 610 611 /* check if this bridge has ejectable slots */ 612 if (detect_ejectable_slots(handle) > 0) { 613 dbg("found PCI host-bus bridge with hot-pluggable slots\n"); 614 add_host_bridge(handle, pci_bus); 615 } 616 617 /* search P2P bridges under this host bridge */ 618 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 619 find_p2p_bridge, pci_bus, NULL); 620 621 if (ACPI_FAILURE(status)) 622 warn("find_p2p_bridge failed (error code = 0x%x)\n", status); 623 624 return 0; 625 } 626 627 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle) 628 { 629 struct list_head *head; 630 list_for_each(head, &bridge_list) { 631 struct acpiphp_bridge *bridge = list_entry(head, 632 struct acpiphp_bridge, list); 633 if (bridge->handle == handle) 634 return bridge; 635 } 636 637 return NULL; 638 } 639 640 static void cleanup_bridge(struct acpiphp_bridge *bridge) 641 { 642 struct list_head *list, *tmp; 643 struct acpiphp_slot *slot; 644 acpi_status status; 645 acpi_handle handle = bridge->handle; 646 647 status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 648 handle_hotplug_event_bridge); 649 if (ACPI_FAILURE(status)) 650 err("failed to remove notify handler\n"); 651 652 if ((bridge->type != BRIDGE_TYPE_HOST) && 653 ((bridge->flags & BRIDGE_HAS_EJ0) && bridge->func)) { 654 status = acpi_install_notify_handler(bridge->func->handle, 655 ACPI_SYSTEM_NOTIFY, 656 handle_hotplug_event_func, 657 bridge->func); 658 if (ACPI_FAILURE(status)) 659 err("failed to install interrupt notify handler\n"); 660 } 661 662 slot = bridge->slots; 663 while (slot) { 664 struct acpiphp_slot *next = slot->next; 665 list_for_each_safe (list, tmp, &slot->funcs) { 666 struct acpiphp_func *func; 667 func = list_entry(list, struct acpiphp_func, sibling); 668 if (is_dock_device(func->handle)) { 669 unregister_hotplug_dock_device(func->handle); 670 unregister_dock_notifier(&func->nb); 671 } 672 if (!(func->flags & FUNC_HAS_DCK)) { 673 status = acpi_remove_notify_handler(func->handle, 674 ACPI_SYSTEM_NOTIFY, 675 handle_hotplug_event_func); 676 if (ACPI_FAILURE(status)) 677 err("failed to remove notify handler\n"); 678 } 679 pci_dev_put(func->pci_dev); 680 list_del(list); 681 kfree(func); 682 } 683 acpiphp_unregister_hotplug_slot(slot); 684 list_del(&slot->funcs); 685 kfree(slot); 686 slot = next; 687 } 688 689 pci_dev_put(bridge->pci_dev); 690 list_del(&bridge->list); 691 kfree(bridge); 692 } 693 694 static acpi_status 695 cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) 696 { 697 struct acpiphp_bridge *bridge; 698 699 /* cleanup p2p bridges under this P2P bridge 700 in a depth-first manner */ 701 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 702 cleanup_p2p_bridge, NULL, NULL); 703 704 if (!(bridge = acpiphp_handle_to_bridge(handle))) 705 return AE_OK; 706 cleanup_bridge(bridge); 707 return AE_OK; 708 } 709 710 static void remove_bridge(acpi_handle handle) 711 { 712 struct acpiphp_bridge *bridge; 713 714 /* cleanup p2p bridges under this host bridge 715 in a depth-first manner */ 716 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 717 (u32)1, cleanup_p2p_bridge, NULL, NULL); 718 719 bridge = acpiphp_handle_to_bridge(handle); 720 if (bridge) 721 cleanup_bridge(bridge); 722 } 723 724 static struct pci_dev * get_apic_pci_info(acpi_handle handle) 725 { 726 struct acpi_pci_id id; 727 struct pci_bus *bus; 728 struct pci_dev *dev; 729 730 if (ACPI_FAILURE(acpi_get_pci_id(handle, &id))) 731 return NULL; 732 733 bus = pci_find_bus(id.segment, id.bus); 734 if (!bus) 735 return NULL; 736 737 dev = pci_get_slot(bus, PCI_DEVFN(id.device, id.function)); 738 if (!dev) 739 return NULL; 740 741 if ((dev->class != PCI_CLASS_SYSTEM_PIC_IOAPIC) && 742 (dev->class != PCI_CLASS_SYSTEM_PIC_IOXAPIC)) 743 { 744 pci_dev_put(dev); 745 return NULL; 746 } 747 748 return dev; 749 } 750 751 static int get_gsi_base(acpi_handle handle, u32 *gsi_base) 752 { 753 acpi_status status; 754 int result = -1; 755 unsigned long gsb; 756 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 757 union acpi_object *obj; 758 void *table; 759 760 status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb); 761 if (ACPI_SUCCESS(status)) { 762 *gsi_base = (u32)gsb; 763 return 0; 764 } 765 766 status = acpi_evaluate_object(handle, "_MAT", NULL, &buffer); 767 if (ACPI_FAILURE(status) || !buffer.length || !buffer.pointer) 768 return -1; 769 770 obj = buffer.pointer; 771 if (obj->type != ACPI_TYPE_BUFFER) 772 goto out; 773 774 table = obj->buffer.pointer; 775 switch (((struct acpi_subtable_header *)table)->type) { 776 case ACPI_MADT_TYPE_IO_SAPIC: 777 *gsi_base = ((struct acpi_madt_io_sapic *)table)->global_irq_base; 778 result = 0; 779 break; 780 case ACPI_MADT_TYPE_IO_APIC: 781 *gsi_base = ((struct acpi_madt_io_apic *)table)->global_irq_base; 782 result = 0; 783 break; 784 default: 785 break; 786 } 787 out: 788 kfree(buffer.pointer); 789 return result; 790 } 791 792 static acpi_status 793 ioapic_add(acpi_handle handle, u32 lvl, void *context, void **rv) 794 { 795 acpi_status status; 796 unsigned long sta; 797 acpi_handle tmp; 798 struct pci_dev *pdev; 799 u32 gsi_base; 800 u64 phys_addr; 801 struct acpiphp_ioapic *ioapic; 802 803 /* Evaluate _STA if present */ 804 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 805 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL) 806 return AE_CTRL_DEPTH; 807 808 /* Scan only PCI bus scope */ 809 status = acpi_get_handle(handle, "_HID", &tmp); 810 if (ACPI_SUCCESS(status)) 811 return AE_CTRL_DEPTH; 812 813 if (get_gsi_base(handle, &gsi_base)) 814 return AE_OK; 815 816 ioapic = kmalloc(sizeof(*ioapic), GFP_KERNEL); 817 if (!ioapic) 818 return AE_NO_MEMORY; 819 820 pdev = get_apic_pci_info(handle); 821 if (!pdev) 822 goto exit_kfree; 823 824 if (pci_enable_device(pdev)) 825 goto exit_pci_dev_put; 826 827 pci_set_master(pdev); 828 829 if (pci_request_region(pdev, 0, "I/O APIC(acpiphp)")) 830 goto exit_pci_disable_device; 831 832 phys_addr = pci_resource_start(pdev, 0); 833 if (acpi_register_ioapic(handle, phys_addr, gsi_base)) 834 goto exit_pci_release_region; 835 836 ioapic->gsi_base = gsi_base; 837 ioapic->dev = pdev; 838 spin_lock(&ioapic_list_lock); 839 list_add_tail(&ioapic->list, &ioapic_list); 840 spin_unlock(&ioapic_list_lock); 841 842 return AE_OK; 843 844 exit_pci_release_region: 845 pci_release_region(pdev, 0); 846 exit_pci_disable_device: 847 pci_disable_device(pdev); 848 exit_pci_dev_put: 849 pci_dev_put(pdev); 850 exit_kfree: 851 kfree(ioapic); 852 853 return AE_OK; 854 } 855 856 static acpi_status 857 ioapic_remove(acpi_handle handle, u32 lvl, void *context, void **rv) 858 { 859 acpi_status status; 860 unsigned long sta; 861 acpi_handle tmp; 862 u32 gsi_base; 863 struct acpiphp_ioapic *pos, *n, *ioapic = NULL; 864 865 /* Evaluate _STA if present */ 866 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 867 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL) 868 return AE_CTRL_DEPTH; 869 870 /* Scan only PCI bus scope */ 871 status = acpi_get_handle(handle, "_HID", &tmp); 872 if (ACPI_SUCCESS(status)) 873 return AE_CTRL_DEPTH; 874 875 if (get_gsi_base(handle, &gsi_base)) 876 return AE_OK; 877 878 acpi_unregister_ioapic(handle, gsi_base); 879 880 spin_lock(&ioapic_list_lock); 881 list_for_each_entry_safe(pos, n, &ioapic_list, list) { 882 if (pos->gsi_base != gsi_base) 883 continue; 884 ioapic = pos; 885 list_del(&ioapic->list); 886 break; 887 } 888 spin_unlock(&ioapic_list_lock); 889 890 if (!ioapic) 891 return AE_OK; 892 893 pci_release_region(ioapic->dev, 0); 894 pci_disable_device(ioapic->dev); 895 pci_dev_put(ioapic->dev); 896 kfree(ioapic); 897 898 return AE_OK; 899 } 900 901 static int acpiphp_configure_ioapics(acpi_handle handle) 902 { 903 ioapic_add(handle, 0, NULL, NULL); 904 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 905 ACPI_UINT32_MAX, ioapic_add, NULL, NULL); 906 return 0; 907 } 908 909 static int acpiphp_unconfigure_ioapics(acpi_handle handle) 910 { 911 ioapic_remove(handle, 0, NULL, NULL); 912 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 913 ACPI_UINT32_MAX, ioapic_remove, NULL, NULL); 914 return 0; 915 } 916 917 static int power_on_slot(struct acpiphp_slot *slot) 918 { 919 acpi_status status; 920 struct acpiphp_func *func; 921 struct list_head *l; 922 int retval = 0; 923 924 /* if already enabled, just skip */ 925 if (slot->flags & SLOT_POWEREDON) 926 goto err_exit; 927 928 list_for_each (l, &slot->funcs) { 929 func = list_entry(l, struct acpiphp_func, sibling); 930 931 if (func->flags & FUNC_HAS_PS0) { 932 dbg("%s: executing _PS0\n", __FUNCTION__); 933 status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL); 934 if (ACPI_FAILURE(status)) { 935 warn("%s: _PS0 failed\n", __FUNCTION__); 936 retval = -1; 937 goto err_exit; 938 } else 939 break; 940 } 941 } 942 943 /* TBD: evaluate _STA to check if the slot is enabled */ 944 945 slot->flags |= SLOT_POWEREDON; 946 947 err_exit: 948 return retval; 949 } 950 951 952 static int power_off_slot(struct acpiphp_slot *slot) 953 { 954 acpi_status status; 955 struct acpiphp_func *func; 956 struct list_head *l; 957 958 int retval = 0; 959 960 /* if already disabled, just skip */ 961 if ((slot->flags & SLOT_POWEREDON) == 0) 962 goto err_exit; 963 964 list_for_each (l, &slot->funcs) { 965 func = list_entry(l, struct acpiphp_func, sibling); 966 967 if (func->flags & FUNC_HAS_PS3) { 968 status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL); 969 if (ACPI_FAILURE(status)) { 970 warn("%s: _PS3 failed\n", __FUNCTION__); 971 retval = -1; 972 goto err_exit; 973 } else 974 break; 975 } 976 } 977 978 /* TBD: evaluate _STA to check if the slot is disabled */ 979 980 slot->flags &= (~SLOT_POWEREDON); 981 982 err_exit: 983 return retval; 984 } 985 986 987 988 /** 989 * acpiphp_max_busnr - return the highest reserved bus number under 990 * the given bus. 991 * @bus: bus to start search with 992 * 993 */ 994 static unsigned char acpiphp_max_busnr(struct pci_bus *bus) 995 { 996 struct list_head *tmp; 997 unsigned char max, n; 998 999 /* 1000 * pci_bus_max_busnr will return the highest 1001 * reserved busnr for all these children. 1002 * that is equivalent to the bus->subordinate 1003 * value. We don't want to use the parent's 1004 * bus->subordinate value because it could have 1005 * padding in it. 1006 */ 1007 max = bus->secondary; 1008 1009 list_for_each(tmp, &bus->children) { 1010 n = pci_bus_max_busnr(pci_bus_b(tmp)); 1011 if (n > max) 1012 max = n; 1013 } 1014 return max; 1015 } 1016 1017 1018 /** 1019 * acpiphp_bus_add - add a new bus to acpi subsystem 1020 * @func: acpiphp_func of the bridge 1021 * 1022 */ 1023 static int acpiphp_bus_add(struct acpiphp_func *func) 1024 { 1025 acpi_handle phandle; 1026 struct acpi_device *device, *pdevice; 1027 int ret_val; 1028 1029 acpi_get_parent(func->handle, &phandle); 1030 if (acpi_bus_get_device(phandle, &pdevice)) { 1031 dbg("no parent device, assuming NULL\n"); 1032 pdevice = NULL; 1033 } 1034 if (!acpi_bus_get_device(func->handle, &device)) { 1035 dbg("bus exists... trim\n"); 1036 /* this shouldn't be in here, so remove 1037 * the bus then re-add it... 1038 */ 1039 ret_val = acpi_bus_trim(device, 1); 1040 dbg("acpi_bus_trim return %x\n", ret_val); 1041 } 1042 1043 ret_val = acpi_bus_add(&device, pdevice, func->handle, 1044 ACPI_BUS_TYPE_DEVICE); 1045 if (ret_val) { 1046 dbg("error adding bus, %x\n", 1047 -ret_val); 1048 goto acpiphp_bus_add_out; 1049 } 1050 /* 1051 * try to start anyway. We could have failed to add 1052 * simply because this bus had previously been added 1053 * on another add. Don't bother with the return value 1054 * we just keep going. 1055 */ 1056 ret_val = acpi_bus_start(device); 1057 1058 acpiphp_bus_add_out: 1059 return ret_val; 1060 } 1061 1062 1063 /** 1064 * acpiphp_bus_trim - trim a bus from acpi subsystem 1065 * @handle: handle to acpi namespace 1066 * 1067 */ 1068 static int acpiphp_bus_trim(acpi_handle handle) 1069 { 1070 struct acpi_device *device; 1071 int retval; 1072 1073 retval = acpi_bus_get_device(handle, &device); 1074 if (retval) { 1075 dbg("acpi_device not found\n"); 1076 return retval; 1077 } 1078 1079 retval = acpi_bus_trim(device, 1); 1080 if (retval) 1081 err("cannot remove from acpi list\n"); 1082 1083 return retval; 1084 } 1085 1086 /** 1087 * enable_device - enable, configure a slot 1088 * @slot: slot to be enabled 1089 * 1090 * This function should be called per *physical slot*, 1091 * not per each slot object in ACPI namespace. 1092 * 1093 */ 1094 static int enable_device(struct acpiphp_slot *slot) 1095 { 1096 struct pci_dev *dev; 1097 struct pci_bus *bus = slot->bridge->pci_bus; 1098 struct list_head *l; 1099 struct acpiphp_func *func; 1100 int retval = 0; 1101 int num, max, pass; 1102 acpi_status status; 1103 1104 if (slot->flags & SLOT_ENABLED) 1105 goto err_exit; 1106 1107 /* sanity check: dev should be NULL when hot-plugged in */ 1108 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0)); 1109 if (dev) { 1110 /* This case shouldn't happen */ 1111 err("pci_dev structure already exists.\n"); 1112 pci_dev_put(dev); 1113 retval = -1; 1114 goto err_exit; 1115 } 1116 1117 num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0)); 1118 if (num == 0) { 1119 err("No new device found\n"); 1120 retval = -1; 1121 goto err_exit; 1122 } 1123 1124 max = acpiphp_max_busnr(bus); 1125 for (pass = 0; pass < 2; pass++) { 1126 list_for_each_entry(dev, &bus->devices, bus_list) { 1127 if (PCI_SLOT(dev->devfn) != slot->device) 1128 continue; 1129 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || 1130 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) { 1131 max = pci_scan_bridge(bus, dev, max, pass); 1132 if (pass && dev->subordinate) 1133 pci_bus_size_bridges(dev->subordinate); 1134 } 1135 } 1136 } 1137 1138 list_for_each (l, &slot->funcs) { 1139 func = list_entry(l, struct acpiphp_func, sibling); 1140 acpiphp_bus_add(func); 1141 } 1142 1143 pci_bus_assign_resources(bus); 1144 acpiphp_sanitize_bus(bus); 1145 acpiphp_set_hpp_values(slot->bridge->handle, bus); 1146 list_for_each_entry(func, &slot->funcs, sibling) 1147 acpiphp_configure_ioapics(func->handle); 1148 pci_enable_bridges(bus); 1149 pci_bus_add_devices(bus); 1150 1151 /* associate pci_dev to our representation */ 1152 list_for_each (l, &slot->funcs) { 1153 func = list_entry(l, struct acpiphp_func, sibling); 1154 func->pci_dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 1155 func->function)); 1156 if (!func->pci_dev) 1157 continue; 1158 1159 if (func->pci_dev->hdr_type != PCI_HEADER_TYPE_BRIDGE && 1160 func->pci_dev->hdr_type != PCI_HEADER_TYPE_CARDBUS) 1161 continue; 1162 1163 status = find_p2p_bridge(func->handle, (u32)1, bus, NULL); 1164 if (ACPI_FAILURE(status)) 1165 warn("find_p2p_bridge failed (error code = 0x%x)\n", 1166 status); 1167 } 1168 1169 slot->flags |= SLOT_ENABLED; 1170 1171 err_exit: 1172 return retval; 1173 } 1174 1175 static void disable_bridges(struct pci_bus *bus) 1176 { 1177 struct pci_dev *dev; 1178 list_for_each_entry(dev, &bus->devices, bus_list) { 1179 if (dev->subordinate) { 1180 disable_bridges(dev->subordinate); 1181 pci_disable_device(dev); 1182 } 1183 } 1184 } 1185 1186 /** 1187 * disable_device - disable a slot 1188 */ 1189 static int disable_device(struct acpiphp_slot *slot) 1190 { 1191 int retval = 0; 1192 struct acpiphp_func *func; 1193 struct list_head *l; 1194 1195 /* is this slot already disabled? */ 1196 if (!(slot->flags & SLOT_ENABLED)) 1197 goto err_exit; 1198 1199 list_for_each (l, &slot->funcs) { 1200 func = list_entry(l, struct acpiphp_func, sibling); 1201 1202 if (func->bridge) { 1203 /* cleanup p2p bridges under this P2P bridge */ 1204 cleanup_p2p_bridge(func->bridge->handle, 1205 (u32)1, NULL, NULL); 1206 func->bridge = NULL; 1207 } 1208 1209 if (func->pci_dev) { 1210 pci_stop_bus_device(func->pci_dev); 1211 if (func->pci_dev->subordinate) { 1212 disable_bridges(func->pci_dev->subordinate); 1213 pci_disable_device(func->pci_dev); 1214 } 1215 } 1216 } 1217 1218 list_for_each (l, &slot->funcs) { 1219 func = list_entry(l, struct acpiphp_func, sibling); 1220 1221 acpiphp_unconfigure_ioapics(func->handle); 1222 acpiphp_bus_trim(func->handle); 1223 /* try to remove anyway. 1224 * acpiphp_bus_add might have been failed */ 1225 1226 if (!func->pci_dev) 1227 continue; 1228 1229 pci_remove_bus_device(func->pci_dev); 1230 pci_dev_put(func->pci_dev); 1231 func->pci_dev = NULL; 1232 } 1233 1234 slot->flags &= (~SLOT_ENABLED); 1235 1236 err_exit: 1237 return retval; 1238 } 1239 1240 1241 /** 1242 * get_slot_status - get ACPI slot status 1243 * 1244 * if a slot has _STA for each function and if any one of them 1245 * returned non-zero status, return it 1246 * 1247 * if a slot doesn't have _STA and if any one of its functions' 1248 * configuration space is configured, return 0x0f as a _STA 1249 * 1250 * otherwise return 0 1251 */ 1252 static unsigned int get_slot_status(struct acpiphp_slot *slot) 1253 { 1254 acpi_status status; 1255 unsigned long sta = 0; 1256 u32 dvid; 1257 struct list_head *l; 1258 struct acpiphp_func *func; 1259 1260 list_for_each (l, &slot->funcs) { 1261 func = list_entry(l, struct acpiphp_func, sibling); 1262 1263 if (func->flags & FUNC_HAS_STA) { 1264 status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta); 1265 if (ACPI_SUCCESS(status) && sta) 1266 break; 1267 } else { 1268 pci_bus_read_config_dword(slot->bridge->pci_bus, 1269 PCI_DEVFN(slot->device, 1270 func->function), 1271 PCI_VENDOR_ID, &dvid); 1272 if (dvid != 0xffffffff) { 1273 sta = ACPI_STA_ALL; 1274 break; 1275 } 1276 } 1277 } 1278 1279 return (unsigned int)sta; 1280 } 1281 1282 /** 1283 * acpiphp_eject_slot - physically eject the slot 1284 */ 1285 static int acpiphp_eject_slot(struct acpiphp_slot *slot) 1286 { 1287 acpi_status status; 1288 struct acpiphp_func *func; 1289 struct list_head *l; 1290 struct acpi_object_list arg_list; 1291 union acpi_object arg; 1292 1293 list_for_each (l, &slot->funcs) { 1294 func = list_entry(l, struct acpiphp_func, sibling); 1295 1296 /* We don't want to call _EJ0 on non-existing functions. */ 1297 if ((func->flags & FUNC_HAS_EJ0)) { 1298 /* _EJ0 method take one argument */ 1299 arg_list.count = 1; 1300 arg_list.pointer = &arg; 1301 arg.type = ACPI_TYPE_INTEGER; 1302 arg.integer.value = 1; 1303 1304 status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL); 1305 if (ACPI_FAILURE(status)) { 1306 warn("%s: _EJ0 failed\n", __FUNCTION__); 1307 return -1; 1308 } else 1309 break; 1310 } 1311 } 1312 return 0; 1313 } 1314 1315 /** 1316 * acpiphp_check_bridge - re-enumerate devices 1317 * 1318 * Iterate over all slots under this bridge and make sure that if a 1319 * card is present they are enabled, and if not they are disabled. 1320 */ 1321 static int acpiphp_check_bridge(struct acpiphp_bridge *bridge) 1322 { 1323 struct acpiphp_slot *slot; 1324 int retval = 0; 1325 int enabled, disabled; 1326 1327 enabled = disabled = 0; 1328 1329 for (slot = bridge->slots; slot; slot = slot->next) { 1330 unsigned int status = get_slot_status(slot); 1331 if (slot->flags & SLOT_ENABLED) { 1332 if (status == ACPI_STA_ALL) 1333 continue; 1334 retval = acpiphp_disable_slot(slot); 1335 if (retval) { 1336 err("Error occurred in disabling\n"); 1337 goto err_exit; 1338 } else { 1339 acpiphp_eject_slot(slot); 1340 } 1341 disabled++; 1342 } else { 1343 if (status != ACPI_STA_ALL) 1344 continue; 1345 retval = acpiphp_enable_slot(slot); 1346 if (retval) { 1347 err("Error occurred in enabling\n"); 1348 goto err_exit; 1349 } 1350 enabled++; 1351 } 1352 } 1353 1354 dbg("%s: %d enabled, %d disabled\n", __FUNCTION__, enabled, disabled); 1355 1356 err_exit: 1357 return retval; 1358 } 1359 1360 static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge) 1361 { 1362 u16 pci_cmd, pci_bctl; 1363 struct pci_dev *cdev; 1364 1365 /* Program hpp values for this device */ 1366 if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL || 1367 (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE && 1368 (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI))) 1369 return; 1370 1371 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 1372 bridge->hpp.t0->cache_line_size); 1373 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 1374 bridge->hpp.t0->latency_timer); 1375 pci_read_config_word(dev, PCI_COMMAND, &pci_cmd); 1376 if (bridge->hpp.t0->enable_serr) 1377 pci_cmd |= PCI_COMMAND_SERR; 1378 else 1379 pci_cmd &= ~PCI_COMMAND_SERR; 1380 if (bridge->hpp.t0->enable_perr) 1381 pci_cmd |= PCI_COMMAND_PARITY; 1382 else 1383 pci_cmd &= ~PCI_COMMAND_PARITY; 1384 pci_write_config_word(dev, PCI_COMMAND, pci_cmd); 1385 1386 /* Program bridge control value and child devices */ 1387 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) { 1388 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, 1389 bridge->hpp.t0->latency_timer); 1390 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl); 1391 if (bridge->hpp.t0->enable_serr) 1392 pci_bctl |= PCI_BRIDGE_CTL_SERR; 1393 else 1394 pci_bctl &= ~PCI_BRIDGE_CTL_SERR; 1395 if (bridge->hpp.t0->enable_perr) 1396 pci_bctl |= PCI_BRIDGE_CTL_PARITY; 1397 else 1398 pci_bctl &= ~PCI_BRIDGE_CTL_PARITY; 1399 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl); 1400 if (dev->subordinate) { 1401 list_for_each_entry(cdev, &dev->subordinate->devices, 1402 bus_list) 1403 program_hpp(cdev, bridge); 1404 } 1405 } 1406 } 1407 1408 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus) 1409 { 1410 struct acpiphp_bridge bridge; 1411 struct pci_dev *dev; 1412 1413 memset(&bridge, 0, sizeof(bridge)); 1414 bridge.handle = handle; 1415 bridge.pci_bus = bus; 1416 bridge.pci_dev = bus->self; 1417 decode_hpp(&bridge); 1418 list_for_each_entry(dev, &bus->devices, bus_list) 1419 program_hpp(dev, &bridge); 1420 1421 } 1422 1423 /* 1424 * Remove devices for which we could not assign resources, call 1425 * arch specific code to fix-up the bus 1426 */ 1427 static void acpiphp_sanitize_bus(struct pci_bus *bus) 1428 { 1429 struct pci_dev *dev; 1430 int i; 1431 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; 1432 1433 list_for_each_entry(dev, &bus->devices, bus_list) { 1434 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) { 1435 struct resource *res = &dev->resource[i]; 1436 if ((res->flags & type_mask) && !res->start && 1437 res->end) { 1438 /* Could not assign a required resources 1439 * for this device, remove it */ 1440 pci_remove_bus_device(dev); 1441 break; 1442 } 1443 } 1444 } 1445 } 1446 1447 /* Program resources in newly inserted bridge */ 1448 static int acpiphp_configure_bridge (acpi_handle handle) 1449 { 1450 struct acpi_pci_id pci_id; 1451 struct pci_bus *bus; 1452 1453 if (ACPI_FAILURE(acpi_get_pci_id(handle, &pci_id))) { 1454 err("cannot get PCI domain and bus number for bridge\n"); 1455 return -EINVAL; 1456 } 1457 bus = pci_find_bus(pci_id.segment, pci_id.bus); 1458 if (!bus) { 1459 err("cannot find bus %d:%d\n", 1460 pci_id.segment, pci_id.bus); 1461 return -EINVAL; 1462 } 1463 1464 pci_bus_size_bridges(bus); 1465 pci_bus_assign_resources(bus); 1466 acpiphp_sanitize_bus(bus); 1467 acpiphp_set_hpp_values(handle, bus); 1468 pci_enable_bridges(bus); 1469 acpiphp_configure_ioapics(handle); 1470 return 0; 1471 } 1472 1473 static void handle_bridge_insertion(acpi_handle handle, u32 type) 1474 { 1475 struct acpi_device *device, *pdevice; 1476 acpi_handle phandle; 1477 1478 if ((type != ACPI_NOTIFY_BUS_CHECK) && 1479 (type != ACPI_NOTIFY_DEVICE_CHECK)) { 1480 err("unexpected notification type %d\n", type); 1481 return; 1482 } 1483 1484 acpi_get_parent(handle, &phandle); 1485 if (acpi_bus_get_device(phandle, &pdevice)) { 1486 dbg("no parent device, assuming NULL\n"); 1487 pdevice = NULL; 1488 } 1489 if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) { 1490 err("cannot add bridge to acpi list\n"); 1491 return; 1492 } 1493 if (!acpiphp_configure_bridge(handle) && 1494 !acpi_bus_start(device)) 1495 add_bridge(handle); 1496 else 1497 err("cannot configure and start bridge\n"); 1498 1499 } 1500 1501 /* 1502 * ACPI event handlers 1503 */ 1504 1505 /** 1506 * handle_hotplug_event_bridge - handle ACPI event on bridges 1507 * 1508 * @handle: Notify()'ed acpi_handle 1509 * @type: Notify code 1510 * @context: pointer to acpiphp_bridge structure 1511 * 1512 * handles ACPI event notification on {host,p2p} bridges 1513 * 1514 */ 1515 static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *context) 1516 { 1517 struct acpiphp_bridge *bridge; 1518 char objname[64]; 1519 struct acpi_buffer buffer = { .length = sizeof(objname), 1520 .pointer = objname }; 1521 struct acpi_device *device; 1522 1523 if (acpi_bus_get_device(handle, &device)) { 1524 /* This bridge must have just been physically inserted */ 1525 handle_bridge_insertion(handle, type); 1526 return; 1527 } 1528 1529 bridge = acpiphp_handle_to_bridge(handle); 1530 if (!bridge) { 1531 err("cannot get bridge info\n"); 1532 return; 1533 } 1534 1535 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1536 1537 switch (type) { 1538 case ACPI_NOTIFY_BUS_CHECK: 1539 /* bus re-enumerate */ 1540 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname); 1541 acpiphp_check_bridge(bridge); 1542 break; 1543 1544 case ACPI_NOTIFY_DEVICE_CHECK: 1545 /* device check */ 1546 dbg("%s: Device check notify on %s\n", __FUNCTION__, objname); 1547 acpiphp_check_bridge(bridge); 1548 break; 1549 1550 case ACPI_NOTIFY_DEVICE_WAKE: 1551 /* wake event */ 1552 dbg("%s: Device wake notify on %s\n", __FUNCTION__, objname); 1553 break; 1554 1555 case ACPI_NOTIFY_EJECT_REQUEST: 1556 /* request device eject */ 1557 dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname); 1558 if ((bridge->type != BRIDGE_TYPE_HOST) && 1559 (bridge->flags & BRIDGE_HAS_EJ0)) { 1560 struct acpiphp_slot *slot; 1561 slot = bridge->func->slot; 1562 if (!acpiphp_disable_slot(slot)) 1563 acpiphp_eject_slot(slot); 1564 } 1565 break; 1566 1567 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 1568 printk(KERN_ERR "Device %s cannot be configured due" 1569 " to a frequency mismatch\n", objname); 1570 break; 1571 1572 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 1573 printk(KERN_ERR "Device %s cannot be configured due" 1574 " to a bus mode mismatch\n", objname); 1575 break; 1576 1577 case ACPI_NOTIFY_POWER_FAULT: 1578 printk(KERN_ERR "Device %s has suffered a power fault\n", 1579 objname); 1580 break; 1581 1582 default: 1583 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname); 1584 break; 1585 } 1586 } 1587 1588 /** 1589 * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots) 1590 * 1591 * @handle: Notify()'ed acpi_handle 1592 * @type: Notify code 1593 * @context: pointer to acpiphp_func structure 1594 * 1595 * handles ACPI event notification on slots 1596 * 1597 */ 1598 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context) 1599 { 1600 struct acpiphp_func *func; 1601 char objname[64]; 1602 struct acpi_buffer buffer = { .length = sizeof(objname), 1603 .pointer = objname }; 1604 1605 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1606 1607 func = (struct acpiphp_func *)context; 1608 1609 switch (type) { 1610 case ACPI_NOTIFY_BUS_CHECK: 1611 /* bus re-enumerate */ 1612 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname); 1613 acpiphp_enable_slot(func->slot); 1614 break; 1615 1616 case ACPI_NOTIFY_DEVICE_CHECK: 1617 /* device check : re-enumerate from parent bus */ 1618 dbg("%s: Device check notify on %s\n", __FUNCTION__, objname); 1619 acpiphp_check_bridge(func->slot->bridge); 1620 break; 1621 1622 case ACPI_NOTIFY_DEVICE_WAKE: 1623 /* wake event */ 1624 dbg("%s: Device wake notify on %s\n", __FUNCTION__, objname); 1625 break; 1626 1627 case ACPI_NOTIFY_EJECT_REQUEST: 1628 /* request device eject */ 1629 dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname); 1630 if (!(acpiphp_disable_slot(func->slot))) 1631 acpiphp_eject_slot(func->slot); 1632 break; 1633 1634 default: 1635 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname); 1636 break; 1637 } 1638 } 1639 1640 1641 static acpi_status 1642 find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) 1643 { 1644 int *count = (int *)context; 1645 1646 if (acpi_root_bridge(handle)) { 1647 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 1648 handle_hotplug_event_bridge, NULL); 1649 (*count)++; 1650 } 1651 return AE_OK ; 1652 } 1653 1654 static struct acpi_pci_driver acpi_pci_hp_driver = { 1655 .add = add_bridge, 1656 .remove = remove_bridge, 1657 }; 1658 1659 /** 1660 * acpiphp_glue_init - initializes all PCI hotplug - ACPI glue data structures 1661 * 1662 */ 1663 int __init acpiphp_glue_init(void) 1664 { 1665 int num = 0; 1666 1667 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 1668 ACPI_UINT32_MAX, find_root_bridges, &num, NULL); 1669 1670 if (num <= 0) 1671 return -1; 1672 else 1673 acpi_pci_register_driver(&acpi_pci_hp_driver); 1674 1675 return 0; 1676 } 1677 1678 1679 /** 1680 * acpiphp_glue_exit - terminates all PCI hotplug - ACPI glue data structures 1681 * 1682 * This function frees all data allocated in acpiphp_glue_init() 1683 */ 1684 void acpiphp_glue_exit(void) 1685 { 1686 acpi_pci_unregister_driver(&acpi_pci_hp_driver); 1687 } 1688 1689 1690 /** 1691 * acpiphp_get_num_slots - count number of slots in a system 1692 */ 1693 int __init acpiphp_get_num_slots(void) 1694 { 1695 struct acpiphp_bridge *bridge; 1696 int num_slots = 0; 1697 1698 list_for_each_entry (bridge, &bridge_list, list) { 1699 dbg("Bus %04x:%02x has %d slot%s\n", 1700 pci_domain_nr(bridge->pci_bus), 1701 bridge->pci_bus->number, bridge->nr_slots, 1702 bridge->nr_slots == 1 ? "" : "s"); 1703 num_slots += bridge->nr_slots; 1704 } 1705 1706 dbg("Total %d slots\n", num_slots); 1707 return num_slots; 1708 } 1709 1710 1711 #if 0 1712 /** 1713 * acpiphp_for_each_slot - call function for each slot 1714 * @fn: callback function 1715 * @data: context to be passed to callback function 1716 * 1717 */ 1718 static int acpiphp_for_each_slot(acpiphp_callback fn, void *data) 1719 { 1720 struct list_head *node; 1721 struct acpiphp_bridge *bridge; 1722 struct acpiphp_slot *slot; 1723 int retval = 0; 1724 1725 list_for_each (node, &bridge_list) { 1726 bridge = (struct acpiphp_bridge *)node; 1727 for (slot = bridge->slots; slot; slot = slot->next) { 1728 retval = fn(slot, data); 1729 if (!retval) 1730 goto err_exit; 1731 } 1732 } 1733 1734 err_exit: 1735 return retval; 1736 } 1737 #endif 1738 1739 1740 /** 1741 * acpiphp_enable_slot - power on slot 1742 */ 1743 int acpiphp_enable_slot(struct acpiphp_slot *slot) 1744 { 1745 int retval; 1746 1747 mutex_lock(&slot->crit_sect); 1748 1749 /* wake up all functions */ 1750 retval = power_on_slot(slot); 1751 if (retval) 1752 goto err_exit; 1753 1754 if (get_slot_status(slot) == ACPI_STA_ALL) { 1755 /* configure all functions */ 1756 retval = enable_device(slot); 1757 if (retval) 1758 power_off_slot(slot); 1759 } else { 1760 dbg("%s: Slot status is not ACPI_STA_ALL\n", __FUNCTION__); 1761 power_off_slot(slot); 1762 } 1763 1764 err_exit: 1765 mutex_unlock(&slot->crit_sect); 1766 return retval; 1767 } 1768 1769 /** 1770 * acpiphp_disable_slot - power off slot 1771 */ 1772 int acpiphp_disable_slot(struct acpiphp_slot *slot) 1773 { 1774 int retval = 0; 1775 1776 mutex_lock(&slot->crit_sect); 1777 1778 /* unconfigure all functions */ 1779 retval = disable_device(slot); 1780 if (retval) 1781 goto err_exit; 1782 1783 /* power off all functions */ 1784 retval = power_off_slot(slot); 1785 if (retval) 1786 goto err_exit; 1787 1788 err_exit: 1789 mutex_unlock(&slot->crit_sect); 1790 return retval; 1791 } 1792 1793 1794 /* 1795 * slot enabled: 1 1796 * slot disabled: 0 1797 */ 1798 u8 acpiphp_get_power_status(struct acpiphp_slot *slot) 1799 { 1800 return (slot->flags & SLOT_POWEREDON); 1801 } 1802 1803 1804 /* 1805 * latch open: 1 1806 * latch closed: 0 1807 */ 1808 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot) 1809 { 1810 unsigned int sta; 1811 1812 sta = get_slot_status(slot); 1813 1814 return (sta & ACPI_STA_SHOW_IN_UI) ? 0 : 1; 1815 } 1816 1817 1818 /* 1819 * adapter presence : 1 1820 * absence : 0 1821 */ 1822 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) 1823 { 1824 unsigned int sta; 1825 1826 sta = get_slot_status(slot); 1827 1828 return (sta == 0) ? 0 : 1; 1829 } 1830 1831 1832 /* 1833 * pci address (seg/bus/dev) 1834 */ 1835 u32 acpiphp_get_address(struct acpiphp_slot *slot) 1836 { 1837 u32 address; 1838 struct pci_bus *pci_bus = slot->bridge->pci_bus; 1839 1840 address = (pci_domain_nr(pci_bus) << 16) | 1841 (pci_bus->number << 8) | 1842 slot->device; 1843 1844 return address; 1845 } 1846