1 /*********************************************************************
3 * Filename: netwave_cs.c
5 * Description: Netwave AirSurfer Wireless LAN PC Card driver
6 * Status: Experimental.
7 * Authors: John Markus Bjørndalen <johnm@cs.uit.no>
8 * Dag Brattli <dagb@cs.uit.no>
9 * David Hinds <dahinds@users.sourceforge.net>
10 * Created at: A long time ago!
11 * Modified at: Mon Nov 10 11:54:37 1997
12 * Modified by: Dag Brattli <dagb@cs.uit.no>
14 * Copyright (c) 1997 University of Tromsø, Norway
18 * 08-Nov-97 15:14:47 John Markus Bjørndalen <johnm@cs.uit.no>
19 * - Fixed some bugs in netwave_rx and cleaned it up a bit.
20 * (One of the bugs would have destroyed packets when receiving
21 * multiple packets per interrupt).
22 * - Cleaned up parts of newave_hw_xmit.
23 * - A few general cleanups.
24 * 24-Oct-97 13:17:36 Dag Brattli <dagb@cs.uit.no>
25 * - Fixed netwave_rx receive function (got updated docs)
27 * - Changed name from xircnw to netwave, take a look at
28 * http://www.netwave-wireless.com
29 * - Some reorganizing of the code
30 * - Removed possible race condition between interrupt handler and transmit
32 * - Started to add wireless extensions, but still needs some coding
33 * - Added watchdog for better handling of transmission timeouts
34 * (hopefully this works better)
35 ********************************************************************/
37 /* To have statistics (just packets sent) define this */
40 #include <linux/config.h>
41 #include <linux/module.h>
42 #include <linux/kernel.h>
43 #include <linux/init.h>
44 #include <linux/types.h>
45 #include <linux/fcntl.h>
46 #include <linux/interrupt.h>
47 #include <linux/ptrace.h>
48 #include <linux/ioport.h>
50 #include <linux/slab.h>
51 #include <linux/string.h>
52 #include <linux/timer.h>
53 #include <linux/errno.h>
54 #include <linux/netdevice.h>
55 #include <linux/etherdevice.h>
56 #include <linux/skbuff.h>
57 #include <linux/bitops.h>
58 #include <linux/wireless.h>
59 #include <net/iw_handler.h>
61 #include <pcmcia/cs_types.h>
62 #include <pcmcia/cs.h>
63 #include <pcmcia/cistpl.h>
64 #include <pcmcia/cisreg.h>
65 #include <pcmcia/ds.h>
66 #include <pcmcia/mem_op.h>
68 #include <asm/system.h>
72 #define NETWAVE_REGOFF 0x8000
73 /* The Netwave IO registers, offsets to iobase */
74 #define NETWAVE_REG_COR 0x0
75 #define NETWAVE_REG_CCSR 0x2
76 #define NETWAVE_REG_ASR 0x4
77 #define NETWAVE_REG_IMR 0xa
78 #define NETWAVE_REG_PMR 0xc
79 #define NETWAVE_REG_IOLOW 0x6
80 #define NETWAVE_REG_IOHI 0x7
81 #define NETWAVE_REG_IOCONTROL 0x8
82 #define NETWAVE_REG_DATA 0xf
83 /* The Netwave Extended IO registers, offsets to RamBase */
84 #define NETWAVE_EREG_ASCC 0x114
85 #define NETWAVE_EREG_RSER 0x120
86 #define NETWAVE_EREG_RSERW 0x124
87 #define NETWAVE_EREG_TSER 0x130
88 #define NETWAVE_EREG_TSERW 0x134
89 #define NETWAVE_EREG_CB 0x100
90 #define NETWAVE_EREG_SPCQ 0x154
91 #define NETWAVE_EREG_SPU 0x155
92 #define NETWAVE_EREG_LIF 0x14e
93 #define NETWAVE_EREG_ISPLQ 0x156
94 #define NETWAVE_EREG_HHC 0x158
95 #define NETWAVE_EREG_NI 0x16e
96 #define NETWAVE_EREG_MHS 0x16b
97 #define NETWAVE_EREG_TDP 0x140
98 #define NETWAVE_EREG_RDP 0x150
99 #define NETWAVE_EREG_PA 0x160
100 #define NETWAVE_EREG_EC 0x180
101 #define NETWAVE_EREG_CRBP 0x17a
102 #define NETWAVE_EREG_ARW 0x166
105 * Commands used in the extended command buffer
106 * NETWAVE_EREG_CB (0x100-0x10F)
108 #define NETWAVE_CMD_NOP 0x00
109 #define NETWAVE_CMD_SRC 0x01
110 #define NETWAVE_CMD_STC 0x02
111 #define NETWAVE_CMD_AMA 0x03
112 #define NETWAVE_CMD_DMA 0x04
113 #define NETWAVE_CMD_SAMA 0x05
114 #define NETWAVE_CMD_ER 0x06
115 #define NETWAVE_CMD_DR 0x07
116 #define NETWAVE_CMD_TL 0x08
117 #define NETWAVE_CMD_SRP 0x09
118 #define NETWAVE_CMD_SSK 0x0a
119 #define NETWAVE_CMD_SMD 0x0b
120 #define NETWAVE_CMD_SAPD 0x0c
121 #define NETWAVE_CMD_SSS 0x11
122 /* End of Command marker */
123 #define NETWAVE_CMD_EOC 0x00
125 /* ASR register bits */
126 #define NETWAVE_ASR_RXRDY 0x80
127 #define NETWAVE_ASR_TXBA 0x01
129 #define TX_TIMEOUT ((32*HZ)/100)
131 static const unsigned int imrConfRFU1 = 0x10; /* RFU interrupt mask, keep high */
132 static const unsigned int imrConfIENA = 0x02; /* Interrupt enable */
134 static const unsigned int corConfIENA = 0x01; /* Interrupt enable */
135 static const unsigned int corConfLVLREQ = 0x40; /* Keep high */
137 static const unsigned int rxConfRxEna = 0x80; /* Receive Enable */
138 static const unsigned int rxConfMAC = 0x20; /* MAC host receive mode*/
139 static const unsigned int rxConfPro = 0x10; /* Promiscuous */
140 static const unsigned int rxConfAMP = 0x08; /* Accept Multicast Packets */
141 static const unsigned int rxConfBcast = 0x04; /* Accept Broadcast Packets */
143 static const unsigned int txConfTxEna = 0x80; /* Transmit Enable */
144 static const unsigned int txConfMAC = 0x20; /* Host sends MAC mode */
145 static const unsigned int txConfEUD = 0x10; /* Enable Uni-Data packets */
146 static const unsigned int txConfKey = 0x02; /* Scramble data packets */
147 static const unsigned int txConfLoop = 0x01; /* Loopback mode */
150 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
151 you do not define PCMCIA_DEBUG at all, all the debug code will be
152 left out. If you compile with PCMCIA_DEBUG=0, the debug code will
153 be present but disabled -- but it can then be enabled for specific
154 modules at load time with a 'pc_debug=#' option to insmod.
158 static int pc_debug = PCMCIA_DEBUG;
159 module_param(pc_debug, int, 0);
160 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
161 static char *version =
162 "netwave_cs.c 0.3.0 Thu Jul 17 14:36:02 1997 (John Markus Bjørndalen)\n";
164 #define DEBUG(n, args...)
167 /*====================================================================*/
169 /* Parameters that can be set with 'insmod' */
171 /* Choose the domain, default is 0x100 */
172 static u_int domain = 0x100;
174 /* Scramble key, range from 0x0 to 0xffff.
175 * 0x0 is no scrambling.
177 static u_int scramble_key = 0x0;
179 /* Shared memory speed, in ns. The documentation states that
180 * the card should not be read faster than every 400ns.
181 * This timing should be provided by the HBA. If it becomes a
182 * problem, try setting mem_speed to 400.
184 static int mem_speed;
186 module_param(domain, int, 0);
187 module_param(scramble_key, int, 0);
188 module_param(mem_speed, int, 0);
190 /*====================================================================*/
192 /* PCMCIA (Card Services) related functions */
193 static void netwave_release(dev_link_t *link); /* Card removal */
194 static void netwave_pcmcia_config(dev_link_t *arg); /* Runs after card
196 static void netwave_detach(struct pcmcia_device *p_dev); /* Destroy instance */
198 /* Hardware configuration */
199 static void netwave_doreset(kio_addr_t iobase, u_char __iomem *ramBase);
200 static void netwave_reset(struct net_device *dev);
202 /* Misc device stuff */
203 static int netwave_open(struct net_device *dev); /* Open the device */
204 static int netwave_close(struct net_device *dev); /* Close the device */
206 /* Packet transmission and Packet reception */
207 static int netwave_start_xmit( struct sk_buff *skb, struct net_device *dev);
208 static int netwave_rx( struct net_device *dev);
210 /* Interrupt routines */
211 static irqreturn_t netwave_interrupt(int irq, void *dev_id, struct pt_regs *regs);
212 static void netwave_watchdog(struct net_device *);
215 static void update_stats(struct net_device *dev);
216 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
218 /* Wireless extensions */
219 static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev);
221 static void set_multicast_list(struct net_device *dev);
224 A dev_link_t structure has fields for most things that are needed
225 to keep track of a socket, but there will usually be some device
226 specific information that also needs to be kept track of. The
227 'priv' pointer in a dev_link_t structure can be used to point to
228 a device-specific private data structure, like this.
230 A driver needs to provide a dev_node_t structure for each device
231 on a card. In some cases, there is only one device per card (for
232 example, ethernet cards, modems). In other cases, there may be
233 many actual or logical devices (SCSI adapters, memory cards with
234 multiple partitions). The dev_node_t structures need to be kept
235 in a linked list starting at the 'dev' field of a dev_link_t
236 structure. We allocate them in the card's private data structure,
237 because they generally can't be allocated dynamically.
240 static const struct iw_handler_def netwave_handler_def;
242 #define SIOCGIPSNAP SIOCIWFIRSTPRIV + 1 /* Site Survey Snapshot */
246 typedef struct net_addr {
252 u_char struct_revision;
253 u_char roaming_state;
255 u_char sp_existsFlag;
256 u_char sp_link_quality;
257 u_char sp_max_link_quality;
258 u_char linkQualityGoodFairBoundary;
259 u_char linkQualityFairPoorBoundary;
260 u_char sp_utilization;
262 u_char sp_hotheadcount;
263 u_char roaming_condition;
267 net_addr nearByAccessPoints[MAX_ESA];
270 typedef struct netwave_private {
272 spinlock_t spinlock; /* Serialize access to the hardware (SMP) */
274 u_char __iomem *ramBase;
277 struct timer_list watchdog; /* To avoid blocking state */
278 struct site_survey nss;
279 struct net_device_stats stats;
280 struct iw_statistics iw_stats; /* Wireless stats */
284 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
288 * The Netwave card is little-endian, so won't work for big endian
291 static inline unsigned short get_uint16(u_char __iomem *staddr)
293 return readw(staddr); /* Return only 16 bits */
296 static inline short get_int16(u_char __iomem * staddr)
298 return readw(staddr);
302 * Wait until the WOC (Write Operation Complete) bit in the
303 * ASR (Adapter Status Register) is asserted.
304 * This should have aborted if it takes too long time.
306 static inline void wait_WOC(unsigned int iobase)
309 while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ;
312 static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase,
314 u_short resultBuffer;
316 /* if time since last snapshot is > 1 sec. (100 jiffies?) then take
317 * new snapshot, else return cached data. This is the recommended rate.
319 if ( jiffies - priv->lastExec > 100) {
320 /* Take site survey snapshot */
321 /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies -
324 writeb(NETWAVE_CMD_SSS, ramBase + NETWAVE_EREG_CB + 0);
325 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
328 /* Get result and copy to cach */
329 resultBuffer = readw(ramBase + NETWAVE_EREG_CRBP);
330 copy_from_pc( &priv->nss, ramBase+resultBuffer,
331 sizeof(struct site_survey));
336 * Function netwave_get_wireless_stats (dev)
338 * Wireless extensions statistics
341 static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev)
344 kio_addr_t iobase = dev->base_addr;
345 netwave_private *priv = netdev_priv(dev);
346 u_char __iomem *ramBase = priv->ramBase;
347 struct iw_statistics* wstats;
349 wstats = &priv->iw_stats;
351 spin_lock_irqsave(&priv->spinlock, flags);
353 netwave_snapshot( priv, ramBase, iobase);
355 wstats->status = priv->nss.roaming_state;
356 wstats->qual.qual = readb( ramBase + NETWAVE_EREG_SPCQ);
357 wstats->qual.level = readb( ramBase + NETWAVE_EREG_ISPLQ);
358 wstats->qual.noise = readb( ramBase + NETWAVE_EREG_SPU) & 0x3f;
359 wstats->discard.nwid = 0L;
360 wstats->discard.code = 0L;
361 wstats->discard.misc = 0L;
363 spin_unlock_irqrestore(&priv->spinlock, flags);
365 return &priv->iw_stats;
369 * Function netwave_attach (void)
371 * Creates an "instance" of the driver, allocating local data
372 * structures for one device. The device is registered with Card
375 * The dev_link structure is initialized, but we don't actually
376 * configure the card at this point -- we wait until we receive a
377 * card insertion event.
379 static int netwave_attach(struct pcmcia_device *p_dev)
382 struct net_device *dev;
383 netwave_private *priv;
385 DEBUG(0, "netwave_attach()\n");
387 /* Initialize the dev_link_t structure */
388 dev = alloc_etherdev(sizeof(netwave_private));
391 priv = netdev_priv(dev);
395 /* The io structure describes IO port mapping */
396 link->io.NumPorts1 = 16;
397 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
398 /* link->io.NumPorts2 = 16;
399 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
400 link->io.IOAddrLines = 5;
402 /* Interrupt setup */
403 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
404 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
405 link->irq.Handler = &netwave_interrupt;
407 /* General socket configuration */
408 link->conf.Attributes = CONF_ENABLE_IRQ;
410 link->conf.IntType = INT_MEMORY_AND_IO;
411 link->conf.ConfigIndex = 1;
412 link->conf.Present = PRESENT_OPTION;
414 /* Netwave private struct init. link/dev/node already taken care of,
415 * other stuff zero'd - Jean II */
416 spin_lock_init(&priv->spinlock);
418 /* Netwave specific entries in the device structure */
419 SET_MODULE_OWNER(dev);
420 dev->hard_start_xmit = &netwave_start_xmit;
421 dev->get_stats = &netwave_get_stats;
422 dev->set_multicast_list = &set_multicast_list;
423 /* wireless extensions */
424 dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
426 dev->tx_timeout = &netwave_watchdog;
427 dev->watchdog_timeo = TX_TIMEOUT;
429 dev->open = &netwave_open;
430 dev->stop = &netwave_close;
431 link->irq.Instance = dev;
433 link->handle = p_dev;
434 p_dev->instance = link;
436 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
437 netwave_pcmcia_config( link);
440 } /* netwave_attach */
443 * Function netwave_detach (link)
445 * This deletes a driver "instance". The device is de-registered
446 * with Card Services. If it has been released, all local data
447 * structures are freed. Otherwise, the structures will be freed
448 * when the device is released.
450 static void netwave_detach(struct pcmcia_device *p_dev)
452 dev_link_t *link = dev_to_instance(p_dev);
453 struct net_device *dev = link->priv;
455 DEBUG(0, "netwave_detach(0x%p)\n", link);
457 if (link->state & DEV_CONFIG)
458 netwave_release(link);
461 unregister_netdev(dev);
464 } /* netwave_detach */
467 * Wireless Handler : get protocol name
469 static int netwave_get_name(struct net_device *dev,
470 struct iw_request_info *info,
471 union iwreq_data *wrqu,
474 strcpy(wrqu->name, "Netwave");
479 * Wireless Handler : set Network ID
481 static int netwave_set_nwid(struct net_device *dev,
482 struct iw_request_info *info,
483 union iwreq_data *wrqu,
487 kio_addr_t iobase = dev->base_addr;
488 netwave_private *priv = netdev_priv(dev);
489 u_char __iomem *ramBase = priv->ramBase;
491 /* Disable interrupts & save flags */
492 spin_lock_irqsave(&priv->spinlock, flags);
494 if(!wrqu->nwid.disabled) {
495 domain = wrqu->nwid.value;
496 printk( KERN_DEBUG "Setting domain to 0x%x%02x\n",
497 (domain >> 8) & 0x01, domain & 0xff);
499 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
500 writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
501 writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
502 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
505 /* ReEnable interrupts & restore flags */
506 spin_unlock_irqrestore(&priv->spinlock, flags);
512 * Wireless Handler : get Network ID
514 static int netwave_get_nwid(struct net_device *dev,
515 struct iw_request_info *info,
516 union iwreq_data *wrqu,
519 wrqu->nwid.value = domain;
520 wrqu->nwid.disabled = 0;
521 wrqu->nwid.fixed = 1;
526 * Wireless Handler : set scramble key
528 static int netwave_set_scramble(struct net_device *dev,
529 struct iw_request_info *info,
530 union iwreq_data *wrqu,
534 kio_addr_t iobase = dev->base_addr;
535 netwave_private *priv = netdev_priv(dev);
536 u_char __iomem *ramBase = priv->ramBase;
538 /* Disable interrupts & save flags */
539 spin_lock_irqsave(&priv->spinlock, flags);
541 scramble_key = (key[0] << 8) | key[1];
543 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
544 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
545 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
546 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
548 /* ReEnable interrupts & restore flags */
549 spin_unlock_irqrestore(&priv->spinlock, flags);
555 * Wireless Handler : get scramble key
557 static int netwave_get_scramble(struct net_device *dev,
558 struct iw_request_info *info,
559 union iwreq_data *wrqu,
562 key[1] = scramble_key & 0xff;
563 key[0] = (scramble_key>>8) & 0xff;
564 wrqu->encoding.flags = IW_ENCODE_ENABLED;
565 wrqu->encoding.length = 2;
570 * Wireless Handler : get mode
572 static int netwave_get_mode(struct net_device *dev,
573 struct iw_request_info *info,
574 union iwreq_data *wrqu,
578 wrqu->mode = IW_MODE_INFRA;
580 wrqu->mode = IW_MODE_ADHOC;
586 * Wireless Handler : get range info
588 static int netwave_get_range(struct net_device *dev,
589 struct iw_request_info *info,
590 union iwreq_data *wrqu,
593 struct iw_range *range = (struct iw_range *) extra;
596 /* Set the length (very important for backward compatibility) */
597 wrqu->data.length = sizeof(struct iw_range);
599 /* Set all the info we don't care or don't know about to zero */
600 memset(range, 0, sizeof(struct iw_range));
602 /* Set the Wireless Extension versions */
603 range->we_version_compiled = WIRELESS_EXT;
604 range->we_version_source = 9; /* Nothing for us in v10 and v11 */
606 /* Set information in the range struct */
607 range->throughput = 450 * 1000; /* don't argue on this ! */
608 range->min_nwid = 0x0000;
609 range->max_nwid = 0x01FF;
611 range->num_channels = range->num_frequency = 0;
613 range->sensitivity = 0x3F;
614 range->max_qual.qual = 255;
615 range->max_qual.level = 255;
616 range->max_qual.noise = 0;
618 range->num_bitrates = 1;
619 range->bitrate[0] = 1000000; /* 1 Mb/s */
621 range->encoding_size[0] = 2; /* 16 bits scrambling */
622 range->num_encoding_sizes = 1;
623 range->max_encoding_tokens = 1; /* Only one key possible */
629 * Wireless Private Handler : get snapshot
631 static int netwave_get_snap(struct net_device *dev,
632 struct iw_request_info *info,
633 union iwreq_data *wrqu,
637 kio_addr_t iobase = dev->base_addr;
638 netwave_private *priv = netdev_priv(dev);
639 u_char __iomem *ramBase = priv->ramBase;
641 /* Disable interrupts & save flags */
642 spin_lock_irqsave(&priv->spinlock, flags);
644 /* Take snapshot of environment */
645 netwave_snapshot( priv, ramBase, iobase);
646 wrqu->data.length = priv->nss.length;
647 memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
649 priv->lastExec = jiffies;
651 /* ReEnable interrupts & restore flags */
652 spin_unlock_irqrestore(&priv->spinlock, flags);
658 * Structures to export the Wireless Handlers
659 * This is the stuff that are treated the wireless extensions (iwconfig)
662 static const struct iw_priv_args netwave_private_args[] = {
663 /*{ cmd, set_args, get_args, name } */
665 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey),
669 static const iw_handler netwave_handler[] =
671 NULL, /* SIOCSIWNAME */
672 netwave_get_name, /* SIOCGIWNAME */
673 netwave_set_nwid, /* SIOCSIWNWID */
674 netwave_get_nwid, /* SIOCGIWNWID */
675 NULL, /* SIOCSIWFREQ */
676 NULL, /* SIOCGIWFREQ */
677 NULL, /* SIOCSIWMODE */
678 netwave_get_mode, /* SIOCGIWMODE */
679 NULL, /* SIOCSIWSENS */
680 NULL, /* SIOCGIWSENS */
681 NULL, /* SIOCSIWRANGE */
682 netwave_get_range, /* SIOCGIWRANGE */
683 NULL, /* SIOCSIWPRIV */
684 NULL, /* SIOCGIWPRIV */
685 NULL, /* SIOCSIWSTATS */
686 NULL, /* SIOCGIWSTATS */
687 NULL, /* SIOCSIWSPY */
688 NULL, /* SIOCGIWSPY */
689 NULL, /* -- hole -- */
690 NULL, /* -- hole -- */
691 NULL, /* SIOCSIWAP */
692 NULL, /* SIOCGIWAP */
693 NULL, /* -- hole -- */
694 NULL, /* SIOCGIWAPLIST */
695 NULL, /* -- hole -- */
696 NULL, /* -- hole -- */
697 NULL, /* SIOCSIWESSID */
698 NULL, /* SIOCGIWESSID */
699 NULL, /* SIOCSIWNICKN */
700 NULL, /* SIOCGIWNICKN */
701 NULL, /* -- hole -- */
702 NULL, /* -- hole -- */
703 NULL, /* SIOCSIWRATE */
704 NULL, /* SIOCGIWRATE */
705 NULL, /* SIOCSIWRTS */
706 NULL, /* SIOCGIWRTS */
707 NULL, /* SIOCSIWFRAG */
708 NULL, /* SIOCGIWFRAG */
709 NULL, /* SIOCSIWTXPOW */
710 NULL, /* SIOCGIWTXPOW */
711 NULL, /* SIOCSIWRETRY */
712 NULL, /* SIOCGIWRETRY */
713 netwave_set_scramble, /* SIOCSIWENCODE */
714 netwave_get_scramble, /* SIOCGIWENCODE */
717 static const iw_handler netwave_private_handler[] =
719 NULL, /* SIOCIWFIRSTPRIV */
720 netwave_get_snap, /* SIOCIWFIRSTPRIV + 1 */
723 static const struct iw_handler_def netwave_handler_def =
725 .num_standard = sizeof(netwave_handler)/sizeof(iw_handler),
726 .num_private = sizeof(netwave_private_handler)/sizeof(iw_handler),
727 .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
728 .standard = (iw_handler *) netwave_handler,
729 .private = (iw_handler *) netwave_private_handler,
730 .private_args = (struct iw_priv_args *) netwave_private_args,
731 .get_wireless_stats = netwave_get_wireless_stats,
735 * Function netwave_pcmcia_config (link)
737 * netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION
738 * event is received, to configure the PCMCIA socket, and to make the
739 * device available to the system.
743 #define CS_CHECK(fn, ret) \
744 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
746 static void netwave_pcmcia_config(dev_link_t *link) {
747 client_handle_t handle = link->handle;
748 struct net_device *dev = link->priv;
749 netwave_private *priv = netdev_priv(dev);
752 int i, j, last_ret, last_fn;
756 u_char __iomem *ramBase = NULL;
758 DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
761 This reads the card's CONFIG tuple to find its configuration
764 tuple.Attributes = 0;
765 tuple.TupleData = (cisdata_t *) buf;
766 tuple.TupleDataMax = 64;
767 tuple.TupleOffset = 0;
768 tuple.DesiredTuple = CISTPL_CONFIG;
769 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
770 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
771 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
772 link->conf.ConfigBase = parse.config.base;
773 link->conf.Present = parse.config.rmask[0];
776 link->state |= DEV_CONFIG;
779 * Try allocating IO ports. This tries a few fixed addresses.
780 * If you want, you can also read the card's config table to
781 * pick addresses -- see the serial driver for an example.
783 for (i = j = 0x0; j < 0x400; j += 0x20) {
784 link->io.BasePort1 = j ^ 0x300;
785 i = pcmcia_request_io(link->handle, &link->io);
786 if (i == CS_SUCCESS) break;
788 if (i != CS_SUCCESS) {
789 cs_error(link->handle, RequestIO, i);
794 * Now allocate an interrupt line. Note that this does not
795 * actually assign a handler to the interrupt.
797 CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
800 * This actually configures the PCMCIA socket -- setting up
801 * the I/O windows and the interrupt mapping.
803 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
806 * Allocate a 32K memory window. Note that the dev_link_t
807 * structure provides space for one window handle -- if your
808 * device needs several windows, you'll need to keep track of
809 * the handles in your private data structure, dev->priv.
811 DEBUG(1, "Setting mem speed of %d\n", mem_speed);
813 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
814 req.Base = 0; req.Size = 0x8000;
815 req.AccessSpeed = mem_speed;
816 CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &link->win));
817 mem.CardOffset = 0x20000; mem.Page = 0;
818 CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
820 /* Store base address of the common window frame */
821 ramBase = ioremap(req.Base, 0x8000);
822 priv->ramBase = ramBase;
824 dev->irq = link->irq.AssignedIRQ;
825 dev->base_addr = link->io.BasePort1;
826 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
828 if (register_netdev(dev) != 0) {
829 printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
833 strcpy(priv->node.dev_name, dev->name);
834 link->dev = &priv->node;
835 link->state &= ~DEV_CONFIG_PENDING;
837 /* Reset card before reading physical address */
838 netwave_doreset(dev->base_addr, ramBase);
840 /* Read the ethernet address and fill in the Netwave registers. */
841 for (i = 0; i < 6; i++)
842 dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
844 printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
845 "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
846 (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
847 (int) readb(ramBase+NETWAVE_EREG_NI+1));
848 for (i = 0; i < 6; i++)
849 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
851 /* get revision words */
852 printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n",
853 get_uint16(ramBase + NETWAVE_EREG_ARW),
854 get_uint16(ramBase + NETWAVE_EREG_ARW+2));
858 cs_error(link->handle, last_fn, last_ret);
860 netwave_release(link);
861 } /* netwave_pcmcia_config */
864 * Function netwave_release (arg)
866 * After a card is removed, netwave_release() will unregister the net
867 * device, and release the PCMCIA configuration. If the device is
868 * still open, this will be postponed until it is closed.
870 static void netwave_release(dev_link_t *link)
872 struct net_device *dev = link->priv;
873 netwave_private *priv = netdev_priv(dev);
875 DEBUG(0, "netwave_release(0x%p)\n", link);
877 pcmcia_disable_device(link->handle);
879 iounmap(priv->ramBase);
882 static int netwave_suspend(struct pcmcia_device *p_dev)
884 dev_link_t *link = dev_to_instance(p_dev);
885 struct net_device *dev = link->priv;
887 if ((link->state & DEV_CONFIG) && (link->open))
888 netif_device_detach(dev);
893 static int netwave_resume(struct pcmcia_device *p_dev)
895 dev_link_t *link = dev_to_instance(p_dev);
896 struct net_device *dev = link->priv;
898 if ((link->state & DEV_CONFIG) && (link->open)) {
900 netif_device_attach(dev);
908 * Function netwave_doreset (ioBase, ramBase)
910 * Proper hardware reset of the card.
912 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
916 outb(0x80, ioBase + NETWAVE_REG_PMR);
917 writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
918 outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
922 * Function netwave_reset (dev)
924 * Reset and restore all of the netwave registers
926 static void netwave_reset(struct net_device *dev) {
928 netwave_private *priv = netdev_priv(dev);
929 u_char __iomem *ramBase = priv->ramBase;
930 kio_addr_t iobase = dev->base_addr;
932 DEBUG(0, "netwave_reset: Done with hardware reset\n");
934 priv->timeoutCounter = 0;
937 netwave_doreset(iobase, ramBase);
938 printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
940 /* Write a NOP to check the card */
942 writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
943 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
945 /* Set receive conf */
947 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
948 writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
949 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
951 /* Set transmit conf */
953 writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
954 writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
955 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
957 /* Now set the MU Domain */
958 printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
960 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
961 writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
962 writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
963 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
965 /* Set scramble key */
966 printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
968 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
969 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
970 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
971 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
973 /* Enable interrupts, bit 4 high to keep unused
974 * source from interrupting us, bit 2 high to
975 * set interrupt enable, 567 to enable TxDN,
979 outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
981 /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
983 * skriv 80 til d000:3688
984 * sjekk om det ble 80
987 /* Enable Receiver */
989 writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
990 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
992 /* Set the IENA bit in COR */
994 outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
998 * Function netwave_hw_xmit (data, len, dev)
1000 static int netwave_hw_xmit(unsigned char* data, int len,
1001 struct net_device* dev) {
1002 unsigned long flags;
1003 unsigned int TxFreeList,
1009 netwave_private *priv = netdev_priv(dev);
1010 u_char __iomem * ramBase = priv->ramBase;
1011 kio_addr_t iobase = dev->base_addr;
1013 /* Disable interrupts & save flags */
1014 spin_lock_irqsave(&priv->spinlock, flags);
1016 /* Check if there are transmit buffers available */
1018 if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
1019 /* No buffers available */
1020 printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
1022 spin_unlock_irqrestore(&priv->spinlock, flags);
1026 priv->stats.tx_bytes += len;
1028 DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
1029 readb(ramBase + NETWAVE_EREG_SPCQ),
1030 readb(ramBase + NETWAVE_EREG_SPU),
1031 readb(ramBase + NETWAVE_EREG_LIF),
1032 readb(ramBase + NETWAVE_EREG_ISPLQ));
1034 /* Now try to insert it into the adapters free memory */
1036 TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1037 MaxData = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1038 DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1040 DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1041 TxFreeList, MaxData, DataOffset);
1043 /* Copy packet to the adapter fragment buffers */
1044 curBuff = TxFreeList;
1046 while (tmpcount < len) {
1047 int tmplen = len - tmpcount;
1048 copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount,
1049 (tmplen < MaxData) ? tmplen : MaxData);
1050 tmpcount += MaxData;
1052 /* Advance to next buffer */
1053 curBuff = get_uint16(ramBase + curBuff);
1056 /* Now issue transmit list */
1058 writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1059 writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1060 writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1061 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1063 spin_unlock_irqrestore(&priv->spinlock, flags);
1067 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1068 /* This flag indicate that the hardware can't perform a transmission.
1069 * Theoritically, NET3 check it before sending a packet to the driver,
1070 * but in fact it never do that and pool continuously.
1071 * As the watchdog will abort too long transmissions, we are quite safe...
1074 netif_stop_queue(dev);
1077 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1078 unsigned char* buf = skb->data;
1080 if (netwave_hw_xmit( buf, length, dev) == 1) {
1081 /* Some error, let's make them call us another time? */
1082 netif_start_queue(dev);
1084 dev->trans_start = jiffies;
1089 } /* netwave_start_xmit */
1092 * Function netwave_interrupt (irq, dev_id, regs)
1094 * This function is the interrupt handler for the Netwave card. This
1095 * routine will be called whenever:
1096 * 1. A packet is received.
1097 * 2. A packet has successfully been transferred and the unit is
1098 * ready to transmit another packet.
1099 * 3. A command has completed execution.
1101 static irqreturn_t netwave_interrupt(int irq, void* dev_id, struct pt_regs *regs)
1104 u_char __iomem *ramBase;
1105 struct net_device *dev = (struct net_device *)dev_id;
1106 struct netwave_private *priv = netdev_priv(dev);
1107 dev_link_t *link = &priv->link;
1110 if (!netif_device_present(dev))
1113 iobase = dev->base_addr;
1114 ramBase = priv->ramBase;
1116 /* Now find what caused the interrupt, check while interrupts ready */
1117 for (i = 0; i < 10; i++) {
1121 if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1122 break; /* None of the interrupt sources asserted (normal exit) */
1124 status = inb(iobase + NETWAVE_REG_ASR);
1126 if (!DEV_OK(link)) {
1127 DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1128 "from removed or suspended card!\n", status);
1133 if (status & 0x80) {
1135 /* wait_WOC(iobase); */
1136 /* RxRdy cannot be reset directly by the host */
1139 if (status & 0x40) {
1142 rser = readb(ramBase + NETWAVE_EREG_RSER);
1145 ++priv->stats.rx_dropped;
1146 ++priv->stats.rx_crc_errors;
1149 ++priv->stats.rx_frame_errors;
1151 /* Clear the RxErr bit in RSER. RSER+4 is the
1152 * write part. Also clear the RxCRC (0x04) and
1153 * RxBig (0x02) bits if present */
1155 writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1157 /* Write bit 6 high to ASCC to clear RxErr in ASR,
1158 * WOC must be set first!
1161 writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1163 /* Remember to count up priv->stats on error packets */
1164 ++priv->stats.rx_errors;
1167 if (status & 0x20) {
1170 txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1171 DEBUG(3, "Transmit done. TSER = %x id %x\n",
1172 txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1174 if (txStatus & 0x20) {
1175 /* Transmitting was okay, clear bits */
1177 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1178 ++priv->stats.tx_packets;
1181 if (txStatus & 0xd0) {
1182 if (txStatus & 0x80) {
1183 ++priv->stats.collisions; /* Because of /proc/net/dev*/
1184 /* ++priv->stats.tx_aborted_errors; */
1185 /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1187 if (txStatus & 0x40)
1188 ++priv->stats.tx_carrier_errors;
1189 /* 0x80 TxGU Transmit giveup - nine times and no luck
1190 * 0x40 TxNOAP No access point. Discarded packet.
1191 * 0x10 TxErr Transmit error. Always set when
1192 * TxGU and TxNOAP is set. (Those are the only ones
1195 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n",
1198 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1200 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1201 ++priv->stats.tx_errors;
1203 DEBUG(3, "New status is TSER %x ASR %x\n",
1204 readb(ramBase + NETWAVE_EREG_TSER),
1205 inb(iobase + NETWAVE_REG_ASR));
1207 netif_wake_queue(dev);
1209 /* TxBA, this would trigger on all error packets received */
1210 /* if (status & 0x01) {
1211 DEBUG(4, "Transmit buffers available, %x\n", status);
1215 /* Handled if we looped at least one time - Jean II */
1216 return IRQ_RETVAL(i);
1217 } /* netwave_interrupt */
1220 * Function netwave_watchdog (a)
1222 * Watchdog : when we start a transmission, we set a timer in the
1223 * kernel. If the transmission complete, this timer is disabled. If
1224 * it expire, we reset the card.
1227 static void netwave_watchdog(struct net_device *dev) {
1229 DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1231 dev->trans_start = jiffies;
1232 netif_wake_queue(dev);
1233 } /* netwave_watchdog */
1235 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1236 netwave_private *priv = netdev_priv(dev);
1240 DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1241 " %x tx %x %x %x %x\n",
1242 readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1243 readb(priv->ramBase + NETWAVE_EREG_SPU),
1244 readb(priv->ramBase + NETWAVE_EREG_LIF),
1245 readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1246 readb(priv->ramBase + NETWAVE_EREG_MHS),
1247 readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1248 readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1249 readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1250 readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1251 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1252 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1254 return &priv->stats;
1257 static void update_stats(struct net_device *dev) {
1258 //unsigned long flags;
1259 /* netwave_private *priv = netdev_priv(dev); */
1261 //spin_lock_irqsave(&priv->spinlock, flags);
1263 /* priv->stats.rx_packets = readb(priv->ramBase + 0x18e);
1264 priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1266 //spin_unlock_irqrestore(&priv->spinlock, flags);
1269 static int netwave_rx(struct net_device *dev)
1271 netwave_private *priv = netdev_priv(dev);
1272 u_char __iomem *ramBase = priv->ramBase;
1273 kio_addr_t iobase = dev->base_addr;
1275 struct sk_buff *skb = NULL;
1276 unsigned int curBuffer,
1280 int dataCount, dataOffset;
1284 DEBUG(3, "xinw_rx: Receiving ... \n");
1286 /* Receive max 10 packets for now. */
1287 for (i = 0; i < 10; i++) {
1290 rxStatus = readb(ramBase + NETWAVE_EREG_RSER);
1291 if ( !( rxStatus & 0x80)) /* No more packets */
1294 /* Check if multicast/broadcast or other */
1295 /* multicast = (rxStatus & 0x20); */
1297 /* The receive list pointer and length of the packet */
1299 rcvLen = get_int16( ramBase + NETWAVE_EREG_RDP);
1300 rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1303 printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n",
1308 skb = dev_alloc_skb(rcvLen+5);
1310 DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1311 "length %d\n", rcvLen);
1312 ++priv->stats.rx_dropped;
1313 /* Tell the adapter to skip the packet */
1315 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1316 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1320 skb_reserve( skb, 2); /* Align IP on 16 byte */
1321 skb_put( skb, rcvLen);
1324 /* Copy packet fragments to the skb data area */
1325 ptr = (u_char*) skb->data;
1326 curBuffer = rcvList;
1328 while ( tmpcount < rcvLen) {
1329 /* Get length and offset of current buffer */
1330 dataCount = get_uint16( ramBase+curBuffer+2);
1331 dataOffset = get_uint16( ramBase+curBuffer+4);
1333 copy_from_pc( ptr + tmpcount,
1334 ramBase+curBuffer+dataOffset, dataCount);
1336 tmpcount += dataCount;
1338 /* Point to next buffer */
1339 curBuffer = get_uint16(ramBase + curBuffer);
1342 skb->protocol = eth_type_trans(skb,dev);
1343 /* Queue packet for network layer */
1346 dev->last_rx = jiffies;
1347 priv->stats.rx_packets++;
1348 priv->stats.rx_bytes += rcvLen;
1350 /* Got the packet, tell the adapter to skip it */
1352 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1353 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1354 DEBUG(3, "Packet reception ok\n");
1359 static int netwave_open(struct net_device *dev) {
1360 netwave_private *priv = netdev_priv(dev);
1361 dev_link_t *link = &priv->link;
1363 DEBUG(1, "netwave_open: starting.\n");
1370 netif_start_queue(dev);
1376 static int netwave_close(struct net_device *dev) {
1377 netwave_private *priv = netdev_priv(dev);
1378 dev_link_t *link = &priv->link;
1380 DEBUG(1, "netwave_close: finishing.\n");
1383 netif_stop_queue(dev);
1388 static struct pcmcia_device_id netwave_ids[] = {
1389 PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1392 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1394 static struct pcmcia_driver netwave_driver = {
1395 .owner = THIS_MODULE,
1397 .name = "netwave_cs",
1399 .probe = netwave_attach,
1400 .remove = netwave_detach,
1401 .id_table = netwave_ids,
1402 .suspend = netwave_suspend,
1403 .resume = netwave_resume,
1406 static int __init init_netwave_cs(void)
1408 return pcmcia_register_driver(&netwave_driver);
1411 static void __exit exit_netwave_cs(void)
1413 pcmcia_unregister_driver(&netwave_driver);
1416 module_init(init_netwave_cs);
1417 module_exit(exit_netwave_cs);
1419 /* Set or clear the multicast filter for this adaptor.
1420 num_addrs == -1 Promiscuous mode, receive all packets
1421 num_addrs == 0 Normal mode, clear multicast list
1422 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
1423 best-effort filtering.
1425 static void set_multicast_list(struct net_device *dev)
1427 kio_addr_t iobase = dev->base_addr;
1428 netwave_private *priv = netdev_priv(dev);
1429 u_char __iomem * ramBase = priv->ramBase;
1435 if (old != dev->mc_count) {
1436 old = dev->mc_count;
1437 DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1438 dev->name, dev->mc_count);
1443 if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1444 /* Multicast Mode */
1445 rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1446 } else if (dev->flags & IFF_PROMISC) {
1447 /* Promiscous mode */
1448 rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1451 rcvMode = rxConfRxEna + rxConfBcast;
1454 /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1455 /* Now set receive mode */
1457 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1458 writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1459 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1461 MODULE_LICENSE("GPL");