Fix the following checkpatch.pl issues in wl_netdev.c:
ERROR: space prohibited after that open parenthesis '('
Signed-off-by: Jelena Bjelja <jelena.bjelja....@gmail.com>
---
drivers/staging/wlags49_h2/wl_netdev.c | 628 ++++++++++++++++----------------
1 file changed, 314 insertions(+), 314 deletions(-)
diff --git a/drivers/staging/wlags49_h2/wl_netdev.c
b/drivers/staging/wlags49_h2/wl_netdev.c
index 128e6a2..a8672db 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,17 +494,17 @@ 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 */
@@ -514,16 +514,16 @@ int wl_ioctl( struct net_device *dev, struct ifreq *rq,
int cmd )
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 @@ static 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, ®s);
- wl_unlock( lp, &flags );
+ wl_unlock(lp, &flags );
}
#endif
@@ -559,7 +559,7 @@ static 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 ) {
- DBG_WARNING( DbgInfo,
+ if((hfs_stat & HFS_STAT_ERR ) != HCF_SUCCESS ) {
+ DBG_WARNING(DbgInfo,
"HFS_STAT_ERROR (0x%x) in Rx Packet\n",
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,96 +996,96 @@ 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));
+ DBG_PRINT(" mc_count: %d\n", netdev_mc_count(dev));
netdev_for_each_mc_addr(ha, dev)
DBG_PRINT(" %pM (%d)\n", ha->addr, dev->addr_len);
}
#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,9 +1160,9 @@ 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",
+ DBG_WARNING(DbgInfo, "%s: MTU set too high, limiting to %d.\n",
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->wds_port[count].is_registered &&
+ 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 );
+ 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->wds_port[count].is_registered &&
+ 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 );
+ 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->wds_port[count].is_registered &&
+ 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 );
+ 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",
+ DBG_WARNING(DbgInfo, "HFS_STAT_ERROR (0x%x) in
Rx Packet\n",
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++;
}
--
1.7.9.5
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
