[PATCH] Compaq PCI Hotplug: fix C++ style comments

This is not C++! Fix comments from C++ style to C style, removing some useless
ones (e.g. no need to tell up and down protect a critical section).

drivers/pci/hotplug/cpqphp_ctrl.c

@@ -78,7 +78,7 @@ static void long_delay(int delay)
 }
 
 
-//FIXME: The following line needs to be somewhere else...
+/* FIXME: The following line needs to be somewhere else... */
 #define WRONG_BUS_FREQUENCY 0x07
 static u8 handle_switch_change(u8 change, struct controller * ctrl)
 {
@@ -91,19 +91,19 @@ static u8 handle_switch_change(u8 change, struct controller * ctrl)
 	if (!change)
 		return 0;
 
-	// Switch Change
+	/* Switch Change */
 	dbg("cpqsbd:  Switch interrupt received.\n");
 
 	for (hp_slot = 0; hp_slot < 6; hp_slot++) {
 		if (change & (0x1L << hp_slot)) {
-			//*********************************
-			// this one changed.
-			//*********************************
+			/**********************************
+			 * 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
+			/* this is the structure that tells the worker thread
+			 *what to do */
 			taskInfo = &(ctrl->event_queue[ctrl->next_event]);
 			ctrl->next_event = (ctrl->next_event + 1) % 10;
 			taskInfo->hp_slot = hp_slot;
@@ -115,17 +115,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
-				//*********************************
+				/**********************************
+				 * Switch opened
+				 **********************************/
 
 				func->switch_save = 0;
 
 				taskInfo->event_type = INT_SWITCH_OPEN;
 			} else {
-				//*********************************
-				// Switch closed
-				//*********************************
+				/**********************************
+				 * Switch closed
+				 **********************************/
 
 				func->switch_save = 0x10;
 
@@ -137,9 +137,10 @@ static u8 handle_switch_change(u8 change, struct controller * ctrl)
 	return rc;
 }
 
-
-/*
- * cpqhp_find_slot
+/**
+ * cpqhp_find_slot: find the struct slot of given device
+ * @ctrl: scan lots of this controller
+ * @device: the device id to find
  */
 struct slot *cpqhp_find_slot(struct controller *ctrl, u8 device)
 {
@@ -166,17 +167,17 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
 	if (!change)
 		return 0;
 
-	//*********************************
-	// Presence Change
-	//*********************************
+	/**********************************
+	 * 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.
-			//*********************************
+			/**********************************
+			 * this one changed.
+			 **********************************/
 			func = cpqhp_slot_find(ctrl->bus,
 				(hp_slot + ctrl->slot_device_offset), 0);
 
@@ -190,55 +191,51 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
 			if (!p_slot)
 				return 0;
 
-			// If the switch closed, must be a button
-			// If not in button mode, nevermind
+			/* If the switch closed, must be a button
+			 * 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)
-					//*********************************
+					/**************************************
+					 * 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!!!!
-					//*********************************
+					/**********************************
+					 * button Released - TAKE ACTION!!!!
+					 **********************************/
 					dbg("hp_slot %d button released\n", hp_slot);
 					taskInfo->event_type = INT_BUTTON_RELEASE;
 
-					// Cancel if we are still blinking
+					/* Cancel if we are still blinking */
 					if ((p_slot->state == BLINKINGON_STATE)
 					    || (p_slot->state == BLINKINGOFF_STATE)) {
 						taskInfo->event_type = INT_BUTTON_CANCEL;
 						dbg("hp_slot %d button cancel\n", hp_slot);
 					} else if ((p_slot->state == POWERON_STATE)
 						   || (p_slot->state == POWEROFF_STATE)) {
-						//info(msg_button_ignore, p_slot->number);
+						/* info(msg_button_ignore, p_slot->number); */
 						taskInfo->event_type = INT_BUTTON_IGNORE;
 						dbg("hp_slot %d button ignore\n", hp_slot);
 					}
 				}
 			} else {
-				// Switch is open, assume a presence change
-				// Save the presence state
+				/* Switch is open, assume a presence change
+				 * 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;
 
 				if ((!(ctrl->ctrl_int_comp & (0x010000 << hp_slot))) ||
 				    (!(ctrl->ctrl_int_comp & (0x01000000 << hp_slot)))) {
-					//*********************************
-					// Present
-					//*********************************
+					/* Present */
 					taskInfo->event_type = INT_PRESENCE_ON;
 				} else {
-					//*********************************
-					// Not Present
-					//*********************************
+					/* Not Present */
 					taskInfo->event_type = INT_PRESENCE_OFF;
 				}
 			}
@@ -259,17 +256,17 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
 	if (!change)
 		return 0;
 
-	//*********************************
-	// power fault
-	//*********************************
+	/**********************************
+	 * power fault
+	 **********************************/
 
 	info("power fault interrupt\n");
 
 	for (hp_slot = 0; hp_slot < 6; hp_slot++) {
 		if (change & (0x01 << hp_slot)) {
-			//*********************************
-			// this one changed.
-			//*********************************
+			/**********************************
+			 * this one changed.
+			 **********************************/
 			func = cpqhp_slot_find(ctrl->bus,
 				(hp_slot + ctrl->slot_device_offset), 0);
 
@@ -280,16 +277,16 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
 			rc++;
 
 			if (ctrl->ctrl_int_comp & (0x00000100 << hp_slot)) {
-				//*********************************
-				// power fault Cleared
-				//*********************************
+				/**********************************
+				 * power fault Cleared
+				 **********************************/
 				func->status = 0x00;
 
 				taskInfo->event_type = INT_POWER_FAULT_CLEAR;
 			} else {
-				//*********************************
-				// power fault
-				//*********************************
+				/**********************************
+				 * power fault
+				 **********************************/
 				taskInfo->event_type = INT_POWER_FAULT;
 
 				if (ctrl->rev < 4) {
@@ -297,18 +294,20 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
 					green_LED_off (ctrl, hp_slot);
 					set_SOGO (ctrl);
 
-					// this is a fatal condition, we want to crash the
-					// machine to protect from data corruption
-					// simulated_NMI shouldn't ever return
-					//FIXME
-					//simulated_NMI(hp_slot, ctrl);
-
-					//The following code causes a software crash just in
-					//case simulated_NMI did return
-					//FIXME
-					//panic(msg_power_fault);
+					/* this is a fatal condition, we want
+					 * to crash the machine to protect from
+					 * data corruption. simulated_NMI
+					 * shouldn't ever return */
+					/* FIXME
+					simulated_NMI(hp_slot, ctrl); */
+
+					/* The following code causes a software
+					 * crash just in case simulated_NMI did
+					 * return */
+					/*FIXME
+					panic(msg_power_fault); */
 				} else {
-					// set power fault status for this board
+					/* set power fault status for this board */
 					func->status = 0xFF;
 					info("power fault bit %x set\n", hp_slot);
 				}
@@ -340,7 +339,7 @@ static int sort_by_size(struct pci_resource **head)
 	while (out_of_order) {
 		out_of_order = 0;
 
-		// Special case for swapping list head
+		/* Special case for swapping list head */
 		if (((*head)->next) &&
 		    ((*head)->length > (*head)->next->length)) {
 			out_of_order++;
@@ -363,7 +362,7 @@ static int sort_by_size(struct pci_resource **head)
 			} else
 				current_res = current_res->next;
 		}
-	}  // End of out_of_order loop
+	}  /* End of out_of_order loop */
 
 	return 0;
 }
@@ -389,7 +388,7 @@ static int sort_by_max_size(struct pci_resource **head)
 	while (out_of_order) {
 		out_of_order = 0;
 
-		// Special case for swapping list head
+		/* Special case for swapping list head */
 		if (((*head)->next) &&
 		    ((*head)->length < (*head)->next->length)) {
 			out_of_order++;
@@ -412,7 +411,7 @@ static int sort_by_max_size(struct pci_resource **head)
 			} else
 				current_res = current_res->next;
 		}
-	}  // End of out_of_order loop
+	}  /* End of out_of_order loop */
 
 	return 0;
 }
