drivers/pci/hotplug/acpiphp_core.c

   1 /*
   2  * ACPI PCI Hot Plug Controller Driver
   3  *
   4  * Copyright (C) 1995,2001 Compaq Computer Corporation
   5  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
   6  * Copyright (C) 2001 IBM Corp.
   7  * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
   8  * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
   9  * Copyright (C) 2002,2003 NEC Corporation
  10  * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com)
  11  * Copyright (C) 2003-2005 Hewlett Packard
  12  *
  13  * All rights reserved.
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or (at
  18  * your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful, but
  21  * WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  23  * NON INFRINGEMENT.  See the GNU General Public License for more
  24  * details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29  *
  30  * Send feedback to <kristen.c.accardi@intel.com>
  31  *
  32  */
  33
  34 #define pr_fmt(fmt) "acpiphp: " fmt
  35
  36 #include <linux/init.h>
  37 #include <linux/module.h>
  38 #include <linux/moduleparam.h>
  39
  40 #include <linux/kernel.h>
  41 #include <linux/pci.h>
  42 #include <linux/pci-acpi.h>
  43 #include <linux/pci_hotplug.h>
  44 #include <linux/slab.h>
  45 #include <linux/smp.h>
  46 #include "acpiphp.h"
  47
  48 /* name size which is used for entries in pcihpfs */
  49 #define SLOT_NAME_SIZE  21              /* {_SUN} */
  50
  51 bool acpiphp_disabled;
  52
  53 /* local variables */
  54 static struct acpiphp_attention_info *attention_info;
  55
  56 #define DRIVER_VERSION  "0.5"
  57 #define DRIVER_AUTHOR   "Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@hp.com>"
  58 #define DRIVER_DESC     "ACPI Hot Plug PCI Controller Driver"
  59
  60 MODULE_AUTHOR(DRIVER_AUTHOR);
  61 MODULE_DESCRIPTION(DRIVER_DESC);
  62 MODULE_LICENSE("GPL");
  63 MODULE_PARM_DESC(disable, "disable acpiphp driver");
  64 module_param_named(disable, acpiphp_disabled, bool, 0444);
  65
  66 static int enable_slot(struct hotplug_slot *slot);
  67 static int disable_slot(struct hotplug_slot *slot);
  68 static int set_attention_status(struct hotplug_slot *slot, u8 value);
  69 static int get_power_status(struct hotplug_slot *slot, u8 *value);
  70 static int get_attention_status(struct hotplug_slot *slot, u8 *value);
  71 static int get_latch_status(struct hotplug_slot *slot, u8 *value);
  72 static int get_adapter_status(struct hotplug_slot *slot, u8 *value);
  73
  74 static struct hotplug_slot_ops acpi_hotplug_slot_ops = {
  75         .enable_slot            = enable_slot,
  76         .disable_slot           = disable_slot,
  77         .set_attention_status   = set_attention_status,
  78         .get_power_status       = get_power_status,
  79         .get_attention_status   = get_attention_status,
  80         .get_latch_status       = get_latch_status,
  81         .get_adapter_status     = get_adapter_status,
  82 };
  83
  84 /**
  85  * acpiphp_register_attention - set attention LED callback
  86  * @info: must be completely filled with LED callbacks
  87  *
  88  * Description: This is used to register a hardware specific ACPI
  89  * driver that manipulates the attention LED.  All the fields in
  90  * info must be set.
  91  */
  92 int acpiphp_register_attention(struct acpiphp_attention_info *info)
  93 {
  94         int retval = -EINVAL;
  95
  96         if (info && info->owner && info->set_attn &&
  97                         info->get_attn && !attention_info) {
  98                 retval = 0;
  99                 attention_info = info;
 100         }
 101         return retval;
 102 }
 103 EXPORT_SYMBOL_GPL(acpiphp_register_attention);
 104
 105
 106 /**
 107  * acpiphp_unregister_attention - unset attention LED callback
 108  * @info: must match the pointer used to register
 109  *
 110  * Description: This is used to un-register a hardware specific acpi
 111  * driver that manipulates the attention LED.  The pointer to the
 112  * info struct must be the same as the one used to set it.
 113  */
 114 int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
 115 {
 116         int retval = -EINVAL;
 117
 118         if (info && attention_info == info) {
 119                 attention_info = NULL;
 120                 retval = 0;
 121         }
 122         return retval;
 123 }
 124 EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
 125
 126
 127 /**
 128  * enable_slot - power on and enable a slot
 129  * @hotplug_slot: slot to enable
 130  *
 131  * Actual tasks are done in acpiphp_enable_slot()
 132  */
 133 static int enable_slot(struct hotplug_slot *hotplug_slot)
 134 {
 135         struct slot *slot = hotplug_slot->private;
 136
 137         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 138
 139         /* enable the specified slot */
 140         return acpiphp_enable_slot(slot->acpi_slot);
 141 }
 142
 143
 144 /**
 145  * disable_slot - disable and power off a slot
 146  * @hotplug_slot: slot to disable
 147  *
 148  * Actual tasks are done in acpiphp_disable_slot()
 149  */
 150 static int disable_slot(struct hotplug_slot *hotplug_slot)
 151 {
 152         struct slot *slot = hotplug_slot->private;
 153
 154         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 155
 156         /* disable the specified slot */
 157         return acpiphp_disable_slot(slot->acpi_slot);
 158 }
 159
 160
 161 /**
 162  * set_attention_status - set attention LED
 163  * @hotplug_slot: slot to set attention LED on
 164  * @status: value to set attention LED to (0 or 1)
 165  *
 166  * attention status LED, so we use a callback that
 167  * was registered with us.  This allows hardware specific
 168  * ACPI implementations to blink the light for us.
 169  */
 170 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 171 {
 172         int retval = -ENODEV;
 173
 174         pr_debug("%s - physical_slot = %s\n", __func__,
 175                 hotplug_slot_name(hotplug_slot));
 176
 177         if (attention_info && try_module_get(attention_info->owner)) {
 178                 retval = attention_info->set_attn(hotplug_slot, status);
 179                 module_put(attention_info->owner);
 180         } else
 181                 attention_info = NULL;
 182         return retval;
 183 }
 184
 185
 186 /**
 187  * get_power_status - get power status of a slot
 188  * @hotplug_slot: slot to get status
 189  * @value: pointer to store status
 190  *
 191  * Some platforms may not implement _STA method properly.
 192  * In that case, the value returned may not be reliable.
 193  */
 194 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
 195 {
 196         struct slot *slot = hotplug_slot->private;
 197
 198         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 199
 200         *value = acpiphp_get_power_status(slot->acpi_slot);
 201
 202         return 0;
 203 }
 204
 205
 206 /**
 207  * get_attention_status - get attention LED status
 208  * @hotplug_slot: slot to get status from
 209  * @value: returns with value of attention LED
 210  *
 211  * ACPI doesn't have known method to determine the state
 212  * of the attention status LED, so we use a callback that
 213  * was registered with us.  This allows hardware specific
 214  * ACPI implementations to determine its state.
 215  */
 216 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
 217 {
 218         int retval = -EINVAL;
 219
 220         pr_debug("%s - physical_slot = %s\n", __func__,
 221                 hotplug_slot_name(hotplug_slot));
 222
 223         if (attention_info && try_module_get(attention_info->owner)) {
 224                 retval = attention_info->get_attn(hotplug_slot, value);
 225                 module_put(attention_info->owner);
 226         } else
 227                 attention_info = NULL;
 228         return retval;
 229 }
 230
 231
 232 /**
 233  * get_latch_status - get latch status of a slot
 234  * @hotplug_slot: slot to get status
 235  * @value: pointer to store status
 236  *
 237  * ACPI doesn't provide any formal means to access latch status.
 238  * Instead, we fake latch status from _STA.
 239  */
 240 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
 241 {
 242         struct slot *slot = hotplug_slot->private;
 243
 244         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 245
 246         *value = acpiphp_get_latch_status(slot->acpi_slot);
 247
 248         return 0;
 249 }
 250
 251
 252 /**
 253  * get_adapter_status - get adapter status of a slot
 254  * @hotplug_slot: slot to get status
 255  * @value: pointer to store status
 256  *
 257  * ACPI doesn't provide any formal means to access adapter status.
 258  * Instead, we fake adapter status from _STA.
 259  */
 260 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
 261 {
 262         struct slot *slot = hotplug_slot->private;
 263
 264         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 265
 266         *value = acpiphp_get_adapter_status(slot->acpi_slot);
 267
 268         return 0;
 269 }
 270
 271 /**
 272  * release_slot - free up the memory used by a slot
 273  * @hotplug_slot: slot to free
 274  */
 275 static void release_slot(struct hotplug_slot *hotplug_slot)
 276 {
 277         struct slot *slot = hotplug_slot->private;
 278
 279         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 280
 281         kfree(slot->hotplug_slot);
 282         kfree(slot);
 283 }
 284
 285 /* callback routine to initialize 'struct slot' for each slot */
 286 int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot,
 287                                   unsigned int sun)
 288 {
 289         struct slot *slot;
 290         int retval = -ENOMEM;
 291         char name[SLOT_NAME_SIZE];
 292
 293         slot = kzalloc(sizeof(*slot), GFP_KERNEL);
 294         if (!slot)
 295                 goto error;
 296
 297         slot->hotplug_slot = kzalloc(sizeof(*slot->hotplug_slot), GFP_KERNEL);
 298         if (!slot->hotplug_slot)
 299                 goto error_slot;
 300
 301         slot->hotplug_slot->info = &slot->info;
 302
 303         slot->hotplug_slot->private = slot;
 304         slot->hotplug_slot->release = &release_slot;
 305         slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
 306
 307         slot->acpi_slot = acpiphp_slot;
 308         slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
 309         slot->hotplug_slot->info->attention_status = 0;
 310         slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
 311         slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
 312
 313         acpiphp_slot->slot = slot;
 314         slot->sun = sun;
 315         snprintf(name, SLOT_NAME_SIZE, "%u", sun);
 316
 317         retval = pci_hp_register(slot->hotplug_slot, acpiphp_slot->bus,
 318                                  acpiphp_slot->device, name);
 319         if (retval == -EBUSY)
 320                 goto error_hpslot;
 321         if (retval) {
 322                 pr_err("pci_hp_register failed with error %d\n", retval);
 323                 goto error_hpslot;
 324         }
 325
 326         pr_info("Slot [%s] registered\n", slot_name(slot));
 327
 328         return 0;
 329 error_hpslot:
 330         kfree(slot->hotplug_slot);
 331 error_slot:
 332         kfree(slot);
 333 error:
 334         return retval;
 335 }
 336
 337
 338 void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
 339 {
 340         struct slot *slot = acpiphp_slot->slot;
 341         int retval = 0;
 342
 343         pr_info("Slot [%s] unregistered\n", slot_name(slot));
 344
 345         retval = pci_hp_deregister(slot->hotplug_slot);
 346         if (retval)
 347                 pr_err("pci_hp_deregister failed with error %d\n", retval);
 348 }
 349
 350
 351 void __init acpiphp_init(void)
 352 {
 353         pr_info(DRIVER_DESC " version: " DRIVER_VERSION "%s\n",
 354                 acpiphp_disabled ? ", disabled by user; please report a bug"
 355                                  : "");
 356 }