Pileus Git - ~andy/linux/blob - 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 #include <linux/init.h>
  35 #include <linux/module.h>
  36 #include <linux/moduleparam.h>
  37
  38 #include <linux/kernel.h>
  39 #include <linux/pci.h>
  40 #include <linux/pci-acpi.h>
  41 #include <linux/pci_hotplug.h>
  42 #include <linux/slab.h>
  43 #include <linux/smp.h>
  44 #include "acpiphp.h"
  45
  46 #define MY_NAME "acpiphp"
  47
  48 /* name size which is used for entries in pcihpfs */
  49 #define SLOT_NAME_SIZE  21              /* {_SUN} */
  50
  51 bool acpiphp_debug;
  52 bool acpiphp_disabled;
  53
  54 /* local variables */
  55 static struct acpiphp_attention_info *attention_info;
  56
  57 #define DRIVER_VERSION  "0.5"
  58 #define DRIVER_AUTHOR   "Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@hp.com>"
  59 #define DRIVER_DESC     "ACPI Hot Plug PCI Controller Driver"
  60
  61 MODULE_AUTHOR(DRIVER_AUTHOR);
  62 MODULE_DESCRIPTION(DRIVER_DESC);
  63 MODULE_LICENSE("GPL");
  64 MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
  65 MODULE_PARM_DESC(disable, "disable acpiphp driver");
  66 module_param_named(debug, acpiphp_debug, bool, 0644);
  67 module_param_named(disable, acpiphp_disabled, bool, 0444);
  68
  69 /* export the attention callback registration methods */
  70 EXPORT_SYMBOL_GPL(acpiphp_register_attention);
  71 EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
  72
  73 static int enable_slot          (struct hotplug_slot *slot);
  74 static int disable_slot         (struct hotplug_slot *slot);
  75 static int set_attention_status (struct hotplug_slot *slot, u8 value);
  76 static int get_power_status     (struct hotplug_slot *slot, u8 *value);
  77 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
  78 static int get_latch_status     (struct hotplug_slot *slot, u8 *value);
  79 static int get_adapter_status   (struct hotplug_slot *slot, u8 *value);
  80
  81 static struct hotplug_slot_ops acpi_hotplug_slot_ops = {
  82         .enable_slot            = enable_slot,
  83         .disable_slot           = disable_slot,
  84         .set_attention_status   = set_attention_status,
  85         .get_power_status       = get_power_status,
  86         .get_attention_status   = get_attention_status,
  87         .get_latch_status       = get_latch_status,
  88         .get_adapter_status     = get_adapter_status,
  89 };
  90
  91 /**
  92  * acpiphp_register_attention - set attention LED callback
  93  * @info: must be completely filled with LED callbacks
  94  *
  95  * Description: This is used to register a hardware specific ACPI
  96  * driver that manipulates the attention LED.  All the fields in
  97  * info must be set.
  98  */
  99 int acpiphp_register_attention(struct acpiphp_attention_info *info)
 100 {
 101         int retval = -EINVAL;
 102
 103         if (info && info->owner && info->set_attn &&
 104                         info->get_attn && !attention_info) {
 105                 retval = 0;
 106                 attention_info = info;
 107         }
 108         return retval;
 109 }
 110
 111
 112 /**
 113  * acpiphp_unregister_attention - unset attention LED callback
 114  * @info: must match the pointer used to register
 115  *
 116  * Description: This is used to un-register a hardware specific acpi
 117  * driver that manipulates the attention LED.  The pointer to the
 118  * info struct must be the same as the one used to set it.
 119  */
 120 int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
 121 {
 122         int retval = -EINVAL;
 123
 124         if (info && attention_info == info) {
 125                 attention_info = NULL;
 126                 retval = 0;
 127         }
 128         return retval;
 129 }
 130
 131
 132 /**
 133  * enable_slot - power on and enable a slot
 134  * @hotplug_slot: slot to enable
 135  *
 136  * Actual tasks are done in acpiphp_enable_slot()
 137  */
 138 static int enable_slot(struct hotplug_slot *hotplug_slot)
 139 {
 140         struct slot *slot = hotplug_slot->private;
 141
 142         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 143
 144         /* enable the specified slot */
 145         return acpiphp_enable_slot(slot->acpi_slot);
 146 }
 147
 148
 149 /**
 150  * disable_slot - disable and power off a slot
 151  * @hotplug_slot: slot to disable
 152  *
 153  * Actual tasks are done in acpiphp_disable_slot()
 154  */
 155 static int disable_slot(struct hotplug_slot *hotplug_slot)
 156 {
 157         struct slot *slot = hotplug_slot->private;
 158         int retval;
 159
 160         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 161
 162         /* disable the specified slot */
 163         retval = acpiphp_disable_slot(slot->acpi_slot);
 164         if (!retval)
 165                 retval = acpiphp_eject_slot(slot->acpi_slot);
 166         return retval;
 167 }
 168
 169
 170 /**
 171  * set_attention_status - set attention LED
 172  * @hotplug_slot: slot to set attention LED on
 173  * @status: value to set attention LED to (0 or 1)
 174  *
 175  * attention status LED, so we use a callback that
 176  * was registered with us.  This allows hardware specific
 177  * ACPI implementations to blink the light for us.
 178  */
 179  static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 180  {
 181         int retval = -ENODEV;
 182
 183         dbg("%s - physical_slot = %s\n", __func__, hotplug_slot_name(hotplug_slot));
 184
 185         if (attention_info && try_module_get(attention_info->owner)) {
 186                 retval = attention_info->set_attn(hotplug_slot, status);
 187                 module_put(attention_info->owner);
 188         } else
 189                 attention_info = NULL;
 190         return retval;
 191  }
 192
 193
 194 /**
 195  * get_power_status - get power status of a slot
 196  * @hotplug_slot: slot to get status
 197  * @value: pointer to store status
 198  *
 199  * Some platforms may not implement _STA method properly.
 200  * In that case, the value returned may not be reliable.
 201  */
 202 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
 203 {
 204         struct slot *slot = hotplug_slot->private;
 205
 206         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 207
 208         *value = acpiphp_get_power_status(slot->acpi_slot);
 209
 210         return 0;
 211 }
 212
 213
 214 /**
 215  * get_attention_status - get attention LED status
 216  * @hotplug_slot: slot to get status from
 217  * @value: returns with value of attention LED
 218  *
 219  * ACPI doesn't have known method to determine the state
 220  * of the attention status LED, so we use a callback that
 221  * was registered with us.  This allows hardware specific
 222  * ACPI implementations to determine its state.
 223  */
 224 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
 225 {
 226         int retval = -EINVAL;
 227
 228         dbg("%s - physical_slot = %s\n", __func__, hotplug_slot_name(hotplug_slot));
 229
 230         if (attention_info && try_module_get(attention_info->owner)) {
 231                 retval = attention_info->get_attn(hotplug_slot, value);
 232                 module_put(attention_info->owner);
 233         } else
 234                 attention_info = NULL;
 235         return retval;
 236 }
 237
 238
 239 /**
 240  * get_latch_status - get latch status of a slot
 241  * @hotplug_slot: slot to get status
 242  * @value: pointer to store status
 243  *
 244  * ACPI doesn't provide any formal means to access latch status.
 245  * Instead, we fake latch status from _STA.
 246  */
 247 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
 248 {
 249         struct slot *slot = hotplug_slot->private;
 250
 251         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 252
 253         *value = acpiphp_get_latch_status(slot->acpi_slot);
 254
 255         return 0;
 256 }
 257
 258
 259 /**
 260  * get_adapter_status - get adapter status of a slot
 261  * @hotplug_slot: slot to get status
 262  * @value: pointer to store status
 263  *
 264  * ACPI doesn't provide any formal means to access adapter status.
 265  * Instead, we fake adapter status from _STA.
 266  */
 267 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
 268 {
 269         struct slot *slot = hotplug_slot->private;
 270
 271         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 272
 273         *value = acpiphp_get_adapter_status(slot->acpi_slot);
 274
 275         return 0;
 276 }
 277
 278 /**
 279  * release_slot - free up the memory used by a slot
 280  * @hotplug_slot: slot to free
 281  */
 282 static void release_slot(struct hotplug_slot *hotplug_slot)
 283 {
 284         struct slot *slot = hotplug_slot->private;
 285
 286         dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
 287
 288         kfree(slot->hotplug_slot);
 289         kfree(slot);
 290 }
 291
 292 /* callback routine to initialize 'struct slot' for each slot */
 293 int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
 294 {
 295         struct slot *slot;
 296         int retval = -ENOMEM;
 297         char name[SLOT_NAME_SIZE];
 298
 299         slot = kzalloc(sizeof(*slot), GFP_KERNEL);
 300         if (!slot)
 301                 goto error;
 302
 303         slot->hotplug_slot = kzalloc(sizeof(*slot->hotplug_slot), GFP_KERNEL);
 304         if (!slot->hotplug_slot)
 305                 goto error_slot;
 306
 307         slot->hotplug_slot->info = &slot->info;
 308
 309         slot->hotplug_slot->private = slot;
 310         slot->hotplug_slot->release = &release_slot;
 311         slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
 312
 313         slot->acpi_slot = acpiphp_slot;
 314         slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
 315         slot->hotplug_slot->info->attention_status = 0;
 316         slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
 317         slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
 318
 319         acpiphp_slot->slot = slot;
 320         snprintf(name, SLOT_NAME_SIZE, "%llu", slot->acpi_slot->sun);
 321
 322         retval = pci_hp_register(slot->hotplug_slot,
 323                                         acpiphp_slot->bridge->pci_bus,
 324                                         acpiphp_slot->device,
 325                                         name);
 326         if (retval == -EBUSY)
 327                 goto error_hpslot;
 328         if (retval) {
 329                 err("pci_hp_register failed with error %d\n", retval);
 330                 goto error_hpslot;
 331         }
 332
 333         info("Slot [%s] registered\n", slot_name(slot));
 334
 335         return 0;
 336 error_hpslot:
 337         kfree(slot->hotplug_slot);
 338 error_slot:
 339         kfree(slot);
 340 error:
 341         return retval;
 342 }
 343
 344
 345 void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
 346 {
 347         struct slot *slot = acpiphp_slot->slot;
 348         int retval = 0;
 349
 350         info("Slot [%s] unregistered\n", slot_name(slot));
 351
 352         retval = pci_hp_deregister(slot->hotplug_slot);
 353         if (retval)
 354                 err("pci_hp_deregister failed with error %d\n", retval);
 355 }
 356
 357
 358 void __init acpiphp_init(void)
 359 {
 360         info(DRIVER_DESC " version: " DRIVER_VERSION "%s\n",
 361                 acpiphp_disabled ? ", disabled by user; please report a bug"
 362                                  : "");
 363 }