@@ -447,15 +446,15 @@ static struct pci_resource *do_pre_bridge_resource_split(struct pci_resource **h
 		return NULL;
 
 
-	// If we got here, there the bridge requires some of the resource, but
-	// we may be able to split some off of the front
+	/* If we got here, there the bridge requires some of the resource, but
+	 * 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.
-		split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
+		/* this one isn't an aligned length, so we'll make a new entry
+		 * and split it up. */
+		split_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
 
 		if (!split_node)
 			return NULL;
@@ -468,16 +467,15 @@ static struct pci_resource *do_pre_bridge_resource_split(struct pci_resource **h
 		node->length -= temp_dword;
 		node->base += split_node->length;
 
-		// Put it in the list
+		/* Put it in the list */
 		*head = split_node;
 		split_node->next = node;
 	}
 
-	if (node->length < alignment) {
+	if (node->length < alignment)
 		return NULL;
-	}
 
-	// Now unlink it
+	/* Now unlink it */
 	if (*head == node) {
 		*head = node->next;
 		node->next = NULL;
@@ -527,7 +525,7 @@ static struct pci_resource *do_bridge_resource_split(struct pci_resource **head,
 	}
 
 	if (node->base & (alignment - 1)) {
-		// Short circuit if adjusted size is too small
+		/* Short circuit if adjusted size is too small */
 		temp_dword = (node->base | (alignment-1)) + 1;
 		if ((node->length - (temp_dword - node->base)) < alignment) {
 			kfree(node);
@@ -539,7 +537,7 @@ static struct pci_resource *do_bridge_resource_split(struct pci_resource **head,
 	}
 
 	if (node->length & (alignment - 1)) {
-		// There's stuff in use after this node
+		/* There's stuff in use after this node */
 		kfree(node);
 		return NULL;
 	}
@@ -579,11 +577,11 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
 			continue;
 
 		if (node->base & (size - 1)) {
-			// this one isn't base aligned properly
-			// so we'll make a new entry and split it up
+			/* this one isn't base aligned properly
+			 * 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
+			/* Short circuit if adjusted size is too small */
 			if ((node->length - (temp_dword - node->base)) < size)
 				continue;
 
@@ -597,15 +595,15 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
 			node->base = temp_dword;
 			node->length -= split_node->length;
 
-			// Put it in the list
+			/* Put it in the list */
 			split_node->next = node->next;
 			node->next = split_node;
-		} // End of non-aligned base
+		} /* End of non-aligned base */
 
-		// Don't need to check if too small since we already did
+		/* 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
+			/* this one is longer than we need
+			 * so we'll make a new entry and split it up */
 			split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
 
 			if (!split_node)
@@ -615,17 +613,17 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
 			split_node->length = node->length - size;
 			node->length = size;
 
-			// Put it in the list
+			/* Put it in the list */
 			split_node->next = node->next;
 			node->next = split_node;
-		}  // End of too big on top end
+		}  /* End of too big on top end */
 
-		// For IO make sure it's not in the ISA aliasing space
+		/* For IO make sure it's not in the ISA aliasing space */
 		if (node->base & 0x300L)
 			continue;
 
-		// If we got here, then it is the right size
-		// Now take it out of the list
+		/* If we got here, then it is the right size
+		 * Now take it out of the list and break */
 		if (*head == node) {
 			*head = node->next;
 		} else {
@@ -636,7 +634,6 @@ static struct pci_resource *get_io_resource(struct pci_resource **head, u32 size
 			prevnode->next = node->next;
 		}
 		node->next = NULL;
-		// Stop looping
 		break;
 	}
 
@@ -670,18 +667,17 @@ 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
+			/* this one isn't base aligned properly
+			 * 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
+			/* Short circuit if adjusted size is too small */
 			if ((max->length - (temp_dword - max->base)) < size)
 				continue;
 
@@ -695,15 +691,14 @@ static struct pci_resource *get_max_resource(struct pci_resource **head, u32 siz
 			max->base = temp_dword;
 			max->length -= split_node->length;
 
-			// Put it next in the list
 			split_node->next = max->next;
 			max->next = split_node;
 		}
 
 		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
-			split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
+			/* this one isn't end aligned properly at the top
+			 * so we'll make a new entry and split it up */
+			split_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
 
 			if (!split_node)
 				return NULL;
@@ -713,16 +708,15 @@ static struct pci_resource *get_max_resource(struct pci_resource **head, u32 siz
 					     - split_node->base;
 			max->length -= split_node->length;
 
-			// Put it in the list
 			split_node->next = max->next;
 			max->next = split_node;
 		}
 
-		// Make sure it didn't shrink too much when we aligned it
+		/* Make sure it didn't shrink too much when we aligned it */
 		if (max->length < size)
 			continue;
 
-		// Now take it out of the list
+		/* Now take it out of the list */
 		temp = (struct pci_resource*) *head;
 		if (temp == max) {
 			*head = max->next;
@@ -738,7 +732,7 @@ static struct pci_resource *get_max_resource(struct pci_resource **head, u32 siz
 		return max;
 	}
 
-	// If we get here, we couldn't find one
+	/* If we get here, we couldn't find one */
 	return NULL;
 }
 
@@ -778,11 +772,11 @@ static struct pci_resource *get_resource(struct pci_resource **head, u32 size)
 
 		if (node->base & (size - 1)) {
 			dbg("%s: not aligned\n", __FUNCTION__);
-			// this one isn't base aligned properly
-			// so we'll make a new entry and split it up
+			/* this one isn't base aligned properly
+			 * 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
+			/* Short circuit if adjusted size is too small */
 			if ((node->length - (temp_dword - node->base)) < size)
 				continue;
 
@@ -796,16 +790,15 @@ static struct pci_resource *get_resource(struct pci_resource **head, u32 size)
 			node->base = temp_dword;
 			node->length -= split_node->length;
 
-			// Put it in the list
 			split_node->next = node->next;
 			node->next = split_node;
-		} // End of non-aligned base
+		} /* End of non-aligned base */
 
-		// Don't need to check if too small since we already did
+		/* Don't need to check if too small since we already did */
 		if (node->length > size) {
 			dbg("%s: too big\n", __FUNCTION__);
-			// this one is longer than we need
-			// so we'll make a new entry and split it up
+			/* this one is longer than we need
+			 * so we'll make a new entry and split it up */
 			split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
 
 			if (!split_node)
@@ -815,14 +808,14 @@ static struct pci_resource *get_resource(struct pci_resource **head, u32 size)
 			split_node->length = node->length - size;
 			node->length = size;
 
-			// Put it in the list
+			/* Put it in the list */
 			split_node->next = node->next;
 			node->next = split_node;
-		}  // End of too big on top end
+		}  /* End of too big on top end */
 
 		dbg("%s: got one!!!\n", __FUNCTION__);
-		// If we got here, then it is the right size
-		// Now take it out of the list
+		/* If we got here, then it is the right size
+		 * Now take it out of the list */
 		if (*head == node) {
 			*head = node->next;
 		} else {
@@ -833,7 +826,6 @@ static struct pci_resource *get_resource(struct pci_resource **head, u32 size)
 			prevnode->next = node->next;
 		}
 		node->next = NULL;
-		// Stop looping
 		break;
 	}
 	return node;
@@ -871,7 +863,7 @@ int cpqhp_resource_sort_and_combine(struct pci_resource **head)
 	while (out_of_order) {
 		out_of_order = 0;
 
-		// Special case for swapping list head
+		/* Special case for swapping list head */
 		if (((*head)->next) &&
 		    ((*head)->base > (*head)->next->base)) {
 			node1 = *head;
@@ -894,13 +886,13 @@ int cpqhp_resource_sort_and_combine(struct pci_resource **head)
 			} else
 				node1 = node1->next;
 		}
