1 files changed, 191 insertions, 180 deletions

diff --git a/drivers/pci/hotplug/cpqphp_ctrl.c b/drivers/pci/hotplug/cpqphp_ctrl.c
index cc227a8c4b11..2fa47af992a8 100644
--- a/drivers/pci/hotplug/cpqphp_ctrl.c
+++ b/drivers/pci/hotplug/cpqphp_ctrl.c
@@ -81,14 +81,15 @@ static u8 handle_switch_change(u8 change, struct controller * ctrl)
 
         for (hp_slot = 0; hp_slot < 6; hp_slot++) {
                 if (change & (0x1L << hp_slot)) {
-                        /**********************************
+                        /*
                          * this one changed.
-                         **********************************/
+                         */
                         func = cpqhp_slot_find(ctrl->bus,
                                 (hp_slot + ctrl->slot_device_offset), 0);
 
                         /* this is the structure that tells the worker thread
-                         *what to do */
+                         * what to do
+                         */
                         taskInfo = &(ctrl->event_queue[ctrl->next_event]);
                         ctrl->next_event = (ctrl->next_event + 1) % 10;
                         taskInfo->hp_slot = hp_slot;
@@ -100,17 +101,17 @@ static u8 handle_switch_change(u8 change, struct controller * ctrl)
                         func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02;
 
                         if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) {
-                                /**********************************
+                                /*
                                  * Switch opened
-                                 **********************************/
+                                 */
 
                                 func->switch_save = 0;
 
                                 taskInfo->event_type = INT_SWITCH_OPEN;
                         } else {
-                                /**********************************
+                                /*
                                  * Switch closed
-                                 **********************************/
+                                 */
 
                                 func->switch_save = 0x10;
 
@@ -131,9 +132,8 @@ static struct slot *cpqhp_find_slot(struct controller *ctrl, u8 device)
 {
         struct slot *slot = ctrl->slot;
 
-        while (slot && (slot->device != device)) {
+        while (slot && (slot->device != device))
                 slot = slot->next;
-        }
 
         return slot;
 }
@@ -152,17 +152,17 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
         if (!change)
                 return 0;
 
-        /**********************************
+        /*
          * Presence Change
-         **********************************/
+         */
         dbg("cpqsbd:  Presence/Notify input change.\n");
         dbg("         Changed bits are 0x%4.4x\n", change );
 
         for (hp_slot = 0; hp_slot < 6; hp_slot++) {
                 if (change & (0x0101 << hp_slot)) {
-                        /**********************************
+                        /*
                          * this one changed.
-                         **********************************/
+                         */
                         func = cpqhp_slot_find(ctrl->bus,
                                 (hp_slot + ctrl->slot_device_offset), 0);
 
@@ -177,22 +177,23 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
                                 return 0;
 
                         /* If the switch closed, must be a button
-                         * If not in button mode, nevermind */
+                         * If not in button mode, nevermind
+                         */
                         if (func->switch_save && (ctrl->push_button == 1)) {
                                 temp_word = ctrl->ctrl_int_comp >> 16;
                                 temp_byte = (temp_word >> hp_slot) & 0x01;
                                 temp_byte |= (temp_word >> (hp_slot + 7)) & 0x02;
 
                                 if (temp_byte != func->presence_save) {
-                                        /**************************************
+                                        /*
                                          * button Pressed (doesn't do anything)
-                                         **************************************/
+                                         */
                                         dbg("hp_slot %d button pressed\n", hp_slot);
                                         taskInfo->event_type = INT_BUTTON_PRESS;
                                 } else {
-                                        /**********************************
+                                        /*
                                          * button Released - TAKE ACTION!!!!
-                                         **********************************/
+                                         */
                                         dbg("hp_slot %d button released\n", hp_slot);
                                         taskInfo->event_type = INT_BUTTON_RELEASE;
 
@@ -210,7 +211,8 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
                                 }
                         } else {
                                 /* Switch is open, assume a presence change
-                                 * Save the presence state */
+                                 * Save the presence state
+                                 */
                                 temp_word = ctrl->ctrl_int_comp >> 16;
                                 func->presence_save = (temp_word >> hp_slot) & 0x01;
                                 func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02;
@@ -241,17 +243,17 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
         if (!change)
                 return 0;
 
-        /**********************************
+        /*
          * power fault
-         **********************************/
+         */
 
         info("power fault interrupt\n");
 
         for (hp_slot = 0; hp_slot < 6; hp_slot++) {
                 if (change & (0x01 << hp_slot)) {
-                        /**********************************
+                        /*
                          * this one changed.
-                         **********************************/
+                         */
                         func = cpqhp_slot_find(ctrl->bus,
                                 (hp_slot + ctrl->slot_device_offset), 0);
 
@@ -262,16 +264,16 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
                         rc++;
 
                         if (ctrl->ctrl_int_comp & (0x00000100 << hp_slot)) {
-                                /**********************************
+                                /*
                                  * power fault Cleared
-                                 **********************************/
+                                 */
                                 func->status = 0x00;
 
                                 taskInfo->event_type = INT_POWER_FAULT_CLEAR;
                         } else {
-                                /**********************************
+                                /*
                                  * power fault
-                                 **********************************/
+                                 */
                                 taskInfo->event_type = INT_POWER_FAULT;
 
                                 if (ctrl->rev < 4) {
@@ -432,13 +434,15 @@ static struct pci_resource *do_pre_bridge_resource_split(struct pci_resource **h
 
 
         /* If we got here, there the bridge requires some of the resource, but
-         * we may be able to split some off of the front */
+         * we may be able to split some off of the front
+         */
 
         node = *head;
 
         if (node->length & (alignment -1)) {
                 /* this one isn't an aligned length, so we'll make a new entry
-                 * and split it up. */
+                 * and split it up.
+                 */
                 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
 
                 if (!split_node)
@@ -544,10 +548,10 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
         if (!(*head))
                 return NULL;
 
-        if ( cpqhp_resource_sort_and_combine(head) )
+        if (cpqhp_resource_sort_and_combine(head))
                 return NULL;
 
-        if ( sort_by_size(head) )
+        if (sort_by_size(head))
                 return NULL;
 
         for (node = *head; node; node = node->next) {
@@ -556,7 +560,8 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
 
                 if (node->base & (size - 1)) {
                         /* this one isn't base aligned properly
-                         * so we'll make a new entry and split it up */
+                         * so we'll make a new entry and split it up
+                         */
                         temp_dword = (node->base | (size-1)) + 1;
 
                         /* Short circuit if adjusted size is too small */
@@ -581,7 +586,8 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
                 /* Don't need to check if too small since we already did */
                 if (node->length > size) {
                         /* this one is longer than we need
-                         * so we'll make a new entry and split it up */
+                         * so we'll make a new entry and split it up
+                         */
                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
 
                         if (!split_node)
@@ -601,7 +607,8 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
                         continue;
 
                 /* If we got here, then it is the right size
-                 * Now take it out of the list and break */
+                 * Now take it out of the list and break
+                 */
                 if (*head == node) {
                         *head = node->next;
                 } else {
@@ -642,14 +649,16 @@ static struct pci_resource *get_max_resource(struct pci_resource **head, u32 siz
                 return NULL;
 
         for (max = *head; max; max = max->next) {
-                /* If not big enough we could probably just bail, 
-                 * instead we'll continue to the next. */
+                /* If not big enough we could probably just bail,
+                 * instead we'll continue to the next.
+                 */
                 if (max->length < size)
                         continue;
 
                 if (max->base & (size - 1)) {
                         /* this one isn't base aligned properly
-                         * so we'll make a new entry and split it up */
+                         * so we'll make a new entry and split it up
+                         */
                         temp_dword = (max->base | (size-1)) + 1;
 
                         /* Short circuit if adjusted size is too small */
@@ -672,7 +681,8 @@ static struct pci_resource *get_max_resource(struct pci_resource **head, u32 siz
 
                 if ((max->base + max->length) & (size - 1)) {
                         /* this one isn't end aligned properly at the top
-                         * so we'll make a new entry and split it up */
+                         * so we'll make a new entry and split it up
+                         */
                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
 
                         if (!split_node)
@@ -744,7 +754,8 @@ static struct pci_resource *get_resource(struct pci_resource **head, u32 size)
                 if (node->base & (size - 1)) {
                         dbg("%s: not aligned\n", __func__);
                         /* this one isn't base aligned properly
-                         * so we'll make a new entry and split it up */
+                         * so we'll make a new entry and split it up
+                         */
                         temp_dword = (node->base | (size-1)) + 1;
 
                         /* Short circuit if adjusted size is too small */
@@ -769,7 +780,8 @@ static struct pci_resource *get_resource(struct pci_resource **head, u32 size)
                 if (node->length > size) {
                         dbg("%s: too big\n", __func__);
                         /* this one is longer than we need
-                         * so we'll make a new entry and split it up */
+                         * so we'll make a new entry and split it up
+                         */
                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
 
                         if (!split_node)
@@ -886,19 +898,19 @@ irqreturn_t cpqhp_ctrl_intr(int IRQ, void *data)
         u32 Diff;
         u32 temp_dword;
 
-        
+
         misc = readw(ctrl->hpc_reg + MISC);
-        /***************************************
+        /*
          * Check to see if it was our interrupt
-         ***************************************/
+         */
         if (!(misc & 0x000C)) {
                 return IRQ_NONE;
         }
 
         if (misc & 0x0004) {
-                /**********************************
+                /*
                  * Serial Output interrupt Pending
-                 **********************************/
+                 */
 
                 /* Clear the interrupt */
                 misc |= 0x0004;
@@ -961,11 +973,8 @@ struct pci_func *cpqhp_slot_create(u8 busnumber)
         struct pci_func *next;
 
         new_slot = kzalloc(sizeof(*new_slot), GFP_KERNEL);
-        if (new_slot == NULL) {
-                /* I'm not dead yet!
-                 * You will be. */
+        if (new_slot == NULL)
                 return new_slot;
-        }
 
         new_slot->next = NULL;
         new_slot->configured = 1;
@@ -996,10 +1005,8 @@ static int slot_remove(struct pci_func * old_slot)
                 return 1;
 
         next = cpqhp_slot_list[old_slot->bus];
-
-        if (next == NULL) {
+        if (next == NULL)
                 return 1;
-        }
 
         if (next == old_slot) {
                 cpqhp_slot_list[old_slot->bus] = old_slot->next;
@@ -1008,9 +1015,8 @@ static int slot_remove(struct pci_func * old_slot)
                 return 0;
         }
 
-        while ((next->next != old_slot) && (next->next != NULL)) {
+        while ((next->next != old_slot) && (next->next != NULL))
                 next = next->next;
-        }
 
         if (next->next == old_slot) {
                 next->next = old_slot->next;
@@ -1040,9 +1046,8 @@ static int bridge_slot_remove(struct pci_func *bridge)
         for (tempBus = secondaryBus; tempBus <= subordinateBus; tempBus++) {
                 next = cpqhp_slot_list[tempBus];
 
-                while (!slot_remove(next)) {
+                while (!slot_remove(next))
                         next = cpqhp_slot_list[tempBus];
-                }
         }
 
         next = cpqhp_slot_list[bridge->bus];
@@ -1130,39 +1135,43 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
         u8 slot_power = readb(ctrl->hpc_reg + SLOT_POWER);
         u16 reg16;
         u32 leds = readl(ctrl->hpc_reg + LED_CONTROL);
-        
+
         if (ctrl->speed == adapter_speed)
                 return 0;
-        
+
         /* We don't allow freq/mode changes if we find another adapter running
-         * in another slot on this controller */
+         * in another slot on this controller
+         */
         for(slot = ctrl->slot; slot; slot = slot->next) {
-                if (slot->device == (hp_slot + ctrl->slot_device_offset)) 
+                if (slot->device == (hp_slot + ctrl->slot_device_offset))
                         continue;
                 if (!slot->hotplug_slot || !slot->hotplug_slot->info)
                         continue;
-                if (slot->hotplug_slot->info->adapter_status == 0) 
+                if (slot->hotplug_slot->info->adapter_status == 0)
                         continue;
                 /* If another adapter is running on the same segment but at a
                  * lower speed/mode, we allow the new adapter to function at
-                 * this rate if supported */
-                if (ctrl->speed < adapter_speed) 
+                 * this rate if supported
+                 */
+                if (ctrl->speed < adapter_speed)
                         return 0;
 
                 return 1;
         }
-        
+
         /* If the controller doesn't support freq/mode changes and the
-         * controller is running at a higher mode, we bail */
+         * controller is running at a higher mode, we bail
+         */
         if ((ctrl->speed > adapter_speed) && (!ctrl->pcix_speed_capability))
                 return 1;
-        
+
         /* But we allow the adapter to run at a lower rate if possible */
         if ((ctrl->speed < adapter_speed) && (!ctrl->pcix_speed_capability))
                 return 0;
 
         /* We try to set the max speed supported by both the adapter and
-         * controller */
+         * controller
+         */
         if (ctrl->speed_capability < adapter_speed) {
                 if (ctrl->speed == ctrl->speed_capability)
                         return 0;
@@ -1171,22 +1180,22 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
 
         writel(0x0L, ctrl->hpc_reg + LED_CONTROL);
         writeb(0x00, ctrl->hpc_reg + SLOT_ENABLE);
-        
-        set_SOGO(ctrl); 
+
+        set_SOGO(ctrl);
         wait_for_ctrl_irq(ctrl);
-        
+
         if (adapter_speed != PCI_SPEED_133MHz_PCIX)
                 reg = 0xF5;
         else
-                reg = 0xF4;     
+                reg = 0xF4;
         pci_write_config_byte(ctrl->pci_dev, 0x41, reg);
-        
+
         reg16 = readw(ctrl->hpc_reg + NEXT_CURR_FREQ);
         reg16 &= ~0x000F;
         switch(adapter_speed) {
-                case(PCI_SPEED_133MHz_PCIX): 
+                case(PCI_SPEED_133MHz_PCIX):
                         reg = 0x75;
-                        reg16 |= 0xB; 
+                        reg16 |= 0xB;
                         break;
                 case(PCI_SPEED_100MHz_PCIX):
                         reg = 0x74;
@@ -1203,48 +1212,48 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
                 default: /* 33MHz PCI 2.2 */
                         reg = 0x71;
                         break;
-                        
+
         }
         reg16 |= 0xB << 12;
         writew(reg16, ctrl->hpc_reg + NEXT_CURR_FREQ);
-        
-        mdelay(5); 
-        
+
+        mdelay(5);
+
         /* Reenable interrupts */
         writel(0, ctrl->hpc_reg + INT_MASK);
 
-        pci_write_config_byte(ctrl->pci_dev, 0x41, reg); 
-        
+        pci_write_config_byte(ctrl->pci_dev, 0x41, reg);
+
         /* Restart state machine */
         reg = ~0xF;
         pci_read_config_byte(ctrl->pci_dev, 0x43, &reg);
         pci_write_config_byte(ctrl->pci_dev, 0x43, reg);
-        
+
         /* Only if mode change...*/
         if (((ctrl->speed == PCI_SPEED_66MHz) && (adapter_speed == PCI_SPEED_66MHz_PCIX)) ||
                 ((ctrl->speed == PCI_SPEED_66MHz_PCIX) && (adapter_speed == PCI_SPEED_66MHz))) 
                         set_SOGO(ctrl);
-        
+
         wait_for_ctrl_irq(ctrl);
         mdelay(1100);
-        
+
         /* Restore LED/Slot state */
         writel(leds, ctrl->hpc_reg + LED_CONTROL);
         writeb(slot_power, ctrl->hpc_reg + SLOT_ENABLE);
-        
+
         set_SOGO(ctrl);
         wait_for_ctrl_irq(ctrl);
 
         ctrl->speed = adapter_speed;
         slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
 
-        info("Successfully changed frequency/mode for adapter in slot %d\n", 
+        info("Successfully changed frequency/mode for adapter in slot %d\n",
                         slot->number);
         return 0;
 }
 
-/* the following routines constitute the bulk of the 
-   hotplug controller logic
+/* the following routines constitute the bulk of the
+ * hotplug controller logic
  */
 
 
@@ -1268,17 +1277,17 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
 
         hp_slot = func->device - ctrl->slot_device_offset;
 
-        if (readl(ctrl->hpc_reg + INT_INPUT_CLEAR) & (0x01L << hp_slot)) {
-                /**********************************
-                 * The switch is open.
-                 **********************************/
+        /*
+         * The switch is open.
+         */
+        if (readl(ctrl->hpc_reg + INT_INPUT_CLEAR) & (0x01L << hp_slot))
                 rc = INTERLOCK_OPEN;
-        } else if (is_slot_enabled (ctrl, hp_slot)) {
-                /**********************************
-                 * The board is already on
-                 **********************************/
+        /*
+         * The board is already on
+         */
+        else if (is_slot_enabled (ctrl, hp_slot))
                 rc = CARD_FUNCTIONING;
-        } else {
+        else {
                 mutex_lock(&ctrl->crit_sect);
 
                 /* turn on board without attaching to the bus */
@@ -1299,7 +1308,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
 
                 /* Wait for SOBS to be unset */
                 wait_for_ctrl_irq (ctrl);
-                
+
                 adapter_speed = get_adapter_speed(ctrl, hp_slot);
                 if (ctrl->speed != adapter_speed)
                         if (set_controller_speed(ctrl, adapter_speed, hp_slot))
@@ -1352,7 +1361,8 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                          * Get slot won't work for devices behind
                          * bridges, but in this case it will always be
                          * called for the "base" bus/dev/func of an
-                         * adapter. */
+                         * adapter.
+                         */
 
                         mutex_lock(&ctrl->crit_sect);
 
@@ -1377,7 +1387,8 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
 
                          * Get slot won't work for devices behind bridges, but
                          * in this case it will always be called for the "base"
-                         * bus/dev/func of an adapter. */
+                         * bus/dev/func of an adapter.
+                         */
 
                         mutex_lock(&ctrl->crit_sect);
 
@@ -1434,7 +1445,8 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         wait_for_ctrl_irq (ctrl);
 
         /* Change bits in slot power register to force another shift out
-         * NOTE: this is to work around the timer bug */
+         * NOTE: this is to work around the timer bug
+         */
         temp_byte = readb(ctrl->hpc_reg + SLOT_POWER);
         writeb(0x00, ctrl->hpc_reg + SLOT_POWER);
         writeb(temp_byte, ctrl->hpc_reg + SLOT_POWER);
@@ -1443,12 +1455,12 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
 
         /* Wait for SOBS to be unset */
         wait_for_ctrl_irq (ctrl);
-        
+
         adapter_speed = get_adapter_speed(ctrl, hp_slot);
         if (ctrl->speed != adapter_speed)
                 if (set_controller_speed(ctrl, adapter_speed, hp_slot))
                         rc = WRONG_BUS_FREQUENCY;
-        
+
         /* turn off board without attaching to the bus */
         disable_slot_power (ctrl, hp_slot);
 
@@ -1461,7 +1473,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
 
         if (rc)
                 return rc;
-        
+
         p_slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
 
         /* turn on board and blink green LED */
@@ -1521,7 +1533,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         }
 
         /* All F's is an empty slot or an invalid board */
-        if (temp_register != 0xFFFFFFFF) {        /* Check for a board in the slot */
+        if (temp_register != 0xFFFFFFFF) {
                 res_lists.io_head = ctrl->io_head;
                 res_lists.mem_head = ctrl->mem_head;
                 res_lists.p_mem_head = ctrl->p_mem_head;
@@ -1570,9 +1582,8 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
                 index = 0;
                 do {
                         new_slot = cpqhp_slot_find(ctrl->bus, func->device, index++);
-                        if (new_slot && !new_slot->pci_dev) {
+                        if (new_slot && !new_slot->pci_dev)
                                 cpqhp_configure_device(ctrl, new_slot);
-                        }
                 } while (new_slot);
 
                 mutex_lock(&ctrl->crit_sect);
@@ -1859,12 +1870,12 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                 info(msg_button_on, p_slot->number);
                                         }
                                         mutex_lock(&ctrl->crit_sect);
-                                        
+
                                         dbg("blink green LED and turn off amber\n");
-                                        
+
                                         amber_LED_off (ctrl, hp_slot);
                                         green_LED_blink (ctrl, hp_slot);
-                                        
+
                                         set_SOGO(ctrl);
 
                                         /* Wait for SOBS to be unset */
@@ -1958,7 +1969,7 @@ void cpqhp_pushbutton_thread(unsigned long slot)
                         if (cpqhp_process_SI(ctrl, func) != 0) {
                                 amber_LED_on(ctrl, hp_slot);
                                 green_LED_off(ctrl, hp_slot);
-                                
+
                                 set_SOGO(ctrl);
 
                                 /* Wait for SOBS to be unset */
@@ -2079,7 +2090,7 @@ int cpqhp_process_SS(struct controller *ctrl, struct pci_func *func)
         struct pci_bus *pci_bus = ctrl->pci_bus;
         int physical_slot=0;
 
-        device = func->device; 
+        device = func->device;
         func = cpqhp_slot_find(ctrl->bus, device, index++);
         p_slot = cpqhp_find_slot(ctrl, device);
         if (p_slot) {
@@ -2113,9 +2124,8 @@ int cpqhp_process_SS(struct controller *ctrl, struct pci_func *func)
 
                                 /* If the VGA Enable bit is set, remove isn't
                                  * supported */
-                                if (BCR & PCI_BRIDGE_CTL_VGA) {
+                                if (BCR & PCI_BRIDGE_CTL_VGA)
                                         rc = REMOVE_NOT_SUPPORTED;
-                                }
                         }
                 }
 
@@ -2183,67 +2193,67 @@ int cpqhp_hardware_test(struct controller *ctrl, int test_num)
         num_of_slots = readb(ctrl->hpc_reg + SLOT_MASK) & 0x0f;
 
         switch (test_num) {
-                case 1:
-                        /* Do stuff here! */
-
-                        /* Do that funky LED thing */
-                        /* so we can restore them later */
-                        save_LED = readl(ctrl->hpc_reg + LED_CONTROL);
-                        work_LED = 0x01010101;
-                        switch_leds(ctrl, num_of_slots, &work_LED, 0);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 1);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 0);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 1);
-
-                        work_LED = 0x01010000;
-                        writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 0);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 1);
-                        work_LED = 0x00000101;
-                        writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 0);
-                        switch_leds(ctrl, num_of_slots, &work_LED, 1);
+        case 1:
+                /* Do stuff here! */
+
+                /* Do that funky LED thing */
+                /* so we can restore them later */
+                save_LED = readl(ctrl->hpc_reg + LED_CONTROL);
+                work_LED = 0x01010101;
+                switch_leds(ctrl, num_of_slots, &work_LED, 0);
+                switch_leds(ctrl, num_of_slots, &work_LED, 1);
+                switch_leds(ctrl, num_of_slots, &work_LED, 0);
+                switch_leds(ctrl, num_of_slots, &work_LED, 1);
+
+                work_LED = 0x01010000;
+                writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
+                switch_leds(ctrl, num_of_slots, &work_LED, 0);
+                switch_leds(ctrl, num_of_slots, &work_LED, 1);
+                work_LED = 0x00000101;
+                writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
+                switch_leds(ctrl, num_of_slots, &work_LED, 0);
+                switch_leds(ctrl, num_of_slots, &work_LED, 1);
+
+                work_LED = 0x01010000;
+                writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
+                for (loop = 0; loop < num_of_slots; loop++) {
+                        set_SOGO(ctrl);
 
-                        work_LED = 0x01010000;
-                        writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
-                        for (loop = 0; loop < num_of_slots; loop++) {
-                                set_SOGO(ctrl);
+                        /* Wait for SOGO interrupt */
+                        wait_for_ctrl_irq (ctrl);
 
-                                /* Wait for SOGO interrupt */
-                                wait_for_ctrl_irq (ctrl);
+                        /* Get ready for next iteration */
+                        long_delay((3*HZ)/10);
+                        work_LED = work_LED >> 16;
+                        writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
 
-                                /* Get ready for next iteration */
-                                long_delay((3*HZ)/10);
-                                work_LED = work_LED >> 16;
-                                writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
-                                
-                                set_SOGO(ctrl);
+                        set_SOGO(ctrl);
 
-                                /* Wait for SOGO interrupt */
-                                wait_for_ctrl_irq (ctrl);
+                        /* Wait for SOGO interrupt */
+                        wait_for_ctrl_irq (ctrl);
 
-                                /* Get ready for next iteration */
-                                long_delay((3*HZ)/10);
-                                work_LED = work_LED << 16;
-                                writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
-                                work_LED = work_LED << 1;
-                                writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
-                        }
+                        /* Get ready for next iteration */
+                        long_delay((3*HZ)/10);
+                        work_LED = work_LED << 16;
+                        writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
+                        work_LED = work_LED << 1;
+                        writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
+                }
 
-                        /* put it back the way it was */
-                        writel(save_LED, ctrl->hpc_reg + LED_CONTROL);
+                /* put it back the way it was */
+                writel(save_LED, ctrl->hpc_reg + LED_CONTROL);
 
-                        set_SOGO(ctrl);
+                set_SOGO(ctrl);
 
-                        /* Wait for SOBS to be unset */
-                        wait_for_ctrl_irq (ctrl);
-                        break;
-                case 2:
-                        /* Do other stuff here! */
-                        break;
-                case 3:
-                        /* and more... */
-                        break;
+                /* Wait for SOBS to be unset */
+                wait_for_ctrl_irq (ctrl);
+                break;
+        case 2:
+                /* Do other stuff here! */
+                break;
+        case 3:
+                /* and more... */
+                break;
         }
         return 0;
 }
@@ -2312,9 +2322,9 @@ static u32 configure_new_device(struct controller * ctrl, struct pci_func * func
                 while ((function < max_functions) && (!stop_it)) {
                         pci_bus_read_config_dword (ctrl->pci_bus, PCI_DEVFN(func->device, function), 0x00, &ID);
 
-                        if (ID == 0xFFFFFFFF) {   /* There's nothing there. */
+                        if (ID == 0xFFFFFFFF) {
                                 function++;
-                        } else {  /* There's something there */
+                        } else {
                                 /* Setup slot structure. */
                                 new_slot = cpqhp_slot_create(func->bus);
 
@@ -2339,8 +2349,8 @@ static u32 configure_new_device(struct controller * ctrl, struct pci_func * func
 
 
 /*
-  Configuration logic that involves the hotplug data structures and 
-  their bookkeeping
+ * Configuration logic that involves the hotplug data structures and
+ * their bookkeeping
  */
 
 
@@ -2393,7 +2403,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
         if (rc)
                 return rc;
 
-        if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */
+        if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
                 /* set Primary bus */
                 dbg("set Primary bus = %d\n", func->bus);
                 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_PRIMARY_BUS, func->bus);
@@ -2484,7 +2494,8 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
                 temp_resources.irqs = &irqs;
 
                 /* Make copies of the nodes we are going to pass down so that
-                 * if there is a problem,we can just use these to free resources */
+                 * if there is a problem,we can just use these to free resources
+                 */
                 hold_bus_node = kmalloc(sizeof(*hold_bus_node), GFP_KERNEL);
                 hold_IO_node = kmalloc(sizeof(*hold_IO_node), GFP_KERNEL);
                 hold_mem_node = kmalloc(sizeof(*hold_mem_node), GFP_KERNEL);
@@ -2556,7 +2567,8 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
                 temp_word = (p_mem_node->base + p_mem_node->length - 1) >> 16;
                 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);
 
-                /* Adjust this to compensate for extra adjustment in first loop */
+                /* Adjust this to compensate for extra adjustment in first loop
+                 */
                 irqs.barber_pole--;
 
                 rc = 0;
@@ -2917,27 +2929,26 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
                 }               /* End of base register loop */
                 if (cpqhp_legacy_mode) {
                         /* Figure out which interrupt pin this function uses */
-                        rc = pci_bus_read_config_byte (pci_bus, devfn, 
+                        rc = pci_bus_read_config_byte (pci_bus, devfn,
                                 PCI_INTERRUPT_PIN, &temp_byte);
 
                         /* If this function needs an interrupt and we are behind
                          * a bridge and the pin is tied to something that's
                          * alread mapped, set this one the same */
-                        if (temp_byte && resources->irqs && 
-                            (resources->irqs->valid_INT & 
+                        if (temp_byte && resources->irqs &&
+                            (resources->irqs->valid_INT &
                              (0x01 << ((temp_byte + resources->irqs->barber_pole - 1) & 0x03)))) {
                                 /* We have to share with something already set up */
-                                IRQ = resources->irqs->interrupt[(temp_byte + 
+                                IRQ = resources->irqs->interrupt[(temp_byte +
                                         resources->irqs->barber_pole - 1) & 0x03];
                         } else {
                                 /* Program IRQ based on card type */
                                 rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
 
-                                if (class_code == PCI_BASE_CLASS_STORAGE) {
+                                if (class_code == PCI_BASE_CLASS_STORAGE)
                                         IRQ = cpqhp_disk_irq;
-                                } else {
+                                else
                                         IRQ = cpqhp_nic_irq;
-                                }
                         }
 
                         /* IRQ Line */