mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-04 18:09:57 +00:00
Code Issues Releases Wiki Activity

PCI: pciehp: remove hpc_ops

Browse source 
The struct hpc_ops seems a set of hooks to controller specific
routines. But, it is meaningless because no hotplug controller driver
follows this framework.

Acked-by: Alex Chiang <achiang@hp.com>
Signed-off-by: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
This commit is contained in:
Kenji Kaneshige 2009-09-15 17:30:48 +09:00 committed by Jesse Barnes
parent 385e24917e
commit 82a9e79ef1
5 changed files with 87 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
drivers/pci/hotplug/pciehp.h
View file

@ -75,7 +75,6 @@ struct slot {
u8 state; u8 state;
u32 number; u32 number;
struct controller *ctrl; struct controller *ctrl;
struct hpc_ops *hpc_ops;
struct hotplug_slot *hotplug_slot; struct hotplug_slot *hotplug_slot;
struct delayed_work work; /* work for button event */ struct delayed_work work; /* work for button event */
struct mutex lock; struct mutex lock;
@ -91,7 +90,6 @@ struct controller {
struct mutex ctrl_lock; /* controller lock */ struct mutex ctrl_lock; /* controller lock */
struct pcie_device *pcie; /* PCI Express port service */ struct pcie_device *pcie; /* PCI Express port service */
struct slot *slot; struct slot *slot;
struct hpc_ops *hpc_ops;
wait_queue_head_t queue; /* sleep & wake process */ wait_queue_head_t queue; /* sleep & wake process */
u32 slot_cap; u32 slot_cap;
u8 cap_base; u8 cap_base;
@ -154,7 +152,7 @@ struct controller {
extern int pciehp_sysfs_enable_slot(struct slot *slot); extern int pciehp_sysfs_enable_slot(struct slot *slot);
extern int pciehp_sysfs_disable_slot(struct slot *slot); extern int pciehp_sysfs_disable_slot(struct slot *slot);
extern u8 pciehp_handle_attention_button(struct slot *p_slot); extern u8 pciehp_handle_attention_button(struct slot *p_slot);
extern u8 pciehp_handle_switch_change(struct slot *p_slot); extern u8 pciehp_handle_switch_change(struct slot *p_slot);
extern u8 pciehp_handle_presence_change(struct slot *p_slot); extern u8 pciehp_handle_presence_change(struct slot *p_slot);
extern u8 pciehp_handle_power_fault(struct slot *p_slot); extern u8 pciehp_handle_power_fault(struct slot *p_slot);
extern int pciehp_configure_device(struct slot *p_slot); extern int pciehp_configure_device(struct slot *p_slot);
@ -165,32 +163,30 @@ int pcie_init_notification(struct controller *ctrl);
int pciehp_enable_slot(struct slot *p_slot); int pciehp_enable_slot(struct slot *p_slot);
int pciehp_disable_slot(struct slot *p_slot); int pciehp_disable_slot(struct slot *p_slot);
int pcie_enable_notification(struct controller *ctrl); int pcie_enable_notification(struct controller *ctrl);
int pciehp_power_on_slot(struct slot *slot);
int pciehp_power_off_slot(struct slot *slot);
int pciehp_get_power_status(struct slot *slot, u8 *status);
int pciehp_get_attention_status(struct slot *slot, u8 *status);
int pciehp_set_attention_status(struct slot *slot, u8 status);
int pciehp_get_latch_status(struct slot *slot, u8 *status);
int pciehp_get_adapter_status(struct slot *slot, u8 *status);
int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *speed);
int pciehp_get_max_link_width(struct slot *slot, enum pcie_link_width *val);
int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *speed);
int pciehp_get_cur_link_width(struct slot *slot, enum pcie_link_width *val);
int pciehp_query_power_fault(struct slot *slot);
void pciehp_green_led_on(struct slot *slot);
void pciehp_green_led_off(struct slot *slot);
void pciehp_green_led_blink(struct slot *slot);
int pciehp_check_link_status(struct controller *ctrl);
void pciehp_release_ctrl(struct controller *ctrl);
static inline const char *slot_name(struct slot *slot) static inline const char *slot_name(struct slot *slot)
{ {
return hotplug_slot_name(slot->hotplug_slot); return hotplug_slot_name(slot->hotplug_slot);
} }
struct hpc_ops {
int (*power_on_slot)(struct slot *slot);
int (*power_off_slot)(struct slot *slot);
int (*get_power_status)(struct slot *slot, u8 *status);
int (*get_attention_status)(struct slot *slot, u8 *status);
int (*set_attention_status)(struct slot *slot, u8 status);
int (*get_latch_status)(struct slot *slot, u8 *status);
int (*get_adapter_status)(struct slot *slot, u8 *status);
int (*get_max_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
int (*get_cur_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
int (*get_max_lnk_width)(struct slot *slot, enum pcie_link_width *val);
int (*get_cur_lnk_width)(struct slot *slot, enum pcie_link_width *val);
int (*query_power_fault)(struct slot *slot);
void (*green_led_on)(struct slot *slot);
void (*green_led_off)(struct slot *slot);
void (*green_led_blink)(struct slot *slot);
void (*release_ctlr)(struct controller *ctrl);
int (*check_lnk_status)(struct controller *ctrl);
};
#ifdef CONFIG_ACPI #ifdef CONFIG_ACPI
#include <acpi/acpi.h> #include <acpi/acpi.h>
#include <acpi/acpi_bus.h> #include <acpi/acpi_bus.h>

26
drivers/pci/hotplug/pciehp_core.c
View file

@ -163,7 +163,7 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
hotplug_slot->info->attention_status = status; hotplug_slot->info->attention_status = status;
if (ATTN_LED(slot->ctrl)) if (ATTN_LED(slot->ctrl))
slot->hpc_ops->set_attention_status(slot, status); pciehp_set_attention_status(slot, status);
return 0; return 0;
} }
@ -198,7 +198,7 @@ static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n", ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
__func__, slot_name(slot)); __func__, slot_name(slot));
retval = slot->hpc_ops->get_power_status(slot, value); retval = pciehp_get_power_status(slot, value);
if (retval < 0) if (retval < 0)
*value = hotplug_slot->info->power_status; *value = hotplug_slot->info->power_status;
@ -213,7 +213,7 @@ static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n", ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
__func__, slot_name(slot)); __func__, slot_name(slot));
retval = slot->hpc_ops->get_attention_status(slot, value); retval = pciehp_get_attention_status(slot, value);
if (retval < 0) if (retval < 0)
*value = hotplug_slot->info->attention_status; *value = hotplug_slot->info->attention_status;
@ -228,7 +228,7 @@ static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n", ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
__func__, slot_name(slot)); __func__, slot_name(slot));
retval = slot->hpc_ops->get_latch_status(slot, value); retval = pciehp_get_latch_status(slot, value);
if (retval < 0) if (retval < 0)
*value = hotplug_slot->info->latch_status; *value = hotplug_slot->info->latch_status;
@ -243,7 +243,7 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n", ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
__func__, slot_name(slot)); __func__, slot_name(slot));
retval = slot->hpc_ops->get_adapter_status(slot, value); retval = pciehp_get_adapter_status(slot, value);
if (retval < 0) if (retval < 0)
*value = hotplug_slot->info->adapter_status; *value = hotplug_slot->info->adapter_status;
@ -259,7 +259,7 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n", ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
__func__, slot_name(slot)); __func__, slot_name(slot));
retval = slot->hpc_ops->get_max_bus_speed(slot, value); retval = pciehp_get_max_link_speed(slot, value);
if (retval < 0) if (retval < 0)
*value = PCI_SPEED_UNKNOWN; *value = PCI_SPEED_UNKNOWN;
@ -274,7 +274,7 @@ static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n", ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
__func__, slot_name(slot)); __func__, slot_name(slot));
retval = slot->hpc_ops->get_cur_bus_speed(slot, value); retval = pciehp_get_cur_link_speed(slot, value);
if (retval < 0) if (retval < 0)
*value = PCI_SPEED_UNKNOWN; *value = PCI_SPEED_UNKNOWN;
@ -323,14 +323,14 @@ static int pciehp_probe(struct pcie_device *dev)
/* Check if slot is occupied */ /* Check if slot is occupied */
slot = ctrl->slot; slot = ctrl->slot;
slot->hpc_ops->get_adapter_status(slot, &value); pciehp_get_adapter_status(slot, &value);
if (value) { if (value) {
if (pciehp_force) if (pciehp_force)
pciehp_enable_slot(slot); pciehp_enable_slot(slot);
} else { } else {
/* Power off slot if not occupied */ /* Power off slot if not occupied */
if (POWER_CTRL(ctrl)) { if (POWER_CTRL(ctrl)) {
rc = slot->hpc_ops->power_off_slot(slot); rc = pciehp_power_off_slot(slot);
if (rc) if (rc)
goto err_out_free_ctrl_slot; goto err_out_free_ctrl_slot;
} }
@ -341,17 +341,17 @@ static int pciehp_probe(struct pcie_device *dev)
err_out_free_ctrl_slot: err_out_free_ctrl_slot:
cleanup_slot(ctrl); cleanup_slot(ctrl);
err_out_release_ctlr: err_out_release_ctlr:
ctrl->hpc_ops->release_ctlr(ctrl); pciehp_release_ctrl(ctrl);
err_out_none: err_out_none:
return -ENODEV; return -ENODEV;
} }
static void pciehp_remove (struct pcie_device *dev) static void pciehp_remove(struct pcie_device *dev)
{ {
struct controller *ctrl = get_service_data(dev); struct controller *ctrl = get_service_data(dev);
cleanup_slot(ctrl); cleanup_slot(ctrl);
ctrl->hpc_ops->release_ctlr(ctrl); pciehp_release_ctrl(ctrl);
} }
#ifdef CONFIG_PM #ifdef CONFIG_PM
@ -375,7 +375,7 @@ static int pciehp_resume (struct pcie_device *dev)
slot = ctrl->slot; slot = ctrl->slot;
/* Check if slot is occupied */ /* Check if slot is occupied */
slot->hpc_ops->get_adapter_status(slot, &status); pciehp_get_adapter_status(slot, &status);
if (status) if (status)
pciehp_enable_slot(slot); pciehp_enable_slot(slot);
else else

