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