-	}  // End of out_of_order loop
+	}  /* End of out_of_order loop */
 
 	node1 = *head;
 
 	while (node1 && node1->next) {
 		if ((node1->base + node1->length) == node1->next->base) {
-			// Combine
+			/* Combine */
 			dbg("8..\n");
 			node1->length += node1->next->length;
 			node2 = node1->next;
@@ -925,23 +917,23 @@ irqreturn_t cpqhp_ctrl_intr(int IRQ, void *data, struct pt_regs *regs)
 
 	
 	misc = readw(ctrl->hpc_reg + MISC);
-	//*********************************
-	// Check to see if it was our interrupt
-	//*********************************
+	/***************************************
+	 * Check to see if it was our interrupt
+	 ***************************************/
 	if (!(misc & 0x000C)) {
 		return IRQ_NONE;
 	}
 
 	if (misc & 0x0004) {
-		//*********************************
-		// Serial Output interrupt Pending
-		//*********************************
+		/**********************************
+		 * Serial Output interrupt Pending
+		 **********************************/
 
-		// Clear the interrupt
+		/* Clear the interrupt */
 		misc |= 0x0004;
 		writew(misc, ctrl->hpc_reg + MISC);
 
-		// Read to clear posted writes
+		/* Read to clear posted writes */
 		misc = readw(ctrl->hpc_reg + MISC);
 
 		dbg ("%s - waking up\n", __FUNCTION__);
@@ -949,21 +941,20 @@ irqreturn_t cpqhp_ctrl_intr(int IRQ, void *data, struct pt_regs *regs)
 	}
 
 	if (misc & 0x0008) {
-		// General-interrupt-input interrupt Pending
+		/* General-interrupt-input interrupt Pending */
 		Diff = readl(ctrl->hpc_reg + INT_INPUT_CLEAR) ^ ctrl->ctrl_int_comp;
 
 		ctrl->ctrl_int_comp = readl(ctrl->hpc_reg + INT_INPUT_CLEAR);
 
-		// Clear the interrupt
+		/* Clear the interrupt */
 		writel(Diff, ctrl->hpc_reg + INT_INPUT_CLEAR);
 
-		// Read it back to clear any posted writes
+		/* Read it back to clear any posted writes */
 		temp_dword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR);
 
-		if (!Diff) {
-			// Clear all interrupts
+		if (!Diff)
+			/* Clear all interrupts */
 			writel(0xFFFFFFFF, ctrl->hpc_reg + INT_INPUT_CLEAR);
-		}
 
 		schedule_flag += handle_switch_change((u8)(Diff & 0xFFL), ctrl);
 		schedule_flag += handle_presence_change((u16)((Diff & 0xFFFF0000L) >> 16), ctrl);
@@ -1001,8 +992,8 @@ struct pci_func *cpqhp_slot_create(u8 busnumber)
 	new_slot = (struct pci_func *) kmalloc(sizeof(struct pci_func), GFP_KERNEL);
 
 	if (new_slot == NULL) {
-		// I'm not dead yet!
-		// You will be.
+		/* I'm not dead yet!
+		 * You will be. */
 		return new_slot;
 	}
 
@@ -1149,11 +1140,11 @@ struct pci_func *cpqhp_slot_find(u8 bus, u8 device, u8 index)
 }
 
 
-// DJZ: I don't think is_bridge will work as is.
-//FIXME
+/* DJZ: I don't think is_bridge will work as is.
+ * FIXME */
 static int is_bridge(struct pci_func * func)
 {
-	// Check the header type
+	/* Check the header type */
 	if (((func->config_space[0x03] >> 16) & 0xFF) == 0x01)
 		return 1;
 	else
@@ -1320,36 +1311,35 @@ 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.
+		 **********************************/
 		rc = INTERLOCK_OPEN;
 	} else if (is_slot_enabled (ctrl, hp_slot)) {
-		//*********************************
-		// The board is already on
-		//*********************************
+		/**********************************
+		 * The board is already on
+		 **********************************/
 		rc = CARD_FUNCTIONING;
 	} else {
-		// Wait for exclusive access to hardware
 		down(&ctrl->crit_sect);
 
-		// turn on board without attaching to the bus
+		/* turn on board without attaching to the bus */
 		enable_slot_power (ctrl, hp_slot);
 
 		set_SOGO(ctrl);
 
-		// Wait for SOBS to be unset
+		/* Wait for SOBS to be unset */
 		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
+		/* Change bits in slot power register to force another shift out
+		 * 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);
 
 		set_SOGO(ctrl);
 
-		// Wait for SOBS to be unset
+		/* Wait for SOBS to be unset */
 		wait_for_ctrl_irq (ctrl);
 		
 		adapter_speed = get_adapter_speed(ctrl, hp_slot);
@@ -1357,21 +1347,19 @@ static u32 board_replaced(struct pci_func * func, struct controller * ctrl)
 			if (set_controller_speed(ctrl, adapter_speed, hp_slot))
 				rc = WRONG_BUS_FREQUENCY;
 
-		// turn off board without attaching to the bus
+		/* turn off board without attaching to the bus */
 		disable_slot_power (ctrl, hp_slot);
 
 		set_SOGO(ctrl);
 
-		// Wait for SOBS to be unset
+		/* Wait for SOBS to be unset */
 		wait_for_ctrl_irq (ctrl);
 
-		// Done with exclusive hardware access
 		up(&ctrl->crit_sect);
 
 		if (rc)
 			return rc;
 
-		// Wait for exclusive access to hardware
 		down(&ctrl->crit_sect);
 
 		slot_enable (ctrl, hp_slot);
@@ -1381,35 +1369,34 @@ static u32 board_replaced(struct pci_func * func, struct controller * ctrl)
 
 		set_SOGO(ctrl);
 
-		// Wait for SOBS to be unset
+		/* Wait for SOBS to be unset */
 		wait_for_ctrl_irq (ctrl);
 
-		// Done with exclusive hardware access
 		up(&ctrl->crit_sect);
 
-		// Wait for ~1 second because of hot plug spec
+		/* Wait for ~1 second because of hot plug spec */
 		long_delay(1*HZ);
 
-		// Check for a power fault
+		/* Check for a power fault */
 		if (func->status == 0xFF) {
-			// power fault occurred, but it was benign
+			/* power fault occurred, but it was benign */
 			rc = POWER_FAILURE;
 			func->status = 0;
 		} else
 			rc = cpqhp_valid_replace(ctrl, func);
 
 		if (!rc) {
-			// It must be the same board
+			/* It must be the same board */
 
 			rc = cpqhp_configure_board(ctrl, func);
 
 			if (rc || src) {
-				// If configuration fails, turn it off
-				// 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.
+				/* If configuration fails, turn it off
+				 * 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. */
 
-				// Wait for exclusive access to hardware
 				down(&ctrl->crit_sect);
 
 				amber_LED_on (ctrl, hp_slot);
@@ -1418,10 +1405,9 @@ static u32 board_replaced(struct pci_func * func, struct controller * ctrl)
 
 				set_SOGO(ctrl);
 
-				// Wait for SOBS to be unset
+				/* Wait for SOBS to be unset */
 				wait_for_ctrl_irq (ctrl);
 
-				// Done with exclusive hardware access
 				up(&ctrl->crit_sect);
 
 				if (rc)
@@ -1440,12 +1426,12 @@ static u32 board_replaced(struct pci_func * func, struct controller * ctrl)
 			}
 
 			if (rc) {
-				// If configuration fails, turn it off
-				// 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.
+				/* If configuration fails, turn it off
+				 * 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. */
 
-				// Wait for exclusive access to hardware
 				down(&ctrl->crit_sect);
 
 				amber_LED_on (ctrl, hp_slot);
@@ -1454,37 +1440,33 @@ static u32 board_replaced(struct pci_func * func, struct controller * ctrl)
 
 				set_SOGO(ctrl);
 
-				// Wait for SOBS to be unset
+				/* Wait for SOBS to be unset */
 				wait_for_ctrl_irq (ctrl);
 
-				// Done with exclusive hardware access
 				up(&ctrl->crit_sect);
 
 				return rc;
 			}
-			// Done configuring so turn LED on full time
+			/* Done configuring so turn LED on full time */
 
-			// Wait for exclusive access to hardware
 			down(&ctrl->crit_sect);
 
 			green_LED_on (ctrl, hp_slot);
 
 			set_SOGO(ctrl);
 
-			// Wait for SOBS to be unset
+			/* Wait for SOBS to be unset */
 			wait_for_ctrl_irq (ctrl);
 
-			// Done with exclusive hardware access
 			up(&ctrl->crit_sect);
 			rc = 0;
 		} else {
-			// Something is wrong
+			/* Something is wrong
 
-			// 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.
+			 * 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. */
 
-			// Wait for exclusive access to hardware
 			down(&ctrl->crit_sect);
 
 			amber_LED_on (ctrl, hp_slot);
@@ -1493,10 +1475,9 @@ static u32 board_replaced(struct pci_func * func, struct controller * ctrl)
 
 			set_SOGO(ctrl);
 
-			// Wait for SOBS to be unset
+			/* Wait for SOBS to be unset */
 			wait_for_ctrl_irq (ctrl);
 
-			// Done with exclusive hardware access
 			up(&ctrl->crit_sect);
 		}
 
@@ -1529,26 +1510,25 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 	dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n",
 	    __FUNCTION__, func->device, ctrl->slot_device_offset, hp_slot);
 
-	// Wait for exclusive access to hardware
 	down(&ctrl->crit_sect);
 
-	// turn on board without attaching to the bus
+	/* turn on board without attaching to the bus */
 	enable_slot_power(ctrl, hp_slot);
 
 	set_SOGO(ctrl);
 
-	// Wait for SOBS to be unset
+	/* Wait for SOBS to be unset */
 	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
+	/* Change bits in slot power register to force another shift out
+	 * 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);
 
 	set_SOGO(ctrl);
 
-	// Wait for SOBS to be unset
+	/* Wait for SOBS to be unset */
 	wait_for_ctrl_irq (ctrl);
 	
 	adapter_speed = get_adapter_speed(ctrl, hp_slot);
@@ -1556,15 +1536,14 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 		if (set_controller_speed(ctrl, adapter_speed, hp_slot))
 			rc = WRONG_BUS_FREQUENCY;
 	
-	// turn off board without attaching to the bus
+	/* turn off board without attaching to the bus */
 	disable_slot_power (ctrl, hp_slot);
 
 	set_SOGO(ctrl);
 
-	// Wait for SOBS to be unset
+	/* Wait for SOBS to be unset */
 	wait_for_ctrl_irq(ctrl);
 
-	// Done with exclusive hardware access
 	up(&ctrl->crit_sect);
 
 	if (rc)
@@ -1572,9 +1551,8 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 	
 	p_slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
 
-	// turn on board and blink green LED
+	/* turn on board and blink green LED */
 
-	// Wait for exclusive access to hardware
 	dbg("%s: before down\n", __FUNCTION__);
 	down(&ctrl->crit_sect);
 	dbg("%s: after down\n", __FUNCTION__);
@@ -1591,47 +1569,46 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 	dbg("%s: before set_SOGO\n", __FUNCTION__);
 	set_SOGO(ctrl);
 
-	// Wait for SOBS to be unset
+	/* Wait for SOBS to be unset */
 	dbg("%s: before wait_for_ctrl_irq\n", __FUNCTION__);
 	wait_for_ctrl_irq (ctrl);
 	dbg("%s: after wait_for_ctrl_irq\n", __FUNCTION__);
 
-	// Done with exclusive hardware access
 	dbg("%s: before up\n", __FUNCTION__);
 	up(&ctrl->crit_sect);
 	dbg("%s: after up\n", __FUNCTION__);
 
-	// Wait for ~1 second because of hot plug spec
+	/* Wait for ~1 second because of hot plug spec */
 	dbg("%s: before long_delay\n", __FUNCTION__);
 	long_delay(1*HZ);
 	dbg("%s: after long_delay\n", __FUNCTION__);
 
 	dbg("%s: func status = %x\n", __FUNCTION__, func->status);
-	// Check for a power fault
+	/* Check for a power fault */
 	if (func->status == 0xFF) {
-		// power fault occurred, but it was benign
+		/* power fault occurred, but it was benign */
 		temp_register = 0xFFFFFFFF;
 		dbg("%s: temp register set to %x by power fault\n", __FUNCTION__, temp_register);
 		rc = POWER_FAILURE;
 		func->status = 0;
 	} else {
-		// Get vendor/device ID u32
+		/* Get vendor/device ID u32 */
 		ctrl->pci_bus->number = func->bus;
 		rc = pci_bus_read_config_dword (ctrl->pci_bus, PCI_DEVFN(func->device, func->function), PCI_VENDOR_ID, &temp_register);
 		dbg("%s: pci_read_config_dword returns %d\n", __FUNCTION__, rc);
 		dbg("%s: temp_register is %x\n", __FUNCTION__, temp_register);
 
 		if (rc != 0) {
-			// Something's wrong here
+			/* Something's wrong here */
 			temp_register = 0xFFFFFFFF;
 			dbg("%s: temp register set to %x by error\n", __FUNCTION__, temp_register);
 		}
-		// Preset return code.  It will be changed later if things go okay.
+		/* Preset return code.  It will be changed later if things go okay. */
 		rc = NO_ADAPTER_PRESENT;
 	}
 
-	// All F's is an empty slot or an invalid board
-	if (temp_register != 0xFFFFFFFF) {	  // Check for a board in the slot
+	/* All F's is an empty slot or an invalid board */
+	if (temp_register != 0xFFFFFFFF) {	  /* Check for a board in the slot */
 		res_lists.io_head = ctrl->io_head;
 		res_lists.mem_head = ctrl->mem_head;
 		res_lists.p_mem_head = ctrl->p_mem_head;
@@ -1652,7 +1629,6 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 		cpqhp_resource_sort_and_combine(&(ctrl->bus_head));
 
 		if (rc) {
-			// Wait for exclusive access to hardware
 			down(&ctrl->crit_sect);
 
 			amber_LED_on (ctrl, hp_slot);
@@ -1661,10 +1637,9 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 
 			set_SOGO(ctrl);
 
-			// Wait for SOBS to be unset
+			/* Wait for SOBS to be unset */
 			wait_for_ctrl_irq (ctrl);
 
-			// Done with exclusive hardware access
 			up(&ctrl->crit_sect);
 			return rc;
 		} else {
@@ -1676,7 +1651,8 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 		func->switch_save = 0x10;
 		func->is_a_board = 0x01;
 
-		//next, we will instantiate the linux pci_dev structures (with appropriate driver notification, if already present)
+		/* next, we will instantiate the linux pci_dev structures (with
+		 * appropriate driver notification, if already present) */
 		dbg("%s: configure linux pci_dev structure\n", __FUNCTION__);
 		index = 0;
 		do {
@@ -1686,20 +1662,17 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 			}
 		} while (new_slot);
 
-		// Wait for exclusive access to hardware
 		down(&ctrl->crit_sect);
 
 		green_LED_on (ctrl, hp_slot);
 
 		set_SOGO(ctrl);
 
-		// Wait for SOBS to be unset
+		/* Wait for SOBS to be unset */
 		wait_for_ctrl_irq (ctrl);
 
-		// Done with exclusive hardware access
 		up(&ctrl->crit_sect);
 	} else {
-		// Wait for exclusive access to hardware
 		down(&ctrl->crit_sect);
 
 		amber_LED_on (ctrl, hp_slot);
@@ -1708,10 +1681,9 @@ static u32 board_added(struct pci_func * func, struct controller * ctrl)
 
 		set_SOGO(ctrl);
 
-		// Wait for SOBS to be unset
+		/* Wait for SOBS to be unset */
 		wait_for_ctrl_irq (ctrl);
 
-		// Done with exclusive hardware access
 		up(&ctrl->crit_sect);
 
 		return rc;
@@ -1746,15 +1718,15 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
 	hp_slot = func->device - ctrl->slot_device_offset;
 	dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot);
 
-	// When we get here, it is safe to change base Address Registers.
-	// We will attempt to save the base Address Register Lengths
+	/* When we get here, it is safe to change base address registers.
+	 * We will attempt to save the base address register lengths */
 	if (replace_flag || !ctrl->add_support)
 		rc = cpqhp_save_base_addr_length(ctrl, func);
 	else if (!func->bus_head && !func->mem_head &&
 		 !func->p_mem_head && !func->io_head) {
-		// Here we check to see if we've saved any of the board's
-		// resources already.  If so, we'll skip the attempt to
-		// determine what's being used.
+		/* Here we check to see if we've saved any of the board's
+		 * resources already.  If so, we'll skip the attempt to
+		 * determine what's being used. */
 		index = 0;
 		temp_func = cpqhp_slot_find(func->bus, func->device, index++);
 		while (temp_func) {
@@ -1769,12 +1741,11 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
 		if (!skip)
 			rc = cpqhp_save_used_resources(ctrl, func);
 	}
-	// Change status to shutdown
+	/* Change status to shutdown */
 	if (func->is_a_board)
 		func->status = 0x01;
 	func->configured = 0;
 
-	// Wait for exclusive access to hardware
 	down(&ctrl->crit_sect);
 
 	green_LED_off (ctrl, hp_slot);
@@ -1782,15 +1753,14 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
 
 	set_SOGO(ctrl);
 
-	// turn off SERR for slot
+	/* turn off SERR for slot */
 	temp_byte = readb(ctrl->hpc_reg + SLOT_SERR);
 	temp_byte &= ~(0x01 << hp_slot);
 	writeb(temp_byte, ctrl->hpc_reg + SLOT_SERR);
 
-	// Wait for SOBS to be unset
+	/* Wait for SOBS to be unset */
 	wait_for_ctrl_irq (ctrl);
 
-	// Done with exclusive hardware access
 	up(&ctrl->crit_sect);
 
 	if (!replace_flag && ctrl->add_support) {
@@ -1820,13 +1790,11 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
 			func = cpqhp_slot_find(ctrl->bus, device, 0);
 		}
 
-		// Setup slot structure with entry for empty slot
+		/* Setup slot structure with entry for empty slot */
 		func = cpqhp_slot_create(ctrl->bus);
 
-		if (func == NULL) {
-			// Out of memory
+		if (func == NULL)
 			return 1;
-		}
 
 		func->bus = ctrl->bus;
 		func->device = device;
@@ -1847,7 +1815,7 @@ static void pushbutton_helper_thread(unsigned long data)
 }
 
 
-// this is the main worker thread
+/* this is the main worker thread */
 static int event_thread(void* data)
 {
 	struct controller *ctrl;
@@ -1934,7 +1902,7 @@ static void interrupt_event_handler(struct controller *ctrl)
 		change = 0;
 
 		for (loop = 0; loop < 10; loop++) {
-			//dbg("loop %d\n", loop);
+			/* dbg("loop %d\n", loop); */
 			if (ctrl->event_queue[loop].event_type != 0) {
 				hp_slot = ctrl->event_queue[loop].hp_slot;
 
@@ -1956,17 +1924,14 @@ static void interrupt_event_handler(struct controller *ctrl)
 					dbg("button cancel\n");
 					del_timer(&p_slot->task_event);
 
-					// Wait for exclusive access to hardware
 					down(&ctrl->crit_sect);
 
 					if (p_slot->state == BLINKINGOFF_STATE) {
-						// slot is on
-						// turn on green LED
+						/* slot is on */
 						dbg("turn on green LED\n");
 						green_LED_on (ctrl, hp_slot);
 					} else if (p_slot->state == BLINKINGON_STATE) {
-						// slot is off
-						// turn off green LED
+						/* slot is off */
 						dbg("turn off green LED\n");
 						green_LED_off (ctrl, hp_slot);
 					}
@@ -1979,28 +1944,24 @@ static void interrupt_event_handler(struct controller *ctrl)
 
 					set_SOGO(ctrl);
 
-					// Wait for SOBS to be unset
+					/* Wait for SOBS to be unset */
 					wait_for_ctrl_irq (ctrl);
 
-					// Done with exclusive hardware access
 					up(&ctrl->crit_sect);
 				}
-				// ***********button Released (No action on press...)
+				/*** button Released (No action on press...) */
 				else if (ctrl->event_queue[loop].event_type == INT_BUTTON_RELEASE) {
 					dbg("button release\n");
 
 					if (is_slot_enabled (ctrl, hp_slot)) {
-						// slot is on
 						dbg("slot is on\n");
 						p_slot->state = BLINKINGOFF_STATE;
 						info(msg_button_off, p_slot->number);
 					} else {
-						// slot is off
 						dbg("slot is off\n");
 						p_slot->state = BLINKINGON_STATE;
 						info(msg_button_on, p_slot->number);
 					}
-					// Wait for exclusive access to hardware
 					down(&ctrl->crit_sect);
 					
 					dbg("blink green LED and turn off amber\n");
@@ -2010,23 +1971,22 @@ static void interrupt_event_handler(struct controller *ctrl)
 					
 					set_SOGO(ctrl);
 
-					// Wait for SOBS to be unset
+					/* Wait for SOBS to be unset */
 					wait_for_ctrl_irq (ctrl);
 
-					// Done with exclusive hardware access
 					up(&ctrl->crit_sect);
 					init_timer(&p_slot->task_event);
 					p_slot->hp_slot = hp_slot;
 					p_slot->ctrl = ctrl;
-//					p_slot->physical_slot = physical_slot;
-					p_slot->task_event.expires = jiffies + 5 * HZ;   // 5 second delay
+/*					p_slot->physical_slot = physical_slot; */
+					p_slot->task_event.expires = jiffies + 5 * HZ;   /* 5 second delay */
 					p_slot->task_event.function = pushbutton_helper_thread;
 					p_slot->task_event.data = (u32) p_slot;
 
 					dbg("add_timer p_slot = %p\n", p_slot);
 					add_timer(&p_slot->task_event);
 				}
-				// ***********POWER FAULT
+				/***********POWER FAULT */
 				else if (ctrl->event_queue[loop].event_type == INT_POWER_FAULT) {
 					dbg("power fault\n");
 				} else {
@@ -2039,7 +1999,7 @@ static void interrupt_event_handler(struct controller *ctrl)
 
 				change = 1;
 			}
-		}		// End of FOR loop
+		}		/* End of FOR loop */
 	}
 
 	return;
@@ -2068,7 +2028,7 @@ void cpqhp_pushbutton_thread (unsigned long slot)
 
 	if (is_slot_enabled (ctrl, hp_slot)) {
 		p_slot->state = POWEROFF_STATE;
-		// power Down board
+		/* power Down board */
 		func = cpqhp_slot_find(p_slot->bus, p_slot->device, 0);
 		dbg("In power_down_board, func = %p, ctrl = %p\n", func, ctrl);
 		if (!func) {
@@ -2083,7 +2043,7 @@ void cpqhp_pushbutton_thread (unsigned long slot)
 				
 				set_SOGO(ctrl);
 
-				// Wait for SOBS to be unset
+				/* Wait for SOBS to be unset */
 				wait_for_ctrl_irq (ctrl);
 			}
 		}
@@ -2091,7 +2051,7 @@ void cpqhp_pushbutton_thread (unsigned long slot)
 		p_slot->state = STATIC_STATE;
 	} else {
 		p_slot->state = POWERON_STATE;
-		// slot is off
+		/* slot is off */
 
 		func = cpqhp_slot_find(p_slot->bus, p_slot->device, 0);
 		dbg("In add_board, func = %p, ctrl = %p\n", func, ctrl);
@@ -2107,7 +2067,7 @@ void cpqhp_pushbutton_thread (unsigned long slot)
 				
 				set_SOGO(ctrl);
 
-				// Wait for SOBS to be unset
+				/* Wait for SOBS to be unset */
 				wait_for_ctrl_irq (ctrl);
 			}
 		}
