[OPW,kernel,03/16] staging: wlags49_h2: Delete space before close parenthesis
diff mbox

Message ID 8c293f42fdeefafeb11c5c3d2309366c56f7662d.1395092556.git.jelena.bjelja.ing@gmail.com
State New, archived
Headers show

Commit Message

Jelena Bjelja March 17, 2014, 10:38 p.m. UTC
This patch fixes the following checkpatch.pl issues in wl_netdev.c:
ERROR: space prohibited before that close parenthesis ')'

Signed-off-by: Jelena Bjelja <jelena.bjelja.ing@gmail.com>
---
 drivers/staging/wlags49_h2/wl_netdev.c |  628 ++++++++++++++++----------------
 1 file changed, 314 insertions(+), 314 deletions(-)

Patch
diff mbox

diff --git a/drivers/staging/wlags49_h2/wl_netdev.c b/drivers/staging/wlags49_h2/wl_netdev.c
index 4ccac5e..dc38721 100644
--- a/drivers/staging/wlags49_h2/wl_netdev.c
+++ b/drivers/staging/wlags49_h2/wl_netdev.c
@@ -133,7 +133,7 @@ 
 	desc->BUF_SIZE = len; \
 	status = hcf_rcv_msg(&(lp->hcfCtx), desc, 0)
 
-#define BLOCK_INPUT_DMA(buf, len) memcpy(buf, desc_next->buf_addr, pktlen )
+#define BLOCK_INPUT_DMA(buf, len) memcpy(buf, desc_next->buf_addr, pktlen)
 
 /*******************************************************************************
  * function prototypes
@@ -158,17 +158,17 @@ 
  *      errno value otherwise
  *
  ******************************************************************************/
-int wl_init(struct net_device *dev )
+int wl_init(struct net_device *dev)
 {
 //    unsigned long       flags;
 //    struct wl_private   *lp = wl_priv(dev);
 
-	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
+	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
 
 	/* Nothing to do, but grab the spinlock anyway just in case we ever need
 	this routine */
-//  wl_lock(lp, &flags );
-//  wl_unlock(lp, &flags );
+//  wl_lock(lp, &flags);
+//  wl_unlock(lp, &flags);
 
 	return 0;
 } // wl_init
@@ -193,10 +193,10 @@  int wl_init(struct net_device *dev )
  *      errno otherwise
  *
  ******************************************************************************/