75
drivers/pci/hotplug/pciehp_ctrl.c
View file

@ -82,7 +82,7 @@ u8 pciehp_handle_switch_change(struct slot *p_slot)
/* Switch Change */ /* Switch Change */
ctrl_dbg(ctrl, "Switch interrupt received\n"); 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) { if (getstatus) {
/* /*
* Switch opened * Switch opened
@ -114,7 +114,7 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
/* Switch is open, assume a presence change /* Switch is open, assume a presence change
* Save the presence state * 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) { if (presence_save) {
/* /*
* Card Present * Card Present
@ -143,7 +143,7 @@ u8 pciehp_handle_power_fault(struct slot *p_slot)
/* power fault */ /* power fault */
ctrl_dbg(ctrl, "Power fault interrupt received\n"); 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 * 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*/ /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
if (POWER_CTRL(ctrl)) { if (POWER_CTRL(ctrl)) {
if (pslot->hpc_ops->power_off_slot(pslot)) { if (pciehp_power_off_slot(pslot)) {
ctrl_err(ctrl, ctrl_err(ctrl,
"Issue of Slot Power Off command failed\n"); "Issue of Slot Power Off command failed\n");
return; return;
@ -186,10 +186,10 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
} }
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
pslot->hpc_ops->green_led_off(pslot); pciehp_green_led_off(pslot);
if (ATTN_LED(ctrl)) { if (ATTN_LED(ctrl)) {
if (pslot->hpc_ops->set_attention_status(pslot, 1)) { if (pciehp_set_attention_status(pslot, 1)) {
ctrl_err(ctrl, ctrl_err(ctrl,
"Issue of Set Attention Led command failed\n"); "Issue of Set Attention Led command failed\n");
return; return;
@ -212,16 +212,16 @@ static int board_added(struct slot *p_slot)
if (POWER_CTRL(ctrl)) { if (POWER_CTRL(ctrl)) {
/* Power on slot */ /* Power on slot */
retval = p_slot->hpc_ops->power_on_slot(p_slot); retval = pciehp_power_on_slot(p_slot);
if (retval) if (retval)
return retval; return retval;
} }
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
p_slot->hpc_ops->green_led_blink(p_slot); pciehp_green_led_blink(p_slot);
/* Check link training status */ /* Check link training status */
retval = p_slot->hpc_ops->check_lnk_status(ctrl); retval = pciehp_check_link_status(ctrl);
if (retval) { if (retval) {
ctrl_err(ctrl, "Failed to check link status\n"); ctrl_err(ctrl, "Failed to check link status\n");
set_slot_off(ctrl, p_slot); set_slot_off(ctrl, p_slot);
@ -229,7 +229,7 @@ static int board_added(struct slot *p_slot)
} }
/* Check for a power fault */ /* 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"); ctrl_dbg(ctrl, "Power fault detected\n");
retval = POWER_FAILURE; retval = POWER_FAILURE;
goto err_exit; goto err_exit;
@ -243,7 +243,7 @@ static int board_added(struct slot *p_slot)
} }
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
p_slot->hpc_ops->green_led_on(p_slot); pciehp_green_led_on(p_slot);
return 0; return 0;
@ -267,7 +267,7 @@ static int remove_board(struct slot *p_slot)
if (POWER_CTRL(ctrl)) { if (POWER_CTRL(ctrl)) {
/* power off slot */ /* power off slot */
retval = p_slot->hpc_ops->power_off_slot(p_slot); retval = pciehp_power_off_slot(p_slot);
if (retval) { if (retval) {
ctrl_err(ctrl, ctrl_err(ctrl,
"Issue of Slot Disable command failed\n"); "Issue of Slot Disable command failed\n");
@ -281,9 +281,9 @@ static int remove_board(struct slot *p_slot)
msleep(1000); msleep(1000);
} }
/* turn off Green LED */
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
/* turn off Green LED */ pciehp_green_led_off(p_slot);
p_slot->hpc_ops->green_led_off(p_slot);
return 0; return 0;
} }
@ -320,9 +320,8 @@ static void pciehp_power_thread(struct work_struct *work)
break; break;
case POWERON_STATE: case POWERON_STATE:
mutex_unlock(&p_slot->lock); mutex_unlock(&p_slot->lock);
if (pciehp_enable_slot(p_slot) && if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
PWR_LED(p_slot->ctrl)) pciehp_green_led_off(p_slot);
p_slot->hpc_ops->green_led_off(p_slot);
mutex_lock(&p_slot->lock); mutex_lock(&p_slot->lock);
p_slot->state = STATIC_STATE; p_slot->state = STATIC_STATE;
break; break;
@ -373,10 +372,10 @@ static int update_slot_info(struct slot *slot)
if (!info) if (!info)
return -ENOMEM; return -ENOMEM;
slot->hpc_ops->get_power_status(slot, &(info->power_status)); pciehp_get_power_status(slot, &info->power_status);
slot->hpc_ops->get_attention_status(slot, &(info->attention_status)); pciehp_get_attention_status(slot, &info->attention_status);
slot->hpc_ops->get_latch_status(slot, &(info->latch_status)); pciehp_get_latch_status(slot, &info->latch_status);
slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status)); pciehp_get_adapter_status(slot, &info->adapter_status);
result = pci_hp_change_slot_info(slot->hotplug_slot, info); result = pci_hp_change_slot_info(slot->hotplug_slot, info);
kfree (info); kfree (info);
@ -393,7 +392,7 @@ static void handle_button_press_event(struct slot *p_slot)
switch (p_slot->state) { switch (p_slot->state) {
case STATIC_STATE: case STATIC_STATE:
p_slot->hpc_ops->get_power_status(p_slot, &getstatus); pciehp_get_power_status(p_slot, &getstatus);
if (getstatus) { if (getstatus) {
p_slot->state = BLINKINGOFF_STATE; p_slot->state = BLINKINGOFF_STATE;
ctrl_info(ctrl, ctrl_info(ctrl,
@ -407,9 +406,9 @@ static void handle_button_press_event(struct slot *p_slot)
} }
/* blink green LED and turn off amber */ /* blink green LED and turn off amber */
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
p_slot->hpc_ops->green_led_blink(p_slot); pciehp_green_led_blink(p_slot);
if (ATTN_LED(ctrl)) 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); schedule_delayed_work(&p_slot->work, 5*HZ);
break; break;
@ -424,13 +423,13 @@ static void handle_button_press_event(struct slot *p_slot)
cancel_delayed_work(&p_slot->work); cancel_delayed_work(&p_slot->work);
if (p_slot->state == BLINKINGOFF_STATE) { if (p_slot->state == BLINKINGOFF_STATE) {
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
p_slot->hpc_ops->green_led_on(p_slot); pciehp_green_led_on(p_slot);
} else { } else {
if (PWR_LED(ctrl)) if (PWR_LED(ctrl))
p_slot->hpc_ops->green_led_off(p_slot); pciehp_green_led_off(p_slot);
} }
if (ATTN_LED(ctrl)) 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 " ctrl_info(ctrl, "PCI slot #%s - action canceled "
"due to button press\n", slot_name(p_slot)); "due to button press\n", slot_name(p_slot));
p_slot->state = STATIC_STATE; p_slot->state = STATIC_STATE;
@ -468,7 +467,7 @@ static void handle_surprise_event(struct slot *p_slot)
info->p_slot = p_slot; info->p_slot = p_slot;
INIT_WORK(&info->work, pciehp_power_thread); 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) if (!getstatus)
p_slot->state = POWEROFF_STATE; p_slot->state = POWEROFF_STATE;
else else
@ -492,9 +491,9 @@ static void interrupt_event_handler(struct work_struct *work)
if (!POWER_CTRL(ctrl)) if (!POWER_CTRL(ctrl))
break; break;
if (ATTN_LED(ctrl)) 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)) if (PWR_LED(ctrl))
p_slot->hpc_ops->green_led_off(p_slot); pciehp_green_led_off(p_slot);
break; break;
case INT_PRESENCE_ON: case INT_PRESENCE_ON:
case INT_PRESENCE_OFF: case INT_PRESENCE_OFF:
@ -519,13 +518,13 @@ int pciehp_enable_slot(struct slot *p_slot)
int rc; int rc;
struct controller *ctrl = p_slot->ctrl; struct controller *ctrl = p_slot->ctrl;
rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus); rc = pciehp_get_adapter_status(p_slot, &getstatus);
if (rc || !getstatus) { if (rc || !getstatus) {
ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot)); ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
return -ENODEV; return -ENODEV;
} }
if (MRL_SENS(p_slot->ctrl)) { 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) { if (rc || getstatus) {
ctrl_info(ctrl, "Latch open on slot(%s)\n", ctrl_info(ctrl, "Latch open on slot(%s)\n",
slot_name(p_slot)); slot_name(p_slot));
@ -534,7 +533,7 @@ int pciehp_enable_slot(struct slot *p_slot)
} }
if (POWER_CTRL(p_slot->ctrl)) { 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) { if (rc || getstatus) {
ctrl_info(ctrl, "Already enabled on slot(%s)\n", ctrl_info(ctrl, "Already enabled on slot(%s)\n",
slot_name(p_slot)); slot_name(p_slot));
@ -542,11 +541,11 @@ int pciehp_enable_slot(struct slot *p_slot)
} }
} }
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); pciehp_get_latch_status(p_slot, &getstatus);
rc = board_added(p_slot); rc = board_added(p_slot);
if (rc) { if (rc) {
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); pciehp_get_latch_status(p_slot, &getstatus);
} }
update_slot_info(p_slot); update_slot_info(p_slot);
@ -565,7 +564,7 @@ int pciehp_disable_slot(struct slot *p_slot)
return 1; return 1;
if (!HP_SUPR_RM(p_slot->ctrl)) { 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) { if (ret || !getstatus) {
ctrl_info(ctrl, "No adapter on slot(%s)\n", ctrl_info(ctrl, "No adapter on slot(%s)\n",
slot_name(p_slot)); slot_name(p_slot));
@ -574,7 +573,7 @@ int pciehp_disable_slot(struct slot *p_slot)
} }
if (MRL_SENS(p_slot->ctrl)) { 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) { if (ret || getstatus) {
ctrl_info(ctrl, "Latch open on slot(%s)\n", ctrl_info(ctrl, "Latch open on slot(%s)\n",
slot_name(p_slot)); slot_name(p_slot));
@ -583,7 +582,7 @@ int pciehp_disable_slot(struct slot *p_slot)
} }
if (POWER_CTRL(p_slot->ctrl)) { 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) { if (ret || !getstatus) {
ctrl_info(ctrl, "Already disabled on slot(%s)\n", ctrl_info(ctrl, "Already disabled on slot(%s)\n",
slot_name(p_slot)); slot_name(p_slot));

60
drivers/pci/hotplug/pciehp_hpc.c
View file

@ -266,7 +266,7 @@ static void pcie_wait_link_active(struct controller *ctrl)
ctrl_dbg(ctrl, "Data Link Layer Link Active not set in 1000 msec\n"); ctrl_dbg(ctrl, "Data Link Layer Link Active not set in 1000 msec\n");
} }
static int hpc_check_lnk_status(struct controller *ctrl) int pciehp_check_link_status(struct controller *ctrl)
{ {
u16 lnk_status; u16 lnk_status;
int retval = 0; int retval = 0;
@ -305,7 +305,7 @@ static int hpc_check_lnk_status(struct controller *ctrl)
return retval; return retval;
} }
static int hpc_get_attention_status(struct slot *slot, u8 *status) int pciehp_get_attention_status(struct slot *slot, u8 *status)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_ctrl; u16 slot_ctrl;
@ -344,7 +344,7 @@ static int hpc_get_attention_status(struct slot *slot, u8 *status)
return 0; return 0;
} }
static int hpc_get_power_status(struct slot *slot, u8 *status) int pciehp_get_power_status(struct slot *slot, u8 *status)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_ctrl; u16 slot_ctrl;
@ -376,7 +376,7 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
return retval; return retval;
} }
static int hpc_get_latch_status(struct slot *slot, u8 *status) int pciehp_get_latch_status(struct slot *slot, u8 *status)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_status; u16 slot_status;
@ -392,7 +392,7 @@ static int hpc_get_latch_status(struct slot *slot, u8 *status)
return 0; return 0;
} }
static int hpc_get_adapter_status(struct slot *slot, u8 *status) int pciehp_get_adapter_status(struct slot *slot, u8 *status)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_status; u16 slot_status;
@ -408,7 +408,7 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
return 0; return 0;
} }
static int hpc_query_power_fault(struct slot *slot) int pciehp_query_power_fault(struct slot *slot)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_status; u16 slot_status;
@ -422,7 +422,7 @@ static int hpc_query_power_fault(struct slot *slot)
return !!(slot_status & PCI_EXP_SLTSTA_PFD); return !!(slot_status & PCI_EXP_SLTSTA_PFD);
} }
static int hpc_set_attention_status(struct slot *slot, u8 value) int pciehp_set_attention_status(struct slot *slot, u8 value)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_cmd; u16 slot_cmd;
@ -450,7 +450,7 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
return rc; return rc;
} }
static void hpc_set_green_led_on(struct slot *slot) void pciehp_green_led_on(struct slot *slot)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_cmd; u16 slot_cmd;
@ -463,7 +463,7 @@ static void hpc_set_green_led_on(struct slot *slot)
__func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd); __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
} }
static void hpc_set_green_led_off(struct slot *slot) void pciehp_green_led_off(struct slot *slot)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_cmd; u16 slot_cmd;
@ -476,7 +476,7 @@ static void hpc_set_green_led_off(struct slot *slot)
__func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd); __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
} }
static void hpc_set_green_led_blink(struct slot *slot) void pciehp_green_led_blink(struct slot *slot)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_cmd; u16 slot_cmd;
@ -489,7 +489,7 @@ static void hpc_set_green_led_blink(struct slot *slot)
__func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd); __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
} }
static int hpc_power_on_slot(struct slot * slot) int pciehp_power_on_slot(struct slot * slot)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_cmd; u16 slot_cmd;
@ -568,7 +568,7 @@ static inline void pcie_unmask_bad_dllp(struct controller *ctrl)
pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, reg); pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, reg);
} }
static int hpc_power_off_slot(struct slot * slot) int pciehp_power_off_slot(struct slot * slot)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
u16 slot_cmd; u16 slot_cmd;
@ -672,7 +672,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value) int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *value)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
enum pcie_link_speed lnk_speed; enum pcie_link_speed lnk_speed;
@ -703,7 +703,7 @@ static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
return retval; return retval;
} }
static int hpc_get_max_lnk_width(struct slot *slot, int pciehp_get_max_lnk_width(struct slot *slot,
enum pcie_link_width *value) enum pcie_link_width *value)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
@ -753,7 +753,7 @@ static int hpc_get_max_lnk_width(struct slot *slot,
return retval; return retval;
} }
static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value) int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *value)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN; enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN;
@ -785,7 +785,7 @@ static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
return retval; return retval;
} }
static int hpc_get_cur_lnk_width(struct slot *slot, int pciehp_get_cur_lnk_width(struct slot *slot,
enum pcie_link_width *value) enum pcie_link_width *value)
{ {
struct controller *ctrl = slot->ctrl; struct controller *ctrl = slot->ctrl;
@ -836,30 +836,6 @@ static int hpc_get_cur_lnk_width(struct slot *slot,
return retval; return retval;
} }
static void pcie_release_ctrl(struct controller *ctrl);
static struct hpc_ops pciehp_hpc_ops = {
.power_on_slot = hpc_power_on_slot,
.power_off_slot = hpc_power_off_slot,
.set_attention_status = hpc_set_attention_status,
.get_power_status = hpc_get_power_status,
.get_attention_status = hpc_get_attention_status,
.get_latch_status = hpc_get_latch_status,
.get_adapter_status = hpc_get_adapter_status,
.get_max_bus_speed = hpc_get_max_lnk_speed,
.get_cur_bus_speed = hpc_get_cur_lnk_speed,
.get_max_lnk_width = hpc_get_max_lnk_width,
.get_cur_lnk_width = hpc_get_cur_lnk_width,
.query_power_fault = hpc_query_power_fault,
.green_led_on = hpc_set_green_led_on,
.green_led_off = hpc_set_green_led_off,
.green_led_blink = hpc_set_green_led_blink,
.release_ctlr = pcie_release_ctrl,
.check_lnk_status = hpc_check_lnk_status,
};
int pcie_enable_notification(struct controller *ctrl) int pcie_enable_notification(struct controller *ctrl)
{ {
u16 cmd, mask; u16 cmd, mask;
@ -925,7 +901,6 @@ static int pcie_init_slot(struct controller *ctrl)
return -ENOMEM; return -ENOMEM;
slot->ctrl = ctrl; slot->ctrl = ctrl;
slot->hpc_ops = ctrl->hpc_ops;
slot->number = PSN(ctrl); slot->number = PSN(ctrl);
mutex_init(&slot->lock); mutex_init(&slot->lock);
INIT_DELAYED_WORK(&slot->work, pciehp_queue_pushbutton_work); INIT_DELAYED_WORK(&slot->work, pciehp_queue_pushbutton_work);
@ -1015,7 +990,6 @@ struct controller *pcie_init(struct pcie_device *dev)
} }
ctrl->slot_cap = slot_cap; ctrl->slot_cap = slot_cap;
ctrl->hpc_ops = &pciehp_hpc_ops;
mutex_init(&ctrl->ctrl_lock); mutex_init(&ctrl->ctrl_lock);
init_waitqueue_head(&ctrl->queue); init_waitqueue_head(&ctrl->queue);
dbg_ctrl(ctrl); dbg_ctrl(ctrl);
@ -1071,7 +1045,7 @@ struct controller *pcie_init(struct pcie_device *dev)
return NULL; return NULL;
} }
void pcie_release_ctrl(struct controller *ctrl) void pciehp_release_ctrl(struct controller *ctrl)
{ {
pcie_shutdown_notification(ctrl); pcie_shutdown_notification(ctrl);
pcie_cleanup_slot(ctrl); pcie_cleanup_slot(ctrl);

2
drivers/pci/hotplug/pciehp_pci.c
View file

@ -117,7 +117,7 @@ int pciehp_unconfigure_device(struct slot *p_slot)
ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:00\n", ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:00\n",
__func__, pci_domain_nr(parent), parent->number); __func__, pci_domain_nr(parent), parent->number);
ret = p_slot->hpc_ops->get_adapter_status(p_slot, &presence); ret = pciehp_get_adapter_status(p_slot, &presence);
if (ret) if (ret)
presence = 0; presence = 0;