@@ -2136,11 +2096,10 @@ int cpqhp_process_SI (struct controller *ctrl, struct pci_func *func)
 	device = func->device;
 	hp_slot = device - ctrl->slot_device_offset;
 	p_slot = cpqhp_find_slot(ctrl, device);
-	if (p_slot) {
+	if (p_slot)
 		physical_slot = p_slot->number;
-	}
 
-	// Check to see if the interlock is closed
+	/* Check to see if the interlock is closed */
 	tempdword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR);
 
 	if (tempdword & (0x01 << hp_slot)) {
@@ -2150,13 +2109,12 @@ int cpqhp_process_SI (struct controller *ctrl, struct pci_func *func)
 	if (func->is_a_board) {
 		rc = board_replaced(func, ctrl);
 	} else {
-		// add board
+		/* add board */
 		slot_remove(func);
 
 		func = cpqhp_slot_create(ctrl->bus);
-		if (func == NULL) {
+		if (func == NULL)
 			return 1;
-		}
 
 		func->bus = ctrl->bus;
 		func->device = device;
@@ -2164,7 +2122,7 @@ int cpqhp_process_SI (struct controller *ctrl, struct pci_func *func)
 		func->configured = 0;
 		func->is_a_board = 1;
 
-		// We have to save the presence info for these slots
+		/* We have to save the presence info for these slots */
 		temp_word = ctrl->ctrl_int_comp >> 16;
 		func->presence_save = (temp_word >> hp_slot) & 0x01;
 		func->presence_save |= (temp_word >> (hp_slot + 7)) & 0x02;
@@ -2182,13 +2140,11 @@ int cpqhp_process_SI (struct controller *ctrl, struct pci_func *func)
 			} else
 				slot_remove(func);
 
-			// Setup slot structure with entry for empty slot
+			/* Setup slot structure with entry for empty slot */
 			func = cpqhp_slot_create(ctrl->bus);
 
-			if (func == NULL) {
-				// Out of memory
+			if (func == NULL)
 				return 1;
-			}
 
 			func->bus = ctrl->bus;
 			func->device = device;
@@ -2196,7 +2152,7 @@ int cpqhp_process_SI (struct controller *ctrl, struct pci_func *func)
 			func->configured = 0;
 			func->is_a_board = 0;
 
-			// We have to save the presence info for these slots
+			/* We have to save the presence info for these slots */
 			temp_word = ctrl->ctrl_int_comp >> 16;
 			func->presence_save = (temp_word >> hp_slot) & 0x01;
 			func->presence_save |=
@@ -2239,12 +2195,12 @@ int cpqhp_process_SS (struct controller *ctrl, struct pci_func *func)
 		physical_slot = p_slot->number;
 	}
 
