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