drivers/pci/hotplug/acpiphp_glue.c

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