-	// Make sure there are no video controllers here
+	/* Make sure there are no video controllers here */
 	while (func && !rc) {
 		pci_bus->number = func->bus;
 		devfn = PCI_DEVFN(func->device, func->function);
 
-		// Check the Class Code
+		/* Check the Class Code */
 		rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
 		if (rc)
 			return rc;
@@ -2253,18 +2209,19 @@ int cpqhp_process_SS (struct controller *ctrl, struct pci_func *func)
 			/* Display/Video adapter (not supported) */
 			rc = REMOVE_NOT_SUPPORTED;
 		} else {
-			// See if it's a bridge
+			/* See if it's a bridge */
 			rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type);
 			if (rc)
 				return rc;
 
-			// If it's a bridge, check the VGA Enable bit
+			/* 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 rc;
 
-				// If the VGA Enable bit is set, remove isn't supported
+				/* If the VGA Enable bit is set, remove isn't
+				 * supported */
 				if (BCR & PCI_BRIDGE_CTL_VGA) {
 					rc = REMOVE_NOT_SUPPORTED;
 				}
@@ -2276,7 +2233,7 @@ int cpqhp_process_SS (struct controller *ctrl, struct pci_func *func)
 
 	func = cpqhp_slot_find(ctrl->bus, device, 0);
 	if ((func != NULL) && !rc) {
-		//FIXME: Replace flag should be passed into process_SS
+		/* FIXME: Replace flag should be passed into process_SS */
 		replace_flag = !(ctrl->add_support);
 		rc = remove_board(func, replace_flag, ctrl);
 	} else if (!rc) {
@@ -2341,7 +2298,6 @@ int cpqhp_hardware_test(struct controller *ctrl, int test_num)
 			/* so we can restore them later */
 			save_LED = readl(ctrl->hpc_reg + LED_CONTROL);
 			work_LED = 0x01010101;
-			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);
 			switch_leds(ctrl, num_of_slots, &work_LED, 0);
