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