-int wl_config(struct net_device *dev, struct ifmap *map )
+int wl_config(struct net_device *dev, struct ifmap *map)
 {
-	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
-	DBG_PARAM(DbgInfo, "map", "0x%p", map );
+	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
+	DBG_PARAM(DbgInfo, "map", "0x%p", map);
 
 	/* The only thing we care about here is a port change. Since this not needed,
 	ignore the request. */
@@ -224,7 +224,7 @@  int wl_config(struct net_device *dev, struct ifmap *map )
  *      statistics.
  *
  ******************************************************************************/
-struct net_device_stats *wl_stats(struct net_device *dev )
+struct net_device_stats *wl_stats(struct net_device *dev)
 {
 #ifdef USE_WDS
 	int                         count;
@@ -233,15 +233,15 @@  struct net_device_stats *wl_stats(struct net_device *dev )
 	struct net_device_stats     *pStats;
 	struct wl_private           *lp = wl_priv(dev);
 
-	//DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
+	//DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
 
 	pStats = NULL;
 
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
 #ifdef USE_RTS
-	if(lp->useRTS == 1 ) {
-		wl_unlock(lp, &flags );
+	if(lp->useRTS == 1) {
+		wl_unlock(lp, &flags);
 		return NULL;
 	}
 #endif  /* USE_RTS */
@@ -249,20 +249,20 @@  struct net_device_stats *wl_stats(struct net_device *dev )
     /* Return the statistics for the appropriate device */
 #ifdef USE_WDS
 
-	for(count = 0; count < NUM_WDS_PORTS; count++ ) {
-		if(dev == lp->wds_port[count].dev ) {
-			pStats = &(lp->wds_port[count].stats );
+	for(count = 0; count < NUM_WDS_PORTS; count++) {
+		if(dev == lp->wds_port[count].dev) {
+			pStats = &(lp->wds_port[count].stats);
 		}
 	}
 
 #endif  /* USE_WDS */
 
 	/* If pStats is still NULL, then the device is not a WDS port */
-	if(pStats == NULL ) {
-		pStats = &(lp->stats );
+	if(pStats == NULL) {
+		pStats = &(lp->stats);
 	}
 
-	wl_unlock(lp, &flags );
+	wl_unlock(lp, &flags);
 
 	return pStats;
 } // wl_stats
@@ -292,68 +292,68 @@  int wl_open(struct net_device *dev)
 	struct wl_private   *lp = wl_priv(dev);
 	unsigned long       flags;
 
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
 #ifdef USE_RTS
-	if(lp->useRTS == 1 ) {
-		DBG_TRACE(DbgInfo, "Skipping device open, in RTS mode\n" );
-		wl_unlock(lp, &flags );
+	if(lp->useRTS == 1) {
+		DBG_TRACE(DbgInfo, "Skipping device open, in RTS mode\n");
+		wl_unlock(lp, &flags);
 		return -EIO;
 	}
 #endif  /* USE_RTS */
 
 #ifdef USE_PROFILE
-	parse_config(dev );
+	parse_config(dev);
 #endif
 
-	if(lp->portState == WVLAN_PORT_STATE_DISABLED ) {
-		DBG_TRACE(DbgInfo, "Enabling Port 0\n" );
-		status = wl_enable(lp );
+	if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
+		DBG_TRACE(DbgInfo, "Enabling Port 0\n");
+		status = wl_enable(lp);
 
-		if(status != HCF_SUCCESS ) {
-			DBG_TRACE(DbgInfo, "Enable port 0 failed: 0x%x\n", status );
+		if(status != HCF_SUCCESS) {
+			DBG_TRACE(DbgInfo, "Enable port 0 failed: 0x%x\n", status);
 		}
 	}
 
 	// Holding the lock too long, make a gap to allow other processes
 	wl_unlock(lp, &flags);
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
-	if (strlen(lp->fw_image_filename ) ) {
-		DBG_TRACE(DbgInfo, ";???? Kludgy way to force a download\n" );
-		status = wl_go(lp );
+	if (strlen(lp->fw_image_filename)) {
+		DBG_TRACE(DbgInfo, ";???? Kludgy way to force a download\n");
+		status = wl_go(lp);
 	} else {
-		status = wl_apply(lp );
+		status = wl_apply(lp);
 	}
 
 	// Holding the lock too long, make a gap to allow other processes
 	wl_unlock(lp, &flags);
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
-	if(status != HCF_SUCCESS ) {
+	if(status != HCF_SUCCESS) {
 	// Unsuccessful, try reset of the card to recover
-	status = wl_reset(dev );
+	status = wl_reset(dev);
 	}
 
 	// Holding the lock too long, make a gap to allow other processes
 	wl_unlock(lp, &flags);
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
-	if(status == HCF_SUCCESS ) {
-		netif_carrier_on(dev );
-		WL_WDS_NETIF_CARRIER_ON(lp );
+	if(status == HCF_SUCCESS) {
+		netif_carrier_on(dev);
+		WL_WDS_NETIF_CARRIER_ON(lp);
 
 		lp->is_handling_int = WL_HANDLING_INT; // Start handling interrupts
-		wl_act_int_on(lp );
+		wl_act_int_on(lp);
 
-		netif_start_queue(dev );
-		WL_WDS_NETIF_START_QUEUE(lp );
+		netif_start_queue(dev);
+		WL_WDS_NETIF_START_QUEUE(lp);
 	} else {
-		wl_hcf_error(dev, status );		/* Report the error */
-		netif_device_detach(dev );		/* Stop the device and queue */
+		wl_hcf_error(dev, status);		/* Report the error */
+		netif_device_detach(dev);		/* Stop the device and queue */
 	}
 
-	wl_unlock(lp, &flags );
+	wl_unlock(lp, &flags);
 
 	return status;
 } // wl_open
@@ -377,7 +377,7 @@  int wl_open(struct net_device *dev)
  *      errno otherwise
  *
  ******************************************************************************/
-int wl_close(struct net_device *dev )
+int wl_close(struct net_device *dev)
 {
 	struct wl_private   *lp = wl_priv(dev);
 	unsigned long   flags;
@@ -385,11 +385,11 @@  int wl_close(struct net_device *dev )
 	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
 
 	/* Mark the adapter as busy */
-	netif_stop_queue(dev );
-	WL_WDS_NETIF_STOP_QUEUE(lp );
+	netif_stop_queue(dev);
+	WL_WDS_NETIF_STOP_QUEUE(lp);
 
-	netif_carrier_off(dev );
-	WL_WDS_NETIF_CARRIER_OFF(lp );
+	netif_carrier_off(dev);
+	WL_WDS_NETIF_CARRIER_OFF(lp);
 
 	/* Shutdown the adapter:
 	Disable adapter interrupts
@@ -398,23 +398,23 @@  int wl_close(struct net_device *dev )
 	Set low power mode
 	*/
 
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
-	wl_act_int_off(lp );
+	wl_act_int_off(lp);
 	lp->is_handling_int = WL_NOT_HANDLING_INT; // Stop handling interrupts
 
 #ifdef USE_RTS
-	if(lp->useRTS == 1 ) {
-		DBG_TRACE(DbgInfo, "Skipping device close, in RTS mode\n" );
-		wl_unlock(lp, &flags );
+	if(lp->useRTS == 1) {
+		DBG_TRACE(DbgInfo, "Skipping device close, in RTS mode\n");
+		wl_unlock(lp, &flags);
 		return -EIO;
 	}
 #endif  /* USE_RTS */
 
 	/* Disable the ports */
-	wl_disable(lp );
+	wl_disable(lp);
 
-	wl_unlock(lp, &flags );
+	wl_unlock(lp, &flags);
 
 	return 0;
 } // wl_close
@@ -464,7 +464,7 @@  static struct ethtool_ops wl_ethtool_ops = {
  *      errno value otherwise
  *
  ******************************************************************************/
-int wl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd )
+int wl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
 	struct wl_private  *lp = wl_priv(dev);
 	unsigned long           flags;
@@ -474,18 +474,18 @@  int wl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd )
 	DBG_PARAM(DbgInfo, "rq", "0x%p", rq);
 	DBG_PARAM(DbgInfo, "cmd", "0x%04x", cmd);
 
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
-	wl_act_int_off(lp );
+	wl_act_int_off(lp);
 
 #ifdef USE_RTS
-	if(lp->useRTS == 1 ) {
+	if(lp->useRTS == 1) {
 	/* Handle any RTS IOCTL here */
-		if(cmd == WL_IOCTL_RTS ) {
-			DBG_TRACE(DbgInfo, "IOCTL: WL_IOCTL_RTS\n" );
-			ret = wvlan_rts((struct rtsreq *)rq, dev->base_addr );
+		if(cmd == WL_IOCTL_RTS) {
+			DBG_TRACE(DbgInfo, "IOCTL: WL_IOCTL_RTS\n");
+			ret = wvlan_rts((struct rtsreq *)rq, dev->base_addr);
 		} else {
-			DBG_TRACE(DbgInfo, "IOCTL not supported in RTS mode: 0x%X\n", cmd );
+			DBG_TRACE(DbgInfo, "IOCTL not supported in RTS mode: 0x%X\n", cmd);
 			ret = -EOPNOTSUPP;
 		}
 
@@ -494,36 +494,36 @@  int wl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd )
 #endif  /* USE_RTS */
 
 	/* Only handle UIL IOCTL requests when the UIL has the system blocked. */
-	if(!((lp->flags & WVLAN2_UIL_BUSY ) && (cmd != WVLAN2_IOCTL_UIL ))) {
+	if(!((lp->flags & WVLAN2_UIL_BUSY) && (cmd != WVLAN2_IOCTL_UIL))) {
 #ifdef USE_UIL
 		struct uilreq  *urq = (struct uilreq *)rq;
 #endif /* USE_UIL */
 
-		switch(cmd ) {
+		switch(cmd) {
 	// ================== Private IOCTLs (up to 16) ==================
 #ifdef USE_UIL
 		case WVLAN2_IOCTL_UIL:
-			DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL\n" );
-			ret = wvlan_uil(urq, lp );
+			DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL\n");
+			ret = wvlan_uil(urq, lp);
 			break;
 #endif  /* USE_UIL */
 
 		default:
-			DBG_TRACE(DbgInfo, "IOCTL CODE NOT SUPPORTED: 0x%X\n", cmd );
+			DBG_TRACE(DbgInfo, "IOCTL CODE NOT SUPPORTED: 0x%X\n", cmd);
 			ret = -EOPNOTSUPP;
 			break;
 		}
 	} else {
-		DBG_WARNING(DbgInfo, "DEVICE IS BUSY, CANNOT PROCESS REQUEST\n" );
+		DBG_WARNING(DbgInfo, "DEVICE IS BUSY, CANNOT PROCESS REQUEST\n");
 		ret = -EBUSY;
 	}
 
 #ifdef USE_RTS
 out_act_int_on_unlock:
 #endif  /* USE_RTS */
-	wl_act_int_on(lp );
+	wl_act_int_on(lp);
 
-	wl_unlock(lp, &flags );
+	wl_unlock(lp, &flags);
 
 	return ret;
 } // wl_ioctl
@@ -536,9 +536,9 @@  void wl_poll(struct net_device *dev)
 	unsigned long flags;
 	struct pt_regs regs;
 
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 	wl_isr(dev->irq, dev, &regs);
-	wl_unlock(lp, &flags );
+	wl_unlock(lp, &flags);
 }
 #endif
 
@@ -559,7 +559,7 @@  void wl_poll(struct net_device *dev)
  *      N/A
  *
  ******************************************************************************/
-void wl_tx_timeout(struct net_device *dev )
+void wl_tx_timeout(struct net_device *dev)
 {
 #ifdef USE_WDS
 	int                     count;
@@ -568,14 +568,14 @@  void wl_tx_timeout(struct net_device *dev )
 	struct wl_private       *lp = wl_priv(dev);
 	struct net_device_stats *pStats = NULL;
 
-	DBG_WARNING(DbgInfo, "%s: Transmit timeout.\n", dev->name );
+	DBG_WARNING(DbgInfo, "%s: Transmit timeout.\n", dev->name);
 
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
 #ifdef USE_RTS
-	if(lp->useRTS == 1 ) {
-		DBG_TRACE(DbgInfo, "Skipping tx_timeout handler, in RTS mode\n" );
-		wl_unlock(lp, &flags );
+	if(lp->useRTS == 1) {
+		DBG_TRACE(DbgInfo, "Skipping tx_timeout handler, in RTS mode\n");
+		wl_unlock(lp, &flags);
 		return;
 	}
 #endif  /* USE_RTS */
@@ -584,9 +584,9 @@  void wl_tx_timeout(struct net_device *dev )
        is for */
 #ifdef USE_WDS
 
-	for(count = 0; count < NUM_WDS_PORTS; count++ ) {
-		if(dev == lp->wds_port[count].dev ) {
-			pStats = &(lp->wds_port[count].stats );
+	for(count = 0; count < NUM_WDS_PORTS; count++) {
+		if(dev == lp->wds_port[count].dev) {
+			pStats = &(lp->wds_port[count].stats);
 
 	/* Break the loop so that we can use the counter to access WDS
 	information in the private structure */
@@ -597,14 +597,14 @@  void wl_tx_timeout(struct net_device *dev )
 #endif  /* USE_WDS */
 
 	/* If pStats is still NULL, then the device is not a WDS port */
-	if(pStats == NULL ) {
-		pStats = &(lp->stats );
+	if(pStats == NULL) {
+		pStats = &(lp->stats);
 	}
 
 	/* Accumulate the timeout error */
 	pStats->tx_errors++;
 
-	wl_unlock(lp, &flags );
+	wl_unlock(lp, &flags);
 } // wl_tx_timeout
 /*============================================================================*/
 
@@ -626,7 +626,7 @@  void wl_tx_timeout(struct net_device *dev )
  *      1 on error
  *
  ******************************************************************************/
-int wl_send(struct wl_private *lp )
+int wl_send(struct wl_private *lp)
 {
 
 	int                 status;
@@ -636,50 +636,50 @@  int wl_send(struct wl_private *lp )
 	int                 len;
 	/*------------------------------------------------------------------------*/
 
-	if(lp == NULL ) {
-		DBG_ERROR(DbgInfo, "Private adapter struct is NULL\n" );
+	if(lp == NULL) {
+		DBG_ERROR(DbgInfo, "Private adapter struct is NULL\n");
 		return FALSE;
 	}
-	if(lp->dev == NULL ) {
-		DBG_ERROR(DbgInfo, "net_device struct in wl_private is NULL\n" );
+	if(lp->dev == NULL) {
+		DBG_ERROR(DbgInfo, "net_device struct in wl_private is NULL\n");
 		return FALSE;
 	}
 
 	/* Check for the availability of FIDs; if none are available, don't take any
 	frames off the txQ */
-	if(lp->hcfCtx.IFB_RscInd == 0 ) {
+	if(lp->hcfCtx.IFB_RscInd == 0) {
 		return FALSE;
 	}
 
 	/* Reclaim the TxQ Elements and place them back on the free queue */
-	if(!list_empty(&(lp->txQ[0] ))) {
+	if(!list_empty(&(lp->txQ[0]))) {
 		element = lp->txQ[0].next;
 
-		txF = (WVLAN_LFRAME * )list_entry(element, WVLAN_LFRAME, node );
-		if(txF != NULL ) {
+		txF = (WVLAN_LFRAME *)list_entry(element, WVLAN_LFRAME, node);
+		if(txF != NULL) {
 			lp->txF.skb  = txF->frame.skb;
 			lp->txF.port = txF->frame.port;
 
 			txF->frame.skb  = NULL;
 			txF->frame.port = 0;
 
-			list_del(&(txF->node ));
-			list_add(element, &(lp->txFree ));
+			list_del(&(txF->node));
+			list_add(element, &(lp->txFree));
 
 			lp->txQ_count--;
 
-			if(lp->txQ_count < TX_Q_LOW_WATER_MARK ) {
-				if(lp->netif_queue_on == FALSE ) {
-					DBG_TX(DbgInfo, "Kickstarting Q: %d\n", lp->txQ_count );
-					netif_wake_queue(lp->dev );
-					WL_WDS_NETIF_WAKE_QUEUE(lp );
+			if(lp->txQ_count < TX_Q_LOW_WATER_MARK) {
+				if(lp->netif_queue_on == FALSE) {
+					DBG_TX(DbgInfo, "Kickstarting Q: %d\n", lp->txQ_count);
+					netif_wake_queue(lp->dev);
+					WL_WDS_NETIF_WAKE_QUEUE(lp);
 					lp->netif_queue_on = TRUE;
 				}
 			}
 		}
 	}
 
-	if(lp->txF.skb == NULL ) {
+	if(lp->txF.skb == NULL) {
 		return FALSE;
 	}
 
@@ -687,19 +687,19 @@  int wl_send(struct wl_private *lp )
 	/* Format the TxRequest and send it to the adapter */
 	len = lp->txF.skb->len < ETH_ZLEN ? ETH_ZLEN : lp->txF.skb->len;
 
-	desc                    = &(lp->desc_tx );
+	desc                    = &(lp->desc_tx);
 	desc->buf_addr          = lp->txF.skb->data;
 	desc->BUF_CNT           = len;
 	desc->next_desc_addr    = NULL;
 
-	status = hcf_send_msg(&(lp->hcfCtx ), desc, lp->txF.port );
+	status = hcf_send_msg(&(lp->hcfCtx), desc, lp->txF.port);
 
-	if(status == HCF_SUCCESS ) {
+	if(status == HCF_SUCCESS) {
 		lp->dev->trans_start = jiffies;
 
-		DBG_TX(DbgInfo, "Transmit...\n" );
+		DBG_TX(DbgInfo, "Transmit...\n");
 
-		if(lp->txF.port == HCF_PORT_0 ) {
+		if(lp->txF.port == HCF_PORT_0) {
 			lp->stats.tx_packets++;
 			lp->stats.tx_bytes += lp->txF.skb->len;
 		}
@@ -707,15 +707,15 @@  int wl_send(struct wl_private *lp )
 #ifdef USE_WDS
 		else
 		{
-			lp->wds_port[((lp->txF.port >> 8 ) - 1)].stats.tx_packets++;
-			lp->wds_port[((lp->txF.port >> 8 ) - 1)].stats.tx_bytes += lp->txF.skb->len;
+			lp->wds_port[((lp->txF.port >> 8) - 1)].stats.tx_packets++;
+			lp->wds_port[((lp->txF.port >> 8) - 1)].stats.tx_bytes += lp->txF.skb->len;
 		}
 
 #endif  /* USE_WDS */
 
 	/* Free the skb and perform queue cleanup, as the buffer was
 	transmitted successfully */
-		dev_kfree_skb(lp->txF.skb );
+		dev_kfree_skb(lp->txF.skb);
 
 		lp->txF.skb = NULL;
 		lp->txF.port = 0;
@@ -744,7 +744,7 @@  int wl_send(struct wl_private *lp )
  *      1 on error
  *
  ******************************************************************************/
-int wl_tx(struct sk_buff *skb, struct net_device *dev, int port )
+int wl_tx(struct sk_buff *skb, struct net_device *dev, int port)
 {
 	unsigned long           flags;
 	struct wl_private       *lp = wl_priv(dev);
@@ -753,30 +753,30 @@  int wl_tx(struct sk_buff *skb, struct net_device *dev, int port )
 	/*------------------------------------------------------------------------*/
 
 	/* Grab the spinlock */
-	wl_lock(lp, &flags );
+	wl_lock(lp, &flags);
 
-	if(lp->flags & WVLAN2_UIL_BUSY ) {
-		DBG_WARNING(DbgInfo, "UIL has device blocked\n" );
+	if(lp->flags & WVLAN2_UIL_BUSY) {
+		DBG_WARNING(DbgInfo, "UIL has device blocked\n");
 	/* Start dropping packets here??? */
-		wl_unlock(lp, &flags );
+		wl_unlock(lp, &flags);
 		return 1;
 	}
 
 #ifdef USE_RTS
-	if(lp->useRTS == 1 ) {
-		DBG_PRINT("RTS: we're getting a Tx...\n" );
-		wl_unlock(lp, &flags );
+	if(lp->useRTS == 1) {
+		DBG_PRINT("RTS: we're getting a Tx...\n");
+		wl_unlock(lp, &flags);
 		return 1;
 	}
 #endif  /* USE_RTS */
 
-	if(!lp->use_dma ) {
+	if(!lp->use_dma) {
 		/* Get an element from the queue */
 		element = lp->txFree.next;
-		txF = (WVLAN_LFRAME *)list_entry(element, WVLAN_LFRAME, node );
-		if(txF == NULL ) {
-			DBG_ERROR(DbgInfo, "Problem with list_entry\n" );
-			wl_unlock(lp, &flags );
+		txF = (WVLAN_LFRAME *)list_entry(element, WVLAN_LFRAME, node);
+		if(txF == NULL) {
+			DBG_ERROR(DbgInfo, "Problem with list_entry\n");
+			wl_unlock(lp, &flags);
 			return 1;
 		}
 		/* Fill out the frame */
@@ -787,30 +787,30 @@  int wl_tx(struct sk_buff *skb, struct net_device *dev, int port )
 		list_move(&(txF->node), &(lp->txQ[0]));
 
 		lp->txQ_count++;
-		if(lp->txQ_count >= DEFAULT_NUM_TX_FRAMES ) {
-			DBG_TX(DbgInfo, "Q Full: %d\n", lp->txQ_count );
-			if(lp->netif_queue_on == TRUE ) {
-				netif_stop_queue(lp->dev );
-				WL_WDS_NETIF_STOP_QUEUE(lp );
+		if(lp->txQ_count >= DEFAULT_NUM_TX_FRAMES) {
+			DBG_TX(DbgInfo, "Q Full: %d\n", lp->txQ_count);
+			if(lp->netif_queue_on == TRUE) {
+				netif_stop_queue(lp->dev);
+				WL_WDS_NETIF_STOP_QUEUE(lp);
 				lp->netif_queue_on = FALSE;
 			}
 		}
 	}
-	wl_act_int_off(lp ); /* Disable Interrupts */
+	wl_act_int_off(lp); /* Disable Interrupts */
 
 	/* Send the data to the hardware using the appropriate method */
 #ifdef ENABLE_DMA
-	if(lp->use_dma ) {
-		wl_send_dma(lp, skb, port );
+	if(lp->use_dma) {
+		wl_send_dma(lp, skb, port);
 	}
 	else
 #endif
 	{
-		wl_send(lp );
+		wl_send(lp);
 	}
 	/* Re-enable Interrupts, release the spinlock and return */
-	wl_act_int_on(lp );
-	wl_unlock(lp, &flags );
+	wl_act_int_on(lp);
+	wl_unlock(lp, &flags);
 	return 0;
 } // wl_tx
 /*============================================================================*/
@@ -846,37 +846,37 @@  int wl_rx(struct net_device *dev)
 
 	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
 
-	if(!(lp->flags & WVLAN2_UIL_BUSY )) {
+	if(!(lp->flags & WVLAN2_UIL_BUSY)) {
 
 #ifdef USE_RTS
-		if(lp->useRTS == 1 ) {
-			DBG_PRINT("RTS: We're getting an Rx...\n" );
+		if(lp->useRTS == 1) {
+			DBG_PRINT("RTS: We're getting an Rx...\n");
 			return -EIO;
 		}
 #endif  /* USE_RTS */
 
 	/* Read the HFS_STAT register from the lookahead buffer */
-		hfs_stat = (hcf_16)((lp->lookAheadBuf[HFS_STAT] ) |
-			(lp->lookAheadBuf[HFS_STAT + 1] << 8 ));
+		hfs_stat = (hcf_16)((lp->lookAheadBuf[HFS_STAT]) |
+			(lp->lookAheadBuf[HFS_STAT + 1] << 8));
 
 		/* Make sure the frame isn't bad */
-		if((hfs_stat & HFS_STAT_ERR ) != HCF_SUCCESS ) {
+		if((hfs_stat & HFS_STAT_ERR) != HCF_SUCCESS) {
 			DBG_WARNING(DbgInfo,
 			"HFS_STAT_ERROR (0x%x) in Rx Packet\n",
-			lp->lookAheadBuf[HFS_STAT] );
+			lp->lookAheadBuf[HFS_STAT]);
 			return -EIO;
 		}
 
 		/* Determine what port this packet is for */
-		port = (hfs_stat >> 8 ) & 0x0007;
-		DBG_RX(DbgInfo, "Rx frame for port %d\n", port );
+		port = (hfs_stat >> 8) & 0x0007;
+		DBG_RX(DbgInfo, "Rx frame for port %d\n", port);
 
 		pktlen = lp->hcfCtx.IFB_RxLen;
 		if (pktlen != 0) {
 			skb = ALLOC_SKB(pktlen);
 			if (skb != NULL) {
 		/* Set the netdev based on the port */
-				switch(port ) {
+				switch(port) {
 #ifdef USE_WDS
 				case 1:
 				case 2:
@@ -893,7 +893,7 @@  int wl_rx(struct net_device *dev)
 					break;
 				}
 
-				desc = &(lp->desc_rx );
+				desc = &(lp->desc_rx);
 
 				desc->next_desc_addr = NULL;
 
@@ -904,12 +904,12 @@  int wl_rx(struct net_device *dev)
 	status = hcf_rcv_msg(&(lp->hcfCtx), desc, 0)
 */
 
-				GET_PACKET(skb->dev, skb, pktlen );
+				GET_PACKET(skb->dev, skb, pktlen);
 
-				if(status == HCF_SUCCESS ) {
-					netif_rx(skb );
+				if(status == HCF_SUCCESS) {
+					netif_rx(skb);
 
-					if(port == 0 ) {
+					if(port == 0) {
 						lp->stats.rx_packets++;
 						lp->stats.rx_bytes += pktlen;
 					}
@@ -925,17 +925,17 @@  int wl_rx(struct net_device *dev)
 
 #ifdef WIRELESS_EXT
 #ifdef WIRELESS_SPY
-					if(lp->spydata.spy_number > 0 ) {
+					if(lp->spydata.spy_number > 0) {
 						char *srcaddr = skb->mac.raw + MAC_ADDR_SIZE;
 
-						wl_spy_gather(dev, srcaddr );
+						wl_spy_gather(dev, srcaddr);
 					}
 #endif /* WIRELESS_SPY */
 #endif /* WIRELESS_EXT */
 					} else {
-						DBG_ERROR(DbgInfo, "Rx request to card FAILED\n" );
+						DBG_ERROR(DbgInfo, "Rx request to card FAILED\n");
 
-						if(port == 0 ) {
+						if(port == 0) {
 							lp->stats.rx_dropped++;
 						}
 #ifdef USE_WDS
@@ -945,12 +945,12 @@  int wl_rx(struct net_device *dev)
 						}
 #endif  /* USE_WDS */
 
-						dev_kfree_skb(skb );
+						dev_kfree_skb(skb);
 					}
 			} else {
-				DBG_ERROR(DbgInfo, "Could not alloc skb\n" );
+				DBG_ERROR(DbgInfo, "Could not alloc skb\n");
 
-				if(port == 0 ) {
+				if(port == 0) {
 						lp->stats.rx_dropped++;
 				}
 #ifdef USE_WDS
@@ -986,7 +986,7 @@  int wl_rx(struct net_device *dev)
  ******************************************************************************/
 #ifdef NEW_MULTICAST
 
-void wl_multicast(struct net_device *dev )
+void wl_multicast(struct net_device *dev)
 {
 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA //;?should we return an error status in AP mode
 //;?seems reasonable that even an AP-only driver could afford this small additional footprint
@@ -996,17 +996,17 @@  void wl_multicast(struct net_device *dev )
 	struct wl_private   *lp = wl_priv(dev);
 	unsigned long       flags;
 
-	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
+	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
 
-	if(!wl_adapter_is_open(dev ))
+	if(!wl_adapter_is_open(dev))
 		return;
 
 #if DBG
-	if(DBG_FLAGS(DbgInfo ) & DBG_PARAM_ON ) {
+	if(DBG_FLAGS(DbgInfo) & DBG_PARAM_ON) {
 		DBG_PRINT("  flags: %s%s%s\n",
-		(dev->flags & IFF_PROMISC ) ? "Promiscuous " : "",
-		(dev->flags & IFF_MULTICAST ) ? "Multicast " : "",
-		(dev->flags & IFF_ALLMULTI ) ? "All-Multicast" : "" );
+		(dev->flags & IFF_PROMISC) ? "Promiscuous " : "",
+		(dev->flags & IFF_MULTICAST) ? "Multicast " : "",
+		(dev->flags & IFF_ALLMULTI) ? "All-Multicast" : "");
 
 		DBG_PRINT("  mc_count: %d\n", netdev_mc_count(dev));
 
@@ -1015,77 +1015,77 @@  void wl_multicast(struct net_device *dev )
 	}
 #endif /* DBG */
 
-	if(!(lp->flags & WVLAN2_UIL_BUSY )) {
+	if(!(lp->flags & WVLAN2_UIL_BUSY)) {
 
 #ifdef USE_RTS
-		if(lp->useRTS == 1 ) {
-			DBG_TRACE(DbgInfo, "Skipping multicast, in RTS mode\n" );
+		if(lp->useRTS == 1) {
+			DBG_TRACE(DbgInfo, "Skipping multicast, in RTS mode\n");
 			return;
 		}
 #endif  /* USE_RTS */
 
-		wl_lock(lp, &flags );
-		wl_act_int_off(lp );
+		wl_lock(lp, &flags);
+		wl_act_int_off(lp);
 
-		if (CNV_INT_TO_LITTLE(lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA  ) {
-			if(dev->flags & IFF_PROMISC ) {
+		if (CNV_INT_TO_LITTLE(lp->hcfCtx.IFB_FWIdentity.comp_id) == COMP_ID_FW_STA) {
+			if(dev->flags & IFF_PROMISC) {
 			/* Enable promiscuous mode */
 				lp->ltvRecord.len       = 2;
 				lp->ltvRecord.typ       = CFG_PROMISCUOUS_MODE;
-				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(1 );
-				DBG_PRINT("Enabling Promiscuous mode (IFF_PROMISC)\n" );
-				hcf_put_info(&(lp->hcfCtx ), (LTVP)&(lp->ltvRecord ));
+				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(1);
+				DBG_PRINT("Enabling Promiscuous mode (IFF_PROMISC)\n");
+				hcf_put_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
 			}
 			else if ((netdev_mc_count(dev) > HCF_MAX_MULTICAST) ||
-				(dev->flags & IFF_ALLMULTI )) {
+				(dev->flags & IFF_ALLMULTI)) {
 			/* Shutting off this filter will enable all multicast frames to
 			be sent up from the device; however, this is a static RID, so
 			a call to wl_apply() is needed */
 				lp->ltvRecord.len       = 2;
 				lp->ltvRecord.typ       = CFG_CNF_RX_ALL_GROUP_ADDR;
-				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(0 );
-				DBG_PRINT("Enabling all multicast mode (IFF_ALLMULTI)\n" );
-				hcf_put_info(&(lp->hcfCtx ), (LTVP)&(lp->ltvRecord ));
-				wl_apply(lp );
+				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(0);
+				DBG_PRINT("Enabling all multicast mode (IFF_ALLMULTI)\n");
+				hcf_put_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
+				wl_apply(lp);
 			}
 			else if (!netdev_mc_empty(dev)) {
 			/* Set the multicast addresses */
-				lp->ltvRecord.len = (netdev_mc_count(dev) * 3 ) + 1;
+				lp->ltvRecord.len = (netdev_mc_count(dev) * 3) + 1;
 				lp->ltvRecord.typ = CFG_GROUP_ADDR;
 
 				x = 0;
 				netdev_for_each_mc_addr(ha, dev)
 				memcpy(&(lp->ltvRecord.u.u8[x++ * ETH_ALEN]),
 					ha->addr, ETH_ALEN);
-				DBG_PRINT("Setting multicast list\n" );
-				hcf_put_info(&(lp->hcfCtx ), (LTVP)&(lp->ltvRecord ));
+				DBG_PRINT("Setting multicast list\n");
+				hcf_put_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
 			} else {
 				/* Disable promiscuous mode */
 				lp->ltvRecord.len       = 2;
 				lp->ltvRecord.typ       = CFG_PROMISCUOUS_MODE;
-				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(0 );
-				DBG_PRINT("Disabling Promiscuous mode\n" );
-				hcf_put_info(&(lp->hcfCtx ), (LTVP)&(lp->ltvRecord ));
+				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(0);
+				DBG_PRINT("Disabling Promiscuous mode\n");
+				hcf_put_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
 
 				/* Disable multicast mode */
 				lp->ltvRecord.len = 2;
 				lp->ltvRecord.typ = CFG_GROUP_ADDR;
-				DBG_PRINT("Disabling Multicast mode\n" );
-				hcf_put_info(&(lp->hcfCtx ), (LTVP)&(lp->ltvRecord ));
+				DBG_PRINT("Disabling Multicast mode\n");
+				hcf_put_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
 
 				/* Turning on this filter will prevent all multicast frames from
 				being sent up from the device; however, this is a static RID,
 				so a call to wl_apply() is needed */
 				lp->ltvRecord.len       = 2;
 				lp->ltvRecord.typ       = CFG_CNF_RX_ALL_GROUP_ADDR;
-				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(1 );
-				DBG_PRINT("Disabling all multicast mode (IFF_ALLMULTI)\n" );
-				hcf_put_info(&(lp->hcfCtx ), (LTVP)&(lp->ltvRecord ));
-				wl_apply(lp );
+				lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(1);
+				DBG_PRINT("Disabling all multicast mode (IFF_ALLMULTI)\n");
+				hcf_put_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
+				wl_apply(lp);
 			}
 		}
-		wl_act_int_on(lp );
-		wl_unlock(lp, &flags );
+		wl_act_int_on(lp);
+		wl_unlock(lp, &flags);
 	}
 #endif /* HCF_STA */
 } // wl_multicast
@@ -1093,11 +1093,11 @@  void wl_multicast(struct net_device *dev )
 
 #else /* NEW_MULTICAST */
 
-void wl_multicast(struct net_device *dev, int num_addrs, void *addrs )
+void wl_multicast(struct net_device *dev, int num_addrs, void *addrs)
 {
-	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
-	DBG_PARAM(DbgInfo, "num_addrs", "%d", num_addrs );
-	DBG_PARAM(DbgInfo, "addrs", "0x%p", addrs );
+	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
+	DBG_PARAM(DbgInfo, "num_addrs", "%d", num_addrs);
+	DBG_PARAM(DbgInfo, "addrs", "0x%p", addrs);
 
 #error Obsolete set multicast interface!
 } // wl_multicast
@@ -1144,7 +1144,7 @@  static const struct net_device_ops wl_netdev_ops =
  *      device.
  *
  ******************************************************************************/
-struct net_device * wl_device_alloc(void )
+struct net_device * wl_device_alloc(void)
 {
 	struct net_device   *dev = NULL;
 	struct wl_private   *lp = NULL;
@@ -1160,10 +1160,10 @@  struct net_device * wl_device_alloc(void )
 
 
 	/* Check MTU */
-	if(dev->mtu > MTU_MAX )
+	if(dev->mtu > MTU_MAX)
 	{
 		DBG_WARNING(DbgInfo, "%s: MTU set too high, limiting to %d.\n",
-			dev->name, MTU_MAX );
+			dev->name, MTU_MAX);
 		dev->mtu = MTU_MAX;
 	}
 
@@ -1179,10 +1179,10 @@  struct net_device * wl_device_alloc(void )
 
 	dev->ethtool_ops	    = &wl_ethtool_ops;
 
-	netif_stop_queue(dev );
+	netif_stop_queue(dev);
 
 	/* Allocate virtual devices for WDS support if needed */
-	WL_WDS_DEVICE_ALLOC(lp );
+	WL_WDS_DEVICE_ALLOC(lp);
 
 	return dev;
 } // wl_device_alloc
@@ -1206,14 +1206,14 @@  struct net_device * wl_device_alloc(void )
  *      N/A
  *
  ******************************************************************************/
-void wl_device_dealloc(struct net_device *dev )
+void wl_device_dealloc(struct net_device *dev)
 {
 //	struct wl_private   *lp = wl_priv(dev);
 
 	/* Dealloc the WDS ports */
-	WL_WDS_DEVICE_DEALLOC(lp );
+	WL_WDS_DEVICE_DEALLOC(lp);
 
-	free_netdev(dev );
+	free_netdev(dev);
 } // wl_device_dealloc
 /*============================================================================*/
 
@@ -1235,13 +1235,13 @@  void wl_device_dealloc(struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port0(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port0(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 0\n" );
+	DBG_TX(DbgInfo, "Tx on Port 0\n");
 
-	return wl_tx(skb, dev, HCF_PORT_0 );
+	return wl_tx(skb, dev, HCF_PORT_0);
 #ifdef ENABLE_DMA
-	return wl_tx_dma(skb, dev, HCF_PORT_0 );
+	return wl_tx_dma(skb, dev, HCF_PORT_0);
 #endif
 } // wl_tx_port0
 /*============================================================================*/
@@ -1266,10 +1266,10 @@  int wl_tx_port0(struct sk_buff *skb, struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port1(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port1(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 1\n" );
-	return wl_tx(skb, dev, HCF_PORT_1 );
+	DBG_TX(DbgInfo, "Tx on Port 1\n");
+	return wl_tx(skb, dev, HCF_PORT_1);
 } // wl_tx_port1
 /*============================================================================*/
 
@@ -1291,10 +1291,10 @@  int wl_tx_port1(struct sk_buff *skb, struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port2(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port2(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 2\n" );
-	return wl_tx(skb, dev, HCF_PORT_2 );
+	DBG_TX(DbgInfo, "Tx on Port 2\n");
+	return wl_tx(skb, dev, HCF_PORT_2);
 } // wl_tx_port2
 /*============================================================================*/
 
@@ -1316,10 +1316,10 @@  int wl_tx_port2(struct sk_buff *skb, struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port3(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port3(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 3\n" );
-	return wl_tx(skb, dev, HCF_PORT_3 );
+	DBG_TX(DbgInfo, "Tx on Port 3\n");
+	return wl_tx(skb, dev, HCF_PORT_3);
 } // wl_tx_port3
 /*============================================================================*/
 
@@ -1341,10 +1341,10 @@  int wl_tx_port3(struct sk_buff *skb, struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port4(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port4(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 4\n" );
-	return wl_tx(skb, dev, HCF_PORT_4 );
+	DBG_TX(DbgInfo, "Tx on Port 4\n");
+	return wl_tx(skb, dev, HCF_PORT_4);
 } // wl_tx_port4
 /*============================================================================*/
 
@@ -1366,10 +1366,10 @@  int wl_tx_port4(struct sk_buff *skb, struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port5(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port5(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 5\n" );
-	return wl_tx(skb, dev, HCF_PORT_5 );
+	DBG_TX(DbgInfo, "Tx on Port 5\n");
+	return wl_tx(skb, dev, HCF_PORT_5);
 } // wl_tx_port5
 /*============================================================================*/
 
@@ -1391,10 +1391,10 @@  int wl_tx_port5(struct sk_buff *skb, struct net_device *dev )
  *      N/A
  *
  ******************************************************************************/
-int wl_tx_port6(struct sk_buff *skb, struct net_device *dev )
+int wl_tx_port6(struct sk_buff *skb, struct net_device *dev)
 {
-	DBG_TX(DbgInfo, "Tx on Port 6\n" );
-	return wl_tx(skb, dev, HCF_PORT_6 );
+	DBG_TX(DbgInfo, "Tx on Port 6\n");
+	return wl_tx(skb, dev, HCF_PORT_6);
 } // wl_tx_port6
 /*============================================================================*/
 
@@ -1417,21 +1417,21 @@  int wl_tx_port6(struct sk_buff *skb, struct net_device *dev )
  *      structs in the private adapter structure.
  *
  ******************************************************************************/
-void wl_wds_device_alloc(struct wl_private *lp )
+void wl_wds_device_alloc(struct wl_private *lp)
 {
 	int count;
 
     /* WDS support requires additional net_device structs to be allocated,
        so that user space apps can use these virtual devices to specify the
        port on which to Tx/Rx */
-	for(count = 0; count < NUM_WDS_PORTS; count++ ) {
+	for(count = 0; count < NUM_WDS_PORTS; count++) {
 		struct net_device *dev_wds = NULL;
 
 		dev_wds = kzalloc(sizeof(struct net_device), GFP_KERNEL);
 		if (!dev_wds)
 			return;
 
-		ether_setup(dev_wds );
+		ether_setup(dev_wds);
 
 		lp->wds_port[count].dev = dev_wds;
 
@@ -1448,7 +1448,7 @@  void wl_wds_device_alloc(struct wl_private *lp )
 		lp->wds_port[count].dev->watchdog_timeo = TX_TIMEOUT;
 		lp->wds_port[count].dev->priv           = lp;
 
-		sprintf(lp->wds_port[count].dev->name, "wds%d", count );
+		sprintf(lp->wds_port[count].dev->name, "wds%d", count);
 	}
 
     /* Register the Tx handlers */
@@ -1459,7 +1459,7 @@  void wl_wds_device_alloc(struct wl_private *lp )
 	lp->wds_port[4].dev->hard_start_xmit = &wl_tx_port5;
 	lp->wds_port[5].dev->hard_start_xmit = &wl_tx_port6;
 
-	WL_WDS_NETIF_STOP_QUEUE(lp );
+	WL_WDS_NETIF_STOP_QUEUE(lp);
 } // wl_wds_device_alloc
 /*============================================================================*/
 
@@ -1480,19 +1480,19 @@  void wl_wds_device_alloc(struct wl_private *lp )
  *      N/A
  *
  ******************************************************************************/
-void wl_wds_device_dealloc(struct wl_private *lp )
+void wl_wds_device_dealloc(struct wl_private *lp)
 {
 	int count;
 
-	for(count = 0; count < NUM_WDS_PORTS; count++ ) {
+	for(count = 0; count < NUM_WDS_PORTS; count++) {
 		struct net_device *dev_wds = NULL;
 
 		dev_wds = lp->wds_port[count].dev;
 
-		if(dev_wds != NULL ) {
-			if(dev_wds->flags & IFF_UP ) {
-				dev_close(dev_wds );
-				dev_wds->flags &= ~(IFF_UP | IFF_RUNNING );
+		if(dev_wds != NULL) {
+			if(dev_wds->flags & IFF_UP) {
+				dev_close(dev_wds);
+				dev_wds->flags &= ~(IFF_UP | IFF_RUNNING);
 			}
 
 			free_netdev(dev_wds);
@@ -1520,16 +1520,16 @@  void wl_wds_device_dealloc(struct wl_private *lp )
  *      N/A
  *
  ******************************************************************************/
-void wl_wds_netif_start_queue(struct wl_private *lp )
+void wl_wds_netif_start_queue(struct wl_private *lp)
 {
 	int count;
     /*------------------------------------------------------------------------*/
 
-	if(lp != NULL ) {
-		for(count = 0; count < NUM_WDS_PORTS; count++ ) {
+	if(lp != NULL) {
+		for(count = 0; count < NUM_WDS_PORTS; count++) {
 			if(lp->wds_port[count].is_registered &&
-				lp->wds_port[count].netif_queue_on == FALSE ) {
-				netif_start_queue(lp->wds_port[count].dev );
+				lp->wds_port[count].netif_queue_on == FALSE) {
+				netif_start_queue(lp->wds_port[count].dev);
 				lp->wds_port[count].netif_queue_on = TRUE;
 			}
 		}
@@ -1555,16 +1555,16 @@  void wl_wds_netif_start_queue(struct wl_private *lp )
  *      N/A
  *
  ******************************************************************************/
-void wl_wds_netif_stop_queue(struct wl_private *lp )
+void wl_wds_netif_stop_queue(struct wl_private *lp)
 {
 	int count;
     /*------------------------------------------------------------------------*/
 
-	if(lp != NULL ) {
-		for(count = 0; count < NUM_WDS_PORTS; count++ ) {
+	if(lp != NULL) {
+		for(count = 0; count < NUM_WDS_PORTS; count++) {
 			if(lp->wds_port[count].is_registered &&
-				lp->wds_port[count].netif_queue_on == TRUE ) {
-				netif_stop_queue(lp->wds_port[count].dev );
+				lp->wds_port[count].netif_queue_on == TRUE) {
+				netif_stop_queue(lp->wds_port[count].dev);
 				lp->wds_port[count].netif_queue_on = FALSE;
 			}
 		}
@@ -1590,16 +1590,16 @@  void wl_wds_netif_stop_queue(struct wl_private *lp )
  *      N/A
  *
  ******************************************************************************/
-void wl_wds_netif_wake_queue(struct wl_private *lp )
+void wl_wds_netif_wake_queue(struct wl_private *lp)
 {
 	int count;
     /*------------------------------------------------------------------------*/
 
-	if(lp != NULL ) {
-		for(count = 0; count < NUM_WDS_PORTS; count++ ) {
+	if(lp != NULL) {
+		for(count = 0; count < NUM_WDS_PORTS; count++) {
 			if(lp->wds_port[count].is_registered &&
-				lp->wds_port[count].netif_queue_on == FALSE ) {
-				netif_wake_queue(lp->wds_port[count].dev );
+				lp->wds_port[count].netif_queue_on == FALSE) {
+				netif_wake_queue(lp->wds_port[count].dev);
 				lp->wds_port[count].netif_queue_on = TRUE;
 			}
 		}
@@ -1625,15 +1625,15 @@  void wl_wds_netif_wake_queue(struct wl_private *lp )
  *      N/A
  *
  ******************************************************************************/
-void wl_wds_netif_carrier_on(struct wl_private *lp )
+void wl_wds_netif_carrier_on(struct wl_private *lp)
 {
 	int count;
     /*------------------------------------------------------------------------*/
 
-	if(lp != NULL ) {
-		for(count = 0; count < NUM_WDS_PORTS; count++ ) {
-			if(lp->wds_port[count].is_registered ) {
-				netif_carrier_on(lp->wds_port[count].dev );
+	if(lp != NULL) {
+		for(count = 0; count < NUM_WDS_PORTS; count++) {
+			if(lp->wds_port[count].is_registered) {
+				netif_carrier_on(lp->wds_port[count].dev);
 			}
 		}
 	}
@@ -1658,7 +1658,7 @@  void wl_wds_netif_carrier_on(struct wl_private *lp )
  *      N/A
  *
  ******************************************************************************/
-void wl_wds_netif_carrier_off(struct wl_private *lp )
+void wl_wds_netif_carrier_off(struct wl_private *lp)
 {
 	int count;
 
@@ -1695,26 +1695,26 @@  void wl_wds_netif_carrier_off(struct wl_private *lp )
  *      1 on error
  *
  ******************************************************************************/
-int wl_send_dma(struct wl_private *lp, struct sk_buff *skb, int port )
+int wl_send_dma(struct wl_private *lp, struct sk_buff *skb, int port)
 {
 	int         len;
 	DESC_STRCT *desc = NULL;
 	DESC_STRCT *desc_next = NULL;
 /*------------------------------------------------------------------------*/
 
-	if(lp == NULL ) {
-		DBG_ERROR(DbgInfo, "Private adapter struct is NULL\n" );
+	if(lp == NULL) {
+		DBG_ERROR(DbgInfo, "Private adapter struct is NULL\n");
 		return FALSE;
 	}
 
-	if(lp->dev == NULL ) {
-		DBG_ERROR(DbgInfo, "net_device struct in wl_private is NULL\n" );
+	if(lp->dev == NULL) {
+		DBG_ERROR(DbgInfo, "net_device struct in wl_private is NULL\n");
 		return FALSE;
 	}
 
 	/* AGAIN, ALL THE QUEUEING DONE HERE IN I/O MODE IS NOT PERFORMED */
 
-	if(skb == NULL ) {
+	if(skb == NULL) {
 		DBG_WARNING (DbgInfo, "Nothing to send.\n");
 		return FALSE;
 	}
@@ -1722,40 +1722,40 @@  int wl_send_dma(struct wl_private *lp, struct sk_buff *skb, int port )
 	len = skb->len;
 
 	/* Get a free descriptor */
-	desc = wl_pci_dma_get_tx_packet(lp );
+	desc = wl_pci_dma_get_tx_packet(lp);
 
-	if(desc == NULL ) {
-		if(lp->netif_queue_on == TRUE ) {
-			netif_stop_queue(lp->dev );
-			WL_WDS_NETIF_STOP_QUEUE(lp );
+	if(desc == NULL) {
+		if(lp->netif_queue_on == TRUE) {
+			netif_stop_queue(lp->dev);
+			WL_WDS_NETIF_STOP_QUEUE(lp);
 			lp->netif_queue_on = FALSE;
 
-			dev_kfree_skb(skb );
+			dev_kfree_skb(skb);
 			return 0;
 		}
 	}
 
-	SET_BUF_CNT(desc, /*HCF_DMA_FD_CNT*/HFS_ADDR_DEST );
-	SET_BUF_SIZE(desc, HCF_DMA_TX_BUF1_SIZE );
+	SET_BUF_CNT(desc, /*HCF_DMA_FD_CNT*/HFS_ADDR_DEST);
+	SET_BUF_SIZE(desc, HCF_DMA_TX_BUF1_SIZE);
 
 	desc_next = desc->next_desc_addr;
 
-	if(desc_next->buf_addr == NULL ) {
-		DBG_ERROR(DbgInfo, "DMA descriptor buf_addr is NULL\n" );
+	if(desc_next->buf_addr == NULL) {
+		DBG_ERROR(DbgInfo, "DMA descriptor buf_addr is NULL\n");
 		return FALSE;
 	}
 
 	/* Copy the payload into the DMA packet */
-	memcpy(desc_next->buf_addr, skb->data, len );
+	memcpy(desc_next->buf_addr, skb->data, len);
 
-	SET_BUF_CNT(desc_next, len );
-	SET_BUF_SIZE(desc_next, HCF_MAX_PACKET_SIZE );
+	SET_BUF_CNT(desc_next, len);
+	SET_BUF_SIZE(desc_next, HCF_MAX_PACKET_SIZE);
 
-	hcf_dma_tx_put(&(lp->hcfCtx ), desc, 0 );
+	hcf_dma_tx_put(&(lp->hcfCtx), desc, 0);
 
 	/* Free the skb and perform queue cleanup, as the buffer was
 	transmitted successfully */
-	dev_kfree_skb(skb );
+	dev_kfree_skb(skb);
 
 	return TRUE;
 } // wl_send_dma
@@ -1779,7 +1779,7 @@  int wl_send_dma(struct wl_private *lp, struct sk_buff *skb, int port )
  *      1 on error
  *
  ******************************************************************************/
-int wl_rx_dma(struct net_device *dev )
+int wl_rx_dma(struct net_device *dev)
 {
 	int                      port;
 	hcf_16                   pktlen;
@@ -1792,75 +1792,75 @@  int wl_rx_dma(struct net_device *dev )
 
 	DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
 
-	if(((lp = dev->priv ) != NULL ) &&
-		!(lp->flags & WVLAN2_UIL_BUSY )) {
+	if(((lp = dev->priv) != NULL) &&
+		!(lp->flags & WVLAN2_UIL_BUSY)) {
 
 #ifdef USE_RTS
-		if(lp->useRTS == 1 ) {
-			DBG_PRINT("RTS: We're getting an Rx...\n" );
+		if(lp->useRTS == 1) {
+			DBG_PRINT("RTS: We're getting an Rx...\n");
 			return -EIO;
 		}
 #endif	/* USE_RTS */
 
-	//if(lp->dma.status == 0 )
+	//if(lp->dma.status == 0)
 	//{
-		desc = hcf_dma_rx_get(&(lp->hcfCtx ));
+		desc = hcf_dma_rx_get(&(lp->hcfCtx));
 
-		if(desc != NULL )
+		if(desc != NULL)
 		{
 /* Check and see if we rcvd. a WMP frame */
 /*
-		if(((*(hcf_8 *)&desc->buf_addr[HFS_STAT] ) &
-			(HFS_STAT_MSG_TYPE | HFS_STAT_ERR )) == HFS_STAT_WMP_MSG )
+		if(((*(hcf_8 *)&desc->buf_addr[HFS_STAT]) &
+			(HFS_STAT_MSG_TYPE | HFS_STAT_ERR)) == HFS_STAT_WMP_MSG)
 		{
-			DBG_TRACE(DbgInfo, "Got a WMP frame\n" );
+			DBG_TRACE(DbgInfo, "Got a WMP frame\n");
 
-			x.len = sizeof(CFG_MB_INFO_RANGE2_STRCT ) / sizeof(hcf_16 );
+			x.len = sizeof(CFG_MB_INFO_RANGE2_STRCT) / sizeof(hcf_16);
 			x.typ = CFG_MB_INFO;
 			x.base_typ = CFG_WMP;
 			x.frag_cnt = 2;
-			x.frag_buf[0].frag_len  = GET_BUF_CNT(descp ) / sizeof(hcf_16 );
+			x.frag_buf[0].frag_len  = GET_BUF_CNT(descp) / sizeof(hcf_16);
 			x.frag_buf[0].frag_addr = (hcf_8 *) descp->buf_addr ;
-			x.frag_buf[1].frag_len  = (GET_BUF_CNT(descp->next_desc_addr ) + 1 ) / sizeof(hcf_16 );
+			x.frag_buf[1].frag_len  = (GET_BUF_CNT(descp->next_desc_addr) + 1) / sizeof(hcf_16);
 			x.frag_buf[1].frag_addr = (hcf_8 *) descp->next_desc_addr->buf_addr ;
 
-			hcf_put_info(&(lp->hcfCtx ), (LTVP)&x );
+			hcf_put_info(&(lp->hcfCtx), (LTVP)&x);
 		}
 */
 			desc_next = desc->next_desc_addr;
 
 			/* Make sure the buffer isn't empty */
-			if(GET_BUF_CNT(desc ) == 0 ) {
-				DBG_WARNING(DbgInfo, "Buffer is empty!\n" );
+			if(GET_BUF_CNT(desc) == 0) {
+				DBG_WARNING(DbgInfo, "Buffer is empty!\n");
 
 				/* Give the descriptor back to the HCF */
-				hcf_dma_rx_put(&(lp->hcfCtx ), desc );
+				hcf_dma_rx_put(&(lp->hcfCtx), desc);
 				return -EIO;
 			}
 
 		/* Read the HFS_STAT register from the lookahead buffer */
-			hfs_stat = (hcf_16)(desc->buf_addr[HFS_STAT/2] );
+			hfs_stat = (hcf_16)(desc->buf_addr[HFS_STAT/2]);
 
 			/* Make sure the frame isn't bad */
-			if((hfs_stat & HFS_STAT_ERR ) != HCF_SUCCESS )
+			if((hfs_stat & HFS_STAT_ERR) != HCF_SUCCESS)
 			{
 				DBG_WARNING(DbgInfo, "HFS_STAT_ERROR (0x%x) in Rx Packet\n",
-				desc->buf_addr[HFS_STAT/2] );
+				desc->buf_addr[HFS_STAT/2]);
 
 				/* Give the descriptor back to the HCF */
-				hcf_dma_rx_put(&(lp->hcfCtx ), desc );
+				hcf_dma_rx_put(&(lp->hcfCtx), desc);
 				return -EIO;
 			}
 
 			/* Determine what port this packet is for */
-			port = (hfs_stat >> 8 ) & 0x0007;
-			DBG_RX(DbgInfo, "Rx frame for port %d\n", port );
+			port = (hfs_stat >> 8) & 0x0007;
+			DBG_RX(DbgInfo, "Rx frame for port %d\n", port);
 
 			pktlen = GET_BUF_CNT(desc_next);
 			if (pktlen != 0) {
 				skb = ALLOC_SKB(pktlen);
 				if (skb != NULL) {
-					switch(port ) {
+					switch(port) {
 #ifdef USE_WDS
 					case 1:
 					case 2:
@@ -1878,14 +1878,14 @@  int wl_rx_dma(struct net_device *dev )
 						break;
 					}
 
-					GET_PACKET_DMA(skb->dev, skb, pktlen );
+					GET_PACKET_DMA(skb->dev, skb, pktlen);
 
 				/* Give the descriptor back to the HCF */
-					hcf_dma_rx_put(&(lp->hcfCtx ), desc );
+					hcf_dma_rx_put(&(lp->hcfCtx), desc);
 
-					netif_rx(skb );
+					netif_rx(skb);
 
-					if(port == 0 ) {
+					if(port == 0) {
 						lp->stats.rx_packets++;
 						lp->stats.rx_bytes += pktlen;
 					}
@@ -1900,9 +1900,9 @@  int wl_rx_dma(struct net_device *dev )
 					dev->last_rx = jiffies;
 
 				} else {
-					DBG_ERROR(DbgInfo, "Could not alloc skb\n" );
+					DBG_ERROR(DbgInfo, "Could not alloc skb\n");
 
-					if(port == 0 )
+					if(port == 0)
 					{
 						lp->stats.rx_dropped++;
 					}