drivers/pci/hotplug/pciehp_ctrl.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 ([email protected])
   7  * Copyright (C) 2001 IBM Corp.
   8  * Copyright (C) 2003-2004 Intel Corporation
   9  *
  10  * All rights reserved.
  11  *
  12  * Send feedback to <[email protected]>, <[email protected]>
  13  *
  14  */
  15
  16 #define dev_fmt(fmt) "pciehp: " fmt
  17
  18 #include <linux/kernel.h>
  19 #include <linux/types.h>
  20 #include <linux/pm_runtime.h>
  21 #include <linux/pci.h>
  22 #include "pciehp.h"
  23
  24 /* The following routines constitute the bulk of the
  25    hotplug controller logic
  26  */
  27
  28 #define SAFE_REMOVAL     true
  29 #define SURPRISE_REMOVAL false
  30
  31 static void set_slot_off(struct controller *ctrl)
  32 {
  33         /*
  34          * Turn off slot, turn on attention indicator, turn off power
  35          * indicator
  36          */
  37         if (POWER_CTRL(ctrl)) {
  38                 pciehp_power_off_slot(ctrl);
  39
  40                 /*
  41                  * After turning power off, we must wait for at least 1 second
  42                  * before taking any action that relies on power having been
  43                  * removed from the slot/adapter.
  44                  */
  45                 msleep(1000);
  46         }
  47
  48         pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
  49                               PCI_EXP_SLTCTL_ATTN_IND_ON);
  50 }
  51
  52 /**
  53  * board_added - Called after a board has been added to the system.
  54  * @ctrl: PCIe hotplug controller where board is added
  55  *
  56  * Turns power on for the board.
  57  * Configures board.
  58  */
  59 static int board_added(struct controller *ctrl)
  60 {
  61         int retval = 0;
  62         struct pci_bus *parent = ctrl->pcie->port->subordinate;
  63
  64         if (POWER_CTRL(ctrl)) {
  65                 /* Power on slot */
  66                 retval = pciehp_power_on_slot(ctrl);
  67                 if (retval)
  68                         return retval;
  69         }
  70
  71         pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK,
  72                               INDICATOR_NOOP);
  73
  74         /* Check link training status */
  75         retval = pciehp_check_link_status(ctrl);
  76         if (retval) {
  77                 ctrl_err(ctrl, "Failed to check link status\n");
  78                 goto err_exit;
  79         }
  80
  81         /* Check for a power fault */
  82         if (ctrl->power_fault_detected || pciehp_query_power_fault(ctrl)) {
  83                 ctrl_err(ctrl, "Slot(%s): Power fault\n", slot_name(ctrl));
  84                 retval = -EIO;
  85                 goto err_exit;
  86         }
  87
  88         retval = pciehp_configure_device(ctrl);
  89         if (retval) {
  90                 if (retval != -EEXIST) {
  91                         ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
  92                                  pci_domain_nr(parent), parent->number);
  93                         goto err_exit;
  94                 }
  95         }
  96
  97         pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON,
  98                               PCI_EXP_SLTCTL_ATTN_IND_OFF);
  99         return 0;
 100
 101 err_exit:
 102         set_slot_off(ctrl);
 103         return retval;
 104 }
 105
 106 /**
 107  * remove_board - Turn off slot and Power Indicator
 108  * @ctrl: PCIe hotplug controller where board is being removed
 109  * @safe_removal: whether the board is safely removed (versus surprise removed)
 110  */
 111 static void remove_board(struct controller *ctrl, bool safe_removal)
 112 {
 113         pciehp_unconfigure_device(ctrl, safe_removal);
 114
 115         if (POWER_CTRL(ctrl)) {
 116                 pciehp_power_off_slot(ctrl);
 117
 118                 /*
 119                  * After turning power off, we must wait for at least 1 second
 120                  * before taking any action that relies on power having been
 121                  * removed from the slot/adapter.
 122                  */
 123                 msleep(1000);
 124
 125                 /* Ignore link or presence changes caused by power off */
 126                 atomic_and(~(PCI_EXP_SLTSTA_DLLSC | PCI_EXP_SLTSTA_PDC),
 127                            &ctrl->pending_events);
 128         }
 129
 130         pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
 131                               INDICATOR_NOOP);
 132 }
 133
 134 static int pciehp_enable_slot(struct controller *ctrl);
 135 static int pciehp_disable_slot(struct controller *ctrl, bool safe_removal);
 136
 137 void pciehp_request(struct controller *ctrl, int action)
 138 {
 139         atomic_or(action, &ctrl->pending_events);
 140         if (!pciehp_poll_mode)
 141                 irq_wake_thread(ctrl->pcie->irq, ctrl);
 142 }
 143
 144 void pciehp_queue_pushbutton_work(struct work_struct *work)
 145 {
 146         struct controller *ctrl = container_of(work, struct controller,
 147                                                button_work.work);
 148
 149         mutex_lock(&ctrl->state_lock);
 150         switch (ctrl->state) {
 151         case BLINKINGOFF_STATE:
 152                 pciehp_request(ctrl, DISABLE_SLOT);
 153                 break;
 154         case BLINKINGON_STATE:
 155                 pciehp_request(ctrl, PCI_EXP_SLTSTA_PDC);
 156                 break;
 157         default:
 158                 break;
 159         }
 160         mutex_unlock(&ctrl->state_lock);
 161 }
 162
 163 void pciehp_handle_button_press(struct controller *ctrl)
 164 {
 165         mutex_lock(&ctrl->state_lock);
 166         switch (ctrl->state) {
 167         case OFF_STATE:
 168         case ON_STATE:
 169                 if (ctrl->state == ON_STATE) {
 170                         ctrl->state = BLINKINGOFF_STATE;
 171                         ctrl_info(ctrl, "Slot(%s): Powering off due to button press\n",
 172                                   slot_name(ctrl));
 173                 } else {
 174                         ctrl->state = BLINKINGON_STATE;
 175                         ctrl_info(ctrl, "Slot(%s) Powering on due to button press\n",
 176                                   slot_name(ctrl));
 177                 }
 178                 /* blink power indicator and turn off attention */
 179                 pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK,
 180                                       PCI_EXP_SLTCTL_ATTN_IND_OFF);
 181                 schedule_delayed_work(&ctrl->button_work, 5 * HZ);
 182                 break;
 183         case BLINKINGOFF_STATE:
 184         case BLINKINGON_STATE:
 185                 /*
 186                  * Cancel if we are still blinking; this means that we
 187                  * press the attention again before the 5 sec. limit
 188                  * expires to cancel hot-add or hot-remove
 189                  */
 190                 ctrl_info(ctrl, "Slot(%s): Button cancel\n", slot_name(ctrl));
 191                 cancel_delayed_work(&ctrl->button_work);
 192                 if (ctrl->state == BLINKINGOFF_STATE) {
 193                         ctrl->state = ON_STATE;
 194                         pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON,
 195                                               PCI_EXP_SLTCTL_ATTN_IND_OFF);
 196                 } else {
 197                         ctrl->state = OFF_STATE;
 198                         pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
 199                                               PCI_EXP_SLTCTL_ATTN_IND_OFF);
 200                 }
 201                 ctrl_info(ctrl, "Slot(%s): Action canceled due to button press\n",
 202                           slot_name(ctrl));
 203                 break;
 204         default:
 205                 ctrl_err(ctrl, "Slot(%s): Ignoring invalid state %#x\n",
 206                          slot_name(ctrl), ctrl->state);
 207                 break;
 208         }
 209         mutex_unlock(&ctrl->state_lock);
 210 }
 211
 212 void pciehp_handle_disable_request(struct controller *ctrl)
 213 {
 214         mutex_lock(&ctrl->state_lock);
 215         switch (ctrl->state) {
 216         case BLINKINGON_STATE:
 217         case BLINKINGOFF_STATE:
 218                 cancel_delayed_work(&ctrl->button_work);
 219                 break;
 220         }
 221         ctrl->state = POWEROFF_STATE;
 222         mutex_unlock(&ctrl->state_lock);
 223
 224         ctrl->request_result = pciehp_disable_slot(ctrl, SAFE_REMOVAL);
 225 }
 226
 227 void pciehp_handle_presence_or_link_change(struct controller *ctrl, u32 events)
 228 {
 229         int present, link_active;
 230
 231         /*
 232          * If the slot is on and presence or link has changed, turn it off.
 233          * Even if it's occupied again, we cannot assume the card is the same.
 234          */
 235         mutex_lock(&ctrl->state_lock);
 236         switch (ctrl->state) {
 237         case BLINKINGOFF_STATE:
 238                 cancel_delayed_work(&ctrl->button_work);
 239                 /* fall through */
 240         case ON_STATE:
 241                 ctrl->state = POWEROFF_STATE;
 242                 mutex_unlock(&ctrl->state_lock);
 243                 if (events & PCI_EXP_SLTSTA_DLLSC)
 244                         ctrl_info(ctrl, "Slot(%s): Link Down\n",
 245                                   slot_name(ctrl));
 246                 if (events & PCI_EXP_SLTSTA_PDC)
 247                         ctrl_info(ctrl, "Slot(%s): Card not present\n",
 248                                   slot_name(ctrl));
 249                 pciehp_disable_slot(ctrl, SURPRISE_REMOVAL);
 250                 break;
 251         default:
 252                 mutex_unlock(&ctrl->state_lock);
 253                 break;
 254         }
 255
 256         /* Turn the slot on if it's occupied or link is up */
 257         mutex_lock(&ctrl->state_lock);
 258         present = pciehp_card_present(ctrl);
 259         link_active = pciehp_check_link_active(ctrl);
 260         if (present <= 0 && link_active <= 0) {
 261                 mutex_unlock(&ctrl->state_lock);
 262                 return;
 263         }
 264
 265         switch (ctrl->state) {
 266         case BLINKINGON_STATE:
 267                 cancel_delayed_work(&ctrl->button_work);
 268                 /* fall through */
 269         case OFF_STATE:
 270                 ctrl->state = POWERON_STATE;
 271                 mutex_unlock(&ctrl->state_lock);
 272                 if (present)
 273                         ctrl_info(ctrl, "Slot(%s): Card present\n",
 274                                   slot_name(ctrl));
 275                 if (link_active)
 276                         ctrl_info(ctrl, "Slot(%s): Link Up\n",
 277                                   slot_name(ctrl));
 278                 ctrl->request_result = pciehp_enable_slot(ctrl);
 279                 break;
 280         default:
 281                 mutex_unlock(&ctrl->state_lock);
 282                 break;
 283         }
 284 }
 285
 286 static int __pciehp_enable_slot(struct controller *ctrl)
 287 {
 288         u8 getstatus = 0;
 289
 290         if (MRL_SENS(ctrl)) {
 291                 pciehp_get_latch_status(ctrl, &getstatus);
 292                 if (getstatus) {
 293                         ctrl_info(ctrl, "Slot(%s): Latch open\n",
 294                                   slot_name(ctrl));
 295                         return -ENODEV;
 296                 }
 297         }
 298
 299         if (POWER_CTRL(ctrl)) {
 300                 pciehp_get_power_status(ctrl, &getstatus);
 301                 if (getstatus) {
 302                         ctrl_info(ctrl, "Slot(%s): Already enabled\n",
 303                                   slot_name(ctrl));
 304                         return 0;
 305                 }
 306         }
 307
 308         return board_added(ctrl);
 309 }
 310
 311 static int pciehp_enable_slot(struct controller *ctrl)
 312 {
 313         int ret;
 314
 315         pm_runtime_get_sync(&ctrl->pcie->port->dev);
 316         ret = __pciehp_enable_slot(ctrl);
 317         if (ret && ATTN_BUTTN(ctrl))
 318                 /* may be blinking */
 319                 pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
 320                                       INDICATOR_NOOP);
 321         pm_runtime_put(&ctrl->pcie->port->dev);
 322
 323         mutex_lock(&ctrl->state_lock);
 324         ctrl->state = ret ? OFF_STATE : ON_STATE;
 325         mutex_unlock(&ctrl->state_lock);
 326
 327         return ret;
 328 }
 329
 330 static int __pciehp_disable_slot(struct controller *ctrl, bool safe_removal)
 331 {
 332         u8 getstatus = 0;
 333
 334         if (POWER_CTRL(ctrl)) {
 335                 pciehp_get_power_status(ctrl, &getstatus);
 336                 if (!getstatus) {
 337                         ctrl_info(ctrl, "Slot(%s): Already disabled\n",
 338                                   slot_name(ctrl));
 339                         return -EINVAL;
 340                 }
 341         }
 342
 343         remove_board(ctrl, safe_removal);
 344         return 0;
 345 }
 346
 347 static int pciehp_disable_slot(struct controller *ctrl, bool safe_removal)
 348 {
 349         int ret;
 350
 351         pm_runtime_get_sync(&ctrl->pcie->port->dev);
 352         ret = __pciehp_disable_slot(ctrl, safe_removal);
 353         pm_runtime_put(&ctrl->pcie->port->dev);
 354
 355         mutex_lock(&ctrl->state_lock);
 356         ctrl->state = OFF_STATE;
 357         mutex_unlock(&ctrl->state_lock);
 358
 359         return ret;
 360 }
 361
 362 int pciehp_sysfs_enable_slot(struct hotplug_slot *hotplug_slot)
 363 {
 364         struct controller *ctrl = to_ctrl(hotplug_slot);
 365
 366         mutex_lock(&ctrl->state_lock);
 367         switch (ctrl->state) {
 368         case BLINKINGON_STATE:
 369         case OFF_STATE:
 370                 mutex_unlock(&ctrl->state_lock);
 371                 /*
 372                  * The IRQ thread becomes a no-op if the user pulls out the
 373                  * card before the thread wakes up, so initialize to -ENODEV.
 374                  */
 375                 ctrl->request_result = -ENODEV;
 376                 pciehp_request(ctrl, PCI_EXP_SLTSTA_PDC);
 377                 wait_event(ctrl->requester,
 378                            !atomic_read(&ctrl->pending_events) &&
 379                            !ctrl->ist_running);
 380                 return ctrl->request_result;
 381         case POWERON_STATE:
 382                 ctrl_info(ctrl, "Slot(%s): Already in powering on state\n",
 383                           slot_name(ctrl));
 384                 break;
 385         case BLINKINGOFF_STATE:
 386         case ON_STATE:
 387         case POWEROFF_STATE:
 388                 ctrl_info(ctrl, "Slot(%s): Already enabled\n",
 389                           slot_name(ctrl));
 390                 break;
 391         default:
 392                 ctrl_err(ctrl, "Slot(%s): Invalid state %#x\n",
 393                          slot_name(ctrl), ctrl->state);
 394                 break;
 395         }
 396         mutex_unlock(&ctrl->state_lock);
 397
 398         return -ENODEV;
 399 }
 400
 401 int pciehp_sysfs_disable_slot(struct hotplug_slot *hotplug_slot)
 402 {
 403         struct controller *ctrl = to_ctrl(hotplug_slot);
 404
 405         mutex_lock(&ctrl->state_lock);
 406         switch (ctrl->state) {
 407         case BLINKINGOFF_STATE:
 408         case ON_STATE:
 409                 mutex_unlock(&ctrl->state_lock);
 410                 pciehp_request(ctrl, DISABLE_SLOT);
 411                 wait_event(ctrl->requester,
 412                            !atomic_read(&ctrl->pending_events) &&
 413                            !ctrl->ist_running);
 414                 return ctrl->request_result;
 415         case POWEROFF_STATE:
 416                 ctrl_info(ctrl, "Slot(%s): Already in powering off state\n",
 417                           slot_name(ctrl));
 418                 break;
 419         case BLINKINGON_STATE:
 420         case OFF_STATE:
 421         case POWERON_STATE:
 422                 ctrl_info(ctrl, "Slot(%s): Already disabled\n",
 423                           slot_name(ctrl));
 424                 break;
 425         default:
 426                 ctrl_err(ctrl, "Slot(%s): Invalid state %#x\n",
 427                          slot_name(ctrl), ctrl->state);
 428                 break;
 429         }
 430         mutex_unlock(&ctrl->state_lock);
 431
 432         return -ENODEV;
 433 }