@@ -2361,20 +2317,20 @@ int cpqhp_hardware_test(struct controller *ctrl, int test_num)
 			for (loop = 0; loop < num_of_slots; loop++) {
 				set_SOGO(ctrl);
 
-				// Wait for SOGO interrupt
+				/* Wait for SOGO interrupt */
 				wait_for_ctrl_irq (ctrl);
 
-				// Get ready for next iteration
+				/* 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);
 
-				// Wait for SOGO interrupt
+				/* Wait for SOGO interrupt */
 				wait_for_ctrl_irq (ctrl);
 
-				// Get ready for next iteration
+				/* Get ready for next iteration */
 				long_delay((3*HZ)/10);
 				work_LED = work_LED << 16;
 				writel(work_LED, ctrl->hpc_reg + LED_CONTROL);
@@ -2387,14 +2343,14 @@ int cpqhp_hardware_test(struct controller *ctrl, int test_num)
 
 			set_SOGO(ctrl);
 
-			// Wait for SOBS to be unset
+			/* Wait for SOBS to be unset */
 			wait_for_ctrl_irq (ctrl);
 			break;
 		case 2:
-			// Do other stuff here!
+			/* Do other stuff here! */
 			break;
 		case 3:
-			// and more...
+			/* and more... */
 			break;
 	}
 	return 0;
@@ -2424,7 +2380,7 @@ static u32 configure_new_device (struct controller * ctrl, struct pci_func * fun
 	new_slot = func;
 
 	dbg("%s\n", __FUNCTION__);
-	// Check for Multi-function device
+	/* Check for Multi-function device */
 	ctrl->pci_bus->number = func->bus;
 	rc = pci_bus_read_config_byte (ctrl->pci_bus, PCI_DEVFN(func->device, func->function), 0x0E, &temp_byte);
 	if (rc) {
@@ -2432,7 +2388,7 @@ static u32 configure_new_device (struct controller * ctrl, struct pci_func * fun
 		return rc;
 	}
 
-	if (temp_byte & 0x80)	// Multi-function device
+	if (temp_byte & 0x80)	/* Multi-function device */
 		max_functions = 8;
 	else
 		max_functions = 1;
@@ -2460,22 +2416,20 @@ static u32 configure_new_device (struct controller * ctrl, struct pci_func * fun
 
 		stop_it = 0;
 
-		//  The following loop skips to the next present function
-		//  and creates a board structure
+		/* The following loop skips to the next present function
+		 * and creates a board structure */
 
 		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) {	  /* There's nothing there. */
 				function++;
-			} else {  // There's something there
-				// Setup slot structure.
+			} else {  /* There's something there */
+				/* Setup slot structure. */
 				new_slot = cpqhp_slot_create(func->bus);
 
-				if (new_slot == NULL) {
-					// Out of memory
+				if (new_slot == NULL)
 					return 1;
-				}
 
 				new_slot->bus = func->bus;
 				new_slot->device = func->device;
@@ -2546,41 +2500,41 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 	pci_bus->number = func->bus;
 	devfn = PCI_DEVFN(func->device, func->function);
 
-	// Check for Bridge
+	/* Check for Bridge */
 	rc = pci_bus_read_config_byte(pci_bus, devfn, PCI_HEADER_TYPE, &temp_byte);
 	if (rc)
 		return rc;
 
-	if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { // PCI-PCI Bridge
-		// set Primary bus
+	if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI 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);
 		if (rc)
 			return rc;
 
-		// find range of busses to use
+		/* find range of busses to use */
 		dbg("find ranges of buses to use\n");
 		bus_node = get_max_resource(&resources->bus_head, 1);
 
-		// If we don't have any busses to allocate, we can't continue
+		/* If we don't have any busses to allocate, we can't continue */
 		if (!bus_node)
 			return -ENOMEM;
 
-		// set Secondary bus
+		/* set Secondary bus */
 		temp_byte = bus_node->base;
 		dbg("set Secondary bus = %d\n", bus_node->base);
 		rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, temp_byte);
 		if (rc)
 			return rc;
 
-		// set subordinate bus
+		/* set subordinate bus */
 		temp_byte = bus_node->base + bus_node->length - 1;
 		dbg("set subordinate bus = %d\n", bus_node->base + bus_node->length - 1);
 		rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte);
 		if (rc)
 			return rc;
 
-		// set subordinate Latency Timer and base Latency Timer
+		/* set subordinate Latency Timer and base Latency Timer */
 		temp_byte = 0x40;
 		rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SEC_LATENCY_TIMER, temp_byte);
 		if (rc)
@@ -2589,14 +2543,13 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 		if (rc)
 			return rc;
 
-		// set Cache Line size
+		/* set Cache Line size */
 		temp_byte = 0x08;
 		rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_CACHE_LINE_SIZE, temp_byte);
 		if (rc)
 			return rc;
 
-		// Setup the IO, memory, and prefetchable windows
-
+		/* Setup the IO, memory, and prefetchable windows */
 		io_node = get_max_resource(&(resources->io_head), 0x1000);
 		if (!io_node)
 			return -ENOMEM;
@@ -2617,7 +2570,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 		dbg("(base, len, next) (%x, %x, %p)\n", p_mem_node->base,
 					p_mem_node->length, p_mem_node->next);
 
-		// set up the IRQ info
+		/* set up the IRQ info */
 		if (!resources->irqs) {
 			irqs.barber_pole = 0;
 			irqs.interrupt[0] = 0;
@@ -2634,16 +2587,16 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			irqs.valid_INT = resources->irqs->valid_INT;
 		}
 
-		// set up resource lists that are now aligned on top and bottom
-		// for anything behind the bridge.
+		/* set up resource lists that are now aligned on top and bottom
+		 * for anything behind the bridge. */
 		temp_resources.bus_head = bus_node;
 		temp_resources.io_head = io_node;
 		temp_resources.mem_head = mem_node;
 		temp_resources.p_mem_head = p_mem_node;
 		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
+		/* 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 */
 		hold_bus_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
 		hold_IO_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
 		hold_mem_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
@@ -2674,7 +2627,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			memcpy(hold_IO_node, io_node, sizeof(struct pci_resource));
 			io_node->next = NULL;
 
-			// set IO base and Limit registers
+			/* set IO base and Limit registers */
 			temp_byte = io_node->base >> 8;
 			rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_BASE, temp_byte);
 
@@ -2685,14 +2638,14 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			hold_IO_node = NULL;
 		}
 
-		/* If we have memory resources copy them and fill in the bridge's
-		 * memory range registers.  Otherwise, fill in the range
-		 * registers with values that disable them. */
+		/* If we have memory resources copy them and fill in the
+		 * bridge's memory range registers.  Otherwise, fill in the
+		 * range registers with values that disable them. */
 		if (mem_node) {
 			memcpy(hold_mem_node, mem_node, sizeof(struct pci_resource));
 			mem_node->next = NULL;
 
-			// set Mem base and Limit registers
+			/* set Mem base and Limit registers */
 			temp_word = mem_node->base >> 16;
 			rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word);
 
