1 files changed, 44 insertions, 65 deletions

diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index b97cb4c3e0fe..84487d126e4d 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -82,7 +82,7 @@ u8 pciehp_handle_switch_change(struct slot *p_slot)
         /* Switch Change */
         ctrl_dbg(ctrl, "Switch interrupt received\n");
 
-        p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+        pciehp_get_latch_status(p_slot, &getstatus);
         if (getstatus) {
                 /*
                  * Switch opened
@@ -114,7 +114,7 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
         /* Switch is open, assume a presence change
          * Save the presence state
          */
-        p_slot->hpc_ops->get_adapter_status(p_slot, &presence_save);
+        pciehp_get_adapter_status(p_slot, &presence_save);
         if (presence_save) {
                 /*
                  * Card Present
@@ -143,7 +143,7 @@ u8 pciehp_handle_power_fault(struct slot *p_slot)
         /* power fault */
         ctrl_dbg(ctrl, "Power fault interrupt received\n");
 
-        if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
+        if (!pciehp_query_power_fault(p_slot)) {
                 /*
                  * power fault Cleared
                  */
@@ -172,7 +172,7 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
 {
         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
         if (POWER_CTRL(ctrl)) {
-                if (pslot->hpc_ops->power_off_slot(pslot)) {
+                if (pciehp_power_off_slot(pslot)) {
                         ctrl_err(ctrl,
                                  "Issue of Slot Power Off command failed\n");
                         return;
@@ -186,10 +186,10 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
         }
 
         if (PWR_LED(ctrl))
-                pslot->hpc_ops->green_led_off(pslot);
+                pciehp_green_led_off(pslot);
 
         if (ATTN_LED(ctrl)) {
-                if (pslot->hpc_ops->set_attention_status(pslot, 1)) {
+                if (pciehp_set_attention_status(pslot, 1)) {
                         ctrl_err(ctrl,
                                  "Issue of Set Attention Led command failed\n");
                         return;
@@ -208,24 +208,20 @@ static int board_added(struct slot *p_slot)
 {
         int retval = 0;
         struct controller *ctrl = p_slot->ctrl;
-        struct pci_bus *parent = ctrl->pci_dev->subordinate;
-
-        ctrl_dbg(ctrl, "%s: slot device, slot offset, hp slot = %d, %d, %d\n",
-                 __func__, p_slot->device, ctrl->slot_device_offset,
-                 p_slot->hp_slot);
+        struct pci_bus *parent = ctrl->pcie->port->subordinate;
 
         if (POWER_CTRL(ctrl)) {
                 /* Power on slot */
-                retval = p_slot->hpc_ops->power_on_slot(p_slot);
+                retval = pciehp_power_on_slot(p_slot);
                 if (retval)
                         return retval;
         }
 
         if (PWR_LED(ctrl))
-                p_slot->hpc_ops->green_led_blink(p_slot);
+                pciehp_green_led_blink(p_slot);
 
         /* Check link training status */
-        retval = p_slot->hpc_ops->check_lnk_status(ctrl);
+        retval = pciehp_check_link_status(ctrl);
         if (retval) {
                 ctrl_err(ctrl, "Failed to check link status\n");
                 set_slot_off(ctrl, p_slot);
@@ -233,21 +229,21 @@ static int board_added(struct slot *p_slot)
         }
 
         /* Check for a power fault */
-        if (p_slot->hpc_ops->query_power_fault(p_slot)) {
+        if (pciehp_query_power_fault(p_slot)) {
                 ctrl_dbg(ctrl, "Power fault detected\n");
-                retval = POWER_FAILURE;
+                retval = -EIO;
                 goto err_exit;
         }
 
         retval = pciehp_configure_device(p_slot);
         if (retval) {
-                ctrl_err(ctrl, "Cannot add device at %04x:%02x:%02x\n",
-                         pci_domain_nr(parent), p_slot->bus, p_slot->device);
+                ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
+                         pci_domain_nr(parent), parent->number);
                 goto err_exit;
         }
 
         if (PWR_LED(ctrl))
-                p_slot->hpc_ops->green_led_on(p_slot);
+                pciehp_green_led_on(p_slot);
 
         return 0;
 
@@ -269,11 +265,9 @@ static int remove_board(struct slot *p_slot)
         if (retval)
                 return retval;
 
-        ctrl_dbg(ctrl, "%s: hp_slot = %d\n", __func__, p_slot->hp_slot);
-
         if (POWER_CTRL(ctrl)) {
                 /* power off slot */
-                retval = p_slot->hpc_ops->power_off_slot(p_slot);
+                retval = pciehp_power_off_slot(p_slot);
                 if (retval) {
                         ctrl_err(ctrl,
                                  "Issue of Slot Disable command failed\n");
@@ -287,9 +281,9 @@ static int remove_board(struct slot *p_slot)
                 msleep(1000);
         }
 
+        /* turn off Green LED */
         if (PWR_LED(ctrl))
-                /* turn off Green LED */
-                p_slot->hpc_ops->green_led_off(p_slot);
+                pciehp_green_led_off(p_slot);
 
         return 0;
 }
@@ -317,18 +311,17 @@ static void pciehp_power_thread(struct work_struct *work)
         case POWEROFF_STATE:
                 mutex_unlock(&p_slot->lock);
                 ctrl_dbg(p_slot->ctrl,
-                         "Disabling domain:bus:device=%04x:%02x:%02x\n",
-                         pci_domain_nr(p_slot->ctrl->pci_dev->subordinate),
-                         p_slot->bus, p_slot->device);
+                         "Disabling domain:bus:device=%04x:%02x:00\n",
+                         pci_domain_nr(p_slot->ctrl->pcie->port->subordinate),
+                         p_slot->ctrl->pcie->port->subordinate->number);
                 pciehp_disable_slot(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
                 break;
         case POWERON_STATE:
                 mutex_unlock(&p_slot->lock);
-                if (pciehp_enable_slot(p_slot) &&
-                    PWR_LED(p_slot->ctrl))
-                        p_slot->hpc_ops->green_led_off(p_slot);
+                if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
+                        pciehp_green_led_off(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
                 break;
@@ -379,10 +372,10 @@ static int update_slot_info(struct slot *slot)
         if (!info)
                 return -ENOMEM;
 
-        slot->hpc_ops->get_power_status(slot, &(info->power_status));
-        slot->hpc_ops->get_attention_status(slot, &(info->attention_status));
-        slot->hpc_ops->get_latch_status(slot, &(info->latch_status));
-        slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status));
+        pciehp_get_power_status(slot, &info->power_status);
+        pciehp_get_attention_status(slot, &info->attention_status);
+        pciehp_get_latch_status(slot, &info->latch_status);
+        pciehp_get_adapter_status(slot, &info->adapter_status);
 
         result = pci_hp_change_slot_info(slot->hotplug_slot, info);
         kfree (info);
@@ -399,7 +392,7 @@ static void handle_button_press_event(struct slot *p_slot)
 
         switch (p_slot->state) {
         case STATIC_STATE:
-                p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                pciehp_get_power_status(p_slot, &getstatus);
                 if (getstatus) {
                         p_slot->state = BLINKINGOFF_STATE;
                         ctrl_info(ctrl,
@@ -413,9 +406,9 @@ static void handle_button_press_event(struct slot *p_slot)
                 }
                 /* blink green LED and turn off amber */
                 if (PWR_LED(ctrl))
-                        p_slot->hpc_ops->green_led_blink(p_slot);
+                        pciehp_green_led_blink(p_slot);
                 if (ATTN_LED(ctrl))
-                        p_slot->hpc_ops->set_attention_status(p_slot, 0);
+                        pciehp_set_attention_status(p_slot, 0);
 
                 schedule_delayed_work(&p_slot->work, 5*HZ);
                 break;
@@ -430,13 +423,13 @@ static void handle_button_press_event(struct slot *p_slot)
                 cancel_delayed_work(&p_slot->work);
                 if (p_slot->state == BLINKINGOFF_STATE) {
                         if (PWR_LED(ctrl))
-                                p_slot->hpc_ops->green_led_on(p_slot);
+                                pciehp_green_led_on(p_slot);
                 } else {
                         if (PWR_LED(ctrl))
-                                p_slot->hpc_ops->green_led_off(p_slot);
+                                pciehp_green_led_off(p_slot);
                 }
                 if (ATTN_LED(ctrl))
-                        p_slot->hpc_ops->set_attention_status(p_slot, 0);
+                        pciehp_set_attention_status(p_slot, 0);
                 ctrl_info(ctrl, "PCI slot #%s - action canceled "
                           "due to button press\n", slot_name(p_slot));
                 p_slot->state = STATIC_STATE;
@@ -474,7 +467,7 @@ static void handle_surprise_event(struct slot *p_slot)
         info->p_slot = p_slot;
         INIT_WORK(&info->work, pciehp_power_thread);
 
-        p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+        pciehp_get_adapter_status(p_slot, &getstatus);
         if (!getstatus)
                 p_slot->state = POWEROFF_STATE;
         else
@@ -498,9 +491,9 @@ static void interrupt_event_handler(struct work_struct *work)
                 if (!POWER_CTRL(ctrl))
                         break;
                 if (ATTN_LED(ctrl))
-                        p_slot->hpc_ops->set_attention_status(p_slot, 1);
+                        pciehp_set_attention_status(p_slot, 1);
                 if (PWR_LED(ctrl))
-                        p_slot->hpc_ops->green_led_off(p_slot);
+                        pciehp_green_led_off(p_slot);
                 break;
         case INT_PRESENCE_ON:
         case INT_PRESENCE_OFF:
@@ -525,45 +518,38 @@ int pciehp_enable_slot(struct slot *p_slot)
         int rc;
         struct controller *ctrl = p_slot->ctrl;
 
-        /* Check to see if (latch closed, card present, power off) */
-        mutex_lock(&p_slot->ctrl->crit_sect);
-
-        rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+        rc = pciehp_get_adapter_status(p_slot, &getstatus);
         if (rc || !getstatus) {
                 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
-                mutex_unlock(&p_slot->ctrl->crit_sect);
                 return -ENODEV;
         }
         if (MRL_SENS(p_slot->ctrl)) {
-                rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+                rc = pciehp_get_latch_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                rc = pciehp_get_power_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         ctrl_info(ctrl, "Already enabled on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
         }
 
-        p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+        pciehp_get_latch_status(p_slot, &getstatus);
 
         rc = board_added(p_slot);
         if (rc) {
-                p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+                pciehp_get_latch_status(p_slot, &getstatus);
         }
 
         update_slot_info(p_slot);
 
-        mutex_unlock(&p_slot->ctrl->crit_sect);
         return rc;
 }
 
@@ -577,35 +563,29 @@ int pciehp_disable_slot(struct slot *p_slot)
         if (!p_slot->ctrl)
                 return 1;
 
-        /* Check to see if (latch closed, card present, power on) */
-        mutex_lock(&p_slot->ctrl->crit_sect);
-
         if (!HP_SUPR_RM(p_slot->ctrl)) {
-                ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+                ret = pciehp_get_adapter_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         ctrl_info(ctrl, "No adapter on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
         }
 
         if (MRL_SENS(p_slot->ctrl)) {
-                ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+                ret = pciehp_get_latch_status(p_slot, &getstatus);
                 if (ret || getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                ret = pciehp_get_power_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         ctrl_info(ctrl, "Already disabled on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
         }
@@ -613,7 +593,6 @@ int pciehp_disable_slot(struct slot *p_slot)
         ret = remove_board(p_slot);
         update_slot_info(p_slot);
 
-        mutex_unlock(&p_slot->ctrl->crit_sect);
         return ret;
 }