luck/tmp_suning_uos_patched
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[PATCH] shpchp: remove redundant data structures

Browse Source 
State information is currently stored in per-slot as well as
per-pci-function data structures in shpchp. There's a lot of
overlap in the information kept, and some of it is never used.
This patch consolidates the state information to per-slot and
eliminates unused data structures. The biggest change is to
eliminate the pci_func structure and the code around managing
its lists.

Signed-off-by: Rajesh Shah <rajesh.shah@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
rajesh.shah@intel.com 2005-10-13 12:05:41 -07:00 committed by Greg Kroah-Hartman
parent 70b6091946
commit 2178bfad9c
4 changed files with 63 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
drivers/pci/hotplug/shpchp.h
View File

@ -52,34 +52,18 @@ extern int shpchp_debug;
#define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
#define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
struct pci_func {
struct pci_func *next;
u8 bus;
u8 device;
u8 function;
u8 is_a_board;
u16 status;
u8 configured;
u8 switch_save;
u8 presence_save;
u8 pwr_save;
struct pci_dev* pci_dev;
};
#define SLOT_MAGIC 0x67267321
struct slot {
u32 magic;
struct slot *next;
u8 bus;
u8 device;
u16 status;
u32 number;
u8 is_a_board;
u8 configured;
u8 state;
u8 switch_save;
u8 presence_save;
u32 capabilities;
u16 reserved2;
u8 pwr_save;
struct timer_list task_event;
u8 hp_slot;
struct controller *ctrl;
@ -106,19 +90,14 @@ struct controller {
struct hpc_ops *hpc_ops;
wait_queue_head_t queue; /* sleep & wake process */
u8 next_event;
u8 seg;
u8 bus;
u8 device;
u8 function;
u8 rev;
u8 slot_device_offset;
u8 add_support;
enum pci_bus_speed speed;
u32 first_slot; /* First physical slot number */
u8 slot_bus; /* Bus where the slots handled by this controller sit */
u8 push_flag;
u16 ctlrcap;
u16 vendor_id;
};
struct hotplug_params {
@ -169,13 +148,9 @@ struct hotplug_params {
* error Messages
*/
#define msg_initialization_err "Initialization failure, error=%d\n"
#define msg_HPC_rev_error "Unsupported revision of the PCI hot plug controller found.\n"
#define msg_HPC_non_shpc "The PCI hot plug controller is not supported by this driver.\n"
#define msg_HPC_not_supported "This system is not supported by this version of shpcphd mdoule. Upgrade to a newer version of shpchpd\n"
#define msg_button_on "PCI slot #%d - powering on due to button press.\n"
#define msg_button_off "PCI slot #%d - powering off due to button press.\n"
#define msg_button_cancel "PCI slot #%d - action canceled due to button press.\n"
#define msg_button_ignore "PCI slot #%d - button press ignored. (action in progress...)\n"
/* sysfs functions for the hotplug controller info */
extern void shpchp_create_ctrl_files (struct controller *ctrl);
@ -183,8 +158,6 @@ extern void shpchp_create_ctrl_files (struct controller *ctrl);
/* controller functions */
extern int shpchp_event_start_thread(void);
extern void shpchp_event_stop_thread(void);
extern struct pci_func *shpchp_slot_create(unsigned char busnumber);
extern struct pci_func *shpchp_slot_find(unsigned char bus, unsigned char device, unsigned char index);
extern int shpchp_enable_slot(struct slot *slot);
extern int shpchp_disable_slot(struct slot *slot);
@ -195,9 +168,8 @@ extern u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id);
/* pci functions */
extern int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num);
extern int shpchp_save_slot_config(struct controller *ctrl, struct pci_func * new_slot);
extern int shpchp_configure_device(struct slot *p_slot);
extern int shpchp_unconfigure_device(struct pci_func* func);
extern int shpchp_unconfigure_device(struct slot *p_slot);
extern void get_hp_hw_control_from_firmware(struct pci_dev *dev);
extern void get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp);
@ -207,7 +179,6 @@ extern int shpchprm_get_physical_slot_number(struct controller *ctrl,
/* Global variables */
extern struct controller *shpchp_ctrl_list;
extern struct pci_func *shpchp_slot_list[256];
struct ctrl_reg {
volatile u32 base_offset;

20
drivers/pci/hotplug/shpchp_core.c
View File

@ -45,7 +45,6 @@ int shpchp_debug;
int shpchp_poll_mode;
int shpchp_poll_time;
struct controller *shpchp_ctrl_list; /* = NULL */
struct pci_func *shpchp_slot_list[256];
#define DRIVER_VERSION "0.4"
#define DRIVER_AUTHOR "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
@ -475,7 +474,6 @@ static int shpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
static int shpc_start_thread(void)
{
int loop;
int retval = 0;
dbg("Initialize + Start the notification/polling mechanism \n");
@ -486,20 +484,11 @@ static int shpc_start_thread(void)
return retval;
}
dbg("Initialize slot lists\n");
/* One slot list for each bus in the system */
for (loop = 0; loop < 256; loop++) {
shpchp_slot_list[loop] = NULL;
}
return retval;
}
static void __exit unload_shpchpd(void)
{
struct pci_func *next;
struct pci_func *TempSlot;
int loop;
struct controller *ctrl;
struct controller *tctrl;
@ -519,15 +508,6 @@ static void __exit unload_shpchpd(void)
kfree(tctrl);
}
for (loop = 0; loop < 256; loop++) {
next = shpchp_slot_list[loop];
while (next != NULL) {
TempSlot = next;
next = next->next;
kfree(TempSlot);
}
}
/* Stop the notification mechanism */
shpchp_event_stop_thread();

405
drivers/pci/hotplug/shpchp_ctrl.c
View File

@ -54,19 +54,16 @@ u8 shpchp_handle_attention_button(u8 hp_slot, void *inst_id)
struct slot *p_slot;
u8 rc = 0;
u8 getstatus;
struct pci_func *func;
struct event_info *taskInfo;
/* Attention Button Change */
dbg("shpchp: Attention button interrupt received.\n");
func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
/* This is the structure that tells the worker thread what to do */
taskInfo = &(ctrl->event_queue[ctrl->next_event]);
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
ctrl->next_event = (ctrl->next_event + 1) % 10;
@ -111,14 +108,11 @@ u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
struct slot *p_slot;
u8 rc = 0;
u8 getstatus;
struct pci_func *func;
struct event_info *taskInfo;
/* Switch Change */
dbg("shpchp: Switch interrupt received.\n");
func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
/* This is the structure that tells the worker thread
* what to do
*/
@ -128,19 +122,18 @@ u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
rc++;
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
dbg("%s: Card present %x Power status %x\n", __FUNCTION__,
func->presence_save, func->pwr_save);
p_slot->presence_save, p_slot->pwr_save);
if (getstatus) {
/*
* Switch opened
*/
info("Latch open on Slot(%d)\n", ctrl->first_slot + hp_slot);
func->switch_save = 0;
taskInfo->event_type = INT_SWITCH_OPEN;
if (func->pwr_save && func->presence_save) {
if (p_slot->pwr_save && p_slot->presence_save) {
taskInfo->event_type = INT_POWER_FAULT;
err("Surprise Removal of card\n");
}
@ -149,7 +142,6 @@ u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
* Switch closed
*/
info("Latch close on Slot(%d)\n", ctrl->first_slot + hp_slot);
func->switch_save = 0x10;
taskInfo->event_type = INT_SWITCH_CLOSE;
}
@ -165,14 +157,11 @@ u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id)
struct slot *p_slot;
u8 rc = 0;
/*u8 temp_byte;*/
struct pci_func *func;
struct event_info *taskInfo;
/* Presence Change */
dbg("shpchp: Presence/Notify input change.\n");
func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
/* This is the structure that tells the worker thread
* what to do
*/
@ -186,8 +175,8 @@ u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id)
/*
* Save the presence state
*/
p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
if (func->presence_save) {
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
if (p_slot->presence_save) {
/*
* Card Present
*/
@ -212,14 +201,11 @@ u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
struct controller *ctrl = (struct controller *) inst_id;
struct slot *p_slot;
u8 rc = 0;
struct pci_func *func;
struct event_info *taskInfo;
/* Power fault */
dbg("shpchp: Power fault interrupt received.\n");
func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
/* This is the structure that tells the worker thread
* what to do
*/
@ -235,7 +221,7 @@ u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
* Power fault Cleared
*/
info("Power fault cleared on Slot(%d)\n", ctrl->first_slot + hp_slot);
func->status = 0x00;
p_slot->status = 0x00;
taskInfo->event_type = INT_POWER_FAULT_CLEAR;
} else {
/*
@ -244,7 +230,7 @@ u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
info("Power fault on Slot(%d)\n", ctrl->first_slot + hp_slot);
taskInfo->event_type = INT_POWER_FAULT;
/* set power fault status for this board */
func->status = 0xFF;
p_slot->status = 0xFF;
info("power fault bit %x set\n", hp_slot);
}
if (rc)
@ -253,179 +239,6 @@ u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
return rc;
}
/**
* shpchp_slot_create - Creates a node and adds it to the proper bus.
* @busnumber - bus where new node is to be located
*
* Returns pointer to the new node or NULL if unsuccessful
*/
struct pci_func *shpchp_slot_create(u8 busnumber)
{
struct pci_func *new_slot;
struct pci_func *next;
new_slot = kmalloc(sizeof(*new_slot), GFP_KERNEL);
if (new_slot == NULL) {
return(new_slot);
}
memset(new_slot, 0, sizeof(struct pci_func));
new_slot->next = NULL;
new_slot->configured = 1;
if (shpchp_slot_list[busnumber] == NULL) {
shpchp_slot_list[busnumber] = new_slot;
} else {
next = shpchp_slot_list[busnumber];
while (next->next != NULL)
next = next->next;
next->next = new_slot;
}
return(new_slot);
}
/*
* slot_remove - Removes a node from the linked list of slots.
* @old_slot: slot to remove
*
* Returns 0 if successful, !0 otherwise.
*/
static int slot_remove(struct pci_func * old_slot)
{
struct pci_func *next;
if (old_slot == NULL)
return(1);
next = shpchp_slot_list[old_slot->bus];
if (next == NULL) {
return(1);
}
if (next == old_slot) {
shpchp_slot_list[old_slot->bus] = old_slot->next;
kfree(old_slot);
return(0);
}
while ((next->next != old_slot) && (next->next != NULL)) {
next = next->next;
}
if (next->next == old_slot) {
next->next = old_slot->next;
kfree(old_slot);
return(0);
} else
return(2);
}
/**
* bridge_slot_remove - Removes a node from the linked list of slots.
* @bridge: bridge to remove
* @secondaryBus: secondary PCI bus number for bridge being removed
* @subordinateBus: subordinate PCI bus number for bridge being removed
*
* Returns 0 if successful, !0 otherwise.
*/
static int bridge_slot_remove(struct pci_func *bridge, u8 secondaryBus,
u8 subordinateBus)
{
u8 tempBus;
struct pci_func *next;
if (bridge == NULL)
return(1);
for (tempBus = secondaryBus; tempBus <= subordinateBus; tempBus++) {
next = shpchp_slot_list[tempBus];
while (!slot_remove(next)) {
next = shpchp_slot_list[tempBus];
}
}
next = shpchp_slot_list[bridge->bus];
if (next == NULL) {
return(1);
}
if (next == bridge) {
shpchp_slot_list[bridge->bus] = bridge->next;
kfree(bridge);
return(0);
}
while ((next->next != bridge) && (next->next != NULL)) {
next = next->next;
}
if (next->next == bridge) {
next->next = bridge->next;
kfree(bridge);
return(0);
} else
return(2);
}
/**
* shpchp_slot_find - Looks for a node by bus, and device, multiple functions accessed
* @bus: bus to find
* @device: device to find
* @index: is 0 for first function found, 1 for the second...
*
* Returns pointer to the node if successful, %NULL otherwise.
*/
struct pci_func *shpchp_slot_find(u8 bus, u8 device, u8 index)
{
int found = -1;
struct pci_func *func;
func = shpchp_slot_list[bus];
if ((func == NULL) || ((func->device == device) && (index == 0)))
return(func);
if (func->device == device)
found++;
while (func->next != NULL) {
func = func->next;
if (func->device == device)
found++;
if (found == index)
return(func);
}
return(NULL);
}
static int is_bridge(struct pci_func *func, struct controller *ctrl)
{
u8 hdr_type;
struct pci_bus *bus = ctrl->pci_dev->subordinate;
/*
* Note: device may have just been hot-added and not yet scanned
* by the pci core, so its pci_dev structure may not exist yet
*/
pci_bus_read_config_byte(bus, PCI_DEVFN(func->device, func->function),
PCI_HEADER_TYPE, &hdr_type);
if ((hdr_type & 0x7f) == PCI_HEADER_TYPE_BRIDGE)
return 1;
else
return 0;
}
/* The following routines constitute the bulk of the
hotplug controller logic
*/
@ -495,19 +308,20 @@ enum pci_bus_speed asp, enum pci_bus_speed bsp, enum pci_bus_speed msp)
* Configures board
*
*/
static u32 board_added(struct pci_func * func, struct controller * ctrl)
static u32 board_added(struct slot *p_slot)
{
u8 hp_slot;
u8 slots_not_empty = 0;
u32 rc = 0;
struct slot *p_slot;
enum pci_bus_speed adapter_speed, bus_speed, max_bus_speed;
u8 pi, mode;
struct controller *ctrl = p_slot->ctrl;
p_slot = shpchp_find_slot(ctrl, func->device);
hp_slot = func->device - ctrl->slot_device_offset;
hp_slot = p_slot->device - ctrl->slot_device_offset;
dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n", __FUNCTION__, func->device, ctrl->slot_device_offset, hp_slot);
dbg("%s: p_slot->device, slot_offset, hp_slot = %d, %d ,%d\n",
__FUNCTION__, p_slot->device,
ctrl->slot_device_offset, hp_slot);
/* Wait for exclusive access to hardware */
down(&ctrl->crit_sect);
@ -699,13 +513,13 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
wait_for_ctrl_irq (ctrl);
dbg("%s: after long_delay\n", __FUNCTION__);
dbg("%s: func status = %x\n", __FUNCTION__, func->status);
dbg("%s: slot status = %x\n", __FUNCTION__, p_slot->status);
/* Check for a power fault */
if (func->status == 0xFF) {
if (p_slot->status == 0xFF) {
/* power fault occurred, but it was benign */
dbg("%s: power fault\n", __FUNCTION__);
rc = POWER_FAILURE;
func->status = 0;
p_slot->status = 0;
goto err_exit;
}
@ -715,10 +529,9 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
goto err_exit;
}
func->status = 0;
func->switch_save = 0x10;
func->is_a_board = 0x01;
func->pwr_save = 1;
p_slot->status = 0;
p_slot->is_a_board = 0x01;
p_slot->pwr_save = 1;
/* Wait for exclusive access to hardware */
down(&ctrl->crit_sect);
@ -767,38 +580,23 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
* remove_board - Turns off slot and LED's
*
*/
static u32 remove_board(struct pci_func *func, struct controller *ctrl)
static u32 remove_board(struct slot *p_slot)
{
u8 device;
struct controller *ctrl = p_slot->ctrl;
u8 hp_slot;
u32 rc;
struct slot *p_slot;
u8 secondary = 0, subordinate = 0;
int remove_bridge;
if (func == NULL)
if (shpchp_unconfigure_device(p_slot))
return(1);
if ((remove_bridge = is_bridge(func, ctrl))) {
/* Stash away bus information before we destroy it */
secondary = func->pci_dev->subordinate->secondary;
subordinate = func->pci_dev->subordinate->subordinate;
}
if (shpchp_unconfigure_device(func))
return(1);
device = func->device;
hp_slot = func->device - ctrl->slot_device_offset;
hp_slot = p_slot->device - ctrl->slot_device_offset;
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot);
/* Change status to shutdown */
if (func->is_a_board)
func->status = 0x01;
func->configured = 0;
if (p_slot->is_a_board)
p_slot->status = 0x01;
/* Wait for exclusive access to hardware */
down(&ctrl->crit_sect);
@ -835,36 +633,8 @@ static u32 remove_board(struct pci_func *func, struct controller *ctrl)
/* Done with exclusive hardware access */
up(&ctrl->crit_sect);
if (ctrl->add_support) {
while (func) {
if (remove_bridge) {
dbg("PCI Bridge Hot-Remove s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus,
func->device, func->function);
bridge_slot_remove(func, secondary,
subordinate);
} else
dbg("PCI Function Hot-Remove s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus,
func->device, func->function);
slot_remove(func);
func = shpchp_slot_find(ctrl->slot_bus, device, 0);
}
/* Setup slot structure with entry for empty slot */
func = shpchp_slot_create(ctrl->slot_bus);
if (func == NULL) {
return(1);
}
func->bus = ctrl->slot_bus;
func->device = device;
func->function = 0;
func->configured = 0;
func->switch_save = 0x10;
func->pwr_save = 0;
func->is_a_board = 0;
}
p_slot->pwr_save = 0;
p_slot->is_a_board = 0;
return 0;
}
@ -1006,7 +776,6 @@ static void interrupt_event_handler(struct controller *ctrl)
{
int loop = 0;
int change = 1;
struct pci_func *func;
u8 hp_slot;
u8 getstatus;
struct slot *p_slot;
@ -1021,11 +790,10 @@ static void interrupt_event_handler(struct controller *ctrl)
ctrl->event_queue[loop].event_type);
hp_slot = ctrl->event_queue[loop].hp_slot;
func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
dbg("%s: hp_slot %d, func %p, p_slot %p\n", __FUNCTION__, hp_slot, func, p_slot);
dbg("%s: hp_slot %d, p_slot %p\n",
__FUNCTION__, hp_slot, p_slot);
if (ctrl->event_queue[loop].event_type == INT_BUTTON_CANCEL) {
dbg("%s: button cancel\n", __FUNCTION__);
@ -1147,13 +915,6 @@ int shpchp_enable_slot (struct slot *p_slot)
{
u8 getstatus = 0;
int rc;
struct pci_func *func;
func = shpchp_slot_find(p_slot->bus, p_slot->device, 0);
if (!func) {
dbg("%s: Error! slot NULL\n", __FUNCTION__);
return -ENODEV;
}
/* Check to see if (latch closed, card present, power off) */
down(&p_slot->ctrl->crit_sect);
@ -1177,75 +938,35 @@ int shpchp_enable_slot (struct slot *p_slot)
}
up(&p_slot->ctrl->crit_sect);
slot_remove(func);
func = shpchp_slot_create(p_slot->bus);
if (func == NULL)
return -ENOMEM;
func->bus = p_slot->bus;
func->device = p_slot->device;
func->function = 0;
func->configured = 0;
func->is_a_board = 1;
p_slot->is_a_board = 1;
/* We have to save the presence info for these slots */
p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
p_slot->hpc_ops->get_power_status(p_slot, &(func->pwr_save));
dbg("%s: func->pwr_save %x\n", __FUNCTION__, func->pwr_save);
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
p_slot->hpc_ops->get_power_status(p_slot, &(p_slot->pwr_save));
dbg("%s: p_slot->pwr_save %x\n", __FUNCTION__, p_slot->pwr_save);
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
func->switch_save = !getstatus? 0x10:0;
rc = board_added(func, p_slot->ctrl);
rc = board_added(p_slot);
if (rc) {
if (is_bridge(func, p_slot->ctrl)) {
u8 secondary = func->pci_dev->subordinate->secondary;
u8 subordinate =
func->pci_dev->subordinate->subordinate;
bridge_slot_remove(func, secondary, subordinate);
} else
slot_remove(func);
/* Setup slot structure with entry for empty slot */
func = shpchp_slot_create(p_slot->bus);
if (func == NULL)
return -ENOMEM; /* Out of memory */
func->bus = p_slot->bus;
func->device = p_slot->device;
func->function = 0;
func->configured = 0;
func->is_a_board = 1;
/* We have to save the presence info for these slots */
p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
p_slot->hpc_ops->get_adapter_status(p_slot,
&(p_slot->presence_save));
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
func->switch_save = !getstatus? 0x10:0;
}
if (p_slot)
update_slot_info(p_slot);
update_slot_info(p_slot);
return rc;
}
int shpchp_disable_slot (struct slot *p_slot)
{
u8 class_code, header_type, BCR;
u8 index = 0;
u8 getstatus = 0;
u32 rc = 0;
int ret = 0;
unsigned int devfn;
struct pci_bus *pci_bus;
struct pci_func *func;
if (!p_slot->ctrl)
return -ENODEV;
pci_bus = p_slot->ctrl->pci_dev->subordinate;
/* Check to see if (latch closed, card present, power on) */
down(&p_slot->ctrl->crit_sect);
@ -1269,54 +990,8 @@ int shpchp_disable_slot (struct slot *p_slot)
}
up(&p_slot->ctrl->crit_sect);
func = shpchp_slot_find(p_slot->bus, p_slot->device, index++);
/* Make sure there are no video controllers here
* for all func of p_slot
*/
while (func && !rc) {
pci_bus->number = func->bus;
devfn = PCI_DEVFN(func->device, func->function);
/* Check the Class Code */
rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
if (rc)
return -ENODEV;
if (class_code == PCI_BASE_CLASS_DISPLAY) {
/* Display/Video adapter (not supported) */
rc = REMOVE_NOT_SUPPORTED;
} else {
/* See if it's a bridge */
rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type);
if (rc)
return -ENODEV;
/* If it's a bridge, check the VGA Enable bit */
if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_BRIDGE_CONTROL, &BCR);
if (rc)
return -ENODEV;
/* If the VGA Enable bit is set, remove isn't supported */
if (BCR & PCI_BRIDGE_CTL_VGA) {
rc = REMOVE_NOT_SUPPORTED;
}
}
}
func = shpchp_slot_find(p_slot->bus, p_slot->device, index++);
}
func = shpchp_slot_find(p_slot->bus, p_slot->device, 0);
if ((func != NULL) && !rc) {
rc = remove_board(func, p_slot->ctrl);
} else if (!rc)
rc = -ENODEV;
if (p_slot)
update_slot_info(p_slot);
rc = remove_board(p_slot);
update_slot_info(p_slot);
return rc;
}

27
drivers/pci/hotplug/shpchp_pci.c
View File

@ -148,20 +148,33 @@ int shpchp_configure_device(struct slot *p_slot)
return 0;
}
int shpchp_unconfigure_device(struct pci_func* func)
int shpchp_unconfigure_device(struct slot *p_slot)
{
int rc = 0;
int j;
u8 bctl = 0;
dbg("%s: bus/dev/func = %x/%x/%x\n", __FUNCTION__, func->bus,
func->device, func->function);
dbg("%s: bus/dev = %x/%x\n", __FUNCTION__, p_slot->bus, p_slot->device);
for (j=0; j<8 ; j++) {
struct pci_dev* temp = pci_find_slot(func->bus,
(func->device << 3) | j);
if (temp) {
pci_remove_bus_device(temp);
struct pci_dev* temp = pci_find_slot(p_slot->bus,
(p_slot->device << 3) | j);
if (!temp)
continue;
if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
err("Cannot remove display device %s\n",
pci_name(temp));
continue;
}
if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
if (bctl & PCI_BRIDGE_CTL_VGA) {
err("Cannot remove display device %s\n",
pci_name(temp));
continue;
}
}
pci_remove_bus_device(temp);
}
return rc;
}