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@xxxxxxxxx>
---
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 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, ®s);
- 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++;
}
--
1.7.9.5
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
