drivers/pci/hotplug/acpiphp_core.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * ACPI PCI Hot Plug Controller Driver
   4  *
   5  * Copyright (C) 1995,2001 Compaq Computer Corporation
   6  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
   7  * Copyright (C) 2001 IBM Corp.
   8  * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
   9  * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
  10  * Copyright (C) 2002,2003 NEC Corporation
  11  * Copyright (C) 2003-2005 Matthew Wilcox (willy@infradead.org)
  12  * Copyright (C) 2003-2005 Hewlett Packard
  13  *
  14  * All rights reserved.
  15  *
  16  * Send feedback to <kristen.c.accardi@intel.com>
  17  *
  18  */
  19
  20 #define pr_fmt(fmt) "acpiphp: " fmt
  21
  22 #include <linux/init.h>
  23 #include <linux/module.h>
  24 #include <linux/moduleparam.h>
  25
  26 #include <linux/kernel.h>
  27 #include <linux/pci.h>
  28 #include <linux/pci-acpi.h>
  29 #include <linux/pci_hotplug.h>
  30 #include <linux/slab.h>
  31 #include <linux/smp.h>
  32 #include "acpiphp.h"
  33
  34 /* name size which is used for entries in pcihpfs */
  35 #define SLOT_NAME_SIZE  21              /* {_SUN} */
  36
  37 bool acpiphp_disabled;
  38
  39 /* local variables */
  40 static struct acpiphp_attention_info *attention_info;
  41
  42 #define DRIVER_VERSION  "0.5"
  43 #define DRIVER_AUTHOR   "Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@infradead.org>"
  44 #define DRIVER_DESC     "ACPI Hot Plug PCI Controller Driver"
  45
  46 MODULE_AUTHOR(DRIVER_AUTHOR);
  47 MODULE_DESCRIPTION(DRIVER_DESC);
  48 MODULE_PARM_DESC(disable, "disable acpiphp driver");
  49 module_param_named(disable, acpiphp_disabled, bool, 0444);
  50
  51 static int enable_slot(struct hotplug_slot *slot);
  52 static int disable_slot(struct hotplug_slot *slot);
  53 static int set_attention_status(struct hotplug_slot *slot, u8 value);
  54 static int get_power_status(struct hotplug_slot *slot, u8 *value);
  55 static int get_attention_status(struct hotplug_slot *slot, u8 *value);
  56 static int get_latch_status(struct hotplug_slot *slot, u8 *value);
  57 static int get_adapter_status(struct hotplug_slot *slot, u8 *value);
  58
  59 static const struct hotplug_slot_ops acpi_hotplug_slot_ops = {
  60         .enable_slot            = enable_slot,
  61         .disable_slot           = disable_slot,
  62         .set_attention_status   = set_attention_status,
  63         .get_power_status       = get_power_status,
  64         .get_attention_status   = get_attention_status,
  65         .get_latch_status       = get_latch_status,
  66         .get_adapter_status     = get_adapter_status,
  67 };
  68
  69 /**
  70  * acpiphp_register_attention - set attention LED callback
  71  * @info: must be completely filled with LED callbacks
  72  *
  73  * Description: This is used to register a hardware specific ACPI
  74  * driver that manipulates the attention LED.  All the fields in
  75  * info must be set.
  76  */
  77 int acpiphp_register_attention(struct acpiphp_attention_info *info)
  78 {
  79         int retval = -EINVAL;
  80
  81         if (info && info->set_attn && info->get_attn && !attention_info) {
  82                 retval = 0;
  83                 attention_info = info;
  84         }
  85         return retval;
  86 }
  87 EXPORT_SYMBOL_GPL(acpiphp_register_attention);
  88
  89
  90 /**
  91  * acpiphp_unregister_attention - unset attention LED callback
  92  * @info: must match the pointer used to register
  93  *
  94  * Description: This is used to un-register a hardware specific acpi
  95  * driver that manipulates the attention LED.  The pointer to the
  96  * info struct must be the same as the one used to set it.
  97  */
  98 int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
  99 {
 100         int retval = -EINVAL;
 101
 102         if (info && attention_info == info) {
 103                 attention_info = NULL;
 104                 retval = 0;
 105         }
 106         return retval;
 107 }
 108 EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
 109
 110
 111 /**
 112  * enable_slot - power on and enable a slot
 113  * @hotplug_slot: slot to enable
 114  *
 115  * Actual tasks are done in acpiphp_enable_slot()
 116  */
 117 static int enable_slot(struct hotplug_slot *hotplug_slot)
 118 {
 119         struct slot *slot = to_slot(hotplug_slot);
 120
 121         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 122
 123         /* enable the specified slot */
 124         return acpiphp_enable_slot(slot->acpi_slot);
 125 }
 126
 127
 128 /**
 129  * disable_slot - disable and power off a slot
 130  * @hotplug_slot: slot to disable
 131  *
 132  * Actual tasks are done in acpiphp_disable_slot()
 133  */
 134 static int disable_slot(struct hotplug_slot *hotplug_slot)
 135 {
 136         struct slot *slot = to_slot(hotplug_slot);
 137
 138         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 139
 140         /* disable the specified slot */
 141         return acpiphp_disable_slot(slot->acpi_slot);
 142 }
 143
 144
 145 /**
 146  * set_attention_status - set attention LED
 147  * @hotplug_slot: slot to set attention LED on
 148  * @status: value to set attention LED to (0 or 1)
 149  *
 150  * attention status LED, so we use a callback that
 151  * was registered with us.  This allows hardware specific
 152  * ACPI implementations to blink the light for us.
 153  */
 154 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 155 {
 156         int retval = -ENODEV;
 157
 158         pr_debug("%s - physical_slot = %s\n", __func__,
 159                 hotplug_slot_name(hotplug_slot));
 160
 161         if (attention_info && try_module_get(attention_info->owner)) {
 162                 retval = attention_info->set_attn(hotplug_slot, status);
 163                 module_put(attention_info->owner);
 164         } else
 165                 attention_info = NULL;
 166         return retval;
 167 }
 168
 169
 170 /**
 171  * get_power_status - get power status of a slot
 172  * @hotplug_slot: slot to get status
 173  * @value: pointer to store status
 174  *
 175  * Some platforms may not implement _STA method properly.
 176  * In that case, the value returned may not be reliable.
 177  */
 178 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
 179 {
 180         struct slot *slot = to_slot(hotplug_slot);
 181
 182         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 183
 184         *value = acpiphp_get_power_status(slot->acpi_slot);
 185
 186         return 0;
 187 }
 188
 189
 190 /**
 191  * get_attention_status - get attention LED status
 192  * @hotplug_slot: slot to get status from
 193  * @value: returns with value of attention LED
 194  *
 195  * ACPI doesn't have known method to determine the state
 196  * of the attention status LED, so we use a callback that
 197  * was registered with us.  This allows hardware specific
 198  * ACPI implementations to determine its state.
 199  */
 200 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
 201 {
 202         int retval = -EINVAL;
 203
 204         pr_debug("%s - physical_slot = %s\n", __func__,
 205                 hotplug_slot_name(hotplug_slot));
 206
 207         if (attention_info && try_module_get(attention_info->owner)) {
 208                 retval = attention_info->get_attn(hotplug_slot, value);
 209                 module_put(attention_info->owner);
 210         } else
 211                 attention_info = NULL;
 212         return retval;
 213 }
 214
 215
 216 /**
 217  * get_latch_status - get latch status of a slot
 218  * @hotplug_slot: slot to get status
 219  * @value: pointer to store status
 220  *
 221  * ACPI doesn't provide any formal means to access latch status.
 222  * Instead, we fake latch status from _STA.
 223  */
 224 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
 225 {
 226         struct slot *slot = to_slot(hotplug_slot);
 227
 228         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 229
 230         *value = acpiphp_get_latch_status(slot->acpi_slot);
 231
 232         return 0;
 233 }
 234
 235
 236 /**
 237  * get_adapter_status - get adapter 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 adapter status.
 242  * Instead, we fake adapter status from _STA.
 243  */
 244 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
 245 {
 246         struct slot *slot = to_slot(hotplug_slot);
 247
 248         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 249
 250         *value = acpiphp_get_adapter_status(slot->acpi_slot);
 251
 252         return 0;
 253 }
 254
 255 /* callback routine to initialize 'struct slot' for each slot */
 256 int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot,
 257                                   unsigned int sun)
 258 {
 259         struct slot *slot;
 260         int retval = -ENOMEM;
 261         char name[SLOT_NAME_SIZE];
 262
 263         slot = kzalloc(sizeof(*slot), GFP_KERNEL);
 264         if (!slot)
 265                 goto error;
 266
 267         slot->hotplug_slot.ops = &acpi_hotplug_slot_ops;
 268
 269         slot->acpi_slot = acpiphp_slot;
 270
 271         acpiphp_slot->slot = slot;
 272         slot->sun = sun;
 273         snprintf(name, SLOT_NAME_SIZE, "%u", sun);
 274
 275         retval = pci_hp_register(&slot->hotplug_slot, acpiphp_slot->bus,
 276                                  acpiphp_slot->device, name);
 277         if (retval == -EBUSY)
 278                 goto error_slot;
 279         if (retval) {
 280                 pr_err("pci_hp_register failed with error %d\n", retval);
 281                 goto error_slot;
 282         }
 283
 284         pr_info("Slot [%s] registered\n", slot_name(slot));
 285
 286         return 0;
 287 error_slot:
 288         kfree(slot);
 289 error:
 290         return retval;
 291 }
 292
 293
 294 void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
 295 {
 296         struct slot *slot = acpiphp_slot->slot;
 297
 298         pr_info("Slot [%s] unregistered\n", slot_name(slot));
 299
 300         pci_hp_deregister(&slot->hotplug_slot);
 301         kfree(slot);
 302 }
 303
 304
 305 void __init acpiphp_init(void)
 306 {
 307         pr_info(DRIVER_DESC " version: " DRIVER_VERSION "%s\n",
 308                 acpiphp_disabled ? ", disabled by user; please report a bug"
 309                                  : "");
 310 }