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(struct pcmcia_device *link); /* Card removal */
194 static void netwave_pcmcia_config(struct pcmcia_device *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 struct pcmcia_device 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 struct pcmcia_device 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 struct pcmcia_device
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 {
271 struct pcmcia_device *p_dev;
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 *link)
381 struct net_device *dev;
382 netwave_private *priv;
384 DEBUG(0, "netwave_attach()\n");
386 /* Initialize the struct pcmcia_device structure */
387 dev = alloc_etherdev(sizeof(netwave_private));
390 priv = netdev_priv(dev);
394 /* The io structure describes IO port mapping */
395 link->io.NumPorts1 = 16;
396 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
397 /* link->io.NumPorts2 = 16;
398 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
399 link->io.IOAddrLines = 5;
401 /* Interrupt setup */
402 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
403 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
404 link->irq.Handler = &netwave_interrupt;
406 /* General socket configuration */
407 link->conf.Attributes = CONF_ENABLE_IRQ;
408 link->conf.IntType = INT_MEMORY_AND_IO;
409 link->conf.ConfigIndex = 1;
410 link->conf.Present = PRESENT_OPTION;
412 /* Netwave private struct init. link/dev/node already taken care of,
413 * other stuff zero'd - Jean II */
414 spin_lock_init(&priv->spinlock);
416 /* Netwave specific entries in the device structure */
417 SET_MODULE_OWNER(dev);
418 dev->hard_start_xmit = &netwave_start_xmit;
419 dev->get_stats = &netwave_get_stats;
420 dev->set_multicast_list = &set_multicast_list;
421 /* wireless extensions */
422 dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
424 dev->tx_timeout = &netwave_watchdog;
425 dev->watchdog_timeo = TX_TIMEOUT;
427 dev->open = &netwave_open;
428 dev->stop = &netwave_close;
429 link->irq.Instance = dev;
431 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
432 netwave_pcmcia_config( link);
435 } /* netwave_attach */
438 * Function netwave_detach (link)
440 * This deletes a driver "instance". The device is de-registered
441 * with Card Services. If it has been released, all local data
442 * structures are freed. Otherwise, the structures will be freed
443 * when the device is released.
445 static void netwave_detach(struct pcmcia_device *link)
447 struct net_device *dev = link->priv;
449 DEBUG(0, "netwave_detach(0x%p)\n", link);
451 if (link->state & DEV_CONFIG)
452 netwave_release(link);
455 unregister_netdev(dev);
458 } /* netwave_detach */
461 * Wireless Handler : get protocol name
463 static int netwave_get_name(struct net_device *dev,
464 struct iw_request_info *info,
465 union iwreq_data *wrqu,
468 strcpy(wrqu->name, "Netwave");
473 * Wireless Handler : set Network ID
475 static int netwave_set_nwid(struct net_device *dev,
476 struct iw_request_info *info,
477 union iwreq_data *wrqu,
481 kio_addr_t iobase = dev->base_addr;
482 netwave_private *priv = netdev_priv(dev);
483 u_char __iomem *ramBase = priv->ramBase;
485 /* Disable interrupts & save flags */
486 spin_lock_irqsave(&priv->spinlock, flags);
488 if(!wrqu->nwid.disabled) {
489 domain = wrqu->nwid.value;
490 printk( KERN_DEBUG "Setting domain to 0x%x%02x\n",
491 (domain >> 8) & 0x01, domain & 0xff);
493 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
494 writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
495 writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
496 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
499 /* ReEnable interrupts & restore flags */
500 spin_unlock_irqrestore(&priv->spinlock, flags);
506 * Wireless Handler : get Network ID
508 static int netwave_get_nwid(struct net_device *dev,
509 struct iw_request_info *info,
510 union iwreq_data *wrqu,
513 wrqu->nwid.value = domain;
514 wrqu->nwid.disabled = 0;
515 wrqu->nwid.fixed = 1;
520 * Wireless Handler : set scramble key
522 static int netwave_set_scramble(struct net_device *dev,
523 struct iw_request_info *info,
524 union iwreq_data *wrqu,
528 kio_addr_t iobase = dev->base_addr;
529 netwave_private *priv = netdev_priv(dev);
530 u_char __iomem *ramBase = priv->ramBase;
532 /* Disable interrupts & save flags */
533 spin_lock_irqsave(&priv->spinlock, flags);
535 scramble_key = (key[0] << 8) | key[1];
537 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
538 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
539 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
540 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
542 /* ReEnable interrupts & restore flags */
543 spin_unlock_irqrestore(&priv->spinlock, flags);
549 * Wireless Handler : get scramble key
551 static int netwave_get_scramble(struct net_device *dev,
552 struct iw_request_info *info,
553 union iwreq_data *wrqu,
556 key[1] = scramble_key & 0xff;
557 key[0] = (scramble_key>>8) & 0xff;
558 wrqu->encoding.flags = IW_ENCODE_ENABLED;
559 wrqu->encoding.length = 2;
564 * Wireless Handler : get mode
566 static int netwave_get_mode(struct net_device *dev,
567 struct iw_request_info *info,
568 union iwreq_data *wrqu,
572 wrqu->mode = IW_MODE_INFRA;
574 wrqu->mode = IW_MODE_ADHOC;
580 * Wireless Handler : get range info
582 static int netwave_get_range(struct net_device *dev,
583 struct iw_request_info *info,
584 union iwreq_data *wrqu,
587 struct iw_range *range = (struct iw_range *) extra;
590 /* Set the length (very important for backward compatibility) */
591 wrqu->data.length = sizeof(struct iw_range);
593 /* Set all the info we don't care or don't know about to zero */
594 memset(range, 0, sizeof(struct iw_range));
596 /* Set the Wireless Extension versions */
597 range->we_version_compiled = WIRELESS_EXT;
598 range->we_version_source = 9; /* Nothing for us in v10 and v11 */
600 /* Set information in the range struct */
601 range->throughput = 450 * 1000; /* don't argue on this ! */
602 range->min_nwid = 0x0000;
603 range->max_nwid = 0x01FF;
605 range->num_channels = range->num_frequency = 0;
607 range->sensitivity = 0x3F;
608 range->max_qual.qual = 255;
609 range->max_qual.level = 255;
610 range->max_qual.noise = 0;
612 range->num_bitrates = 1;
613 range->bitrate[0] = 1000000; /* 1 Mb/s */
615 range->encoding_size[0] = 2; /* 16 bits scrambling */
616 range->num_encoding_sizes = 1;
617 range->max_encoding_tokens = 1; /* Only one key possible */
623 * Wireless Private Handler : get snapshot
625 static int netwave_get_snap(struct net_device *dev,
626 struct iw_request_info *info,
627 union iwreq_data *wrqu,
631 kio_addr_t iobase = dev->base_addr;
632 netwave_private *priv = netdev_priv(dev);
633 u_char __iomem *ramBase = priv->ramBase;
635 /* Disable interrupts & save flags */
636 spin_lock_irqsave(&priv->spinlock, flags);
638 /* Take snapshot of environment */
639 netwave_snapshot( priv, ramBase, iobase);
640 wrqu->data.length = priv->nss.length;
641 memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
643 priv->lastExec = jiffies;
645 /* ReEnable interrupts & restore flags */
646 spin_unlock_irqrestore(&priv->spinlock, flags);
652 * Structures to export the Wireless Handlers
653 * This is the stuff that are treated the wireless extensions (iwconfig)
656 static const struct iw_priv_args netwave_private_args[] = {
657 /*{ cmd, set_args, get_args, name } */
659 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey),
663 static const iw_handler netwave_handler[] =
665 NULL, /* SIOCSIWNAME */
666 netwave_get_name, /* SIOCGIWNAME */
667 netwave_set_nwid, /* SIOCSIWNWID */
668 netwave_get_nwid, /* SIOCGIWNWID */
669 NULL, /* SIOCSIWFREQ */
670 NULL, /* SIOCGIWFREQ */
671 NULL, /* SIOCSIWMODE */
672 netwave_get_mode, /* SIOCGIWMODE */
673 NULL, /* SIOCSIWSENS */
674 NULL, /* SIOCGIWSENS */
675 NULL, /* SIOCSIWRANGE */
676 netwave_get_range, /* SIOCGIWRANGE */
677 NULL, /* SIOCSIWPRIV */
678 NULL, /* SIOCGIWPRIV */
679 NULL, /* SIOCSIWSTATS */
680 NULL, /* SIOCGIWSTATS */
681 NULL, /* SIOCSIWSPY */
682 NULL, /* SIOCGIWSPY */
683 NULL, /* -- hole -- */
684 NULL, /* -- hole -- */
685 NULL, /* SIOCSIWAP */
686 NULL, /* SIOCGIWAP */
687 NULL, /* -- hole -- */
688 NULL, /* SIOCGIWAPLIST */
689 NULL, /* -- hole -- */
690 NULL, /* -- hole -- */
691 NULL, /* SIOCSIWESSID */
692 NULL, /* SIOCGIWESSID */
693 NULL, /* SIOCSIWNICKN */
694 NULL, /* SIOCGIWNICKN */
695 NULL, /* -- hole -- */
696 NULL, /* -- hole -- */
697 NULL, /* SIOCSIWRATE */
698 NULL, /* SIOCGIWRATE */
699 NULL, /* SIOCSIWRTS */
700 NULL, /* SIOCGIWRTS */
701 NULL, /* SIOCSIWFRAG */
702 NULL, /* SIOCGIWFRAG */
703 NULL, /* SIOCSIWTXPOW */
704 NULL, /* SIOCGIWTXPOW */
705 NULL, /* SIOCSIWRETRY */
706 NULL, /* SIOCGIWRETRY */
707 netwave_set_scramble, /* SIOCSIWENCODE */
708 netwave_get_scramble, /* SIOCGIWENCODE */
711 static const iw_handler netwave_private_handler[] =
713 NULL, /* SIOCIWFIRSTPRIV */
714 netwave_get_snap, /* SIOCIWFIRSTPRIV + 1 */
717 static const struct iw_handler_def netwave_handler_def =
719 .num_standard = sizeof(netwave_handler)/sizeof(iw_handler),
720 .num_private = sizeof(netwave_private_handler)/sizeof(iw_handler),
721 .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
722 .standard = (iw_handler *) netwave_handler,
723 .private = (iw_handler *) netwave_private_handler,
724 .private_args = (struct iw_priv_args *) netwave_private_args,
725 .get_wireless_stats = netwave_get_wireless_stats,
729 * Function netwave_pcmcia_config (link)
731 * netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION
732 * event is received, to configure the PCMCIA socket, and to make the
733 * device available to the system.
737 #define CS_CHECK(fn, ret) \
738 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
740 static void netwave_pcmcia_config(struct pcmcia_device *link) {
741 struct net_device *dev = link->priv;
742 netwave_private *priv = netdev_priv(dev);
745 int i, j, last_ret, last_fn;
749 u_char __iomem *ramBase = NULL;
751 DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
754 This reads the card's CONFIG tuple to find its configuration
757 tuple.Attributes = 0;
758 tuple.TupleData = (cisdata_t *) buf;
759 tuple.TupleDataMax = 64;
760 tuple.TupleOffset = 0;
761 tuple.DesiredTuple = CISTPL_CONFIG;
762 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
763 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
764 CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
765 link->conf.ConfigBase = parse.config.base;
766 link->conf.Present = parse.config.rmask[0];
769 link->state |= DEV_CONFIG;
772 * Try allocating IO ports. This tries a few fixed addresses.
773 * If you want, you can also read the card's config table to
774 * pick addresses -- see the serial driver for an example.
776 for (i = j = 0x0; j < 0x400; j += 0x20) {
777 link->io.BasePort1 = j ^ 0x300;
778 i = pcmcia_request_io(link, &link->io);
779 if (i == CS_SUCCESS) break;
781 if (i != CS_SUCCESS) {
782 cs_error(link, RequestIO, i);
787 * Now allocate an interrupt line. Note that this does not
788 * actually assign a handler to the interrupt.
790 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
793 * This actually configures the PCMCIA socket -- setting up
794 * the I/O windows and the interrupt mapping.
796 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
799 * Allocate a 32K memory window. Note that the struct pcmcia_device
800 * structure provides space for one window handle -- if your
801 * device needs several windows, you'll need to keep track of
802 * the handles in your private data structure, dev->priv.
804 DEBUG(1, "Setting mem speed of %d\n", mem_speed);
806 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
807 req.Base = 0; req.Size = 0x8000;
808 req.AccessSpeed = mem_speed;
809 CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
810 mem.CardOffset = 0x20000; mem.Page = 0;
811 CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
813 /* Store base address of the common window frame */
814 ramBase = ioremap(req.Base, 0x8000);
815 priv->ramBase = ramBase;
817 dev->irq = link->irq.AssignedIRQ;
818 dev->base_addr = link->io.BasePort1;
819 SET_NETDEV_DEV(dev, &handle_to_dev(link));
821 if (register_netdev(dev) != 0) {
822 printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
826 strcpy(priv->node.dev_name, dev->name);
827 link->dev_node = &priv->node;
828 link->state &= ~DEV_CONFIG_PENDING;
830 /* Reset card before reading physical address */
831 netwave_doreset(dev->base_addr, ramBase);
833 /* Read the ethernet address and fill in the Netwave registers. */
834 for (i = 0; i < 6; i++)
835 dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
837 printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
838 "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
839 (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
840 (int) readb(ramBase+NETWAVE_EREG_NI+1));
841 for (i = 0; i < 6; i++)
842 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
844 /* get revision words */
845 printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n",
846 get_uint16(ramBase + NETWAVE_EREG_ARW),
847 get_uint16(ramBase + NETWAVE_EREG_ARW+2));
851 cs_error(link, last_fn, last_ret);
853 netwave_release(link);
854 } /* netwave_pcmcia_config */
857 * Function netwave_release (arg)
859 * After a card is removed, netwave_release() will unregister the net
860 * device, and release the PCMCIA configuration. If the device is
861 * still open, this will be postponed until it is closed.
863 static void netwave_release(struct pcmcia_device *link)
865 struct net_device *dev = link->priv;
866 netwave_private *priv = netdev_priv(dev);
868 DEBUG(0, "netwave_release(0x%p)\n", link);
870 pcmcia_disable_device(link);
872 iounmap(priv->ramBase);
875 static int netwave_suspend(struct pcmcia_device *link)
877 struct net_device *dev = link->priv;
879 if ((link->state & DEV_CONFIG) && (link->open))
880 netif_device_detach(dev);
885 static int netwave_resume(struct pcmcia_device *link)
887 struct net_device *dev = link->priv;
889 if ((link->state & DEV_CONFIG) && (link->open)) {
891 netif_device_attach(dev);
899 * Function netwave_doreset (ioBase, ramBase)
901 * Proper hardware reset of the card.
903 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
907 outb(0x80, ioBase + NETWAVE_REG_PMR);
908 writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
909 outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
913 * Function netwave_reset (dev)
915 * Reset and restore all of the netwave registers
917 static void netwave_reset(struct net_device *dev) {
919 netwave_private *priv = netdev_priv(dev);
920 u_char __iomem *ramBase = priv->ramBase;
921 kio_addr_t iobase = dev->base_addr;
923 DEBUG(0, "netwave_reset: Done with hardware reset\n");
925 priv->timeoutCounter = 0;
928 netwave_doreset(iobase, ramBase);
929 printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
931 /* Write a NOP to check the card */
933 writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
934 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
936 /* Set receive conf */
938 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
939 writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
940 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
942 /* Set transmit conf */
944 writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
945 writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
946 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
948 /* Now set the MU Domain */
949 printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
951 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
952 writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
953 writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
954 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
956 /* Set scramble key */
957 printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
959 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
960 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
961 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
962 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
964 /* Enable interrupts, bit 4 high to keep unused
965 * source from interrupting us, bit 2 high to
966 * set interrupt enable, 567 to enable TxDN,
970 outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
972 /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
974 * skriv 80 til d000:3688
975 * sjekk om det ble 80
978 /* Enable Receiver */
980 writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
981 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
983 /* Set the IENA bit in COR */
985 outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
989 * Function netwave_hw_xmit (data, len, dev)
991 static int netwave_hw_xmit(unsigned char* data, int len,
992 struct net_device* dev) {
994 unsigned int TxFreeList,
1000 netwave_private *priv = netdev_priv(dev);
1001 u_char __iomem * ramBase = priv->ramBase;
1002 kio_addr_t iobase = dev->base_addr;
1004 /* Disable interrupts & save flags */
1005 spin_lock_irqsave(&priv->spinlock, flags);
1007 /* Check if there are transmit buffers available */
1009 if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
1010 /* No buffers available */
1011 printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
1013 spin_unlock_irqrestore(&priv->spinlock, flags);
1017 priv->stats.tx_bytes += len;
1019 DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
1020 readb(ramBase + NETWAVE_EREG_SPCQ),
1021 readb(ramBase + NETWAVE_EREG_SPU),
1022 readb(ramBase + NETWAVE_EREG_LIF),
1023 readb(ramBase + NETWAVE_EREG_ISPLQ));
1025 /* Now try to insert it into the adapters free memory */
1027 TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1028 MaxData = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1029 DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1031 DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1032 TxFreeList, MaxData, DataOffset);
1034 /* Copy packet to the adapter fragment buffers */
1035 curBuff = TxFreeList;
1037 while (tmpcount < len) {
1038 int tmplen = len - tmpcount;
1039 copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount,
1040 (tmplen < MaxData) ? tmplen : MaxData);
1041 tmpcount += MaxData;
1043 /* Advance to next buffer */
1044 curBuff = get_uint16(ramBase + curBuff);
1047 /* Now issue transmit list */
1049 writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1050 writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1051 writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1052 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1054 spin_unlock_irqrestore(&priv->spinlock, flags);
1058 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1059 /* This flag indicate that the hardware can't perform a transmission.
1060 * Theoritically, NET3 check it before sending a packet to the driver,
1061 * but in fact it never do that and pool continuously.
1062 * As the watchdog will abort too long transmissions, we are quite safe...
1065 netif_stop_queue(dev);
1068 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1069 unsigned char* buf = skb->data;
1071 if (netwave_hw_xmit( buf, length, dev) == 1) {
1072 /* Some error, let's make them call us another time? */
1073 netif_start_queue(dev);
1075 dev->trans_start = jiffies;
1080 } /* netwave_start_xmit */
1083 * Function netwave_interrupt (irq, dev_id, regs)
1085 * This function is the interrupt handler for the Netwave card. This
1086 * routine will be called whenever:
1087 * 1. A packet is received.
1088 * 2. A packet has successfully been transferred and the unit is
1089 * ready to transmit another packet.
1090 * 3. A command has completed execution.
1092 static irqreturn_t netwave_interrupt(int irq, void* dev_id, struct pt_regs *regs)
1095 u_char __iomem *ramBase;
1096 struct net_device *dev = (struct net_device *)dev_id;
1097 struct netwave_private *priv = netdev_priv(dev);
1098 struct pcmcia_device *link = priv->p_dev;
1101 if (!netif_device_present(dev))
1104 iobase = dev->base_addr;
1105 ramBase = priv->ramBase;
1107 /* Now find what caused the interrupt, check while interrupts ready */
1108 for (i = 0; i < 10; i++) {
1112 if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1113 break; /* None of the interrupt sources asserted (normal exit) */
1115 status = inb(iobase + NETWAVE_REG_ASR);
1117 if (!DEV_OK(link)) {
1118 DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1119 "from removed or suspended card!\n", status);
1124 if (status & 0x80) {
1126 /* wait_WOC(iobase); */
1127 /* RxRdy cannot be reset directly by the host */
1130 if (status & 0x40) {
1133 rser = readb(ramBase + NETWAVE_EREG_RSER);
1136 ++priv->stats.rx_dropped;
1137 ++priv->stats.rx_crc_errors;
1140 ++priv->stats.rx_frame_errors;
1142 /* Clear the RxErr bit in RSER. RSER+4 is the
1143 * write part. Also clear the RxCRC (0x04) and
1144 * RxBig (0x02) bits if present */
1146 writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1148 /* Write bit 6 high to ASCC to clear RxErr in ASR,
1149 * WOC must be set first!
1152 writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1154 /* Remember to count up priv->stats on error packets */
1155 ++priv->stats.rx_errors;
1158 if (status & 0x20) {
1161 txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1162 DEBUG(3, "Transmit done. TSER = %x id %x\n",
1163 txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1165 if (txStatus & 0x20) {
1166 /* Transmitting was okay, clear bits */
1168 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1169 ++priv->stats.tx_packets;
1172 if (txStatus & 0xd0) {
1173 if (txStatus & 0x80) {
1174 ++priv->stats.collisions; /* Because of /proc/net/dev*/
1175 /* ++priv->stats.tx_aborted_errors; */
1176 /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1178 if (txStatus & 0x40)
1179 ++priv->stats.tx_carrier_errors;
1180 /* 0x80 TxGU Transmit giveup - nine times and no luck
1181 * 0x40 TxNOAP No access point. Discarded packet.
1182 * 0x10 TxErr Transmit error. Always set when
1183 * TxGU and TxNOAP is set. (Those are the only ones
1186 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n",
1189 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1191 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1192 ++priv->stats.tx_errors;
1194 DEBUG(3, "New status is TSER %x ASR %x\n",
1195 readb(ramBase + NETWAVE_EREG_TSER),
1196 inb(iobase + NETWAVE_REG_ASR));
1198 netif_wake_queue(dev);
1200 /* TxBA, this would trigger on all error packets received */
1201 /* if (status & 0x01) {
1202 DEBUG(4, "Transmit buffers available, %x\n", status);
1206 /* Handled if we looped at least one time - Jean II */
1207 return IRQ_RETVAL(i);
1208 } /* netwave_interrupt */
1211 * Function netwave_watchdog (a)
1213 * Watchdog : when we start a transmission, we set a timer in the
1214 * kernel. If the transmission complete, this timer is disabled. If
1215 * it expire, we reset the card.
1218 static void netwave_watchdog(struct net_device *dev) {
1220 DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1222 dev->trans_start = jiffies;
1223 netif_wake_queue(dev);
1224 } /* netwave_watchdog */
1226 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1227 netwave_private *priv = netdev_priv(dev);
1231 DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1232 " %x tx %x %x %x %x\n",
1233 readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1234 readb(priv->ramBase + NETWAVE_EREG_SPU),
1235 readb(priv->ramBase + NETWAVE_EREG_LIF),
1236 readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1237 readb(priv->ramBase + NETWAVE_EREG_MHS),
1238 readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1239 readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1240 readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1241 readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1242 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1243 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1245 return &priv->stats;
1248 static void update_stats(struct net_device *dev) {
1249 //unsigned long flags;
1250 /* netwave_private *priv = netdev_priv(dev); */
1252 //spin_lock_irqsave(&priv->spinlock, flags);
1254 /* priv->stats.rx_packets = readb(priv->ramBase + 0x18e);
1255 priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1257 //spin_unlock_irqrestore(&priv->spinlock, flags);
1260 static int netwave_rx(struct net_device *dev)
1262 netwave_private *priv = netdev_priv(dev);
1263 u_char __iomem *ramBase = priv->ramBase;
1264 kio_addr_t iobase = dev->base_addr;
1266 struct sk_buff *skb = NULL;
1267 unsigned int curBuffer,
1271 int dataCount, dataOffset;
1275 DEBUG(3, "xinw_rx: Receiving ... \n");
1277 /* Receive max 10 packets for now. */
1278 for (i = 0; i < 10; i++) {
1281 rxStatus = readb(ramBase + NETWAVE_EREG_RSER);
1282 if ( !( rxStatus & 0x80)) /* No more packets */
1285 /* Check if multicast/broadcast or other */
1286 /* multicast = (rxStatus & 0x20); */
1288 /* The receive list pointer and length of the packet */
1290 rcvLen = get_int16( ramBase + NETWAVE_EREG_RDP);
1291 rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1294 printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n",
1299 skb = dev_alloc_skb(rcvLen+5);
1301 DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1302 "length %d\n", rcvLen);
1303 ++priv->stats.rx_dropped;
1304 /* Tell the adapter to skip the packet */
1306 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1307 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1311 skb_reserve( skb, 2); /* Align IP on 16 byte */
1312 skb_put( skb, rcvLen);
1315 /* Copy packet fragments to the skb data area */
1316 ptr = (u_char*) skb->data;
1317 curBuffer = rcvList;
1319 while ( tmpcount < rcvLen) {
1320 /* Get length and offset of current buffer */
1321 dataCount = get_uint16( ramBase+curBuffer+2);
1322 dataOffset = get_uint16( ramBase+curBuffer+4);
1324 copy_from_pc( ptr + tmpcount,
1325 ramBase+curBuffer+dataOffset, dataCount);
1327 tmpcount += dataCount;
1329 /* Point to next buffer */
1330 curBuffer = get_uint16(ramBase + curBuffer);
1333 skb->protocol = eth_type_trans(skb,dev);
1334 /* Queue packet for network layer */
1337 dev->last_rx = jiffies;
1338 priv->stats.rx_packets++;
1339 priv->stats.rx_bytes += rcvLen;
1341 /* Got the packet, tell the adapter to skip it */
1343 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1344 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1345 DEBUG(3, "Packet reception ok\n");
1350 static int netwave_open(struct net_device *dev) {
1351 netwave_private *priv = netdev_priv(dev);
1352 struct pcmcia_device *link = priv->p_dev;
1354 DEBUG(1, "netwave_open: starting.\n");
1361 netif_start_queue(dev);
1367 static int netwave_close(struct net_device *dev) {
1368 netwave_private *priv = netdev_priv(dev);
1369 struct pcmcia_device *link = priv->p_dev;
1371 DEBUG(1, "netwave_close: finishing.\n");
1374 netif_stop_queue(dev);
1379 static struct pcmcia_device_id netwave_ids[] = {
1380 PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1383 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1385 static struct pcmcia_driver netwave_driver = {
1386 .owner = THIS_MODULE,
1388 .name = "netwave_cs",
1390 .probe = netwave_attach,
1391 .remove = netwave_detach,
1392 .id_table = netwave_ids,
1393 .suspend = netwave_suspend,
1394 .resume = netwave_resume,
1397 static int __init init_netwave_cs(void)
1399 return pcmcia_register_driver(&netwave_driver);
1402 static void __exit exit_netwave_cs(void)
1404 pcmcia_unregister_driver(&netwave_driver);
1407 module_init(init_netwave_cs);
1408 module_exit(exit_netwave_cs);
1410 /* Set or clear the multicast filter for this adaptor.
1411 num_addrs == -1 Promiscuous mode, receive all packets
1412 num_addrs == 0 Normal mode, clear multicast list
1413 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
1414 best-effort filtering.
1416 static void set_multicast_list(struct net_device *dev)
1418 kio_addr_t iobase = dev->base_addr;
1419 netwave_private *priv = netdev_priv(dev);
1420 u_char __iomem * ramBase = priv->ramBase;
1426 if (old != dev->mc_count) {
1427 old = dev->mc_count;
1428 DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1429 dev->name, dev->mc_count);
1434 if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1435 /* Multicast Mode */
1436 rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1437 } else if (dev->flags & IFF_PROMISC) {
1438 /* Promiscous mode */
1439 rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1442 rcvMode = rxConfRxEna + rxConfBcast;
1445 /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1446 /* Now set receive mode */
1448 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1449 writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1450 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1452 MODULE_LICENSE("GPL");