drivers/acpi/pci_slot.c

   1 /*
   2  *  pci_slot.c - ACPI PCI Slot Driver
   3  *
   4  *  The code here is heavily leveraged from the acpiphp module.
   5  *  Thanks to Matthew Wilcox <matthew@wil.cx> for much guidance.
   6  *  Thanks to Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com> for code
   7  *  review and fixes.
   8  *
   9  *  Copyright (C) 2007-2008 Hewlett-Packard Development Company, L.P.
  10  *      Alex Chiang <achiang@hp.com>
  11  *
  12  *  Copyright (C) 2013 Huawei Tech. Co., Ltd.
  13  *      Jiang Liu <jiang.liu@huawei.com>
  14  *
  15  *  This program is free software; you can redistribute it and/or modify it
  16  *  under the terms and conditions of the GNU General Public License,
  17  *  version 2, as published by the Free Software Foundation.
  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.  See the GNU
  22  *  General Public License for more details.
  23  */
  24
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/init.h>
  28 #include <linux/slab.h>
  29 #include <linux/types.h>
  30 #include <linux/list.h>
  31 #include <linux/pci.h>
  32 #include <linux/acpi.h>
  33 #include <linux/dmi.h>
  34 #include <linux/pci-acpi.h>
  35
  36 static bool debug;
  37 static int check_sta_before_sun;
  38
  39 #define DRIVER_VERSION  "0.1"
  40 #define DRIVER_AUTHOR   "Alex Chiang <achiang@hp.com>"
  41 #define DRIVER_DESC     "ACPI PCI Slot Detection Driver"
  42 MODULE_AUTHOR(DRIVER_AUTHOR);
  43 MODULE_DESCRIPTION(DRIVER_DESC);
  44 MODULE_LICENSE("GPL");
  45 MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
  46 module_param(debug, bool, 0644);
  47
  48 #define _COMPONENT              ACPI_PCI_COMPONENT
  49 ACPI_MODULE_NAME("pci_slot");
  50
  51 #define MY_NAME "pci_slot"
  52 #define err(format, arg...) pr_err("%s: " format , MY_NAME , ## arg)
  53 #define info(format, arg...) pr_info("%s: " format , MY_NAME , ## arg)
  54 #define dbg(format, arg...)                                     \
  55         do {                                                    \
  56                 if (debug)                                      \
  57                         pr_debug("%s: " format, MY_NAME , ## arg); \
  58         } while (0)
  59
  60 #define SLOT_NAME_SIZE 21               /* Inspired by #define in acpiphp.h */
  61
  62 struct acpi_pci_slot {
  63         struct pci_slot *pci_slot;      /* corresponding pci_slot */
  64         struct list_head list;          /* node in the list of slots */
  65 };
  66
  67 static LIST_HEAD(slot_list);
  68 static DEFINE_MUTEX(slot_list_lock);
  69
  70 static int
  71 check_slot(acpi_handle handle, unsigned long long *sun)
  72 {
  73         int device = -1;
  74         unsigned long long adr, sta;
  75         acpi_status status;
  76         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
  77
  78         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
  79         dbg("Checking slot on path: %s\n", (char *)buffer.pointer);
  80
  81         if (check_sta_before_sun) {
  82                 /* If SxFy doesn't have _STA, we just assume it's there */
  83                 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
  84                 if (ACPI_SUCCESS(status) && !(sta & ACPI_STA_DEVICE_PRESENT))
  85                         goto out;
  86         }
  87
  88         status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
  89         if (ACPI_FAILURE(status)) {
  90                 dbg("_ADR returned %d on %s\n", status, (char *)buffer.pointer);
  91                 goto out;
  92         }
  93
  94         /* No _SUN == not a slot == bail */
  95         status = acpi_evaluate_integer(handle, "_SUN", NULL, sun);
  96         if (ACPI_FAILURE(status)) {
  97                 dbg("_SUN returned %d on %s\n", status, (char *)buffer.pointer);
  98                 goto out;
  99         }
 100
 101         device = (adr >> 16) & 0xffff;
 102 out:
 103         kfree(buffer.pointer);
 104         return device;
 105 }
 106
 107 /*
 108  * Check whether handle has an associated slot and create PCI slot if it has.
 109  */
 110 static acpi_status
 111 register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
 112 {
 113         int device;
 114         unsigned long long sun;
 115         char name[SLOT_NAME_SIZE];
 116         struct acpi_pci_slot *slot;
 117         struct pci_slot *pci_slot;
 118         struct pci_bus *pci_bus = context;
 119
 120         device = check_slot(handle, &sun);
 121         if (device < 0)
 122                 return AE_OK;
 123
 124         /*
 125          * There may be multiple PCI functions associated with the same slot.
 126          * Check whether PCI slot has already been created for this PCI device.
 127          */
 128         list_for_each_entry(slot, &slot_list, list) {
 129                 pci_slot = slot->pci_slot;
 130                 if (pci_slot->bus == pci_bus && pci_slot->number == device)
 131                         return AE_OK;
 132         }
 133
 134         slot = kmalloc(sizeof(*slot), GFP_KERNEL);
 135         if (!slot) {
 136                 err("%s: cannot allocate memory\n", __func__);
 137                 return AE_OK;
 138         }
 139
 140         snprintf(name, sizeof(name), "%llu", sun);
 141         pci_slot = pci_create_slot(pci_bus, device, name, NULL);
 142         if (IS_ERR(pci_slot)) {
 143                 err("pci_create_slot returned %ld\n", PTR_ERR(pci_slot));
 144                 kfree(slot);
 145                 return AE_OK;
 146         }
 147
 148         slot->pci_slot = pci_slot;
 149         list_add(&slot->list, &slot_list);
 150
 151         get_device(&pci_bus->dev);
 152
 153         dbg("pci_slot: %p, pci_bus: %x, device: %d, name: %s\n",
 154                 pci_slot, pci_bus->number, device, name);
 155
 156         return AE_OK;
 157 }
 158
 159 void acpi_pci_slot_enumerate(struct pci_bus *bus)
 160 {
 161         acpi_handle handle = ACPI_HANDLE(bus->bridge);
 162
 163         if (handle) {
 164                 mutex_lock(&slot_list_lock);
 165                 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
 166                                     register_slot, NULL, bus, NULL);
 167                 mutex_unlock(&slot_list_lock);
 168         }
 169 }
 170
 171 void acpi_pci_slot_remove(struct pci_bus *bus)
 172 {
 173         struct acpi_pci_slot *slot, *tmp;
 174
 175         mutex_lock(&slot_list_lock);
 176         list_for_each_entry_safe(slot, tmp, &slot_list, list) {
 177                 if (slot->pci_slot->bus == bus) {
 178                         list_del(&slot->list);
 179                         pci_destroy_slot(slot->pci_slot);
 180                         put_device(&bus->dev);
 181                         kfree(slot);
 182                 }
 183         }
 184         mutex_unlock(&slot_list_lock);
 185 }
 186
 187 static int do_sta_before_sun(const struct dmi_system_id *d)
 188 {
 189         info("%s detected: will evaluate _STA before calling _SUN\n", d->ident);
 190         check_sta_before_sun = 1;
 191         return 0;
 192 }
 193
 194 static struct dmi_system_id acpi_pci_slot_dmi_table[] __initdata = {
 195         /*
 196          * Fujitsu Primequest machines will return 1023 to indicate an
 197          * error if the _SUN method is evaluated on SxFy objects that
 198          * are not present (as indicated by _STA), so for those machines,
 199          * we want to check _STA before evaluating _SUN.
 200          */
 201         {
 202          .callback = do_sta_before_sun,
 203          .ident = "Fujitsu PRIMEQUEST",
 204          .matches = {
 205                 DMI_MATCH(DMI_BIOS_VENDOR, "FUJITSU LIMITED"),
 206                 DMI_MATCH(DMI_BIOS_VERSION, "PRIMEQUEST"),
 207                 },
 208         },
 209         {}
 210 };
 211
 212 void __init acpi_pci_slot_init(void)
 213 {
 214         dmi_check_system(acpi_pci_slot_dmi_table);
 215 }