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 <gregkh@us.ibm.com>,
  31  *                  <t-kochi@bq.jp.nec.com>
  32  *
  33  */
  34
  35 #include <linux/init.h>
  36 #include <linux/module.h>
  37 #include <linux/moduleparam.h>
  38
  39 #include <linux/kernel.h>
  40 #include <linux/pci.h>
  41 #include <linux/slab.h>
  42 #include <linux/smp.h>
  43 #include <linux/smp_lock.h>
  44 #include "pci_hotplug.h"
  45 #include "acpiphp.h"
  46
  47 static LIST_HEAD(slot_list);
  48
  49 #define MY_NAME "acpiphp"
  50
  51 static int debug;
  52 int acpiphp_debug;
  53
  54 /* local variables */
  55 static int num_slots;
  56 static struct acpiphp_attention_info *attention_info;
  57
  58 #define DRIVER_VERSION  "0.5"
  59 #define DRIVER_AUTHOR   "Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@hp.com>"
  60 #define DRIVER_DESC     "ACPI Hot Plug PCI Controller Driver"
  61
  62 MODULE_AUTHOR(DRIVER_AUTHOR);
  63 MODULE_DESCRIPTION(DRIVER_DESC);
  64 MODULE_LICENSE("GPL");
  65 MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
  66 module_param(debug, bool, 0644);
  67
  68 /* export the attention callback registration methods */
  69 EXPORT_SYMBOL_GPL(acpiphp_register_attention);
  70 EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
  71
  72 static int enable_slot          (struct hotplug_slot *slot);
  73 static int disable_slot         (struct hotplug_slot *slot);
  74 static int set_attention_status (struct hotplug_slot *slot, u8 value);
  75 static int get_power_status     (struct hotplug_slot *slot, u8 *value);
  76 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
  77 static int get_address          (struct hotplug_slot *slot, u32 *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         .owner                  = THIS_MODULE,
  83         .enable_slot            = enable_slot,
  84         .disable_slot           = disable_slot,
  85         .set_attention_status   = set_attention_status,
  86         .get_power_status       = get_power_status,
  87         .get_attention_status   = get_attention_status,
  88         .get_latch_status       = get_latch_status,
  89         .get_adapter_status     = get_adapter_status,
  90         .get_address            = get_address,
  91 };
  92
  93
  94 /**
  95  * acpiphp_register_attention - set attention LED callback
  96  * @info: must be completely filled with LED callbacks
  97  *
  98  * Description: this is used to register a hardware specific ACPI
  99  * driver that manipulates the attention LED.  All the fields in
 100  * info must be set.
 101  **/
 102 int acpiphp_register_attention(struct acpiphp_attention_info *info)
 103 {
 104         int retval = -EINVAL;
 105
 106         if (info && info->owner && info->set_attn &&
 107                         info->get_attn && !attention_info) {
 108                 retval = 0;
 109                 attention_info = info;
 110         }
 111         return retval;
 112 }
 113
 114
 115 /**
 116  * acpiphp_unregister_attention - unset attention LED callback
 117  * @info: must match the pointer used to register
 118  *
 119  * Description: this is used to un-register a hardware specific acpi
 120  * driver that manipulates the attention LED.  The pointer to the
 121  * info struct must be the same as the one used to set it.
 122  **/
 123 int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
 124 {
 125         int retval = -EINVAL;
 126
 127         if (info && attention_info == info) {
 128                 attention_info = NULL;
 129                 retval = 0;
 130         }
 131         return retval;
 132 }
 133
 134
 135 /**
 136  * enable_slot - power on and enable a slot
 137  * @hotplug_slot: slot to enable
 138  *
 139  * Actual tasks are done in acpiphp_enable_slot()
 140  *
 141  */
 142 static int enable_slot(struct hotplug_slot *hotplug_slot)
 143 {
 144         struct slot *slot = hotplug_slot->private;
 145
 146         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 147
 148         /* enable the specified slot */
 149         return acpiphp_enable_slot(slot->acpi_slot);
 150 }
 151
 152
 153 /**
 154  * disable_slot - disable and power off a slot
 155  * @hotplug_slot: slot to disable
 156  *
 157  * Actual tasks are done in acpiphp_disable_slot()
 158  *
 159  */
 160 static int disable_slot(struct hotplug_slot *hotplug_slot)
 161 {
 162         struct slot *slot = hotplug_slot->private;
 163
 164         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 165
 166         /* disable the specified slot */
 167         return acpiphp_disable_slot(slot->acpi_slot);
 168 }
 169
 170
 171  /**
 172   * set_attention_status - set attention LED
 173  * @hotplug_slot: slot to set attention LED on
 174  * @status: value to set attention LED to (0 or 1)
 175  *
 176  * attention status LED, so we use a callback that
 177  * was registered with us.  This allows hardware specific
 178  * ACPI implementations to blink the light for us.
 179  **/
 180  static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 181  {
 182         int retval = -ENODEV;
 183
 184         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 185
 186         if (attention_info && try_module_get(attention_info->owner)) {
 187                 retval = attention_info->set_attn(hotplug_slot, status);
 188                 module_put(attention_info->owner);
 189         } else
 190                 attention_info = NULL;
 191         return retval;
 192  }
 193
 194
 195 /**
 196  * get_power_status - get power status of a slot
 197  * @hotplug_slot: slot to get status
 198  * @value: pointer to store status
 199  *
 200  * Some platforms may not implement _STA method properly.
 201  * In that case, the value returned may not be reliable.
 202  *
 203  */
 204 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
 205 {
 206         struct slot *slot = hotplug_slot->private;
 207
 208         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 209
 210         *value = acpiphp_get_power_status(slot->acpi_slot);
 211
 212         return 0;
 213 }
 214
 215
 216  /**
 217  * get_attention_status - get attention LED status
 218  * @hotplug_slot: slot to get status from
 219  * @value: returns with value of attention LED
 220  *
 221  * ACPI doesn't have known method to determine the state
 222  * of the attention status LED, so we use a callback that
 223  * was registered with us.  This allows hardware specific
 224  * ACPI implementations to determine its state
 225  **/
 226 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
 227 {
 228         int retval = -EINVAL;
 229
 230         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 231
 232         if (attention_info && try_module_get(attention_info->owner)) {
 233                 retval = attention_info->get_attn(hotplug_slot, value);
 234                 module_put(attention_info->owner);
 235         } else
 236                 attention_info = NULL;
 237         return retval;
 238 }
 239
 240
 241 /**
 242  * get_latch_status - get latch status of a slot
 243  * @hotplug_slot: slot to get status
 244  * @value: pointer to store status
 245  *
 246  * ACPI doesn't provide any formal means to access latch status.
 247  * Instead, we fake latch status from _STA
 248  *
 249  */
 250 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
 251 {
 252         struct slot *slot = hotplug_slot->private;
 253
 254         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 255
 256         *value = acpiphp_get_latch_status(slot->acpi_slot);
 257
 258         return 0;
 259 }
 260
 261
 262 /**
 263  * get_adapter_status - get adapter status of a slot
 264  * @hotplug_slot: slot to get status
 265  * @value: pointer to store status
 266  *
 267  * ACPI doesn't provide any formal means to access adapter status.
 268  * Instead, we fake adapter status from _STA
 269  *
 270  */
 271 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
 272 {
 273         struct slot *slot = hotplug_slot->private;
 274
 275         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 276
 277         *value = acpiphp_get_adapter_status(slot->acpi_slot);
 278
 279         return 0;
 280 }
 281
 282
 283 /**
 284  * get_address - get pci address of a slot
 285  * @hotplug_slot: slot to get status
 286  * @value: pointer to struct pci_busdev (seg, bus, dev)
 287  */
 288 static int get_address(struct hotplug_slot *hotplug_slot, u32 *value)
 289 {
 290         struct slot *slot = hotplug_slot->private;
 291
 292         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 293
 294         *value = acpiphp_get_address(slot->acpi_slot);
 295
 296         return 0;
 297 }
 298
 299 static int __init init_acpi(void)
 300 {
 301         int retval;
 302
 303         /* initialize internal data structure etc. */
 304         retval = acpiphp_glue_init();
 305
 306         /* read initial number of slots */
 307         if (!retval) {
 308                 num_slots = acpiphp_get_num_slots();
 309                 if (num_slots == 0)
 310                         retval = -ENODEV;
 311         }
 312
 313         return retval;
 314 }
 315
 316
 317 /**
 318  * make_slot_name - make a slot name that appears in pcihpfs
 319  * @slot: slot to name
 320  *
 321  */
 322 static void make_slot_name(struct slot *slot)
 323 {
 324         snprintf(slot->hotplug_slot->name, SLOT_NAME_SIZE, "%u",
 325                  slot->acpi_slot->sun);
 326 }
 327
 328 /**
 329  * release_slot - free up the memory used by a slot
 330  * @hotplug_slot: slot to free
 331  */
 332 static void release_slot(struct hotplug_slot *hotplug_slot)
 333 {
 334         struct slot *slot = hotplug_slot->private;
 335
 336         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 337
 338         kfree(slot->hotplug_slot->info);
 339         kfree(slot->hotplug_slot->name);
 340         kfree(slot->hotplug_slot);
 341         kfree(slot);
 342 }
 343
 344 /**
 345  * init_slots - initialize 'struct slot' structures for each slot
 346  *
 347  */
 348 static int __init init_slots(void)
 349 {
 350         struct slot *slot;
 351         int retval = -ENOMEM;
 352         int i;
 353
 354         for (i = 0; i < num_slots; ++i) {
 355                 slot = kmalloc(sizeof(struct slot), GFP_KERNEL);
 356                 if (!slot)
 357                         goto error;
 358                 memset(slot, 0, sizeof(struct slot));
 359
 360                 slot->hotplug_slot = kmalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
 361                 if (!slot->hotplug_slot)
 362                         goto error_slot;
 363                 memset(slot->hotplug_slot, 0, sizeof(struct hotplug_slot));
 364
 365                 slot->hotplug_slot->info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
 366                 if (!slot->hotplug_slot->info)
 367                         goto error_hpslot;
 368                 memset(slot->hotplug_slot->info, 0, sizeof(struct hotplug_slot_info));
 369
 370                 slot->hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
 371                 if (!slot->hotplug_slot->name)
 372                         goto error_info;
 373
 374                 slot->number = i;
 375
 376                 slot->hotplug_slot->private = slot;
 377                 slot->hotplug_slot->release = &release_slot;
 378                 slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
 379
 380                 slot->acpi_slot = get_slot_from_id(i);
 381                 slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
 382                 slot->hotplug_slot->info->attention_status = 0;
 383                 slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
 384                 slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
 385                 slot->hotplug_slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
 386                 slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
 387
 388                 make_slot_name(slot);
 389
 390                 retval = pci_hp_register(slot->hotplug_slot);
 391                 if (retval) {
 392                         err("pci_hp_register failed with error %d\n", retval);
 393                         goto error_name;
 394                 }
 395
 396                 /* add slot to our internal list */
 397                 list_add(&slot->slot_list, &slot_list);
 398                 info("Slot [%s] registered\n", slot->hotplug_slot->name);
 399         }
 400
 401         return 0;
 402 error_name:
 403         kfree(slot->hotplug_slot->name);
 404 error_info:
 405         kfree(slot->hotplug_slot->info);
 406 error_hpslot:
 407         kfree(slot->hotplug_slot);
 408 error_slot:
 409         kfree(slot);
 410 error:
 411         return retval;
 412 }
 413
 414
 415 static void __exit cleanup_slots (void)
 416 {
 417         struct list_head *tmp, *n;
 418         struct slot *slot;
 419
 420         list_for_each_safe (tmp, n, &slot_list) {
 421                 /* memory will be freed in release_slot callback */
 422                 slot = list_entry(tmp, struct slot, slot_list);
 423                 list_del(&slot->slot_list);
 424                 pci_hp_deregister(slot->hotplug_slot);
 425         }
 426 }
 427
 428
 429 static int __init acpiphp_init(void)
 430 {
 431         int retval;
 432
 433         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
 434
 435         acpiphp_debug = debug;
 436
 437         /* read all the ACPI info from the system */
 438         retval = init_acpi();
 439         if (retval)
 440                 return retval;
 441
 442         return init_slots();
 443 }
 444
 445
 446 static void __exit acpiphp_exit(void)
 447 {
 448         cleanup_slots();
 449         /* deallocate internal data structures etc. */
 450         acpiphp_glue_exit();
 451 }
 452
 453 module_init(acpiphp_init);
 454 module_exit(acpiphp_exit);