@@ -2716,7 +2669,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			memcpy(hold_p_mem_node, p_mem_node, sizeof(struct pci_resource));
 			p_mem_node->next = NULL;
 
-			// set Pre Mem base and Limit registers
+			/* set Pre Mem base and Limit registers */
 			temp_word = p_mem_node->base >> 16;
 			rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word);
 
@@ -2733,12 +2686,12 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			hold_p_mem_node = NULL;
 		}
 
-		// 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;
 
-		// Here we actually find the devices and configure them
+		/* Here we actually find the devices and configure them */
 		for (device = 0; (device <= 0x1F) && !rc; device++) {
 			irqs.barber_pole = (irqs.barber_pole + 1) & 0x03;
 
@@ -2747,12 +2700,11 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			pci_bus_read_config_dword (pci_bus, PCI_DEVFN(device, 0), 0x00, &ID);
 			pci_bus->number = func->bus;
 
-			if (ID != 0xFFFFFFFF) {	  //  device Present
-				// Setup slot structure.
+			if (ID != 0xFFFFFFFF) {	  /*  device present */
+				/* Setup slot structure. */
 				new_slot = cpqhp_slot_create(hold_bus_node->base);
 
 				if (new_slot == NULL) {
-					// Out of memory
 					rc = -ENOMEM;
 					continue;
 				}
@@ -2765,8 +2717,8 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 				rc = configure_new_device(ctrl, new_slot, 1, &temp_resources);
 				dbg("configure_new_device rc=0x%x\n",rc);
-			}	// End of IF (device in slot?)
-		}		// End of FOR loop
+			}	/* End of IF (device in slot?) */
+		}		/* End of FOR loop */
 
 		if (rc) {
 			cpqhp_destroy_resource_list(&temp_resources);
@@ -2777,7 +2729,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			return_resource(&(resources->p_mem_head), hold_p_mem_node);
 			return rc;
 		}
-		// save the interrupt routing information
+		/* save the interrupt routing information */
 		if (resources->irqs) {
 			resources->irqs->interrupt[0] = irqs.interrupt[0];
 			resources->irqs->interrupt[1] = irqs.interrupt[1];
@@ -2785,7 +2737,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			resources->irqs->interrupt[3] = irqs.interrupt[3];
 			resources->irqs->valid_INT = irqs.valid_INT;
 		} else if (!behind_bridge) {
-			// We need to hook up the interrupts here
+			/* We need to hook up the interrupts here */
 			for (cloop = 0; cloop < 4; cloop++) {
 				if (irqs.valid_INT & (0x01 << cloop)) {
 					rc = cpqhp_set_irq(func->bus, func->device,
@@ -2800,10 +2752,11 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 						return rc;
 					}
 				}
-			}	// end of for loop
+			}	/* end of for loop */
 		}
-		// Return unused bus resources
-		// First use the temporary node to store information for the board
+		/* Return unused bus resources
+		 * First use the temporary node to store information for
+		 * the board */
 		if (hold_bus_node && bus_node && temp_resources.bus_head) {
 			hold_bus_node->length = bus_node->base - hold_bus_node->base;
 
@@ -2812,7 +2765,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 			temp_byte = temp_resources.bus_head->base - 1;
 
-			// set subordinate bus
+			/* set subordinate bus */
 			rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte);
 
 			if (temp_resources.bus_head->length == 0) {
@@ -2823,13 +2776,13 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			}
 		}
 
-		// If we have IO space available and there is some left,
-		// return the unused portion
+		/* If we have IO space available and there is some left,
+		 * return the unused portion */
 		if (hold_IO_node && temp_resources.io_head) {
 			io_node = do_pre_bridge_resource_split(&(temp_resources.io_head),
 							       &hold_IO_node, 0x1000);
 
-			// Check if we were able to split something off
+			/* Check if we were able to split something off */
 			if (io_node) {
 				hold_IO_node->base = io_node->base + io_node->length;
 
@@ -2841,12 +2794,13 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 			io_node = do_bridge_resource_split(&(temp_resources.io_head), 0x1000);
 
-			// Check if we were able to split something off
+			/* Check if we were able to split something off */
 			if (io_node) {
-				// First use the temporary node to store information for the board
+				/* First use the temporary node to store
+				 * information for the board */
 				hold_IO_node->length = io_node->base - hold_IO_node->base;
 
-				// If we used any, add it to the board's list
+				/* If we used any, add it to the board's list */
 				if (hold_IO_node->length) {
 					hold_IO_node->next = func->io_head;
 					func->io_head = hold_IO_node;
@@ -2856,7 +2810,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 					return_resource(&(resources->io_head), io_node);
 				} else {
-					// it doesn't need any IO
+					/* it doesn't need any IO */
 					temp_word = 0x0000;
 					rc = pci_bus_write_config_word (pci_bus, devfn, PCI_IO_LIMIT, temp_word);
 
@@ -2864,22 +2818,22 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					kfree(hold_IO_node);
 				}
 			} else {
-				// it used most of the range
+				/* it used most of the range */
 				hold_IO_node->next = func->io_head;
 				func->io_head = hold_IO_node;
 			}
 		} else if (hold_IO_node) {
-			// it used the whole range
+			/* it used the whole range */
 			hold_IO_node->next = func->io_head;
 			func->io_head = hold_IO_node;
 		}
-		// If we have memory space available and there is some left,
-		// return the unused portion
+		/* If we have memory space available and there is some left,
+		 * return the unused portion */
 		if (hold_mem_node && temp_resources.mem_head) {
 			mem_node = do_pre_bridge_resource_split(&(temp_resources.  mem_head),
 								&hold_mem_node, 0x100000);
 
-			// Check if we were able to split something off
+			/* Check if we were able to split something off */
 			if (mem_node) {
 				hold_mem_node->base = mem_node->base + mem_node->length;
 
@@ -2891,23 +2845,24 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 			mem_node = do_bridge_resource_split(&(temp_resources.mem_head), 0x100000);
 
-			// Check if we were able to split something off
+			/* Check if we were able to split something off */
 			if (mem_node) {
-				// First use the temporary node to store information for the board
+				/* First use the temporary node to store
+				 * information for the board */
 				hold_mem_node->length = mem_node->base - hold_mem_node->base;
 
 				if (hold_mem_node->length) {
 					hold_mem_node->next = func->mem_head;
 					func->mem_head = hold_mem_node;
 
-					// configure end address
+					/* configure end address */
 					temp_word = (mem_node->base - 1) >> 16;
 					rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word);
 
-					// Return unused resources to the pool
+					/* Return unused resources to the pool */
 					return_resource(&(resources->mem_head), mem_node);
 				} else {
-					// it doesn't need any Mem
+					/* it doesn't need any Mem */
 					temp_word = 0x0000;
 					rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word);
 
@@ -2915,22 +2870,22 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					kfree(hold_mem_node);
 				}
 			} else {
-				// it used most of the range
+				/* it used most of the range */
 				hold_mem_node->next = func->mem_head;
 				func->mem_head = hold_mem_node;
 			}
 		} else if (hold_mem_node) {
-			// it used the whole range
+			/* it used the whole range */
 			hold_mem_node->next = func->mem_head;
 			func->mem_head = hold_mem_node;
 		}
-		// If we have prefetchable memory space available and there is some 
-		// left at the end, return the unused portion
+		/* If we have prefetchable memory space available and there
+		 * is some left at the end, return the unused portion */
 		if (hold_p_mem_node && temp_resources.p_mem_head) {
 			p_mem_node = do_pre_bridge_resource_split(&(temp_resources.p_mem_head),
 								  &hold_p_mem_node, 0x100000);
 
-			// Check if we were able to split something off
+			/* Check if we were able to split something off */
 			if (p_mem_node) {
 				hold_p_mem_node->base = p_mem_node->base + p_mem_node->length;
 
@@ -2942,12 +2897,13 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 			p_mem_node = do_bridge_resource_split(&(temp_resources.p_mem_head), 0x100000);
 
-			// Check if we were able to split something off
+			/* Check if we were able to split something off */
 			if (p_mem_node) {
-				// First use the temporary node to store information for the board
+				/* First use the temporary node to store
+				 * information for the board */
 				hold_p_mem_node->length = p_mem_node->base - hold_p_mem_node->base;
 
-				// If we used any, add it to the board's list
+				/* If we used any, add it to the board's list */
 				if (hold_p_mem_node->length) {
 					hold_p_mem_node->next = func->p_mem_head;
 					func->p_mem_head = hold_p_mem_node;
@@ -2957,7 +2913,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 					return_resource(&(resources->p_mem_head), p_mem_node);
 				} else {
-					// it doesn't need any PMem
+					/* it doesn't need any PMem */
 					temp_word = 0x0000;
 					rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);
 
@@ -2965,12 +2921,12 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					kfree(hold_p_mem_node);
 				}
 			} else {
-				// it used the most of the range
+				/* it used the most of the range */
 				hold_p_mem_node->next = func->p_mem_head;
 				func->p_mem_head = hold_p_mem_node;
 			}
 		} else if (hold_p_mem_node) {
-			// it used the whole range
+			/* it used the whole range */
 			hold_p_mem_node->next = func->p_mem_head;
 			func->p_mem_head = hold_p_mem_node;
 		}
