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 <t-kochi@bq.jp.nec.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/smp_lock.h> 49 #include <asm/semaphore.h> 50 51 #include "../pci.h" 52 #include "pci_hotplug.h" 53 #include "acpiphp.h" 54 55 static LIST_HEAD(bridge_list); 56 57 #define MY_NAME "acpiphp_glue" 58 59 static void handle_hotplug_event_bridge (acpi_handle, u32, void *); 60 static void handle_hotplug_event_func (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 64 65 /* 66 * initialization & terminatation routines 67 */ 68 69 /** 70 * is_ejectable - determine if a slot is ejectable 71 * @handle: handle to acpi namespace 72 * 73 * Ejectable slot should satisfy at least these conditions: 74 * 75 * 1. has _ADR method 76 * 2. has _EJ0 method 77 * 78 * optionally 79 * 80 * 1. has _STA method 81 * 2. has _PS0 method 82 * 3. has _PS3 method 83 * 4. .. 84 * 85 */ 86 static int is_ejectable(acpi_handle handle) 87 { 88 acpi_status status; 89 acpi_handle tmp; 90 91 status = acpi_get_handle(handle, "_ADR", &tmp); 92 if (ACPI_FAILURE(status)) { 93 return 0; 94 } 95 96 status = acpi_get_handle(handle, "_EJ0", &tmp); 97 if (ACPI_FAILURE(status)) { 98 return 0; 99 } 100 101 return 1; 102 } 103 104 105 /* callback routine to check the existence of ejectable slots */ 106 static acpi_status 107 is_ejectable_slot(acpi_handle handle, u32 lvl, void *context, void **rv) 108 { 109 int *count = (int *)context; 110 111 if (is_ejectable(handle)) { 112 (*count)++; 113 /* only one ejectable slot is enough */ 114 return AE_CTRL_TERMINATE; 115 } else { 116 return AE_OK; 117 } 118 } 119 120 121 /* callback routine to register each ACPI PCI slot object */ 122 static acpi_status 123 register_slot(acpi_handle handle, u32 lvl, void *context, void **rv) 124 { 125 struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context; 126 struct acpiphp_slot *slot; 127 struct acpiphp_func *newfunc; 128 acpi_handle tmp; 129 acpi_status status = AE_OK; 130 unsigned long adr, sun; 131 int device, function; 132 static int num_slots = 0; /* XXX if we support I/O node hotplug... */ 133 134 status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr); 135 136 if (ACPI_FAILURE(status)) 137 return AE_OK; 138 139 status = acpi_get_handle(handle, "_EJ0", &tmp); 140 141 if (ACPI_FAILURE(status)) 142 return AE_OK; 143 144 device = (adr >> 16) & 0xffff; 145 function = adr & 0xffff; 146 147 newfunc = kmalloc(sizeof(struct acpiphp_func), GFP_KERNEL); 148 if (!newfunc) 149 return AE_NO_MEMORY; 150 memset(newfunc, 0, sizeof(struct acpiphp_func)); 151 152 INIT_LIST_HEAD(&newfunc->sibling); 153 newfunc->handle = handle; 154 newfunc->function = function; 155 newfunc->flags = FUNC_HAS_EJ0; 156 157 if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp))) 158 newfunc->flags |= FUNC_HAS_STA; 159 160 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS0", &tmp))) 161 newfunc->flags |= FUNC_HAS_PS0; 162 163 if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp))) 164 newfunc->flags |= FUNC_HAS_PS3; 165 166 status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun); 167 if (ACPI_FAILURE(status)) 168 sun = -1; 169 170 /* search for objects that share the same slot */ 171 for (slot = bridge->slots; slot; slot = slot->next) 172 if (slot->device == device) { 173 if (slot->sun != sun) 174 warn("sibling found, but _SUN doesn't match!\n"); 175 break; 176 } 177 178 if (!slot) { 179 slot = kmalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); 180 if (!slot) { 181 kfree(newfunc); 182 return AE_NO_MEMORY; 183 } 184 185 memset(slot, 0, sizeof(struct acpiphp_slot)); 186 slot->bridge = bridge; 187 slot->id = num_slots++; 188 slot->device = device; 189 slot->sun = sun; 190 INIT_LIST_HEAD(&slot->funcs); 191 init_MUTEX(&slot->crit_sect); 192 193 slot->next = bridge->slots; 194 bridge->slots = slot; 195 196 bridge->nr_slots++; 197 198 dbg("found ACPI PCI Hotplug slot %d at PCI %04x:%02x:%02x\n", 199 slot->sun, pci_domain_nr(bridge->pci_bus), 200 bridge->pci_bus->number, slot->device); 201 } 202 203 newfunc->slot = slot; 204 list_add_tail(&newfunc->sibling, &slot->funcs); 205 206 /* associate corresponding pci_dev */ 207 newfunc->pci_dev = pci_get_slot(bridge->pci_bus, 208 PCI_DEVFN(device, function)); 209 if (newfunc->pci_dev) { 210 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON); 211 } 212 213 /* install notify handler */ 214 status = acpi_install_notify_handler(handle, 215 ACPI_SYSTEM_NOTIFY, 216 handle_hotplug_event_func, 217 newfunc); 218 219 if (ACPI_FAILURE(status)) { 220 err("failed to register interrupt notify handler\n"); 221 return status; 222 } 223 224 return AE_OK; 225 } 226 227 228 /* see if it's worth looking at this bridge */ 229 static int detect_ejectable_slots(acpi_handle *bridge_handle) 230 { 231 acpi_status status; 232 int count; 233 234 count = 0; 235 236 /* only check slots defined directly below bridge object */ 237 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, (u32)1, 238 is_ejectable_slot, (void *)&count, NULL); 239 240 return count; 241 } 242 243 244 /* decode ACPI 2.0 _HPP hot plug parameters */ 245 static void decode_hpp(struct acpiphp_bridge *bridge) 246 { 247 acpi_status status; 248 struct acpi_buffer buffer = { .length = ACPI_ALLOCATE_BUFFER, 249 .pointer = NULL}; 250 union acpi_object *package; 251 int i; 252 253 /* default numbers */ 254 bridge->hpp.cache_line_size = 0x10; 255 bridge->hpp.latency_timer = 0x40; 256 bridge->hpp.enable_SERR = 0; 257 bridge->hpp.enable_PERR = 0; 258 259 status = acpi_evaluate_object(bridge->handle, "_HPP", NULL, &buffer); 260 261 if (ACPI_FAILURE(status)) { 262 dbg("_HPP evaluation failed\n"); 263 return; 264 } 265 266 package = (union acpi_object *) buffer.pointer; 267 268 if (!package || package->type != ACPI_TYPE_PACKAGE || 269 package->package.count != 4 || !package->package.elements) { 270 err("invalid _HPP object; ignoring\n"); 271 goto err_exit; 272 } 273 274 for (i = 0; i < 4; i++) { 275 if (package->package.elements[i].type != ACPI_TYPE_INTEGER) { 276 err("invalid _HPP parameter type; ignoring\n"); 277 goto err_exit; 278 } 279 } 280 281 bridge->hpp.cache_line_size = package->package.elements[0].integer.value; 282 bridge->hpp.latency_timer = package->package.elements[1].integer.value; 283 bridge->hpp.enable_SERR = package->package.elements[2].integer.value; 284 bridge->hpp.enable_PERR = package->package.elements[3].integer.value; 285 286 dbg("_HPP parameter = (%02x, %02x, %02x, %02x)\n", 287 bridge->hpp.cache_line_size, 288 bridge->hpp.latency_timer, 289 bridge->hpp.enable_SERR, 290 bridge->hpp.enable_PERR); 291 292 bridge->flags |= BRIDGE_HAS_HPP; 293 294 err_exit: 295 kfree(buffer.pointer); 296 } 297 298 299 /* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */ 300 static void init_bridge_misc(struct acpiphp_bridge *bridge) 301 { 302 acpi_status status; 303 304 /* decode ACPI 2.0 _HPP (hot plug parameters) */ 305 decode_hpp(bridge); 306 307 /* register all slot objects under this bridge */ 308 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1, 309 register_slot, bridge, NULL); 310 311 /* install notify handler */ 312 if (bridge->type != BRIDGE_TYPE_HOST) { 313 status = acpi_install_notify_handler(bridge->handle, 314 ACPI_SYSTEM_NOTIFY, 315 handle_hotplug_event_bridge, 316 bridge); 317 318 if (ACPI_FAILURE(status)) { 319 err("failed to register interrupt notify handler\n"); 320 } 321 } 322 323 list_add(&bridge->list, &bridge_list); 324 } 325 326 327 /* allocate and initialize host bridge data structure */ 328 static void add_host_bridge(acpi_handle *handle, struct pci_bus *pci_bus) 329 { 330 struct acpiphp_bridge *bridge; 331 332 bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 333 if (bridge == NULL) 334 return; 335 336 memset(bridge, 0, sizeof(struct acpiphp_bridge)); 337 338 bridge->type = BRIDGE_TYPE_HOST; 339 bridge->handle = handle; 340 341 bridge->pci_bus = pci_bus; 342 343 spin_lock_init(&bridge->res_lock); 344 345 init_bridge_misc(bridge); 346 } 347 348 349 /* allocate and initialize PCI-to-PCI bridge data structure */ 350 static void add_p2p_bridge(acpi_handle *handle, struct pci_dev *pci_dev) 351 { 352 struct acpiphp_bridge *bridge; 353 354 bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); 355 if (bridge == NULL) { 356 err("out of memory\n"); 357 return; 358 } 359 360 memset(bridge, 0, sizeof(struct acpiphp_bridge)); 361 362 bridge->type = BRIDGE_TYPE_P2P; 363 bridge->handle = handle; 364 365 bridge->pci_dev = pci_dev_get(pci_dev); 366 bridge->pci_bus = pci_dev->subordinate; 367 if (!bridge->pci_bus) { 368 err("This is not a PCI-to-PCI bridge!\n"); 369 goto err; 370 } 371 372 spin_lock_init(&bridge->res_lock); 373 374 init_bridge_misc(bridge); 375 return; 376 err: 377 pci_dev_put(pci_dev); 378 kfree(bridge); 379 return; 380 } 381 382 383 /* callback routine to find P2P bridges */ 384 static acpi_status 385 find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) 386 { 387 acpi_status status; 388 acpi_handle dummy_handle; 389 unsigned long tmp; 390 int device, function; 391 struct pci_dev *dev; 392 struct pci_bus *pci_bus = context; 393 394 status = acpi_get_handle(handle, "_ADR", &dummy_handle); 395 if (ACPI_FAILURE(status)) 396 return AE_OK; /* continue */ 397 398 status = acpi_evaluate_integer(handle, "_ADR", NULL, &tmp); 399 if (ACPI_FAILURE(status)) { 400 dbg("%s: _ADR evaluation failure\n", __FUNCTION__); 401 return AE_OK; 402 } 403 404 device = (tmp >> 16) & 0xffff; 405 function = tmp & 0xffff; 406 407 dev = pci_get_slot(pci_bus, PCI_DEVFN(device, function)); 408 409 if (!dev || !dev->subordinate) 410 goto out; 411 412 /* check if this bridge has ejectable slots */ 413 if (detect_ejectable_slots(handle) > 0) { 414 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev)); 415 add_p2p_bridge(handle, dev); 416 } 417 418 out: 419 pci_dev_put(dev); 420 return AE_OK; 421 } 422 423 424 /* find hot-pluggable slots, and then find P2P bridge */ 425 static int add_bridge(acpi_handle handle) 426 { 427 acpi_status status; 428 unsigned long tmp; 429 int seg, bus; 430 acpi_handle dummy_handle; 431 struct pci_bus *pci_bus; 432 433 /* if the bridge doesn't have _STA, we assume it is always there */ 434 status = acpi_get_handle(handle, "_STA", &dummy_handle); 435 if (ACPI_SUCCESS(status)) { 436 status = acpi_evaluate_integer(handle, "_STA", NULL, &tmp); 437 if (ACPI_FAILURE(status)) { 438 dbg("%s: _STA evaluation failure\n", __FUNCTION__); 439 return 0; 440 } 441 if ((tmp & ACPI_STA_FUNCTIONING) == 0) 442 /* don't register this object */ 443 return 0; 444 } 445 446 /* get PCI segment number */ 447 status = acpi_evaluate_integer(handle, "_SEG", NULL, &tmp); 448 449 seg = ACPI_SUCCESS(status) ? tmp : 0; 450 451 /* get PCI bus number */ 452 status = acpi_evaluate_integer(handle, "_BBN", NULL, &tmp); 453 454 if (ACPI_SUCCESS(status)) { 455 bus = tmp; 456 } else { 457 warn("can't get bus number, assuming 0\n"); 458 bus = 0; 459 } 460 461 pci_bus = pci_find_bus(seg, bus); 462 if (!pci_bus) { 463 err("Can't find bus %04x:%02x\n", seg, bus); 464 return 0; 465 } 466 467 /* check if this bridge has ejectable slots */ 468 if (detect_ejectable_slots(handle) > 0) { 469 dbg("found PCI host-bus bridge with hot-pluggable slots\n"); 470 add_host_bridge(handle, pci_bus); 471 return 0; 472 } 473 474 /* search P2P bridges under this host bridge */ 475 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, 476 find_p2p_bridge, pci_bus, NULL); 477 478 if (ACPI_FAILURE(status)) 479 warn("find_p2p_bridge faied (error code = 0x%x)\n",status); 480 481 return 0; 482 } 483 484 static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle) 485 { 486 struct list_head *head; 487 list_for_each(head, &bridge_list) { 488 struct acpiphp_bridge *bridge = list_entry(head, 489 struct acpiphp_bridge, list); 490 if (bridge->handle == handle) 491 return bridge; 492 } 493 494 return NULL; 495 } 496 497 static void cleanup_bridge(struct acpiphp_bridge *bridge) 498 { 499 struct list_head *list, *tmp; 500 struct acpiphp_slot *slot; 501 acpi_status status; 502 acpi_handle handle = bridge->handle; 503 504 status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 505 handle_hotplug_event_bridge); 506 if (ACPI_FAILURE(status)) 507 err("failed to remove notify handler\n"); 508 509 slot = bridge->slots; 510 while (slot) { 511 struct acpiphp_slot *next = slot->next; 512 list_for_each_safe (list, tmp, &slot->funcs) { 513 struct acpiphp_func *func; 514 func = list_entry(list, struct acpiphp_func, sibling); 515 status = acpi_remove_notify_handler(func->handle, 516 ACPI_SYSTEM_NOTIFY, 517 handle_hotplug_event_func); 518 if (ACPI_FAILURE(status)) 519 err("failed to remove notify handler\n"); 520 pci_dev_put(func->pci_dev); 521 list_del(list); 522 kfree(func); 523 } 524 kfree(slot); 525 slot = next; 526 } 527 528 pci_dev_put(bridge->pci_dev); 529 list_del(&bridge->list); 530 kfree(bridge); 531 } 532 533 static acpi_status 534 cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) 535 { 536 struct acpiphp_bridge *bridge; 537 538 if (!(bridge = acpiphp_handle_to_bridge(handle))) 539 return AE_OK; 540 cleanup_bridge(bridge); 541 return AE_OK; 542 } 543 544 static void remove_bridge(acpi_handle handle) 545 { 546 struct acpiphp_bridge *bridge; 547 548 bridge = acpiphp_handle_to_bridge(handle); 549 if (bridge) { 550 cleanup_bridge(bridge); 551 } else { 552 /* clean-up p2p bridges under this host bridge */ 553 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 554 (u32)1, cleanup_p2p_bridge, NULL, NULL); 555 } 556 } 557 558 static struct pci_dev * get_apic_pci_info(acpi_handle handle) 559 { 560 struct acpi_pci_id id; 561 struct pci_bus *bus; 562 struct pci_dev *dev; 563 564 if (ACPI_FAILURE(acpi_get_pci_id(handle, &id))) 565 return NULL; 566 567 bus = pci_find_bus(id.segment, id.bus); 568 if (!bus) 569 return NULL; 570 571 dev = pci_get_slot(bus, PCI_DEVFN(id.device, id.function)); 572 if (!dev) 573 return NULL; 574 575 if ((dev->class != PCI_CLASS_SYSTEM_PIC_IOAPIC) && 576 (dev->class != PCI_CLASS_SYSTEM_PIC_IOXAPIC)) 577 { 578 pci_dev_put(dev); 579 return NULL; 580 } 581 582 return dev; 583 } 584 585 static int get_gsi_base(acpi_handle handle, u32 *gsi_base) 586 { 587 acpi_status status; 588 int result = -1; 589 unsigned long gsb; 590 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 591 union acpi_object *obj; 592 void *table; 593 594 status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb); 595 if (ACPI_SUCCESS(status)) { 596 *gsi_base = (u32)gsb; 597 return 0; 598 } 599 600 status = acpi_evaluate_object(handle, "_MAT", NULL, &buffer); 601 if (ACPI_FAILURE(status) || !buffer.length || !buffer.pointer) 602 return -1; 603 604 obj = buffer.pointer; 605 if (obj->type != ACPI_TYPE_BUFFER) 606 goto out; 607 608 table = obj->buffer.pointer; 609 switch (((acpi_table_entry_header *)table)->type) { 610 case ACPI_MADT_IOSAPIC: 611 *gsi_base = ((struct acpi_table_iosapic *)table)->global_irq_base; 612 result = 0; 613 break; 614 case ACPI_MADT_IOAPIC: 615 *gsi_base = ((struct acpi_table_ioapic *)table)->global_irq_base; 616 result = 0; 617 break; 618 default: 619 break; 620 } 621 out: 622 acpi_os_free(buffer.pointer); 623 return result; 624 } 625 626 static acpi_status 627 ioapic_add(acpi_handle handle, u32 lvl, void *context, void **rv) 628 { 629 acpi_status status; 630 unsigned long sta; 631 acpi_handle tmp; 632 struct pci_dev *pdev; 633 u32 gsi_base; 634 u64 phys_addr; 635 636 /* Evaluate _STA if present */ 637 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 638 if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL) 639 return AE_CTRL_DEPTH; 640 641 /* Scan only PCI bus scope */ 642 status = acpi_get_handle(handle, "_HID", &tmp); 643 if (ACPI_SUCCESS(status)) 644 return AE_CTRL_DEPTH; 645 646 if (get_gsi_base(handle, &gsi_base)) 647 return AE_OK; 648 649 pdev = get_apic_pci_info(handle); 650 if (!pdev) 651 return AE_OK; 652 653 if (pci_enable_device(pdev)) { 654 pci_dev_put(pdev); 655 return AE_OK; 656 } 657 658 pci_set_master(pdev); 659 660 if (pci_request_region(pdev, 0, "I/O APIC(acpiphp)")) { 661 pci_disable_device(pdev); 662 pci_dev_put(pdev); 663 return AE_OK; 664 } 665 666 phys_addr = pci_resource_start(pdev, 0); 667 if (acpi_register_ioapic(handle, phys_addr, gsi_base)) { 668 pci_release_region(pdev, 0); 669 pci_disable_device(pdev); 670 pci_dev_put(pdev); 671 return AE_OK; 672 } 673 674 return AE_OK; 675 } 676 677 static int acpiphp_configure_ioapics(acpi_handle handle) 678 { 679 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 680 ACPI_UINT32_MAX, ioapic_add, NULL, NULL); 681 return 0; 682 } 683 684 static int power_on_slot(struct acpiphp_slot *slot) 685 { 686 acpi_status status; 687 struct acpiphp_func *func; 688 struct list_head *l; 689 int retval = 0; 690 691 /* if already enabled, just skip */ 692 if (slot->flags & SLOT_POWEREDON) 693 goto err_exit; 694 695 list_for_each (l, &slot->funcs) { 696 func = list_entry(l, struct acpiphp_func, sibling); 697 698 if (func->flags & FUNC_HAS_PS0) { 699 dbg("%s: executing _PS0\n", __FUNCTION__); 700 status = acpi_evaluate_object(func->handle, "_PS0", NULL, NULL); 701 if (ACPI_FAILURE(status)) { 702 warn("%s: _PS0 failed\n", __FUNCTION__); 703 retval = -1; 704 goto err_exit; 705 } else 706 break; 707 } 708 } 709 710 /* TBD: evaluate _STA to check if the slot is enabled */ 711 712 slot->flags |= SLOT_POWEREDON; 713 714 err_exit: 715 return retval; 716 } 717 718 719 static int power_off_slot(struct acpiphp_slot *slot) 720 { 721 acpi_status status; 722 struct acpiphp_func *func; 723 struct list_head *l; 724 725 int retval = 0; 726 727 /* if already disabled, just skip */ 728 if ((slot->flags & SLOT_POWEREDON) == 0) 729 goto err_exit; 730 731 list_for_each (l, &slot->funcs) { 732 func = list_entry(l, struct acpiphp_func, sibling); 733 734 if (func->flags & FUNC_HAS_PS3) { 735 status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL); 736 if (ACPI_FAILURE(status)) { 737 warn("%s: _PS3 failed\n", __FUNCTION__); 738 retval = -1; 739 goto err_exit; 740 } else 741 break; 742 } 743 } 744 745 /* TBD: evaluate _STA to check if the slot is disabled */ 746 747 slot->flags &= (~SLOT_POWEREDON); 748 749 err_exit: 750 return retval; 751 } 752 753 754 /** 755 * enable_device - enable, configure a slot 756 * @slot: slot to be enabled 757 * 758 * This function should be called per *physical slot*, 759 * not per each slot object in ACPI namespace. 760 * 761 */ 762 static int enable_device(struct acpiphp_slot *slot) 763 { 764 struct pci_dev *dev; 765 struct pci_bus *bus = slot->bridge->pci_bus; 766 struct list_head *l; 767 struct acpiphp_func *func; 768 int retval = 0; 769 int num, max, pass; 770 771 if (slot->flags & SLOT_ENABLED) 772 goto err_exit; 773 774 /* sanity check: dev should be NULL when hot-plugged in */ 775 dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0)); 776 if (dev) { 777 /* This case shouldn't happen */ 778 err("pci_dev structure already exists.\n"); 779 pci_dev_put(dev); 780 retval = -1; 781 goto err_exit; 782 } 783 784 num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0)); 785 if (num == 0) { 786 err("No new device found\n"); 787 retval = -1; 788 goto err_exit; 789 } 790 791 max = bus->secondary; 792 for (pass = 0; pass < 2; pass++) { 793 list_for_each_entry(dev, &bus->devices, bus_list) { 794 if (PCI_SLOT(dev->devfn) != slot->device) 795 continue; 796 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || 797 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) 798 max = pci_scan_bridge(bus, dev, max, pass); 799 } 800 } 801 802 pci_bus_size_bridges(bus); 803 pci_bus_assign_resources(bus); 804 acpiphp_sanitize_bus(bus); 805 pci_enable_bridges(bus); 806 pci_bus_add_devices(bus); 807 acpiphp_set_hpp_values(DEVICE_ACPI_HANDLE(&bus->self->dev), bus); 808 acpiphp_configure_ioapics(DEVICE_ACPI_HANDLE(&bus->self->dev)); 809 810 /* associate pci_dev to our representation */ 811 list_for_each (l, &slot->funcs) { 812 func = list_entry(l, struct acpiphp_func, sibling); 813 func->pci_dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 814 func->function)); 815 } 816 817 slot->flags |= SLOT_ENABLED; 818 819 err_exit: 820 return retval; 821 } 822 823 824 /** 825 * disable_device - disable a slot 826 */ 827 static int disable_device(struct acpiphp_slot *slot) 828 { 829 int retval = 0; 830 struct acpiphp_func *func; 831 struct list_head *l; 832 833 /* is this slot already disabled? */ 834 if (!(slot->flags & SLOT_ENABLED)) 835 goto err_exit; 836 837 list_for_each (l, &slot->funcs) { 838 func = list_entry(l, struct acpiphp_func, sibling); 839 if (!func->pci_dev) 840 continue; 841 842 pci_remove_bus_device(func->pci_dev); 843 pci_dev_put(func->pci_dev); 844 func->pci_dev = NULL; 845 } 846 847 slot->flags &= (~SLOT_ENABLED); 848 849 err_exit: 850 return retval; 851 } 852 853 854 /** 855 * get_slot_status - get ACPI slot status 856 * 857 * if a slot has _STA for each function and if any one of them 858 * returned non-zero status, return it 859 * 860 * if a slot doesn't have _STA and if any one of its functions' 861 * configuration space is configured, return 0x0f as a _STA 862 * 863 * otherwise return 0 864 */ 865 static unsigned int get_slot_status(struct acpiphp_slot *slot) 866 { 867 acpi_status status; 868 unsigned long sta = 0; 869 u32 dvid; 870 struct list_head *l; 871 struct acpiphp_func *func; 872 873 list_for_each (l, &slot->funcs) { 874 func = list_entry(l, struct acpiphp_func, sibling); 875 876 if (func->flags & FUNC_HAS_STA) { 877 status = acpi_evaluate_integer(func->handle, "_STA", NULL, &sta); 878 if (ACPI_SUCCESS(status) && sta) 879 break; 880 } else { 881 pci_bus_read_config_dword(slot->bridge->pci_bus, 882 PCI_DEVFN(slot->device, 883 func->function), 884 PCI_VENDOR_ID, &dvid); 885 if (dvid != 0xffffffff) { 886 sta = ACPI_STA_ALL; 887 break; 888 } 889 } 890 } 891 892 return (unsigned int)sta; 893 } 894 895 /** 896 * acpiphp_eject_slot - physically eject the slot 897 */ 898 static int acpiphp_eject_slot(struct acpiphp_slot *slot) 899 { 900 acpi_status status; 901 struct acpiphp_func *func; 902 struct list_head *l; 903 struct acpi_object_list arg_list; 904 union acpi_object arg; 905 906 list_for_each (l, &slot->funcs) { 907 func = list_entry(l, struct acpiphp_func, sibling); 908 909 /* We don't want to call _EJ0 on non-existing functions. */ 910 if ((func->flags & FUNC_HAS_EJ0)) { 911 /* _EJ0 method take one argument */ 912 arg_list.count = 1; 913 arg_list.pointer = &arg; 914 arg.type = ACPI_TYPE_INTEGER; 915 arg.integer.value = 1; 916 917 status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL); 918 if (ACPI_FAILURE(status)) { 919 warn("%s: _EJ0 failed\n", __FUNCTION__); 920 return -1; 921 } else 922 break; 923 } 924 } 925 return 0; 926 } 927 928 /** 929 * acpiphp_check_bridge - re-enumerate devices 930 * 931 * Iterate over all slots under this bridge and make sure that if a 932 * card is present they are enabled, and if not they are disabled. 933 */ 934 static int acpiphp_check_bridge(struct acpiphp_bridge *bridge) 935 { 936 struct acpiphp_slot *slot; 937 int retval = 0; 938 int enabled, disabled; 939 940 enabled = disabled = 0; 941 942 for (slot = bridge->slots; slot; slot = slot->next) { 943 unsigned int status = get_slot_status(slot); 944 if (slot->flags & SLOT_ENABLED) { 945 if (status == ACPI_STA_ALL) 946 continue; 947 retval = acpiphp_disable_slot(slot); 948 if (retval) { 949 err("Error occurred in disabling\n"); 950 goto err_exit; 951 } else { 952 acpiphp_eject_slot(slot); 953 } 954 disabled++; 955 } else { 956 if (status != ACPI_STA_ALL) 957 continue; 958 retval = acpiphp_enable_slot(slot); 959 if (retval) { 960 err("Error occurred in enabling\n"); 961 goto err_exit; 962 } 963 enabled++; 964 } 965 } 966 967 dbg("%s: %d enabled, %d disabled\n", __FUNCTION__, enabled, disabled); 968 969 err_exit: 970 return retval; 971 } 972 973 static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge) 974 { 975 u16 pci_cmd, pci_bctl; 976 struct pci_dev *cdev; 977 978 /* Program hpp values for this device */ 979 if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL || 980 (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE && 981 (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI))) 982 return; 983 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 984 bridge->hpp.cache_line_size); 985 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 986 bridge->hpp.latency_timer); 987 pci_read_config_word(dev, PCI_COMMAND, &pci_cmd); 988 if (bridge->hpp.enable_SERR) 989 pci_cmd |= PCI_COMMAND_SERR; 990 else 991 pci_cmd &= ~PCI_COMMAND_SERR; 992 if (bridge->hpp.enable_PERR) 993 pci_cmd |= PCI_COMMAND_PARITY; 994 else 995 pci_cmd &= ~PCI_COMMAND_PARITY; 996 pci_write_config_word(dev, PCI_COMMAND, pci_cmd); 997 998 /* Program bridge control value and child devices */ 999 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) { 1000 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, 1001 bridge->hpp.latency_timer); 1002 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl); 1003 if (bridge->hpp.enable_SERR) 1004 pci_bctl |= PCI_BRIDGE_CTL_SERR; 1005 else 1006 pci_bctl &= ~PCI_BRIDGE_CTL_SERR; 1007 if (bridge->hpp.enable_PERR) 1008 pci_bctl |= PCI_BRIDGE_CTL_PARITY; 1009 else 1010 pci_bctl &= ~PCI_BRIDGE_CTL_PARITY; 1011 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl); 1012 if (dev->subordinate) { 1013 list_for_each_entry(cdev, &dev->subordinate->devices, 1014 bus_list) 1015 program_hpp(cdev, bridge); 1016 } 1017 } 1018 } 1019 1020 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus) 1021 { 1022 struct acpiphp_bridge bridge; 1023 struct pci_dev *dev; 1024 1025 memset(&bridge, 0, sizeof(bridge)); 1026 bridge.handle = handle; 1027 decode_hpp(&bridge); 1028 list_for_each_entry(dev, &bus->devices, bus_list) 1029 program_hpp(dev, &bridge); 1030 1031 } 1032 1033 /* 1034 * Remove devices for which we could not assign resources, call 1035 * arch specific code to fix-up the bus 1036 */ 1037 static void acpiphp_sanitize_bus(struct pci_bus *bus) 1038 { 1039 struct pci_dev *dev; 1040 int i; 1041 unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; 1042 1043 list_for_each_entry(dev, &bus->devices, bus_list) { 1044 for (i=0; i<PCI_BRIDGE_RESOURCES; i++) { 1045 struct resource *res = &dev->resource[i]; 1046 if ((res->flags & type_mask) && !res->start && 1047 res->end) { 1048 /* Could not assign a required resources 1049 * for this device, remove it */ 1050 pci_remove_bus_device(dev); 1051 break; 1052 } 1053 } 1054 } 1055 } 1056 1057 /* Program resources in newly inserted bridge */ 1058 static int acpiphp_configure_bridge (acpi_handle handle) 1059 { 1060 struct acpi_pci_id pci_id; 1061 struct pci_bus *bus; 1062 1063 if (ACPI_FAILURE(acpi_get_pci_id(handle, &pci_id))) { 1064 err("cannot get PCI domain and bus number for bridge\n"); 1065 return -EINVAL; 1066 } 1067 bus = pci_find_bus(pci_id.segment, pci_id.bus); 1068 if (!bus) { 1069 err("cannot find bus %d:%d\n", 1070 pci_id.segment, pci_id.bus); 1071 return -EINVAL; 1072 } 1073 1074 pci_bus_size_bridges(bus); 1075 pci_bus_assign_resources(bus); 1076 acpiphp_sanitize_bus(bus); 1077 acpiphp_set_hpp_values(handle, bus); 1078 pci_enable_bridges(bus); 1079 acpiphp_configure_ioapics(handle); 1080 return 0; 1081 } 1082 1083 static void handle_bridge_insertion(acpi_handle handle, u32 type) 1084 { 1085 struct acpi_device *device, *pdevice; 1086 acpi_handle phandle; 1087 1088 if ((type != ACPI_NOTIFY_BUS_CHECK) && 1089 (type != ACPI_NOTIFY_DEVICE_CHECK)) { 1090 err("unexpected notification type %d\n", type); 1091 return; 1092 } 1093 1094 acpi_get_parent(handle, &phandle); 1095 if (acpi_bus_get_device(phandle, &pdevice)) { 1096 dbg("no parent device, assuming NULL\n"); 1097 pdevice = NULL; 1098 } 1099 if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) { 1100 err("cannot add bridge to acpi list\n"); 1101 return; 1102 } 1103 if (!acpiphp_configure_bridge(handle) && 1104 !acpi_bus_start(device)) 1105 add_bridge(handle); 1106 else 1107 err("cannot configure and start bridge\n"); 1108 1109 } 1110 1111 /* 1112 * ACPI event handlers 1113 */ 1114 1115 /** 1116 * handle_hotplug_event_bridge - handle ACPI event on bridges 1117 * 1118 * @handle: Notify()'ed acpi_handle 1119 * @type: Notify code 1120 * @context: pointer to acpiphp_bridge structure 1121 * 1122 * handles ACPI event notification on {host,p2p} bridges 1123 * 1124 */ 1125 static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *context) 1126 { 1127 struct acpiphp_bridge *bridge; 1128 char objname[64]; 1129 struct acpi_buffer buffer = { .length = sizeof(objname), 1130 .pointer = objname }; 1131 struct acpi_device *device; 1132 1133 if (acpi_bus_get_device(handle, &device)) { 1134 /* This bridge must have just been physically inserted */ 1135 handle_bridge_insertion(handle, type); 1136 return; 1137 } 1138 1139 bridge = acpiphp_handle_to_bridge(handle); 1140 if (!bridge) { 1141 err("cannot get bridge info\n"); 1142 return; 1143 } 1144 1145 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1146 1147 switch (type) { 1148 case ACPI_NOTIFY_BUS_CHECK: 1149 /* bus re-enumerate */ 1150 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname); 1151 acpiphp_check_bridge(bridge); 1152 break; 1153 1154 case ACPI_NOTIFY_DEVICE_CHECK: 1155 /* device check */ 1156 dbg("%s: Device check notify on %s\n", __FUNCTION__, objname); 1157 acpiphp_check_bridge(bridge); 1158 break; 1159 1160 case ACPI_NOTIFY_DEVICE_WAKE: 1161 /* wake event */ 1162 dbg("%s: Device wake notify on %s\n", __FUNCTION__, objname); 1163 break; 1164 1165 case ACPI_NOTIFY_EJECT_REQUEST: 1166 /* request device eject */ 1167 dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname); 1168 break; 1169 1170 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 1171 printk(KERN_ERR "Device %s cannot be configured due" 1172 " to a frequency mismatch\n", objname); 1173 break; 1174 1175 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 1176 printk(KERN_ERR "Device %s cannot be configured due" 1177 " to a bus mode mismatch\n", objname); 1178 break; 1179 1180 case ACPI_NOTIFY_POWER_FAULT: 1181 printk(KERN_ERR "Device %s has suffered a power fault\n", 1182 objname); 1183 break; 1184 1185 default: 1186 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname); 1187 break; 1188 } 1189 } 1190 1191 /** 1192 * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots) 1193 * 1194 * @handle: Notify()'ed acpi_handle 1195 * @type: Notify code 1196 * @context: pointer to acpiphp_func structure 1197 * 1198 * handles ACPI event notification on slots 1199 * 1200 */ 1201 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context) 1202 { 1203 struct acpiphp_func *func; 1204 char objname[64]; 1205 struct acpi_buffer buffer = { .length = sizeof(objname), 1206 .pointer = objname }; 1207 1208 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1209 1210 func = (struct acpiphp_func *)context; 1211 1212 switch (type) { 1213 case ACPI_NOTIFY_BUS_CHECK: 1214 /* bus re-enumerate */ 1215 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname); 1216 acpiphp_enable_slot(func->slot); 1217 break; 1218 1219 case ACPI_NOTIFY_DEVICE_CHECK: 1220 /* device check : re-enumerate from parent bus */ 1221 dbg("%s: Device check notify on %s\n", __FUNCTION__, objname); 1222 acpiphp_check_bridge(func->slot->bridge); 1223 break; 1224 1225 case ACPI_NOTIFY_DEVICE_WAKE: 1226 /* wake event */ 1227 dbg("%s: Device wake notify on %s\n", __FUNCTION__, objname); 1228 break; 1229 1230 case ACPI_NOTIFY_EJECT_REQUEST: 1231 /* request device eject */ 1232 dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname); 1233 if (!(acpiphp_disable_slot(func->slot))) 1234 acpiphp_eject_slot(func->slot); 1235 break; 1236 1237 default: 1238 warn("notify_handler: unknown event type 0x%x for %s\n", type, objname); 1239 break; 1240 } 1241 } 1242 1243 static int is_root_bridge(acpi_handle handle) 1244 { 1245 acpi_status status; 1246 struct acpi_device_info *info; 1247 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 1248 int i; 1249 1250 status = acpi_get_object_info(handle, &buffer); 1251 if (ACPI_SUCCESS(status)) { 1252 info = buffer.pointer; 1253 if ((info->valid & ACPI_VALID_HID) && 1254 !strcmp(PCI_ROOT_HID_STRING, 1255 info->hardware_id.value)) { 1256 acpi_os_free(buffer.pointer); 1257 return 1; 1258 } 1259 if (info->valid & ACPI_VALID_CID) { 1260 for (i=0; i < info->compatibility_id.count; i++) { 1261 if (!strcmp(PCI_ROOT_HID_STRING, 1262 info->compatibility_id.id[i].value)) { 1263 acpi_os_free(buffer.pointer); 1264 return 1; 1265 } 1266 } 1267 } 1268 } 1269 return 0; 1270 } 1271 1272 static acpi_status 1273 find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) 1274 { 1275 int *count = (int *)context; 1276 1277 if (is_root_bridge(handle)) { 1278 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, 1279 handle_hotplug_event_bridge, NULL); 1280 (*count)++; 1281 } 1282 return AE_OK ; 1283 } 1284 1285 static struct acpi_pci_driver acpi_pci_hp_driver = { 1286 .add = add_bridge, 1287 .remove = remove_bridge, 1288 }; 1289 1290 /** 1291 * acpiphp_glue_init - initializes all PCI hotplug - ACPI glue data structures 1292 * 1293 */ 1294 int __init acpiphp_glue_init(void) 1295 { 1296 int num = 0; 1297 1298 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 1299 ACPI_UINT32_MAX, find_root_bridges, &num, NULL); 1300 1301 if (num <= 0) 1302 return -1; 1303 else 1304 acpi_pci_register_driver(&acpi_pci_hp_driver); 1305 1306 return 0; 1307 } 1308 1309 1310 /** 1311 * acpiphp_glue_exit - terminates all PCI hotplug - ACPI glue data structures 1312 * 1313 * This function frees all data allocated in acpiphp_glue_init() 1314 */ 1315 void __exit acpiphp_glue_exit(void) 1316 { 1317 acpi_pci_unregister_driver(&acpi_pci_hp_driver); 1318 } 1319 1320 1321 /** 1322 * acpiphp_get_num_slots - count number of slots in a system 1323 */ 1324 int __init acpiphp_get_num_slots(void) 1325 { 1326 struct list_head *node; 1327 struct acpiphp_bridge *bridge; 1328 int num_slots; 1329 1330 num_slots = 0; 1331 1332 list_for_each (node, &bridge_list) { 1333 bridge = (struct acpiphp_bridge *)node; 1334 dbg("Bus %04x:%02x has %d slot%s\n", 1335 pci_domain_nr(bridge->pci_bus), 1336 bridge->pci_bus->number, bridge->nr_slots, 1337 bridge->nr_slots == 1 ? "" : "s"); 1338 num_slots += bridge->nr_slots; 1339 } 1340 1341 dbg("Total %d slots\n", num_slots); 1342 return num_slots; 1343 } 1344 1345 1346 #if 0 1347 /** 1348 * acpiphp_for_each_slot - call function for each slot 1349 * @fn: callback function 1350 * @data: context to be passed to callback function 1351 * 1352 */ 1353 static int acpiphp_for_each_slot(acpiphp_callback fn, void *data) 1354 { 1355 struct list_head *node; 1356 struct acpiphp_bridge *bridge; 1357 struct acpiphp_slot *slot; 1358 int retval = 0; 1359 1360 list_for_each (node, &bridge_list) { 1361 bridge = (struct acpiphp_bridge *)node; 1362 for (slot = bridge->slots; slot; slot = slot->next) { 1363 retval = fn(slot, data); 1364 if (!retval) 1365 goto err_exit; 1366 } 1367 } 1368 1369 err_exit: 1370 return retval; 1371 } 1372 #endif 1373 1374 /* search matching slot from id */ 1375 struct acpiphp_slot *get_slot_from_id(int id) 1376 { 1377 struct list_head *node; 1378 struct acpiphp_bridge *bridge; 1379 struct acpiphp_slot *slot; 1380 1381 list_for_each (node, &bridge_list) { 1382 bridge = (struct acpiphp_bridge *)node; 1383 for (slot = bridge->slots; slot; slot = slot->next) 1384 if (slot->id == id) 1385 return slot; 1386 } 1387 1388 /* should never happen! */ 1389 err("%s: no object for id %d\n", __FUNCTION__, id); 1390 WARN_ON(1); 1391 return NULL; 1392 } 1393 1394 1395 /** 1396 * acpiphp_enable_slot - power on slot 1397 */ 1398 int acpiphp_enable_slot(struct acpiphp_slot *slot) 1399 { 1400 int retval; 1401 1402 down(&slot->crit_sect); 1403 1404 /* wake up all functions */ 1405 retval = power_on_slot(slot); 1406 if (retval) 1407 goto err_exit; 1408 1409 if (get_slot_status(slot) == ACPI_STA_ALL) 1410 /* configure all functions */ 1411 retval = enable_device(slot); 1412 1413 err_exit: 1414 up(&slot->crit_sect); 1415 return retval; 1416 } 1417 1418 /** 1419 * acpiphp_disable_slot - power off slot 1420 */ 1421 int acpiphp_disable_slot(struct acpiphp_slot *slot) 1422 { 1423 int retval = 0; 1424 1425 down(&slot->crit_sect); 1426 1427 /* unconfigure all functions */ 1428 retval = disable_device(slot); 1429 if (retval) 1430 goto err_exit; 1431 1432 /* power off all functions */ 1433 retval = power_off_slot(slot); 1434 if (retval) 1435 goto err_exit; 1436 1437 err_exit: 1438 up(&slot->crit_sect); 1439 return retval; 1440 } 1441 1442 1443 /* 1444 * slot enabled: 1 1445 * slot disabled: 0 1446 */ 1447 u8 acpiphp_get_power_status(struct acpiphp_slot *slot) 1448 { 1449 return (slot->flags & SLOT_POWEREDON); 1450 } 1451 1452 1453 /* 1454 * latch closed: 1 1455 * latch open: 0 1456 */ 1457 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot) 1458 { 1459 unsigned int sta; 1460 1461 sta = get_slot_status(slot); 1462 1463 return (sta & ACPI_STA_SHOW_IN_UI) ? 1 : 0; 1464 } 1465 1466 1467 /* 1468 * adapter presence : 1 1469 * absence : 0 1470 */ 1471 u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) 1472 { 1473 unsigned int sta; 1474 1475 sta = get_slot_status(slot); 1476 1477 return (sta == 0) ? 0 : 1; 1478 } 1479 1480 1481 /* 1482 * pci address (seg/bus/dev) 1483 */ 1484 u32 acpiphp_get_address(struct acpiphp_slot *slot) 1485 { 1486 u32 address; 1487 struct pci_bus *pci_bus = slot->bridge->pci_bus; 1488 1489 address = (pci_domain_nr(pci_bus) << 16) | 1490 (pci_bus->number << 8) | 1491 slot->device; 1492 1493 return address; 1494 } 1495