drivers/pci/hotplug/pciehp_core.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * PCI Express 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) 2003-2004 Intel Corporation
   9  *
  10  * All rights reserved.
  11  *
  12  * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
  13  *
  14  * Authors:
  15  *   Dan Zink <dan.zink@compaq.com>
  16  *   Greg Kroah-Hartman <greg@kroah.com>
  17  *   Dely Sy <dely.l.sy@intel.com>"
  18  */
  19
  20 #include <linux/moduleparam.h>
  21 #include <linux/kernel.h>
  22 #include <linux/slab.h>
  23 #include <linux/types.h>
  24 #include <linux/pci.h>
  25 #include "pciehp.h"
  26
  27 #include "../pci.h"
  28
  29 /* Global variables */
  30 bool pciehp_debug;
  31 bool pciehp_poll_mode;
  32 int pciehp_poll_time;
  33
  34 /*
  35  * not really modular, but the easiest way to keep compat with existing
  36  * bootargs behaviour is to continue using module_param here.
  37  */
  38 module_param(pciehp_debug, bool, 0644);
  39 module_param(pciehp_poll_mode, bool, 0644);
  40 module_param(pciehp_poll_time, int, 0644);
  41 MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
  42 MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
  43 MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
  44
  45 #define PCIE_MODULE_NAME "pciehp"
  46
  47 static int set_attention_status(struct hotplug_slot *slot, u8 value);
  48 static int get_power_status(struct hotplug_slot *slot, u8 *value);
  49 static int get_latch_status(struct hotplug_slot *slot, u8 *value);
  50 static int get_adapter_status(struct hotplug_slot *slot, u8 *value);
  51
  52 static int init_slot(struct controller *ctrl)
  53 {
  54         struct hotplug_slot_ops *ops;
  55         char name[SLOT_NAME_SIZE];
  56         int retval;
  57
  58         /* Setup hotplug slot ops */
  59         ops = kzalloc(sizeof(*ops), GFP_KERNEL);
  60         if (!ops)
  61                 return -ENOMEM;
  62
  63         ops->enable_slot = pciehp_sysfs_enable_slot;
  64         ops->disable_slot = pciehp_sysfs_disable_slot;
  65         ops->get_power_status = get_power_status;
  66         ops->get_adapter_status = get_adapter_status;
  67         ops->reset_slot = pciehp_reset_slot;
  68         if (MRL_SENS(ctrl))
  69                 ops->get_latch_status = get_latch_status;
  70         if (ATTN_LED(ctrl)) {
  71                 ops->get_attention_status = pciehp_get_attention_status;
  72                 ops->set_attention_status = set_attention_status;
  73         } else if (ctrl->pcie->port->hotplug_user_indicators) {
  74                 ops->get_attention_status = pciehp_get_raw_indicator_status;
  75                 ops->set_attention_status = pciehp_set_raw_indicator_status;
  76         }
  77
  78         /* register this slot with the hotplug pci core */
  79         ctrl->hotplug_slot.ops = ops;
  80         snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));
  81
  82         retval = pci_hp_initialize(&ctrl->hotplug_slot,
  83                                    ctrl->pcie->port->subordinate, 0, name);
  84         if (retval) {
  85                 ctrl_err(ctrl, "pci_hp_initialize failed: error %d\n", retval);
  86                 kfree(ops);
  87         }
  88         return retval;
  89 }
  90
  91 static void cleanup_slot(struct controller *ctrl)
  92 {
  93         struct hotplug_slot *hotplug_slot = &ctrl->hotplug_slot;
  94
  95         pci_hp_destroy(hotplug_slot);
  96         kfree(hotplug_slot->ops);
  97 }
  98
  99 /*
 100  * set_attention_status - Turns the Amber LED for a slot on, off or blink
 101  */
 102 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 103 {
 104         struct controller *ctrl = to_ctrl(hotplug_slot);
 105         struct pci_dev *pdev = ctrl->pcie->port;
 106
 107         pci_config_pm_runtime_get(pdev);
 108         pciehp_set_attention_status(ctrl, status);
 109         pci_config_pm_runtime_put(pdev);
 110         return 0;
 111 }
 112
 113 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
 114 {
 115         struct controller *ctrl = to_ctrl(hotplug_slot);
 116         struct pci_dev *pdev = ctrl->pcie->port;
 117
 118         pci_config_pm_runtime_get(pdev);
 119         pciehp_get_power_status(ctrl, value);
 120         pci_config_pm_runtime_put(pdev);
 121         return 0;
 122 }
 123
 124 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
 125 {
 126         struct controller *ctrl = to_ctrl(hotplug_slot);
 127         struct pci_dev *pdev = ctrl->pcie->port;
 128
 129         pci_config_pm_runtime_get(pdev);
 130         pciehp_get_latch_status(ctrl, value);
 131         pci_config_pm_runtime_put(pdev);
 132         return 0;
 133 }
 134
 135 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
 136 {
 137         struct controller *ctrl = to_ctrl(hotplug_slot);
 138         struct pci_dev *pdev = ctrl->pcie->port;
 139
 140         pci_config_pm_runtime_get(pdev);
 141         *value = pciehp_card_present_or_link_active(ctrl);
 142         pci_config_pm_runtime_put(pdev);
 143         return 0;
 144 }
 145
 146 /**
 147  * pciehp_check_presence() - synthesize event if presence has changed
 148  *
 149  * On probe and resume, an explicit presence check is necessary to bring up an
 150  * occupied slot or bring down an unoccupied slot.  This can't be triggered by
 151  * events in the Slot Status register, they may be stale and are therefore
 152  * cleared.  Secondly, sending an interrupt for "events that occur while
 153  * interrupt generation is disabled [when] interrupt generation is subsequently
 154  * enabled" is optional per PCIe r4.0, sec 6.7.3.4.
 155  */
 156 static void pciehp_check_presence(struct controller *ctrl)
 157 {
 158         bool occupied;
 159
 160         down_read(&ctrl->reset_lock);
 161         mutex_lock(&ctrl->state_lock);
 162
 163         occupied = pciehp_card_present_or_link_active(ctrl);
 164         if ((occupied && (ctrl->state == OFF_STATE ||
 165                           ctrl->state == BLINKINGON_STATE)) ||
 166             (!occupied && (ctrl->state == ON_STATE ||
 167                            ctrl->state == BLINKINGOFF_STATE)))
 168                 pciehp_request(ctrl, PCI_EXP_SLTSTA_PDC);
 169
 170         mutex_unlock(&ctrl->state_lock);
 171         up_read(&ctrl->reset_lock);
 172 }
 173
 174 static int pciehp_probe(struct pcie_device *dev)
 175 {
 176         int rc;
 177         struct controller *ctrl;
 178
 179         /* If this is not a "hotplug" service, we have no business here. */
 180         if (dev->service != PCIE_PORT_SERVICE_HP)
 181                 return -ENODEV;
 182
 183         if (!dev->port->subordinate) {
 184                 /* Can happen if we run out of bus numbers during probe */
 185                 dev_err(&dev->device,
 186                         "Hotplug bridge without secondary bus, ignoring\n");
 187                 return -ENODEV;
 188         }
 189
 190         ctrl = pcie_init(dev);
 191         if (!ctrl) {
 192                 dev_err(&dev->device, "Controller initialization failed\n");
 193                 return -ENODEV;
 194         }
 195         set_service_data(dev, ctrl);
 196
 197         /* Setup the slot information structures */
 198         rc = init_slot(ctrl);
 199         if (rc) {
 200                 if (rc == -EBUSY)
 201                         ctrl_warn(ctrl, "Slot already registered by another hotplug driver\n");
 202                 else
 203                         ctrl_err(ctrl, "Slot initialization failed (%d)\n", rc);
 204                 goto err_out_release_ctlr;
 205         }
 206
 207         /* Enable events after we have setup the data structures */
 208         rc = pcie_init_notification(ctrl);
 209         if (rc) {
 210                 ctrl_err(ctrl, "Notification initialization failed (%d)\n", rc);
 211                 goto err_out_free_ctrl_slot;
 212         }
 213
 214         /* Publish to user space */
 215         rc = pci_hp_add(&ctrl->hotplug_slot);
 216         if (rc) {
 217                 ctrl_err(ctrl, "Publication to user space failed (%d)\n", rc);
 218                 goto err_out_shutdown_notification;
 219         }
 220
 221         pciehp_check_presence(ctrl);
 222
 223         return 0;
 224
 225 err_out_shutdown_notification:
 226         pcie_shutdown_notification(ctrl);
 227 err_out_free_ctrl_slot:
 228         cleanup_slot(ctrl);
 229 err_out_release_ctlr:
 230         pciehp_release_ctrl(ctrl);
 231         return -ENODEV;
 232 }
 233
 234 static void pciehp_remove(struct pcie_device *dev)
 235 {
 236         struct controller *ctrl = get_service_data(dev);
 237
 238         pci_hp_del(&ctrl->hotplug_slot);
 239         pcie_shutdown_notification(ctrl);
 240         cleanup_slot(ctrl);
 241         pciehp_release_ctrl(ctrl);
 242 }
 243
 244 #ifdef CONFIG_PM
 245 static bool pme_is_native(struct pcie_device *dev)
 246 {
 247         const struct pci_host_bridge *host;
 248
 249         host = pci_find_host_bridge(dev->port->bus);
 250         return pcie_ports_native || host->native_pme;
 251 }
 252
 253 static int pciehp_suspend(struct pcie_device *dev)
 254 {
 255         /*
 256          * Disable hotplug interrupt so that it does not trigger
 257          * immediately when the downstream link goes down.
 258          */
 259         if (pme_is_native(dev))
 260                 pcie_disable_interrupt(get_service_data(dev));
 261
 262         return 0;
 263 }
 264
 265 static int pciehp_resume_noirq(struct pcie_device *dev)
 266 {
 267         struct controller *ctrl = get_service_data(dev);
 268
 269         /* pci_restore_state() just wrote to the Slot Control register */
 270         ctrl->cmd_started = jiffies;
 271         ctrl->cmd_busy = true;
 272
 273         /* clear spurious events from rediscovery of inserted card */
 274         if (ctrl->state == ON_STATE || ctrl->state == BLINKINGOFF_STATE)
 275                 pcie_clear_hotplug_events(ctrl);
 276
 277         return 0;
 278 }
 279
 280 static int pciehp_resume(struct pcie_device *dev)
 281 {
 282         struct controller *ctrl = get_service_data(dev);
 283
 284         if (pme_is_native(dev))
 285                 pcie_enable_interrupt(ctrl);
 286
 287         pciehp_check_presence(ctrl);
 288
 289         return 0;
 290 }
 291
 292 static int pciehp_runtime_resume(struct pcie_device *dev)
 293 {
 294         struct controller *ctrl = get_service_data(dev);
 295
 296         /* pci_restore_state() just wrote to the Slot Control register */
 297         ctrl->cmd_started = jiffies;
 298         ctrl->cmd_busy = true;
 299
 300         /* clear spurious events from rediscovery of inserted card */
 301         if ((ctrl->state == ON_STATE || ctrl->state == BLINKINGOFF_STATE) &&
 302              pme_is_native(dev))
 303                 pcie_clear_hotplug_events(ctrl);
 304
 305         return pciehp_resume(dev);
 306 }
 307 #endif /* PM */
 308
 309 static struct pcie_port_service_driver hpdriver_portdrv = {
 310         .name           = PCIE_MODULE_NAME,
 311         .port_type      = PCIE_ANY_PORT,
 312         .service        = PCIE_PORT_SERVICE_HP,
 313
 314         .probe          = pciehp_probe,
 315         .remove         = pciehp_remove,
 316
 317 #ifdef  CONFIG_PM
 318         .suspend        = pciehp_suspend,
 319         .resume_noirq   = pciehp_resume_noirq,
 320         .resume         = pciehp_resume,
 321         .runtime_suspend = pciehp_suspend,
 322         .runtime_resume = pciehp_runtime_resume,
 323 #endif  /* PM */
 324 };
 325
 326 int __init pcie_hp_init(void)
 327 {
 328         int retval = 0;
 329
 330         retval = pcie_port_service_register(&hpdriver_portdrv);
 331         dbg("pcie_port_service_register = %d\n", retval);
 332         if (retval)
 333                 dbg("Failure to register service\n");
 334
 335         return retval;
 336 }