@@ -2978,7 +2934,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 		 * registers if it needs them.  Although we have never seen such
 		 * a device */
 
-		// enable card
+		/* enable card */
 		command = 0x0157;	/* = PCI_COMMAND_IO |
 					 *   PCI_COMMAND_MEMORY |
 					 *   PCI_COMMAND_MASTER |
@@ -2987,20 +2943,20 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					 *   PCI_COMMAND_SERR */
 		rc = pci_bus_write_config_word (pci_bus, devfn, PCI_COMMAND, command);
 
-		// set Bridge Control Register
+		/* set Bridge Control Register */
 		command = 0x07;		/* = PCI_BRIDGE_CTL_PARITY |
 					 *   PCI_BRIDGE_CTL_SERR |
 					 *   PCI_BRIDGE_CTL_NO_ISA */
 		rc = pci_bus_write_config_word (pci_bus, devfn, PCI_BRIDGE_CONTROL, command);
 	} else if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_NORMAL) {
-		// Standard device
+		/* Standard device */
 		rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
 
 		if (class_code == PCI_BASE_CLASS_DISPLAY) {
-			// Display (video) adapter (not supported)
+			/* Display (video) adapter (not supported) */
 			return DEVICE_TYPE_NOT_SUPPORTED;
 		}
-		// Figure out IO and memory needs
+		/* Figure out IO and memory needs */
 		for (cloop = 0x10; cloop <= 0x24; cloop += 4) {
 			temp_register = 0xFFFFFFFF;
 
@@ -3010,11 +2966,11 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			rc = pci_bus_read_config_dword (pci_bus, devfn, cloop, &temp_register);
 			dbg("CND: base = 0x%x\n", temp_register);
 
-			if (temp_register) {	  // If this register is implemented
+			if (temp_register) {	  /* If this register is implemented */
 				if ((temp_register & 0x03L) == 0x01) {
-					// Map IO
+					/* Map IO */
 
-					// set base = amount of IO space
+					/* set base = amount of IO space */
 					base = temp_register & 0xFFFFFFFC;
 					base = ~base + 1;
 
@@ -3024,7 +2980,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					    io_node->base, io_node->length, io_node->next);
 					dbg("func (%p) io_head (%p)\n", func, func->io_head);
 
-					// allocate the resource to the board
+					/* allocate the resource to the board */
 					if (io_node) {
 						base = io_node->base;
 
@@ -3033,14 +2989,14 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					} else
 						return -ENOMEM;
 				} else if ((temp_register & 0x0BL) == 0x08) {
-					// Map prefetchable memory
+					/* Map prefetchable memory */
 					base = temp_register & 0xFFFFFFF0;
 					base = ~base + 1;
 
 					dbg("CND:      length = 0x%x\n", base);
 					p_mem_node = get_resource(&(resources->p_mem_head), base);
 
-					// allocate the resource to the board
+					/* allocate the resource to the board */
 					if (p_mem_node) {
 						base = p_mem_node->base;
 
@@ -3049,14 +3005,14 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					} else
 						return -ENOMEM;
 				} else if ((temp_register & 0x0BL) == 0x00) {
-					// Map memory
+					/* Map memory */
 					base = temp_register & 0xFFFFFFF0;
 					base = ~base + 1;
 
 					dbg("CND:      length = 0x%x\n", base);
 					mem_node = get_resource(&(resources->mem_head), base);
 
-					// allocate the resource to the board
+					/* allocate the resource to the board */
 					if (mem_node) {
 						base = mem_node->base;
 
@@ -3065,14 +3021,14 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					} else
 						return -ENOMEM;
 				} else if ((temp_register & 0x0BL) == 0x04) {
-					// Map memory
+					/* Map memory */
 					base = temp_register & 0xFFFFFFF0;
 					base = ~base + 1;
 
 					dbg("CND:      length = 0x%x\n", base);
 					mem_node = get_resource(&(resources->mem_head), base);
 
-					// allocate the resource to the board
+					/* allocate the resource to the board */
 					if (mem_node) {
 						base = mem_node->base;
 
@@ -3081,42 +3037,44 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					} else
 						return -ENOMEM;
 				} else if ((temp_register & 0x0BL) == 0x06) {
-					// Those bits are reserved, we can't handle this
+					/* Those bits are reserved, we can't handle this */
 					return 1;
 				} else {
-					// Requesting space below 1M
+					/* Requesting space below 1M */
 					return NOT_ENOUGH_RESOURCES;
 				}
 
 				rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base);
 
-				// Check for 64-bit base
+				/* Check for 64-bit base */
 				if ((temp_register & 0x07L) == 0x04) {
 					cloop += 4;
 
-					// Upper 32 bits of address always zero on today's systems
-					// FIXME this is probably not true on Alpha and ia64???
+					/* Upper 32 bits of address always zero
+					 * on today's systems */
+					/* FIXME this is probably not true on
+					 * Alpha and ia64??? */
 					base = 0;
 					rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base);
 				}
 			}
-		}		// End of base register loop
+		}		/* End of base register loop */
 		if (cpqhp_legacy_mode) {
-			// Figure out which interrupt pin this function uses
+			/* Figure out which interrupt pin this function uses */
 			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 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 & 
 			     (0x01 << ((temp_byte + resources->irqs->barber_pole - 1) & 0x03)))) {
-				// We have to share with something already set up
+				/* We have to share with something already set up */
 				IRQ = resources->irqs->interrupt[(temp_byte + 
 					resources->irqs->barber_pole - 1) & 0x03];
 			} else {
-				// Program IRQ based on card type
+				/* 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) {
@@ -3126,7 +3084,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 				}
 			}
 
-			// IRQ Line
+			/* IRQ Line */
 			rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_INTERRUPT_LINE, IRQ);
 		}
 
@@ -3135,27 +3093,28 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 			if (rc)
 				return 1;
 		} else {
-			//TBD - this code may also belong in the other clause of this If statement
+			/* TBD - this code may also belong in the other clause
+			 * of this If statement */
 			resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03] = IRQ;
 			resources->irqs->valid_INT |= 0x01 << (temp_byte + resources->irqs->barber_pole - 1) & 0x03;
 		}
 
-		// Latency Timer
+		/* Latency Timer */
 		temp_byte = 0x40;
 		rc = pci_bus_write_config_byte(pci_bus, devfn,
 					PCI_LATENCY_TIMER, temp_byte);
 
-		// Cache Line size
+		/* Cache Line size */
 		temp_byte = 0x08;
 		rc = pci_bus_write_config_byte(pci_bus, devfn,
 					PCI_CACHE_LINE_SIZE, temp_byte);
 
-		// disable ROM base Address
+		/* disable ROM base Address */
 		temp_dword = 0x00L;
 		rc = pci_bus_write_config_word(pci_bus, devfn,
 					PCI_ROM_ADDRESS, temp_dword);
 
-		// enable card
+		/* enable card */
 		temp_word = 0x0157;	/* = PCI_COMMAND_IO |
 					 *   PCI_COMMAND_MEMORY |
 					 *   PCI_COMMAND_MASTER |
@@ -3164,8 +3123,8 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 					 *   PCI_COMMAND_SERR */
 		rc = pci_bus_write_config_word (pci_bus, devfn,
 					PCI_COMMAND, temp_word);
-	} else {		// End of Not-A-Bridge else
-		// It's some strange type of PCI adapter (Cardbus?)
+	} else {		/* End of Not-A-Bridge else */
+		/* It's some strange type of PCI adapter (Cardbus?) */
 		return DEVICE_TYPE_NOT_SUPPORTED;
 	}
 
@@ -3173,4 +3132,3 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
 
 	return 0;
 }
-