LXR linux/drivers/acpi/pci

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