1 /*******************************************************************************
3 * Wireless device driver for Linux (wlags49).
5 * Copyright (c) 1998-2003 Agere Systems Inc.
9 * Initially developed by TriplePoint, Inc.
10 * http://www.triplepoint.com
12 *------------------------------------------------------------------------------
14 * This file contains handler functions registered with the net_device
17 *------------------------------------------------------------------------------
21 * This software is provided subject to the following terms and conditions,
22 * which you should read carefully before using the software. Using this
23 * software indicates your acceptance of these terms and conditions. If you do
24 * not agree with these terms and conditions, do not use the software.
26 * Copyright © 2003 Agere Systems Inc.
27 * All rights reserved.
29 * Redistribution and use in source or binary forms, with or without
30 * modifications, are permitted provided that the following conditions are met:
32 * . Redistributions of source code must retain the above copyright notice, this
33 * list of conditions and the following Disclaimer as comments in the code as
34 * well as in the documentation and/or other materials provided with the
37 * . Redistributions in binary form must reproduce the above copyright notice,
38 * this list of conditions and the following Disclaimer in the documentation
39 * and/or other materials provided with the distribution.
41 * . Neither the name of Agere Systems Inc. nor the names of the contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
47 * THIS SOFTWARE IS PROVIDED
\93AS IS
\94 AND ANY EXPRESS OR IMPLIED WARRANTIES,
48 * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
49 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
50 * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
51 * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
52 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
53 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
54 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55 * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
60 ******************************************************************************/
62 /*******************************************************************************
64 ******************************************************************************/
65 #include <wl_version.h>
67 #include <linux/module.h>
68 #include <linux/slab.h>
69 #include <linux/types.h>
70 #include <linux/kernel.h>
71 // #include <linux/sched.h>
72 // #include <linux/ptrace.h>
73 // #include <linux/slab.h>
74 // #include <linux/ctype.h>
75 // #include <linux/string.h>
76 //#include <linux/timer.h>
77 // #include <linux/interrupt.h>
78 // #include <linux/in.h>
79 // #include <linux/delay.h>
80 // #include <linux/skbuff.h>
81 // #include <asm/io.h>
82 // #include <asm/system.h>
83 // #include <asm/bitops.h>
85 #include <linux/netdevice.h>
86 #include <linux/ethtool.h>
87 #include <linux/etherdevice.h>
88 // #include <linux/skbuff.h>
89 // #include <linux/if_arp.h>
90 // #include <linux/ioport.h>
96 // #include <hcfdef.h>
99 #include <wl_internal.h>
103 #include <wl_netdev.h>
107 #include <wl_profile.h>
108 #endif /* USE_PROFILE */
112 #endif /* BUS_PCMCIA */
119 /*******************************************************************************
121 ******************************************************************************/
123 extern dbg_info_t *DbgInfo;
128 #define MTU_MAX (HCF_MAX_MSG - ETH_HLEN - 8)
130 #define MTU_MAX (HCF_MAX_MSG - ETH_HLEN)
133 //static int mtu = MTU_MAX;
134 //MODULE_PARM(mtu, "i");
135 //MODULE_PARM_DESC(mtu, "MTU");
137 /*******************************************************************************
139 ******************************************************************************/
140 #define BLOCK_INPUT(buf, len) \
141 desc->buf_addr = buf; \
142 desc->BUF_SIZE = len; \
143 status = hcf_rcv_msg(&(lp->hcfCtx), desc, 0)
145 #define BLOCK_INPUT_DMA(buf, len) memcpy( buf, desc_next->buf_addr, pktlen )
147 /*******************************************************************************
148 * function prototypes
149 ******************************************************************************/
151 /*******************************************************************************
153 *******************************************************************************
157 * We never need to do anything when a "Wireless" device is "initialized"
158 * by the net software, because we only register already-found cards.
162 * dev - a pointer to the device's net_device structure
167 * errno value otherwise
169 ******************************************************************************/
170 int wl_init( struct net_device *dev )
172 // unsigned long flags;
173 // struct wl_private *lp = wl_priv(dev);
174 /*------------------------------------------------------------------------*/
176 DBG_FUNC( "wl_init" );
177 DBG_ENTER( DbgInfo );
179 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
181 /* Nothing to do, but grab the spinlock anyway just in case we ever need
183 // wl_lock( lp, &flags );
184 // wl_unlock( lp, &flags );
186 DBG_LEAVE( DbgInfo );
189 /*============================================================================*/
191 /*******************************************************************************
193 *******************************************************************************
197 * Implement the SIOCSIFMAP interface.
201 * dev - a pointer to the device's net_device structure
202 * map - a pointer to the device's ifmap structure
209 ******************************************************************************/
210 int wl_config( struct net_device *dev, struct ifmap *map )
212 DBG_FUNC( "wl_config" );
213 DBG_ENTER( DbgInfo );
215 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
216 DBG_PARAM( DbgInfo, "map", "0x%p", map );
218 /* The only thing we care about here is a port change. Since this not needed,
219 ignore the request. */
220 DBG_TRACE( DbgInfo, "%s: %s called.\n", dev->name, __FUNC__ );
222 DBG_LEAVE( DbgInfo );
225 /*============================================================================*/
227 /*******************************************************************************
229 *******************************************************************************
233 * Return the current device statistics.
237 * dev - a pointer to the device's net_device structure
241 * a pointer to a net_device_stats structure containing the network
244 ******************************************************************************/
245 struct net_device_stats *wl_stats( struct net_device *dev )
251 struct net_device_stats *pStats;
252 struct wl_private *lp = wl_priv(dev);
253 /*------------------------------------------------------------------------*/
255 //DBG_FUNC( "wl_stats" );
256 //DBG_ENTER( DbgInfo );
257 //DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
261 wl_lock( lp, &flags );
264 if( lp->useRTS == 1 ) {
265 wl_unlock( lp, &flags );
267 //DBG_LEAVE( DbgInfo );
272 /* Return the statistics for the appropriate device */
275 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
276 if( dev == lp->wds_port[count].dev ) {
277 pStats = &( lp->wds_port[count].stats );
283 /* If pStats is still NULL, then the device is not a WDS port */
284 if( pStats == NULL ) {
285 pStats = &( lp->stats );
288 wl_unlock( lp, &flags );
290 //DBG_LEAVE( DbgInfo );
294 /*============================================================================*/
296 /*******************************************************************************
298 *******************************************************************************
306 * dev - a pointer to the device's net_device structure
313 ******************************************************************************/
314 int wl_open(struct net_device *dev)
316 int status = HCF_SUCCESS;
317 struct wl_private *lp = wl_priv(dev);
319 /*------------------------------------------------------------------------*/
321 DBG_FUNC( "wl_open" );
322 DBG_ENTER( DbgInfo );
324 wl_lock( lp, &flags );
327 if( lp->useRTS == 1 ) {
328 DBG_TRACE( DbgInfo, "Skipping device open, in RTS mode\n" );
329 wl_unlock( lp, &flags );
330 DBG_LEAVE( DbgInfo );
339 if( lp->portState == WVLAN_PORT_STATE_DISABLED ) {
340 DBG_TRACE( DbgInfo, "Enabling Port 0\n" );
341 status = wl_enable( lp );
343 if( status != HCF_SUCCESS ) {
344 DBG_TRACE( DbgInfo, "Enable port 0 failed: 0x%x\n", status );
348 // Holding the lock too long, make a gap to allow other processes
349 wl_unlock(lp, &flags);
350 wl_lock( lp, &flags );
352 if ( strlen( lp->fw_image_filename ) ) {
353 DBG_TRACE( DbgInfo, ";???? Kludgy way to force a download\n" );
354 status = wl_go( lp );
356 status = wl_apply( lp );
359 // Holding the lock too long, make a gap to allow other processes
360 wl_unlock(lp, &flags);
361 wl_lock( lp, &flags );
363 if( status != HCF_SUCCESS ) {
364 // Unsuccessful, try reset of the card to recover
365 status = wl_reset( dev );
368 // Holding the lock too long, make a gap to allow other processes
369 wl_unlock(lp, &flags);
370 wl_lock( lp, &flags );
372 if( status == HCF_SUCCESS ) {
373 netif_carrier_on( dev );
374 WL_WDS_NETIF_CARRIER_ON( lp );
376 lp->is_handling_int = WL_HANDLING_INT; // Start handling interrupts
379 netif_start_queue( dev );
380 WL_WDS_NETIF_START_QUEUE( lp );
382 wl_hcf_error( dev, status ); /* Report the error */
383 netif_device_detach( dev ); /* Stop the device and queue */
386 wl_unlock( lp, &flags );
388 DBG_LEAVE( DbgInfo );
391 /*============================================================================*/
393 /*******************************************************************************
395 *******************************************************************************
403 * dev - a pointer to the device's net_device structure
410 ******************************************************************************/
411 int wl_close( struct net_device *dev )
413 struct wl_private *lp = wl_priv(dev);
415 /*------------------------------------------------------------------------*/
417 DBG_FUNC("wl_close");
419 DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
421 /* Mark the adapter as busy */
422 netif_stop_queue( dev );
423 WL_WDS_NETIF_STOP_QUEUE( lp );
425 netif_carrier_off( dev );
426 WL_WDS_NETIF_CARRIER_OFF( lp );
428 /* Shutdown the adapter:
429 Disable adapter interrupts
435 wl_lock( lp, &flags );
437 wl_act_int_off( lp );
438 lp->is_handling_int = WL_NOT_HANDLING_INT; // Stop handling interrupts
441 if( lp->useRTS == 1 ) {
442 DBG_TRACE( DbgInfo, "Skipping device close, in RTS mode\n" );
443 wl_unlock( lp, &flags );
444 DBG_LEAVE( DbgInfo );
449 /* Disable the ports */
452 wl_unlock( lp, &flags );
454 DBG_LEAVE( DbgInfo );
457 /*============================================================================*/
459 static void wl_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
461 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver) - 1);
462 strncpy(info->version, DRV_VERSION_STR, sizeof(info->version) - 1);
463 // strncpy(info.fw_version, priv->fw_name,
464 // sizeof(info.fw_version) - 1);
466 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,20))
467 if (dev->dev.parent) {
468 dev_set_name(dev->dev.parent, "%s", info->bus_info);
469 //strncpy(info->bus_info, dev->dev.parent->bus_id,
470 // sizeof(info->bus_info) - 1);
472 if (dev->class_dev.parent) {
473 sizeof(info->bus_info) - 1);
476 snprintf(info->bus_info, sizeof(info->bus_info) - 1,
478 // "PCMCIA 0x%lx", priv->hw.iobase);
482 static struct ethtool_ops wl_ethtool_ops = {
483 .get_drvinfo = wl_get_drvinfo,
484 .get_link = ethtool_op_get_link,
488 /*******************************************************************************
490 *******************************************************************************
494 * The IOCTL handler for the device.
498 * dev - a pointer to the device's net_device struct.
499 * rq - a pointer to the IOCTL request buffer.
500 * cmd - the IOCTL command code.
505 * errno value otherwise
507 ******************************************************************************/
508 int wl_ioctl( struct net_device *dev, struct ifreq *rq, int cmd )
510 struct wl_private *lp = wl_priv(dev);
513 /*------------------------------------------------------------------------*/
515 DBG_FUNC( "wl_ioctl" );
517 DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
518 DBG_PARAM(DbgInfo, "rq", "0x%p", rq);
519 DBG_PARAM(DbgInfo, "cmd", "0x%04x", cmd);
521 wl_lock( lp, &flags );
523 wl_act_int_off( lp );
526 if( lp->useRTS == 1 ) {
527 /* Handle any RTS IOCTL here */
528 if( cmd == WL_IOCTL_RTS ) {
529 DBG_TRACE( DbgInfo, "IOCTL: WL_IOCTL_RTS\n" );
530 ret = wvlan_rts( (struct rtsreq *)rq, dev->base_addr );
532 DBG_TRACE( DbgInfo, "IOCTL not supported in RTS mode: 0x%X\n", cmd );
536 goto out_act_int_on_unlock;
540 /* Only handle UIL IOCTL requests when the UIL has the system blocked. */
541 if( !(( lp->flags & WVLAN2_UIL_BUSY ) && ( cmd != WVLAN2_IOCTL_UIL ))) {
543 struct uilreq *urq = (struct uilreq *)rq;
547 // ================== Private IOCTLs (up to 16) ==================
549 case WVLAN2_IOCTL_UIL:
550 DBG_TRACE( DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL\n" );
551 ret = wvlan_uil( urq, lp );
556 DBG_TRACE(DbgInfo, "IOCTL CODE NOT SUPPORTED: 0x%X\n", cmd );
561 DBG_WARNING( DbgInfo, "DEVICE IS BUSY, CANNOT PROCESS REQUEST\n" );
566 out_act_int_on_unlock:
570 wl_unlock( lp, &flags );
572 DBG_LEAVE( DbgInfo );
575 /*============================================================================*/
577 #ifdef CONFIG_NET_POLL_CONTROLLER
578 void wl_poll(struct net_device *dev)
580 struct wl_private *lp = wl_priv(dev);
584 wl_lock( lp, &flags );
585 wl_isr(dev->irq, dev, ®s);
586 wl_unlock( lp, &flags );
590 /*******************************************************************************
592 *******************************************************************************
596 * The handler called when, for some reason, a Tx request is not completed.
600 * dev - a pointer to the device's net_device struct.
606 ******************************************************************************/
607 void wl_tx_timeout( struct net_device *dev )
613 struct wl_private *lp = wl_priv(dev);
614 struct net_device_stats *pStats = NULL;
615 /*------------------------------------------------------------------------*/
617 DBG_FUNC( "wl_tx_timeout" );
618 DBG_ENTER( DbgInfo );
620 DBG_WARNING( DbgInfo, "%s: Transmit timeout.\n", dev->name );
622 wl_lock( lp, &flags );
625 if( lp->useRTS == 1 ) {
626 DBG_TRACE( DbgInfo, "Skipping tx_timeout handler, in RTS mode\n" );
627 wl_unlock( lp, &flags );
629 DBG_LEAVE( DbgInfo );
634 /* Figure out which device (the "root" device or WDS port) this timeout
638 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
639 if( dev == lp->wds_port[count].dev ) {
640 pStats = &( lp->wds_port[count].stats );
642 /* Break the loop so that we can use the counter to access WDS
643 information in the private structure */
650 /* If pStats is still NULL, then the device is not a WDS port */
651 if( pStats == NULL ) {
652 pStats = &( lp->stats );
655 /* Accumulate the timeout error */
658 wl_unlock( lp, &flags );
660 DBG_LEAVE( DbgInfo );
663 /*============================================================================*/
665 /*******************************************************************************
667 *******************************************************************************
671 * The routine which performs data transmits.
675 * lp - a pointer to the device's wl_private struct.
682 ******************************************************************************/
683 int wl_send( struct wl_private *lp )
688 WVLAN_LFRAME *txF = NULL;
689 struct list_head *element;
691 /*------------------------------------------------------------------------*/
693 DBG_FUNC( "wl_send" );
696 DBG_ERROR( DbgInfo, "Private adapter struct is NULL\n" );
699 if( lp->dev == NULL ) {
700 DBG_ERROR( DbgInfo, "net_device struct in wl_private is NULL\n" );
704 /* Check for the availability of FIDs; if none are available, don't take any
705 frames off the txQ */
706 if( lp->hcfCtx.IFB_RscInd == 0 ) {
710 /* Reclaim the TxQ Elements and place them back on the free queue */
711 if( !list_empty( &( lp->txQ[0] ))) {
712 element = lp->txQ[0].next;
714 txF = (WVLAN_LFRAME * )list_entry( element, WVLAN_LFRAME, node );
716 lp->txF.skb = txF->frame.skb;
717 lp->txF.port = txF->frame.port;
719 txF->frame.skb = NULL;
722 list_del( &( txF->node ));
723 list_add( element, &( lp->txFree ));
727 if( lp->txQ_count < TX_Q_LOW_WATER_MARK ) {
728 if( lp->netif_queue_on == FALSE ) {
729 DBG_TX( DbgInfo, "Kickstarting Q: %d\n", lp->txQ_count );
730 netif_wake_queue( lp->dev );
731 WL_WDS_NETIF_WAKE_QUEUE( lp );
732 lp->netif_queue_on = TRUE;
738 if( lp->txF.skb == NULL ) {
742 /* If the device has resources (FIDs) available, then Tx the packet */
743 /* Format the TxRequest and send it to the adapter */
744 len = lp->txF.skb->len < ETH_ZLEN ? ETH_ZLEN : lp->txF.skb->len;
746 desc = &( lp->desc_tx );
747 desc->buf_addr = lp->txF.skb->data;
749 desc->next_desc_addr = NULL;
751 status = hcf_send_msg( &( lp->hcfCtx ), desc, lp->txF.port );
753 if( status == HCF_SUCCESS ) {
754 lp->dev->trans_start = jiffies;
756 DBG_TX( DbgInfo, "Transmit...\n" );
758 if( lp->txF.port == HCF_PORT_0 ) {
759 lp->stats.tx_packets++;
760 lp->stats.tx_bytes += lp->txF.skb->len;
766 lp->wds_port[(( lp->txF.port >> 8 ) - 1)].stats.tx_packets++;
767 lp->wds_port[(( lp->txF.port >> 8 ) - 1)].stats.tx_bytes += lp->txF.skb->len;
772 /* Free the skb and perform queue cleanup, as the buffer was
773 transmitted successfully */
774 dev_kfree_skb( lp->txF.skb );
782 /*============================================================================*/
784 /*******************************************************************************
786 *******************************************************************************
790 * The Tx handler function for the network layer.
794 * skb - a pointer to the sk_buff structure containing the data to transfer.
795 * dev - a pointer to the device's net_device structure.
802 ******************************************************************************/
803 int wl_tx( struct sk_buff *skb, struct net_device *dev, int port )
806 struct wl_private *lp = wl_priv(dev);
807 WVLAN_LFRAME *txF = NULL;
808 struct list_head *element;
809 /*------------------------------------------------------------------------*/
813 /* Grab the spinlock */
814 wl_lock( lp, &flags );
816 if( lp->flags & WVLAN2_UIL_BUSY ) {
817 DBG_WARNING( DbgInfo, "UIL has device blocked\n" );
818 /* Start dropping packets here??? */
819 wl_unlock( lp, &flags );
824 if( lp->useRTS == 1 ) {
825 DBG_PRINT( "RTS: we're getting a Tx...\n" );
826 wl_unlock( lp, &flags );
832 /* Get an element from the queue */
833 element = lp->txFree.next;
834 txF = (WVLAN_LFRAME *)list_entry( element, WVLAN_LFRAME, node );
836 DBG_ERROR( DbgInfo, "Problem with list_entry\n" );
837 wl_unlock( lp, &flags );
840 /* Fill out the frame */
841 txF->frame.skb = skb;
842 txF->frame.port = port;
843 /* Move the frame to the txQ */
844 /* NOTE: Here's where we would do priority queueing */
845 list_del( &( txF->node ));
846 list_add( &( txF->node ), &( lp->txQ[0] ));
849 if( lp->txQ_count >= DEFAULT_NUM_TX_FRAMES ) {
850 DBG_TX( DbgInfo, "Q Full: %d\n", lp->txQ_count );
851 if( lp->netif_queue_on == TRUE ) {
852 netif_stop_queue( lp->dev );
853 WL_WDS_NETIF_STOP_QUEUE( lp );
854 lp->netif_queue_on = FALSE;
858 wl_act_int_off( lp ); /* Disable Interrupts */
860 /* Send the data to the hardware using the appropriate method */
863 wl_send_dma( lp, skb, port );
870 /* Re-enable Interrupts, release the spinlock and return */
872 wl_unlock( lp, &flags );
875 /*============================================================================*/
877 /*******************************************************************************
879 *******************************************************************************
883 * The routine which performs data reception.
887 * dev - a pointer to the device's net_device structure.
894 ******************************************************************************/
895 int wl_rx(struct net_device *dev)
899 struct wl_private *lp = wl_priv(dev);
904 /*------------------------------------------------------------------------*/
907 DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
909 if(!( lp->flags & WVLAN2_UIL_BUSY )) {
912 if( lp->useRTS == 1 ) {
913 DBG_PRINT( "RTS: We're getting an Rx...\n" );
918 /* Read the HFS_STAT register from the lookahead buffer */
919 hfs_stat = (hcf_16)(( lp->lookAheadBuf[HFS_STAT] ) |
920 ( lp->lookAheadBuf[HFS_STAT + 1] << 8 ));
922 /* Make sure the frame isn't bad */
923 if(( hfs_stat & HFS_STAT_ERR ) != HCF_SUCCESS ) {
924 DBG_WARNING( DbgInfo, "HFS_STAT_ERROR (0x%x) in Rx Packet\n",
925 lp->lookAheadBuf[HFS_STAT] );
929 /* Determine what port this packet is for */
930 port = ( hfs_stat >> 8 ) & 0x0007;
931 DBG_RX( DbgInfo, "Rx frame for port %d\n", port );
933 if(( pktlen = lp->hcfCtx.IFB_RxLen ) != 0 ) {
934 if(( skb = ALLOC_SKB( pktlen )) != NULL ) {
935 /* Set the netdev based on the port */
944 skb->dev = lp->wds_port[port-1].dev;
954 desc = &( lp->desc_rx );
956 desc->next_desc_addr = NULL;
959 #define BLOCK_INPUT(buf, len) \
960 desc->buf_addr = buf; \
961 desc->BUF_SIZE = len; \
962 status = hcf_rcv_msg(&(lp->hcfCtx), desc, 0)
965 GET_PACKET( skb->dev, skb, pktlen );
967 if( status == HCF_SUCCESS ) {
971 lp->stats.rx_packets++;
972 lp->stats.rx_bytes += pktlen;
977 lp->wds_port[port-1].stats.rx_packets++;
978 lp->wds_port[port-1].stats.rx_bytes += pktlen;
982 dev->last_rx = jiffies;
986 if( lp->spydata.spy_number > 0 ) {
987 char *srcaddr = skb->mac.raw + MAC_ADDR_SIZE;
989 wl_spy_gather( dev, srcaddr );
991 #endif /* WIRELESS_SPY */
992 #endif /* WIRELESS_EXT */
994 DBG_ERROR( DbgInfo, "Rx request to card FAILED\n" );
997 lp->stats.rx_dropped++;
1002 lp->wds_port[port-1].stats.rx_dropped++;
1004 #endif /* USE_WDS */
1006 dev_kfree_skb( skb );
1009 DBG_ERROR( DbgInfo, "Could not alloc skb\n" );
1012 lp->stats.rx_dropped++;
1017 lp->wds_port[port-1].stats.rx_dropped++;
1019 #endif /* USE_WDS */
1026 /*============================================================================*/
1028 /*******************************************************************************
1030 *******************************************************************************
1034 * Function to handle multicast packets
1038 * dev - a pointer to the device's net_device structure.
1044 ******************************************************************************/
1045 #ifdef NEW_MULTICAST
1047 void wl_multicast( struct net_device *dev )
1049 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA //;?should we return an error status in AP mode
1050 //;?seems reasonable that even an AP-only driver could afford this small additional footprint
1053 struct netdev_hw_addr *ha;
1054 struct wl_private *lp = wl_priv(dev);
1055 unsigned long flags;
1056 /*------------------------------------------------------------------------*/
1058 DBG_FUNC( "wl_multicast" );
1059 DBG_ENTER( DbgInfo );
1060 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
1062 if( !wl_adapter_is_open( dev )) {
1063 DBG_LEAVE( DbgInfo );
1068 if( DBG_FLAGS( DbgInfo ) & DBG_PARAM_ON ) {
1069 DBG_PRINT(" flags: %s%s%s\n",
1070 ( dev->flags & IFF_PROMISC ) ? "Promiscous " : "",
1071 ( dev->flags & IFF_MULTICAST ) ? "Multicast " : "",
1072 ( dev->flags & IFF_ALLMULTI ) ? "All-Multicast" : "" );
1074 DBG_PRINT( " mc_count: %d\n", netdev_mc_count(dev));
1076 netdev_for_each_mc_addr(ha, dev)
1077 DBG_PRINT(" %s (%d)\n", DbgHwAddr(ha->addr),
1082 if(!( lp->flags & WVLAN2_UIL_BUSY )) {
1085 if( lp->useRTS == 1 ) {
1086 DBG_TRACE( DbgInfo, "Skipping multicast, in RTS mode\n" );
1088 DBG_LEAVE( DbgInfo );
1091 #endif /* USE_RTS */
1093 wl_lock( lp, &flags );
1094 wl_act_int_off( lp );
1096 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
1097 if( dev->flags & IFF_PROMISC ) {
1098 /* Enable promiscuous mode */
1099 lp->ltvRecord.len = 2;
1100 lp->ltvRecord.typ = CFG_PROMISCUOUS_MODE;
1101 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 1 );
1102 DBG_PRINT( "Enabling Promiscuous mode (IFF_PROMISC)\n" );
1103 hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1105 else if ((netdev_mc_count(dev) > HCF_MAX_MULTICAST) ||
1106 ( dev->flags & IFF_ALLMULTI )) {
1107 /* Shutting off this filter will enable all multicast frames to
1108 be sent up from the device; however, this is a static RID, so
1109 a call to wl_apply() is needed */
1110 lp->ltvRecord.len = 2;
1111 lp->ltvRecord.typ = CFG_CNF_RX_ALL_GROUP_ADDR;
1112 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1113 DBG_PRINT( "Enabling all multicast mode (IFF_ALLMULTI)\n" );
1114 hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1117 else if (!netdev_mc_empty(dev)) {
1118 /* Set the multicast addresses */
1119 lp->ltvRecord.len = ( netdev_mc_count(dev) * 3 ) + 1;
1120 lp->ltvRecord.typ = CFG_GROUP_ADDR;
1123 netdev_for_each_mc_addr(ha, dev)
1124 memcpy(&(lp->ltvRecord.u.u8[x++ * ETH_ALEN]),
1125 ha->addr, ETH_ALEN);
1126 DBG_PRINT( "Setting multicast list\n" );
1127 hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1129 /* Disable promiscuous mode */
1130 lp->ltvRecord.len = 2;
1131 lp->ltvRecord.typ = CFG_PROMISCUOUS_MODE;
1132 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1133 DBG_PRINT( "Disabling Promiscuous mode\n" );
1134 hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1136 /* Disable multicast mode */
1137 lp->ltvRecord.len = 2;
1138 lp->ltvRecord.typ = CFG_GROUP_ADDR;
1139 DBG_PRINT( "Disabling Multicast mode\n" );
1140 hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1142 /* Turning on this filter will prevent all multicast frames from
1143 being sent up from the device; however, this is a static RID,
1144 so a call to wl_apply() is needed */
1145 lp->ltvRecord.len = 2;
1146 lp->ltvRecord.typ = CFG_CNF_RX_ALL_GROUP_ADDR;
1147 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 1 );
1148 DBG_PRINT( "Disabling all multicast mode (IFF_ALLMULTI)\n" );
1149 hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1153 wl_act_int_on( lp );
1154 wl_unlock( lp, &flags );
1156 DBG_LEAVE( DbgInfo );
1157 #endif /* HCF_STA */
1159 /*============================================================================*/
1161 #else /* NEW_MULTICAST */
1163 void wl_multicast( struct net_device *dev, int num_addrs, void *addrs )
1165 DBG_FUNC( "wl_multicast");
1168 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
1169 DBG_PARAM( DbgInfo, "num_addrs", "%d", num_addrs );
1170 DBG_PARAM( DbgInfo, "addrs", "0x%p", addrs );
1172 #error Obsolete set multicast interface!
1174 DBG_LEAVE( DbgInfo );
1176 /*============================================================================*/
1178 #endif /* NEW_MULTICAST */
1180 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30))
1181 static const struct net_device_ops wl_netdev_ops =
1183 .ndo_start_xmit = &wl_tx_port0,
1185 .ndo_set_config = &wl_config,
1186 .ndo_get_stats = &wl_stats,
1187 .ndo_set_multicast_list = &wl_multicast,
1189 .ndo_init = &wl_insert,
1190 .ndo_open = &wl_adapter_open,
1191 .ndo_stop = &wl_adapter_close,
1192 .ndo_do_ioctl = &wl_ioctl,
1194 .ndo_tx_timeout = &wl_tx_timeout,
1196 #ifdef CONFIG_NET_POLL_CONTROLLER
1197 .ndo_poll_controller = wl_poll,
1200 #endif // (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30))
1202 /*******************************************************************************
1204 *******************************************************************************
1208 * Create instances of net_device and wl_private for the new adapter
1209 * and register the device's entry points in the net_device structure.
1217 * a pointer to an allocated and initialized net_device struct for this
1220 ******************************************************************************/
1221 struct net_device * wl_device_alloc( void )
1223 struct net_device *dev = NULL;
1224 struct wl_private *lp = NULL;
1225 /*------------------------------------------------------------------------*/
1227 DBG_FUNC( "wl_device_alloc" );
1228 DBG_ENTER( DbgInfo );
1230 /* Alloc a net_device struct */
1231 dev = alloc_etherdev(sizeof(struct wl_private));
1235 /* Initialize the 'next' pointer in the struct. Currently only used for PCI,
1236 but do it here just in case it's used for other buses in the future */
1241 if( dev->mtu > MTU_MAX )
1243 DBG_WARNING( DbgInfo, "%s: MTU set too high, limiting to %d.\n",
1244 dev->name, MTU_MAX );
1248 /* Setup the function table in the device structure. */
1250 dev->wireless_handlers = (struct iw_handler_def *)&wl_iw_handler_def;
1251 lp->wireless_data.spy_data = &lp->spy_data;
1252 dev->wireless_data = &lp->wireless_data;
1254 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30))
1255 dev->netdev_ops = &wl_netdev_ops;
1257 dev->hard_start_xmit = &wl_tx_port0;
1259 dev->set_config = &wl_config;
1260 dev->get_stats = &wl_stats;
1261 dev->set_multicast_list = &wl_multicast;
1263 dev->init = &wl_insert;
1264 dev->open = &wl_adapter_open;
1265 dev->stop = &wl_adapter_close;
1266 dev->do_ioctl = &wl_ioctl;
1268 dev->tx_timeout = &wl_tx_timeout;
1270 #ifdef CONFIG_NET_POLL_CONTROLLER
1271 dev->poll_controller = wl_poll;
1274 #endif // (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30))
1276 dev->watchdog_timeo = TX_TIMEOUT;
1278 dev->ethtool_ops = &wl_ethtool_ops;
1280 netif_stop_queue( dev );
1282 /* Allocate virutal devices for WDS support if needed */
1283 WL_WDS_DEVICE_ALLOC( lp );
1285 DBG_LEAVE( DbgInfo );
1287 } // wl_device_alloc
1288 /*============================================================================*/
1290 /*******************************************************************************
1291 * wl_device_dealloc()
1292 *******************************************************************************
1296 * Free instances of net_device and wl_private strcutres for an adapter
1297 * and perform basic cleanup.
1301 * dev - a pointer to the device's net_device structure.
1307 ******************************************************************************/
1308 void wl_device_dealloc( struct net_device *dev )
1310 // struct wl_private *lp = wl_priv(dev);
1311 /*------------------------------------------------------------------------*/
1313 DBG_FUNC( "wl_device_dealloc" );
1314 DBG_ENTER( DbgInfo );
1316 /* Dealloc the WDS ports */
1317 WL_WDS_DEVICE_DEALLOC( lp );
1321 DBG_LEAVE( DbgInfo );
1323 } // wl_device_dealloc
1324 /*============================================================================*/
1326 /*******************************************************************************
1328 *******************************************************************************
1332 * The handler routine for Tx over HCF_PORT_0.
1336 * skb - a pointer to the sk_buff to transmit.
1337 * dev - a pointer to a net_device structure representing HCF_PORT_0.
1343 ******************************************************************************/
1344 int wl_tx_port0( struct sk_buff *skb, struct net_device *dev )
1346 DBG_TX( DbgInfo, "Tx on Port 0\n" );
1348 return wl_tx( skb, dev, HCF_PORT_0 );
1350 return wl_tx_dma( skb, dev, HCF_PORT_0 );
1353 /*============================================================================*/
1357 /*******************************************************************************
1359 *******************************************************************************
1363 * The handler routine for Tx over HCF_PORT_1.
1367 * skb - a pointer to the sk_buff to transmit.
1368 * dev - a pointer to a net_device structure representing HCF_PORT_1.
1374 ******************************************************************************/
1375 int wl_tx_port1( struct sk_buff *skb, struct net_device *dev )
1377 DBG_TX( DbgInfo, "Tx on Port 1\n" );
1378 return wl_tx( skb, dev, HCF_PORT_1 );
1380 /*============================================================================*/
1382 /*******************************************************************************
1384 *******************************************************************************
1388 * The handler routine for Tx over HCF_PORT_2.
1392 * skb - a pointer to the sk_buff to transmit.
1393 * dev - a pointer to a net_device structure representing HCF_PORT_2.
1399 ******************************************************************************/
1400 int wl_tx_port2( struct sk_buff *skb, struct net_device *dev )
1402 DBG_TX( DbgInfo, "Tx on Port 2\n" );
1403 return wl_tx( skb, dev, HCF_PORT_2 );
1405 /*============================================================================*/
1407 /*******************************************************************************
1409 *******************************************************************************
1413 * The handler routine for Tx over HCF_PORT_3.
1417 * skb - a pointer to the sk_buff to transmit.
1418 * dev - a pointer to a net_device structure representing HCF_PORT_3.
1424 ******************************************************************************/
1425 int wl_tx_port3( struct sk_buff *skb, struct net_device *dev )
1427 DBG_TX( DbgInfo, "Tx on Port 3\n" );
1428 return wl_tx( skb, dev, HCF_PORT_3 );
1430 /*============================================================================*/
1432 /*******************************************************************************
1434 *******************************************************************************
1438 * The handler routine for Tx over HCF_PORT_4.
1442 * skb - a pointer to the sk_buff to transmit.
1443 * dev - a pointer to a net_device structure representing HCF_PORT_4.
1449 ******************************************************************************/
1450 int wl_tx_port4( struct sk_buff *skb, struct net_device *dev )
1452 DBG_TX( DbgInfo, "Tx on Port 4\n" );
1453 return wl_tx( skb, dev, HCF_PORT_4 );
1455 /*============================================================================*/
1457 /*******************************************************************************
1459 *******************************************************************************
1463 * The handler routine for Tx over HCF_PORT_5.
1467 * skb - a pointer to the sk_buff to transmit.
1468 * dev - a pointer to a net_device structure representing HCF_PORT_5.
1474 ******************************************************************************/
1475 int wl_tx_port5( struct sk_buff *skb, struct net_device *dev )
1477 DBG_TX( DbgInfo, "Tx on Port 5\n" );
1478 return wl_tx( skb, dev, HCF_PORT_5 );
1480 /*============================================================================*/
1482 /*******************************************************************************
1484 *******************************************************************************
1488 * The handler routine for Tx over HCF_PORT_6.
1492 * skb - a pointer to the sk_buff to transmit.
1493 * dev - a pointer to a net_device structure representing HCF_PORT_6.
1499 ******************************************************************************/
1500 int wl_tx_port6( struct sk_buff *skb, struct net_device *dev )
1502 DBG_TX( DbgInfo, "Tx on Port 6\n" );
1503 return wl_tx( skb, dev, HCF_PORT_6 );
1505 /*============================================================================*/
1507 /*******************************************************************************
1508 * wl_wds_device_alloc()
1509 *******************************************************************************
1513 * Create instances of net_device to represent the WDS ports, and register
1514 * the device's entry points in the net_device structure.
1518 * lp - a pointer to the device's private adapter structure
1522 * N/A, but will place pointers to the allocated and initialized net_device
1523 * structs in the private adapter structure.
1525 ******************************************************************************/
1526 void wl_wds_device_alloc( struct wl_private *lp )
1529 /*------------------------------------------------------------------------*/
1531 DBG_FUNC( "wl_wds_device_alloc" );
1532 DBG_ENTER( DbgInfo );
1534 /* WDS support requires additional net_device structs to be allocated,
1535 so that user space apps can use these virtual devices to specify the
1536 port on which to Tx/Rx */
1537 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1538 struct net_device *dev_wds = NULL;
1540 dev_wds = kmalloc( sizeof( struct net_device ), GFP_KERNEL );
1541 memset( dev_wds, 0, sizeof( struct net_device ));
1543 ether_setup( dev_wds );
1545 lp->wds_port[count].dev = dev_wds;
1547 /* Re-use wl_init for all the devices, as it currently does nothing, but
1548 is required. Re-use the stats/tx_timeout handler for all as well; the
1549 WDS port which is requesting these operations can be determined by
1550 the net_device pointer. Set the private member of all devices to point
1551 to the same net_device struct; that way, all information gets
1552 funnelled through the one "real" net_device. Name the WDS ports
1554 lp->wds_port[count].dev->init = &wl_init;
1555 lp->wds_port[count].dev->get_stats = &wl_stats;
1556 lp->wds_port[count].dev->tx_timeout = &wl_tx_timeout;
1557 lp->wds_port[count].dev->watchdog_timeo = TX_TIMEOUT;
1558 lp->wds_port[count].dev->priv = lp;
1560 sprintf( lp->wds_port[count].dev->name, "wds%d", count );
1563 /* Register the Tx handlers */
1564 lp->wds_port[0].dev->hard_start_xmit = &wl_tx_port1;
1565 lp->wds_port[1].dev->hard_start_xmit = &wl_tx_port2;
1566 lp->wds_port[2].dev->hard_start_xmit = &wl_tx_port3;
1567 lp->wds_port[3].dev->hard_start_xmit = &wl_tx_port4;
1568 lp->wds_port[4].dev->hard_start_xmit = &wl_tx_port5;
1569 lp->wds_port[5].dev->hard_start_xmit = &wl_tx_port6;
1571 WL_WDS_NETIF_STOP_QUEUE( lp );
1573 DBG_LEAVE( DbgInfo );
1575 } // wl_wds_device_alloc
1576 /*============================================================================*/
1578 /*******************************************************************************
1579 * wl_wds_device_dealloc()
1580 *******************************************************************************
1584 * Free instances of net_device structures used to support WDS.
1588 * lp - a pointer to the device's private adapter structure
1594 ******************************************************************************/
1595 void wl_wds_device_dealloc( struct wl_private *lp )
1598 /*------------------------------------------------------------------------*/
1600 DBG_FUNC( "wl_wds_device_dealloc" );
1601 DBG_ENTER( DbgInfo );
1603 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1604 struct net_device *dev_wds = NULL;
1606 dev_wds = lp->wds_port[count].dev;
1608 if( dev_wds != NULL ) {
1609 if( dev_wds->flags & IFF_UP ) {
1610 dev_close( dev_wds );
1611 dev_wds->flags &= ~( IFF_UP | IFF_RUNNING );
1615 lp->wds_port[count].dev = NULL;
1619 DBG_LEAVE( DbgInfo );
1621 } // wl_wds_device_dealloc
1622 /*============================================================================*/
1624 /*******************************************************************************
1625 * wl_wds_netif_start_queue()
1626 *******************************************************************************
1630 * Used to start the netif queues of all the "virtual" network devices
1631 * which repesent the WDS ports.
1635 * lp - a pointer to the device's private adapter structure
1641 ******************************************************************************/
1642 void wl_wds_netif_start_queue( struct wl_private *lp )
1645 /*------------------------------------------------------------------------*/
1648 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1649 if( lp->wds_port[count].is_registered &&
1650 lp->wds_port[count].netif_queue_on == FALSE ) {
1651 netif_start_queue( lp->wds_port[count].dev );
1652 lp->wds_port[count].netif_queue_on = TRUE;
1658 } // wl_wds_netif_start_queue
1659 /*============================================================================*/
1661 /*******************************************************************************
1662 * wl_wds_netif_stop_queue()
1663 *******************************************************************************
1667 * Used to stop the netif queues of all the "virtual" network devices
1668 * which repesent the WDS ports.
1672 * lp - a pointer to the device's private adapter structure
1678 ******************************************************************************/
1679 void wl_wds_netif_stop_queue( struct wl_private *lp )
1682 /*------------------------------------------------------------------------*/
1685 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1686 if( lp->wds_port[count].is_registered &&
1687 lp->wds_port[count].netif_queue_on == TRUE ) {
1688 netif_stop_queue( lp->wds_port[count].dev );
1689 lp->wds_port[count].netif_queue_on = FALSE;
1695 } // wl_wds_netif_stop_queue
1696 /*============================================================================*/
1698 /*******************************************************************************
1699 * wl_wds_netif_wake_queue()
1700 *******************************************************************************
1704 * Used to wake the netif queues of all the "virtual" network devices
1705 * which repesent the WDS ports.
1709 * lp - a pointer to the device's private adapter structure
1715 ******************************************************************************/
1716 void wl_wds_netif_wake_queue( struct wl_private *lp )
1719 /*------------------------------------------------------------------------*/
1722 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1723 if( lp->wds_port[count].is_registered &&
1724 lp->wds_port[count].netif_queue_on == FALSE ) {
1725 netif_wake_queue( lp->wds_port[count].dev );
1726 lp->wds_port[count].netif_queue_on = TRUE;
1732 } // wl_wds_netif_wake_queue
1733 /*============================================================================*/
1735 /*******************************************************************************
1736 * wl_wds_netif_carrier_on()
1737 *******************************************************************************
1741 * Used to signal the network layer that carrier is present on all of the
1742 * "virtual" network devices which repesent the WDS ports.
1746 * lp - a pointer to the device's private adapter structure
1752 ******************************************************************************/
1753 void wl_wds_netif_carrier_on( struct wl_private *lp )
1756 /*------------------------------------------------------------------------*/
1759 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1760 if( lp->wds_port[count].is_registered ) {
1761 netif_carrier_on( lp->wds_port[count].dev );
1767 } // wl_wds_netif_carrier_on
1768 /*============================================================================*/
1770 /*******************************************************************************
1771 * wl_wds_netif_carrier_off()
1772 *******************************************************************************
1776 * Used to signal the network layer that carrier is NOT present on all of
1777 * the "virtual" network devices which repesent the WDS ports.
1781 * lp - a pointer to the device's private adapter structure
1787 ******************************************************************************/
1788 void wl_wds_netif_carrier_off( struct wl_private *lp )
1791 /*------------------------------------------------------------------------*/
1794 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
1795 if( lp->wds_port[count].is_registered ) {
1796 netif_carrier_off( lp->wds_port[count].dev );
1802 } // wl_wds_netif_carrier_off
1803 /*============================================================================*/
1805 #endif /* USE_WDS */
1808 /*******************************************************************************
1810 *******************************************************************************
1814 * The routine which performs data transmits when using busmaster DMA.
1818 * lp - a pointer to the device's wl_private struct.
1819 * skb - a pointer to the network layer's data buffer.
1820 * port - the Hermes port on which to transmit.
1827 ******************************************************************************/
1828 int wl_send_dma( struct wl_private *lp, struct sk_buff *skb, int port )
1831 DESC_STRCT *desc = NULL;
1832 DESC_STRCT *desc_next = NULL;
1833 /*------------------------------------------------------------------------*/
1835 DBG_FUNC( "wl_send_dma" );
1839 DBG_ERROR( DbgInfo, "Private adapter struct is NULL\n" );
1843 if( lp->dev == NULL )
1845 DBG_ERROR( DbgInfo, "net_device struct in wl_private is NULL\n" );
1849 /* AGAIN, ALL THE QUEUEING DONE HERE IN I/O MODE IS NOT PERFORMED */
1853 DBG_WARNING (DbgInfo, "Nothing to send.\n");
1859 /* Get a free descriptor */
1860 desc = wl_pci_dma_get_tx_packet( lp );
1864 if( lp->netif_queue_on == TRUE ) {
1865 netif_stop_queue( lp->dev );
1866 WL_WDS_NETIF_STOP_QUEUE( lp );
1867 lp->netif_queue_on = FALSE;
1869 dev_kfree_skb( skb );
1874 SET_BUF_CNT( desc, /*HCF_DMA_FD_CNT*/HFS_ADDR_DEST );
1875 SET_BUF_SIZE( desc, HCF_DMA_TX_BUF1_SIZE );
1877 desc_next = desc->next_desc_addr;
1879 if( desc_next->buf_addr == NULL )
1881 DBG_ERROR( DbgInfo, "DMA descriptor buf_addr is NULL\n" );
1885 /* Copy the payload into the DMA packet */
1886 memcpy( desc_next->buf_addr, skb->data, len );
1888 SET_BUF_CNT( desc_next, len );
1889 SET_BUF_SIZE( desc_next, HCF_MAX_PACKET_SIZE );
1891 hcf_dma_tx_put( &( lp->hcfCtx ), desc, 0 );
1893 /* Free the skb and perform queue cleanup, as the buffer was
1894 transmitted successfully */
1895 dev_kfree_skb( skb );
1899 /*============================================================================*/
1901 /*******************************************************************************
1903 *******************************************************************************
1907 * The routine which performs data reception when using busmaster DMA.
1911 * dev - a pointer to the device's net_device structure.
1918 ******************************************************************************/
1919 int wl_rx_dma( struct net_device *dev )
1924 struct sk_buff *skb;
1925 struct wl_private *lp = NULL;
1926 DESC_STRCT *desc, *desc_next;
1927 //CFG_MB_INFO_RANGE2_STRCT x;
1928 /*------------------------------------------------------------------------*/
1931 DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
1933 if((( lp = (struct wl_private *)dev->priv ) != NULL ) &&
1934 !( lp->flags & WVLAN2_UIL_BUSY )) {
1937 if( lp->useRTS == 1 ) {
1938 DBG_PRINT( "RTS: We're getting an Rx...\n" );
1941 #endif /* USE_RTS */
1943 //if( lp->dma.status == 0 )
1945 desc = hcf_dma_rx_get( &( lp->hcfCtx ));
1949 /* Check and see if we rcvd. a WMP frame */
1951 if((( *(hcf_8 *)&desc->buf_addr[HFS_STAT] ) &
1952 ( HFS_STAT_MSG_TYPE | HFS_STAT_ERR )) == HFS_STAT_WMP_MSG )
1954 DBG_TRACE( DbgInfo, "Got a WMP frame\n" );
1956 x.len = sizeof( CFG_MB_INFO_RANGE2_STRCT ) / sizeof( hcf_16 );
1957 x.typ = CFG_MB_INFO;
1958 x.base_typ = CFG_WMP;
1960 x.frag_buf[0].frag_len = GET_BUF_CNT( descp ) / sizeof( hcf_16 );
1961 x.frag_buf[0].frag_addr = (hcf_8 *) descp->buf_addr ;
1962 x.frag_buf[1].frag_len = ( GET_BUF_CNT( descp->next_desc_addr ) + 1 ) / sizeof( hcf_16 );
1963 x.frag_buf[1].frag_addr = (hcf_8 *) descp->next_desc_addr->buf_addr ;
1965 hcf_put_info( &( lp->hcfCtx ), (LTVP)&x );
1969 desc_next = desc->next_desc_addr;
1971 /* Make sure the buffer isn't empty */
1972 if( GET_BUF_CNT( desc ) == 0 ) {
1973 DBG_WARNING( DbgInfo, "Buffer is empty!\n" );
1975 /* Give the descriptor back to the HCF */
1976 hcf_dma_rx_put( &( lp->hcfCtx ), desc );
1980 /* Read the HFS_STAT register from the lookahead buffer */
1981 hfs_stat = (hcf_16)( desc->buf_addr[HFS_STAT/2] );
1983 /* Make sure the frame isn't bad */
1984 if(( hfs_stat & HFS_STAT_ERR ) != HCF_SUCCESS )
1986 DBG_WARNING( DbgInfo, "HFS_STAT_ERROR (0x%x) in Rx Packet\n",
1987 desc->buf_addr[HFS_STAT/2] );
1989 /* Give the descriptor back to the HCF */
1990 hcf_dma_rx_put( &( lp->hcfCtx ), desc );
1994 /* Determine what port this packet is for */
1995 port = ( hfs_stat >> 8 ) & 0x0007;
1996 DBG_RX( DbgInfo, "Rx frame for port %d\n", port );
1998 if(( pktlen = GET_BUF_CNT( desc_next )) != 0 ) {
1999 if(( skb = ALLOC_SKB( pktlen )) != NULL ) {
2008 skb->dev = lp->wds_port[port-1].dev;
2010 #endif /* USE_WDS */
2018 GET_PACKET_DMA( skb->dev, skb, pktlen );
2020 /* Give the descriptor back to the HCF */
2021 hcf_dma_rx_put( &( lp->hcfCtx ), desc );
2026 lp->stats.rx_packets++;
2027 lp->stats.rx_bytes += pktlen;
2032 lp->wds_port[port-1].stats.rx_packets++;
2033 lp->wds_port[port-1].stats.rx_bytes += pktlen;
2035 #endif /* USE_WDS */
2037 dev->last_rx = jiffies;
2040 DBG_ERROR( DbgInfo, "Could not alloc skb\n" );
2044 lp->stats.rx_dropped++;
2049 lp->wds_port[port-1].stats.rx_dropped++;
2051 #endif /* USE_WDS */
2060 /*============================================================================*/
2061 #endif // ENABLE_DMA