drivers/pci/hotplug/pciehp_core.c

   1 /*
   2  * PCI Express 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) 2003-2004 Intel Corporation
   8  *
   9  * All rights reserved.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or (at
  14  * your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  19  * NON INFRINGEMENT.  See the GNU General Public License for more
  20  * details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  *
  26  * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
  27  *
  28  */
  29
  30 #include <linux/moduleparam.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/types.h>
  34 #include <linux/pci.h>
  35 #include "pciehp.h"
  36 #include <linux/interrupt.h>
  37 #include <linux/time.h>
  38
  39 /* Global variables */
  40 bool pciehp_debug;
  41 bool pciehp_poll_mode;
  42 int pciehp_poll_time;
  43 static bool pciehp_force;
  44
  45 #define DRIVER_VERSION  "0.4"
  46 #define DRIVER_AUTHOR   "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
  47 #define DRIVER_DESC     "PCI Express Hot Plug Controller Driver"
  48
  49 /*
  50  * not really modular, but the easiest way to keep compat with existing
  51  * bootargs behaviour is to continue using module_param here.
  52  */
  53 module_param(pciehp_debug, bool, 0644);
  54 module_param(pciehp_poll_mode, bool, 0644);
  55 module_param(pciehp_poll_time, int, 0644);
  56 module_param(pciehp_force, bool, 0644);
  57 MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
  58 MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
  59 MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
  60 MODULE_PARM_DESC(pciehp_force, "Force pciehp, even if OSHP is missing");
  61
  62 #define PCIE_MODULE_NAME "pciehp"
  63
  64 static int set_attention_status(struct hotplug_slot *slot, u8 value);
  65 static int enable_slot(struct hotplug_slot *slot);
  66 static int disable_slot(struct hotplug_slot *slot);
  67 static int get_power_status(struct hotplug_slot *slot, u8 *value);
  68 static int get_attention_status(struct hotplug_slot *slot, u8 *value);
  69 static int get_latch_status(struct hotplug_slot *slot, u8 *value);
  70 static int get_adapter_status(struct hotplug_slot *slot, u8 *value);
  71 static int reset_slot(struct hotplug_slot *slot, int probe);
  72
  73 /**
  74  * release_slot - free up the memory used by a slot
  75  * @hotplug_slot: slot to free
  76  */
  77 static void release_slot(struct hotplug_slot *hotplug_slot)
  78 {
  79         kfree(hotplug_slot->ops);
  80         kfree(hotplug_slot->info);
  81         kfree(hotplug_slot);
  82 }
  83
  84 static int init_slot(struct controller *ctrl)
  85 {
  86         struct slot *slot = ctrl->slot;
  87         struct hotplug_slot *hotplug = NULL;
  88         struct hotplug_slot_info *info = NULL;
  89         struct hotplug_slot_ops *ops = NULL;
  90         char name[SLOT_NAME_SIZE];
  91         int retval = -ENOMEM;
  92
  93         hotplug = kzalloc(sizeof(*hotplug), GFP_KERNEL);
  94         if (!hotplug)
  95                 goto out;
  96
  97         info = kzalloc(sizeof(*info), GFP_KERNEL);
  98         if (!info)
  99                 goto out;
 100
 101         /* Setup hotplug slot ops */
 102         ops = kzalloc(sizeof(*ops), GFP_KERNEL);
 103         if (!ops)
 104                 goto out;
 105
 106         ops->enable_slot = enable_slot;
 107         ops->disable_slot = disable_slot;
 108         ops->get_power_status = get_power_status;
 109         ops->get_adapter_status = get_adapter_status;
 110         ops->reset_slot = reset_slot;
 111         if (MRL_SENS(ctrl))
 112                 ops->get_latch_status = get_latch_status;
 113         if (ATTN_LED(ctrl)) {
 114                 ops->get_attention_status = get_attention_status;
 115                 ops->set_attention_status = set_attention_status;
 116         }
 117
 118         /* register this slot with the hotplug pci core */
 119         hotplug->info = info;
 120         hotplug->private = slot;
 121         hotplug->release = &release_slot;
 122         hotplug->ops = ops;
 123         slot->hotplug_slot = hotplug;
 124         snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));
 125
 126         retval = pci_hp_register(hotplug,
 127                                  ctrl->pcie->port->subordinate, 0, name);
 128         if (retval)
 129                 ctrl_err(ctrl, "pci_hp_register failed: error %d\n", retval);
 130 out:
 131         if (retval) {
 132                 kfree(ops);
 133                 kfree(info);
 134                 kfree(hotplug);
 135         }
 136         return retval;
 137 }
 138
 139 static void cleanup_slot(struct controller *ctrl)
 140 {
 141         pci_hp_deregister(ctrl->slot->hotplug_slot);
 142 }
 143
 144 /*
 145  * set_attention_status - Turns the Amber LED for a slot on, off or blink
 146  */
 147 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 148 {
 149         struct slot *slot = hotplug_slot->private;
 150
 151         pciehp_set_attention_status(slot, status);
 152         return 0;
 153 }
 154
 155
 156 static int enable_slot(struct hotplug_slot *hotplug_slot)
 157 {
 158         struct slot *slot = hotplug_slot->private;
 159
 160         return pciehp_sysfs_enable_slot(slot);
 161 }
 162
 163
 164 static int disable_slot(struct hotplug_slot *hotplug_slot)
 165 {
 166         struct slot *slot = hotplug_slot->private;
 167
 168         return pciehp_sysfs_disable_slot(slot);
 169 }
 170
 171 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
 172 {
 173         struct slot *slot = hotplug_slot->private;
 174
 175         pciehp_get_power_status(slot, value);
 176         return 0;
 177 }
 178
 179 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
 180 {
 181         struct slot *slot = hotplug_slot->private;
 182
 183         pciehp_get_attention_status(slot, value);
 184         return 0;
 185 }
 186
 187 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
 188 {
 189         struct slot *slot = hotplug_slot->private;
 190
 191         pciehp_get_latch_status(slot, value);
 192         return 0;
 193 }
 194
 195 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
 196 {
 197         struct slot *slot = hotplug_slot->private;
 198
 199         pciehp_get_adapter_status(slot, value);
 200         return 0;
 201 }
 202
 203 static int reset_slot(struct hotplug_slot *hotplug_slot, int probe)
 204 {
 205         struct slot *slot = hotplug_slot->private;
 206
 207         return pciehp_reset_slot(slot, probe);
 208 }
 209
 210 static int pciehp_probe(struct pcie_device *dev)
 211 {
 212         int rc;
 213         struct controller *ctrl;
 214         struct slot *slot;
 215         u8 occupied, poweron;
 216
 217         /* If this is not a "hotplug" service, we have no business here. */
 218         if (dev->service != PCIE_PORT_SERVICE_HP)
 219                 return -ENODEV;
 220
 221         if (!dev->port->subordinate) {
 222                 /* Can happen if we run out of bus numbers during probe */
 223                 dev_err(&dev->device,
 224                         "Hotplug bridge without secondary bus, ignoring\n");
 225                 return -ENODEV;
 226         }
 227
 228         ctrl = pcie_init(dev);
 229         if (!ctrl) {
 230                 dev_err(&dev->device, "Controller initialization failed\n");
 231                 return -ENODEV;
 232         }
 233         set_service_data(dev, ctrl);
 234
 235         /* Setup the slot information structures */
 236         rc = init_slot(ctrl);
 237         if (rc) {
 238                 if (rc == -EBUSY)
 239                         ctrl_warn(ctrl, "Slot already registered by another hotplug driver\n");
 240                 else
 241                         ctrl_err(ctrl, "Slot initialization failed (%d)\n", rc);
 242                 goto err_out_release_ctlr;
 243         }
 244
 245         /* Enable events after we have setup the data structures */
 246         rc = pcie_init_notification(ctrl);
 247         if (rc) {
 248                 ctrl_err(ctrl, "Notification initialization failed (%d)\n", rc);
 249                 goto err_out_free_ctrl_slot;
 250         }
 251
 252         /* Check if slot is occupied */
 253         slot = ctrl->slot;
 254         pciehp_get_adapter_status(slot, &occupied);
 255         pciehp_get_power_status(slot, &poweron);
 256         if (occupied && pciehp_force) {
 257                 mutex_lock(&slot->hotplug_lock);
 258                 pciehp_enable_slot(slot);
 259                 mutex_unlock(&slot->hotplug_lock);
 260         }
 261         /* If empty slot's power status is on, turn power off */
 262         if (!occupied && poweron && POWER_CTRL(ctrl))
 263                 pciehp_power_off_slot(slot);
 264
 265         return 0;
 266
 267 err_out_free_ctrl_slot:
 268         cleanup_slot(ctrl);
 269 err_out_release_ctlr:
 270         pciehp_release_ctrl(ctrl);
 271         return -ENODEV;
 272 }
 273
 274 static void pciehp_remove(struct pcie_device *dev)
 275 {
 276         struct controller *ctrl = get_service_data(dev);
 277
 278         cleanup_slot(ctrl);
 279         pciehp_release_ctrl(ctrl);
 280 }
 281
 282 #ifdef CONFIG_PM
 283 static int pciehp_suspend(struct pcie_device *dev)
 284 {
 285         return 0;
 286 }
 287
 288 static int pciehp_resume(struct pcie_device *dev)
 289 {
 290         struct controller *ctrl;
 291         struct slot *slot;
 292         u8 status;
 293
 294         ctrl = get_service_data(dev);
 295
 296         /* reinitialize the chipset's event detection logic */
 297         pcie_enable_notification(ctrl);
 298
 299         slot = ctrl->slot;
 300
 301         /* Check if slot is occupied */
 302         pciehp_get_adapter_status(slot, &status);
 303         mutex_lock(&slot->hotplug_lock);
 304         if (status)
 305                 pciehp_enable_slot(slot);
 306         else
 307                 pciehp_disable_slot(slot);
 308         mutex_unlock(&slot->hotplug_lock);
 309         return 0;
 310 }
 311 #endif /* PM */
 312
 313 static struct pcie_port_service_driver hpdriver_portdrv = {
 314         .name           = PCIE_MODULE_NAME,
 315         .port_type      = PCIE_ANY_PORT,
 316         .service        = PCIE_PORT_SERVICE_HP,
 317
 318         .probe          = pciehp_probe,
 319         .remove         = pciehp_remove,
 320
 321 #ifdef  CONFIG_PM
 322         .suspend        = pciehp_suspend,
 323         .resume         = pciehp_resume,
 324 #endif  /* PM */
 325 };
 326
 327 static int __init pcied_init(void)
 328 {
 329         int retval = 0;
 330
 331         retval = pcie_port_service_register(&hpdriver_portdrv);
 332         dbg("pcie_port_service_register = %d\n", retval);
 333         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
 334         if (retval)
 335                 dbg("Failure to register service\n");
 336
 337         return retval;
 338 }
 339 device_initcall(pcied_init);