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/module.h>
41 #include <linux/kernel.h>
42 #include <linux/init.h>
43 #include <linux/types.h>
44 #include <linux/fcntl.h>
45 #include <linux/interrupt.h>
46 #include <linux/ptrace.h>
47 #include <linux/ioport.h>
49 #include <linux/slab.h>
50 #include <linux/string.h>
51 #include <linux/timer.h>
52 #include <linux/errno.h>
53 #include <linux/netdevice.h>
54 #include <linux/etherdevice.h>
55 #include <linux/skbuff.h>
56 #include <linux/bitops.h>
57 #include <linux/wireless.h>
58 #include <net/iw_handler.h>
60 #include <pcmcia/cs_types.h>
61 #include <pcmcia/cs.h>
62 #include <pcmcia/cistpl.h>
63 #include <pcmcia/cisreg.h>
64 #include <pcmcia/ds.h>
65 #include <pcmcia/mem_op.h>
67 #include <asm/system.h>
71 #define NETWAVE_REGOFF 0x8000
72 /* The Netwave IO registers, offsets to iobase */
73 #define NETWAVE_REG_COR 0x0
74 #define NETWAVE_REG_CCSR 0x2
75 #define NETWAVE_REG_ASR 0x4
76 #define NETWAVE_REG_IMR 0xa
77 #define NETWAVE_REG_PMR 0xc
78 #define NETWAVE_REG_IOLOW 0x6
79 #define NETWAVE_REG_IOHI 0x7
80 #define NETWAVE_REG_IOCONTROL 0x8
81 #define NETWAVE_REG_DATA 0xf
82 /* The Netwave Extended IO registers, offsets to RamBase */
83 #define NETWAVE_EREG_ASCC 0x114
84 #define NETWAVE_EREG_RSER 0x120
85 #define NETWAVE_EREG_RSERW 0x124
86 #define NETWAVE_EREG_TSER 0x130
87 #define NETWAVE_EREG_TSERW 0x134
88 #define NETWAVE_EREG_CB 0x100
89 #define NETWAVE_EREG_SPCQ 0x154
90 #define NETWAVE_EREG_SPU 0x155
91 #define NETWAVE_EREG_LIF 0x14e
92 #define NETWAVE_EREG_ISPLQ 0x156
93 #define NETWAVE_EREG_HHC 0x158
94 #define NETWAVE_EREG_NI 0x16e
95 #define NETWAVE_EREG_MHS 0x16b
96 #define NETWAVE_EREG_TDP 0x140
97 #define NETWAVE_EREG_RDP 0x150
98 #define NETWAVE_EREG_PA 0x160
99 #define NETWAVE_EREG_EC 0x180
100 #define NETWAVE_EREG_CRBP 0x17a
101 #define NETWAVE_EREG_ARW 0x166
104 * Commands used in the extended command buffer
105 * NETWAVE_EREG_CB (0x100-0x10F)
107 #define NETWAVE_CMD_NOP 0x00
108 #define NETWAVE_CMD_SRC 0x01
109 #define NETWAVE_CMD_STC 0x02
110 #define NETWAVE_CMD_AMA 0x03
111 #define NETWAVE_CMD_DMA 0x04
112 #define NETWAVE_CMD_SAMA 0x05
113 #define NETWAVE_CMD_ER 0x06
114 #define NETWAVE_CMD_DR 0x07
115 #define NETWAVE_CMD_TL 0x08
116 #define NETWAVE_CMD_SRP 0x09
117 #define NETWAVE_CMD_SSK 0x0a
118 #define NETWAVE_CMD_SMD 0x0b
119 #define NETWAVE_CMD_SAPD 0x0c
120 #define NETWAVE_CMD_SSS 0x11
121 /* End of Command marker */
122 #define NETWAVE_CMD_EOC 0x00
124 /* ASR register bits */
125 #define NETWAVE_ASR_RXRDY 0x80
126 #define NETWAVE_ASR_TXBA 0x01
128 #define TX_TIMEOUT ((32*HZ)/100)
130 static const unsigned int imrConfRFU1 = 0x10; /* RFU interrupt mask, keep high */
131 static const unsigned int imrConfIENA = 0x02; /* Interrupt enable */
133 static const unsigned int corConfIENA = 0x01; /* Interrupt enable */
134 static const unsigned int corConfLVLREQ = 0x40; /* Keep high */
136 static const unsigned int rxConfRxEna = 0x80; /* Receive Enable */
137 static const unsigned int rxConfMAC = 0x20; /* MAC host receive mode*/
138 static const unsigned int rxConfPro = 0x10; /* Promiscuous */
139 static const unsigned int rxConfAMP = 0x08; /* Accept Multicast Packets */
140 static const unsigned int rxConfBcast = 0x04; /* Accept Broadcast Packets */
142 static const unsigned int txConfTxEna = 0x80; /* Transmit Enable */
143 static const unsigned int txConfMAC = 0x20; /* Host sends MAC mode */
144 static const unsigned int txConfEUD = 0x10; /* Enable Uni-Data packets */
145 static const unsigned int txConfKey = 0x02; /* Scramble data packets */
146 static const unsigned int txConfLoop = 0x01; /* Loopback mode */
149 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
150 you do not define PCMCIA_DEBUG at all, all the debug code will be
151 left out. If you compile with PCMCIA_DEBUG=0, the debug code will
152 be present but disabled -- but it can then be enabled for specific
153 modules at load time with a 'pc_debug=#' option to insmod.
157 static int pc_debug = PCMCIA_DEBUG;
158 module_param(pc_debug, int, 0);
159 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
160 static char *version =
161 "netwave_cs.c 0.3.0 Thu Jul 17 14:36:02 1997 (John Markus Bjørndalen)\n";
163 #define DEBUG(n, args...)
166 /*====================================================================*/
168 /* Parameters that can be set with 'insmod' */
170 /* Choose the domain, default is 0x100 */
171 static u_int domain = 0x100;
173 /* Scramble key, range from 0x0 to 0xffff.
174 * 0x0 is no scrambling.
176 static u_int scramble_key = 0x0;
178 /* Shared memory speed, in ns. The documentation states that
179 * the card should not be read faster than every 400ns.
180 * This timing should be provided by the HBA. If it becomes a
181 * problem, try setting mem_speed to 400.
183 static int mem_speed;
185 module_param(domain, int, 0);
186 module_param(scramble_key, int, 0);
187 module_param(mem_speed, int, 0);
189 /*====================================================================*/
191 /* PCMCIA (Card Services) related functions */
192 static void netwave_release(struct pcmcia_device *link); /* Card removal */
193 static int netwave_pcmcia_config(struct pcmcia_device *arg); /* Runs after card
195 static void netwave_detach(struct pcmcia_device *p_dev); /* Destroy instance */
197 /* Hardware configuration */
198 static void netwave_doreset(kio_addr_t iobase, u_char __iomem *ramBase);
199 static void netwave_reset(struct net_device *dev);
201 /* Misc device stuff */
202 static int netwave_open(struct net_device *dev); /* Open the device */
203 static int netwave_close(struct net_device *dev); /* Close the device */
205 /* Packet transmission and Packet reception */
206 static int netwave_start_xmit( struct sk_buff *skb, struct net_device *dev);
207 static int netwave_rx( struct net_device *dev);
209 /* Interrupt routines */
210 static irqreturn_t netwave_interrupt(int irq, void *dev_id);
211 static void netwave_watchdog(struct net_device *);
214 static void update_stats(struct net_device *dev);
215 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
217 /* Wireless extensions */
218 static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev);
220 static void set_multicast_list(struct net_device *dev);
223 A struct pcmcia_device structure has fields for most things that are needed
224 to keep track of a socket, but there will usually be some device
225 specific information that also needs to be kept track of. The
226 'priv' pointer in a struct pcmcia_device structure can be used to point to
227 a device-specific private data structure, like this.
229 A driver needs to provide a dev_node_t structure for each device
230 on a card. In some cases, there is only one device per card (for
231 example, ethernet cards, modems). In other cases, there may be
232 many actual or logical devices (SCSI adapters, memory cards with
233 multiple partitions). The dev_node_t structures need to be kept
234 in a linked list starting at the 'dev' field of a struct pcmcia_device
235 structure. We allocate them in the card's private data structure,
236 because they generally can't be allocated dynamically.
239 static const struct iw_handler_def netwave_handler_def;
241 #define SIOCGIPSNAP SIOCIWFIRSTPRIV + 1 /* Site Survey Snapshot */
245 typedef struct net_addr {
251 u_char struct_revision;
252 u_char roaming_state;
254 u_char sp_existsFlag;
255 u_char sp_link_quality;
256 u_char sp_max_link_quality;
257 u_char linkQualityGoodFairBoundary;
258 u_char linkQualityFairPoorBoundary;
259 u_char sp_utilization;
261 u_char sp_hotheadcount;
262 u_char roaming_condition;
266 net_addr nearByAccessPoints[MAX_ESA];
269 typedef struct netwave_private {
270 struct pcmcia_device *p_dev;
271 spinlock_t spinlock; /* Serialize access to the hardware (SMP) */
273 u_char __iomem *ramBase;
276 struct timer_list watchdog; /* To avoid blocking state */
277 struct site_survey nss;
278 struct net_device_stats stats;
279 struct iw_statistics iw_stats; /* Wireless stats */
283 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
287 * The Netwave card is little-endian, so won't work for big endian
290 static inline unsigned short get_uint16(u_char __iomem *staddr)
292 return readw(staddr); /* Return only 16 bits */
295 static inline short get_int16(u_char __iomem * staddr)
297 return readw(staddr);
301 * Wait until the WOC (Write Operation Complete) bit in the
302 * ASR (Adapter Status Register) is asserted.
303 * This should have aborted if it takes too long time.
305 static inline void wait_WOC(unsigned int iobase)
308 while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ;
311 static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase,
313 u_short resultBuffer;
315 /* if time since last snapshot is > 1 sec. (100 jiffies?) then take
316 * new snapshot, else return cached data. This is the recommended rate.
318 if ( jiffies - priv->lastExec > 100) {
319 /* Take site survey snapshot */
320 /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies -
323 writeb(NETWAVE_CMD_SSS, ramBase + NETWAVE_EREG_CB + 0);
324 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
327 /* Get result and copy to cach */
328 resultBuffer = readw(ramBase + NETWAVE_EREG_CRBP);
329 copy_from_pc( &priv->nss, ramBase+resultBuffer,
330 sizeof(struct site_survey));
335 * Function netwave_get_wireless_stats (dev)
337 * Wireless extensions statistics
340 static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev)
343 kio_addr_t iobase = dev->base_addr;
344 netwave_private *priv = netdev_priv(dev);
345 u_char __iomem *ramBase = priv->ramBase;
346 struct iw_statistics* wstats;
348 wstats = &priv->iw_stats;
350 spin_lock_irqsave(&priv->spinlock, flags);
352 netwave_snapshot( priv, ramBase, iobase);
354 wstats->status = priv->nss.roaming_state;
355 wstats->qual.qual = readb( ramBase + NETWAVE_EREG_SPCQ);
356 wstats->qual.level = readb( ramBase + NETWAVE_EREG_ISPLQ);
357 wstats->qual.noise = readb( ramBase + NETWAVE_EREG_SPU) & 0x3f;
358 wstats->discard.nwid = 0L;
359 wstats->discard.code = 0L;
360 wstats->discard.misc = 0L;
362 spin_unlock_irqrestore(&priv->spinlock, flags);
364 return &priv->iw_stats;
368 * Function netwave_attach (void)
370 * Creates an "instance" of the driver, allocating local data
371 * structures for one device. The device is registered with Card
374 * The dev_link structure is initialized, but we don't actually
375 * configure the card at this point -- we wait until we receive a
376 * card insertion event.
378 static int netwave_probe(struct pcmcia_device *link)
380 struct net_device *dev;
381 netwave_private *priv;
383 DEBUG(0, "netwave_attach()\n");
385 /* Initialize the struct pcmcia_device structure */
386 dev = alloc_etherdev(sizeof(netwave_private));
389 priv = netdev_priv(dev);
393 /* The io structure describes IO port mapping */
394 link->io.NumPorts1 = 16;
395 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
396 /* link->io.NumPorts2 = 16;
397 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
398 link->io.IOAddrLines = 5;
400 /* Interrupt setup */
401 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
402 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
403 link->irq.Handler = &netwave_interrupt;
405 /* General socket configuration */
406 link->conf.Attributes = CONF_ENABLE_IRQ;
407 link->conf.IntType = INT_MEMORY_AND_IO;
408 link->conf.ConfigIndex = 1;
410 /* Netwave private struct init. link/dev/node already taken care of,
411 * other stuff zero'd - Jean II */
412 spin_lock_init(&priv->spinlock);
414 /* Netwave specific entries in the device structure */
415 dev->hard_start_xmit = &netwave_start_xmit;
416 dev->get_stats = &netwave_get_stats;
417 dev->set_multicast_list = &set_multicast_list;
418 /* wireless extensions */
419 dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
421 dev->tx_timeout = &netwave_watchdog;
422 dev->watchdog_timeo = TX_TIMEOUT;
424 dev->open = &netwave_open;
425 dev->stop = &netwave_close;
426 link->irq.Instance = dev;
428 return netwave_pcmcia_config( link);
429 } /* netwave_attach */
432 * Function netwave_detach (link)
434 * This deletes a driver "instance". The device is de-registered
435 * with Card Services. If it has been released, all local data
436 * structures are freed. Otherwise, the structures will be freed
437 * when the device is released.
439 static void netwave_detach(struct pcmcia_device *link)
441 struct net_device *dev = link->priv;
443 DEBUG(0, "netwave_detach(0x%p)\n", link);
445 netwave_release(link);
448 unregister_netdev(dev);
451 } /* netwave_detach */
454 * Wireless Handler : get protocol name
456 static int netwave_get_name(struct net_device *dev,
457 struct iw_request_info *info,
458 union iwreq_data *wrqu,
461 strcpy(wrqu->name, "Netwave");
466 * Wireless Handler : set Network ID
468 static int netwave_set_nwid(struct net_device *dev,
469 struct iw_request_info *info,
470 union iwreq_data *wrqu,
474 kio_addr_t iobase = dev->base_addr;
475 netwave_private *priv = netdev_priv(dev);
476 u_char __iomem *ramBase = priv->ramBase;
478 /* Disable interrupts & save flags */
479 spin_lock_irqsave(&priv->spinlock, flags);
481 if(!wrqu->nwid.disabled) {
482 domain = wrqu->nwid.value;
483 printk( KERN_DEBUG "Setting domain to 0x%x%02x\n",
484 (domain >> 8) & 0x01, domain & 0xff);
486 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
487 writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
488 writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
489 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
492 /* ReEnable interrupts & restore flags */
493 spin_unlock_irqrestore(&priv->spinlock, flags);
499 * Wireless Handler : get Network ID
501 static int netwave_get_nwid(struct net_device *dev,
502 struct iw_request_info *info,
503 union iwreq_data *wrqu,
506 wrqu->nwid.value = domain;
507 wrqu->nwid.disabled = 0;
508 wrqu->nwid.fixed = 1;
513 * Wireless Handler : set scramble key
515 static int netwave_set_scramble(struct net_device *dev,
516 struct iw_request_info *info,
517 union iwreq_data *wrqu,
521 kio_addr_t iobase = dev->base_addr;
522 netwave_private *priv = netdev_priv(dev);
523 u_char __iomem *ramBase = priv->ramBase;
525 /* Disable interrupts & save flags */
526 spin_lock_irqsave(&priv->spinlock, flags);
528 scramble_key = (key[0] << 8) | key[1];
530 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
531 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
532 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
533 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
535 /* ReEnable interrupts & restore flags */
536 spin_unlock_irqrestore(&priv->spinlock, flags);
542 * Wireless Handler : get scramble key
544 static int netwave_get_scramble(struct net_device *dev,
545 struct iw_request_info *info,
546 union iwreq_data *wrqu,
549 key[1] = scramble_key & 0xff;
550 key[0] = (scramble_key>>8) & 0xff;
551 wrqu->encoding.flags = IW_ENCODE_ENABLED;
552 wrqu->encoding.length = 2;
557 * Wireless Handler : get mode
559 static int netwave_get_mode(struct net_device *dev,
560 struct iw_request_info *info,
561 union iwreq_data *wrqu,
565 wrqu->mode = IW_MODE_INFRA;
567 wrqu->mode = IW_MODE_ADHOC;
573 * Wireless Handler : get range info
575 static int netwave_get_range(struct net_device *dev,
576 struct iw_request_info *info,
577 union iwreq_data *wrqu,
580 struct iw_range *range = (struct iw_range *) extra;
583 /* Set the length (very important for backward compatibility) */
584 wrqu->data.length = sizeof(struct iw_range);
586 /* Set all the info we don't care or don't know about to zero */
587 memset(range, 0, sizeof(struct iw_range));
589 /* Set the Wireless Extension versions */
590 range->we_version_compiled = WIRELESS_EXT;
591 range->we_version_source = 9; /* Nothing for us in v10 and v11 */
593 /* Set information in the range struct */
594 range->throughput = 450 * 1000; /* don't argue on this ! */
595 range->min_nwid = 0x0000;
596 range->max_nwid = 0x01FF;
598 range->num_channels = range->num_frequency = 0;
600 range->sensitivity = 0x3F;
601 range->max_qual.qual = 255;
602 range->max_qual.level = 255;
603 range->max_qual.noise = 0;
605 range->num_bitrates = 1;
606 range->bitrate[0] = 1000000; /* 1 Mb/s */
608 range->encoding_size[0] = 2; /* 16 bits scrambling */
609 range->num_encoding_sizes = 1;
610 range->max_encoding_tokens = 1; /* Only one key possible */
616 * Wireless Private Handler : get snapshot
618 static int netwave_get_snap(struct net_device *dev,
619 struct iw_request_info *info,
620 union iwreq_data *wrqu,
624 kio_addr_t iobase = dev->base_addr;
625 netwave_private *priv = netdev_priv(dev);
626 u_char __iomem *ramBase = priv->ramBase;
628 /* Disable interrupts & save flags */
629 spin_lock_irqsave(&priv->spinlock, flags);
631 /* Take snapshot of environment */
632 netwave_snapshot( priv, ramBase, iobase);
633 wrqu->data.length = priv->nss.length;
634 memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
636 priv->lastExec = jiffies;
638 /* ReEnable interrupts & restore flags */
639 spin_unlock_irqrestore(&priv->spinlock, flags);
645 * Structures to export the Wireless Handlers
646 * This is the stuff that are treated the wireless extensions (iwconfig)
649 static const struct iw_priv_args netwave_private_args[] = {
650 /*{ cmd, set_args, get_args, name } */
652 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey),
656 static const iw_handler netwave_handler[] =
658 NULL, /* SIOCSIWNAME */
659 netwave_get_name, /* SIOCGIWNAME */
660 netwave_set_nwid, /* SIOCSIWNWID */
661 netwave_get_nwid, /* SIOCGIWNWID */
662 NULL, /* SIOCSIWFREQ */
663 NULL, /* SIOCGIWFREQ */
664 NULL, /* SIOCSIWMODE */
665 netwave_get_mode, /* SIOCGIWMODE */
666 NULL, /* SIOCSIWSENS */
667 NULL, /* SIOCGIWSENS */
668 NULL, /* SIOCSIWRANGE */
669 netwave_get_range, /* SIOCGIWRANGE */
670 NULL, /* SIOCSIWPRIV */
671 NULL, /* SIOCGIWPRIV */
672 NULL, /* SIOCSIWSTATS */
673 NULL, /* SIOCGIWSTATS */
674 NULL, /* SIOCSIWSPY */
675 NULL, /* SIOCGIWSPY */
676 NULL, /* -- hole -- */
677 NULL, /* -- hole -- */
678 NULL, /* SIOCSIWAP */
679 NULL, /* SIOCGIWAP */
680 NULL, /* -- hole -- */
681 NULL, /* SIOCGIWAPLIST */
682 NULL, /* -- hole -- */
683 NULL, /* -- hole -- */
684 NULL, /* SIOCSIWESSID */
685 NULL, /* SIOCGIWESSID */
686 NULL, /* SIOCSIWNICKN */
687 NULL, /* SIOCGIWNICKN */
688 NULL, /* -- hole -- */
689 NULL, /* -- hole -- */
690 NULL, /* SIOCSIWRATE */
691 NULL, /* SIOCGIWRATE */
692 NULL, /* SIOCSIWRTS */
693 NULL, /* SIOCGIWRTS */
694 NULL, /* SIOCSIWFRAG */
695 NULL, /* SIOCGIWFRAG */
696 NULL, /* SIOCSIWTXPOW */
697 NULL, /* SIOCGIWTXPOW */
698 NULL, /* SIOCSIWRETRY */
699 NULL, /* SIOCGIWRETRY */
700 netwave_set_scramble, /* SIOCSIWENCODE */
701 netwave_get_scramble, /* SIOCGIWENCODE */
704 static const iw_handler netwave_private_handler[] =
706 NULL, /* SIOCIWFIRSTPRIV */
707 netwave_get_snap, /* SIOCIWFIRSTPRIV + 1 */
710 static const struct iw_handler_def netwave_handler_def =
712 .num_standard = sizeof(netwave_handler)/sizeof(iw_handler),
713 .num_private = sizeof(netwave_private_handler)/sizeof(iw_handler),
714 .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
715 .standard = (iw_handler *) netwave_handler,
716 .private = (iw_handler *) netwave_private_handler,
717 .private_args = (struct iw_priv_args *) netwave_private_args,
718 .get_wireless_stats = netwave_get_wireless_stats,
722 * Function netwave_pcmcia_config (link)
724 * netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION
725 * event is received, to configure the PCMCIA socket, and to make the
726 * device available to the system.
730 #define CS_CHECK(fn, ret) \
731 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
733 static int netwave_pcmcia_config(struct pcmcia_device *link) {
734 struct net_device *dev = link->priv;
735 netwave_private *priv = netdev_priv(dev);
736 int i, j, last_ret, last_fn;
739 u_char __iomem *ramBase = NULL;
741 DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
744 * Try allocating IO ports. This tries a few fixed addresses.
745 * If you want, you can also read the card's config table to
746 * pick addresses -- see the serial driver for an example.
748 for (i = j = 0x0; j < 0x400; j += 0x20) {
749 link->io.BasePort1 = j ^ 0x300;
750 i = pcmcia_request_io(link, &link->io);
751 if (i == CS_SUCCESS) break;
753 if (i != CS_SUCCESS) {
754 cs_error(link, RequestIO, i);
759 * Now allocate an interrupt line. Note that this does not
760 * actually assign a handler to the interrupt.
762 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
765 * This actually configures the PCMCIA socket -- setting up
766 * the I/O windows and the interrupt mapping.
768 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
771 * Allocate a 32K memory window. Note that the struct pcmcia_device
772 * structure provides space for one window handle -- if your
773 * device needs several windows, you'll need to keep track of
774 * the handles in your private data structure, dev->priv.
776 DEBUG(1, "Setting mem speed of %d\n", mem_speed);
778 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
779 req.Base = 0; req.Size = 0x8000;
780 req.AccessSpeed = mem_speed;
781 CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
782 mem.CardOffset = 0x20000; mem.Page = 0;
783 CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
785 /* Store base address of the common window frame */
786 ramBase = ioremap(req.Base, 0x8000);
787 priv->ramBase = ramBase;
789 dev->irq = link->irq.AssignedIRQ;
790 dev->base_addr = link->io.BasePort1;
791 SET_NETDEV_DEV(dev, &handle_to_dev(link));
793 if (register_netdev(dev) != 0) {
794 printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
798 strcpy(priv->node.dev_name, dev->name);
799 link->dev_node = &priv->node;
801 /* Reset card before reading physical address */
802 netwave_doreset(dev->base_addr, ramBase);
804 /* Read the ethernet address and fill in the Netwave registers. */
805 for (i = 0; i < 6; i++)
806 dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
808 printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
809 "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
810 (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
811 (int) readb(ramBase+NETWAVE_EREG_NI+1));
812 for (i = 0; i < 6; i++)
813 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
815 /* get revision words */
816 printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n",
817 get_uint16(ramBase + NETWAVE_EREG_ARW),
818 get_uint16(ramBase + NETWAVE_EREG_ARW+2));
822 cs_error(link, last_fn, last_ret);
824 netwave_release(link);
826 } /* netwave_pcmcia_config */
829 * Function netwave_release (arg)
831 * After a card is removed, netwave_release() will unregister the net
832 * device, and release the PCMCIA configuration. If the device is
833 * still open, this will be postponed until it is closed.
835 static void netwave_release(struct pcmcia_device *link)
837 struct net_device *dev = link->priv;
838 netwave_private *priv = netdev_priv(dev);
840 DEBUG(0, "netwave_release(0x%p)\n", link);
842 pcmcia_disable_device(link);
844 iounmap(priv->ramBase);
847 static int netwave_suspend(struct pcmcia_device *link)
849 struct net_device *dev = link->priv;
852 netif_device_detach(dev);
857 static int netwave_resume(struct pcmcia_device *link)
859 struct net_device *dev = link->priv;
863 netif_device_attach(dev);
871 * Function netwave_doreset (ioBase, ramBase)
873 * Proper hardware reset of the card.
875 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
879 outb(0x80, ioBase + NETWAVE_REG_PMR);
880 writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
881 outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
885 * Function netwave_reset (dev)
887 * Reset and restore all of the netwave registers
889 static void netwave_reset(struct net_device *dev) {
891 netwave_private *priv = netdev_priv(dev);
892 u_char __iomem *ramBase = priv->ramBase;
893 kio_addr_t iobase = dev->base_addr;
895 DEBUG(0, "netwave_reset: Done with hardware reset\n");
897 priv->timeoutCounter = 0;
900 netwave_doreset(iobase, ramBase);
901 printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
903 /* Write a NOP to check the card */
905 writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
906 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
908 /* Set receive conf */
910 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
911 writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
912 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
914 /* Set transmit conf */
916 writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
917 writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
918 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
920 /* Now set the MU Domain */
921 printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
923 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
924 writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
925 writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
926 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
928 /* Set scramble key */
929 printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
931 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
932 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
933 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
934 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
936 /* Enable interrupts, bit 4 high to keep unused
937 * source from interrupting us, bit 2 high to
938 * set interrupt enable, 567 to enable TxDN,
942 outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
944 /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
946 * skriv 80 til d000:3688
947 * sjekk om det ble 80
950 /* Enable Receiver */
952 writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
953 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
955 /* Set the IENA bit in COR */
957 outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
961 * Function netwave_hw_xmit (data, len, dev)
963 static int netwave_hw_xmit(unsigned char* data, int len,
964 struct net_device* dev) {
966 unsigned int TxFreeList,
972 netwave_private *priv = netdev_priv(dev);
973 u_char __iomem * ramBase = priv->ramBase;
974 kio_addr_t iobase = dev->base_addr;
976 /* Disable interrupts & save flags */
977 spin_lock_irqsave(&priv->spinlock, flags);
979 /* Check if there are transmit buffers available */
981 if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
982 /* No buffers available */
983 printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
985 spin_unlock_irqrestore(&priv->spinlock, flags);
989 priv->stats.tx_bytes += len;
991 DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
992 readb(ramBase + NETWAVE_EREG_SPCQ),
993 readb(ramBase + NETWAVE_EREG_SPU),
994 readb(ramBase + NETWAVE_EREG_LIF),
995 readb(ramBase + NETWAVE_EREG_ISPLQ));
997 /* Now try to insert it into the adapters free memory */
999 TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1000 MaxData = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1001 DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1003 DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1004 TxFreeList, MaxData, DataOffset);
1006 /* Copy packet to the adapter fragment buffers */
1007 curBuff = TxFreeList;
1009 while (tmpcount < len) {
1010 int tmplen = len - tmpcount;
1011 copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount,
1012 (tmplen < MaxData) ? tmplen : MaxData);
1013 tmpcount += MaxData;
1015 /* Advance to next buffer */
1016 curBuff = get_uint16(ramBase + curBuff);
1019 /* Now issue transmit list */
1021 writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1022 writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1023 writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1024 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1026 spin_unlock_irqrestore(&priv->spinlock, flags);
1030 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1031 /* This flag indicate that the hardware can't perform a transmission.
1032 * Theoritically, NET3 check it before sending a packet to the driver,
1033 * but in fact it never do that and pool continuously.
1034 * As the watchdog will abort too long transmissions, we are quite safe...
1037 netif_stop_queue(dev);
1040 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1041 unsigned char* buf = skb->data;
1043 if (netwave_hw_xmit( buf, length, dev) == 1) {
1044 /* Some error, let's make them call us another time? */
1045 netif_start_queue(dev);
1047 dev->trans_start = jiffies;
1052 } /* netwave_start_xmit */
1055 * Function netwave_interrupt (irq, dev_id)
1057 * This function is the interrupt handler for the Netwave card. This
1058 * routine will be called whenever:
1059 * 1. A packet is received.
1060 * 2. A packet has successfully been transferred and the unit is
1061 * ready to transmit another packet.
1062 * 3. A command has completed execution.
1064 static irqreturn_t netwave_interrupt(int irq, void* dev_id)
1067 u_char __iomem *ramBase;
1068 struct net_device *dev = (struct net_device *)dev_id;
1069 struct netwave_private *priv = netdev_priv(dev);
1070 struct pcmcia_device *link = priv->p_dev;
1073 if (!netif_device_present(dev))
1076 iobase = dev->base_addr;
1077 ramBase = priv->ramBase;
1079 /* Now find what caused the interrupt, check while interrupts ready */
1080 for (i = 0; i < 10; i++) {
1084 if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1085 break; /* None of the interrupt sources asserted (normal exit) */
1087 status = inb(iobase + NETWAVE_REG_ASR);
1089 if (!pcmcia_dev_present(link)) {
1090 DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1091 "from removed or suspended card!\n", status);
1096 if (status & 0x80) {
1098 /* wait_WOC(iobase); */
1099 /* RxRdy cannot be reset directly by the host */
1102 if (status & 0x40) {
1105 rser = readb(ramBase + NETWAVE_EREG_RSER);
1108 ++priv->stats.rx_dropped;
1109 ++priv->stats.rx_crc_errors;
1112 ++priv->stats.rx_frame_errors;
1114 /* Clear the RxErr bit in RSER. RSER+4 is the
1115 * write part. Also clear the RxCRC (0x04) and
1116 * RxBig (0x02) bits if present */
1118 writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1120 /* Write bit 6 high to ASCC to clear RxErr in ASR,
1121 * WOC must be set first!
1124 writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1126 /* Remember to count up priv->stats on error packets */
1127 ++priv->stats.rx_errors;
1130 if (status & 0x20) {
1133 txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1134 DEBUG(3, "Transmit done. TSER = %x id %x\n",
1135 txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1137 if (txStatus & 0x20) {
1138 /* Transmitting was okay, clear bits */
1140 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1141 ++priv->stats.tx_packets;
1144 if (txStatus & 0xd0) {
1145 if (txStatus & 0x80) {
1146 ++priv->stats.collisions; /* Because of /proc/net/dev*/
1147 /* ++priv->stats.tx_aborted_errors; */
1148 /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1150 if (txStatus & 0x40)
1151 ++priv->stats.tx_carrier_errors;
1152 /* 0x80 TxGU Transmit giveup - nine times and no luck
1153 * 0x40 TxNOAP No access point. Discarded packet.
1154 * 0x10 TxErr Transmit error. Always set when
1155 * TxGU and TxNOAP is set. (Those are the only ones
1158 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n",
1161 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1163 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1164 ++priv->stats.tx_errors;
1166 DEBUG(3, "New status is TSER %x ASR %x\n",
1167 readb(ramBase + NETWAVE_EREG_TSER),
1168 inb(iobase + NETWAVE_REG_ASR));
1170 netif_wake_queue(dev);
1172 /* TxBA, this would trigger on all error packets received */
1173 /* if (status & 0x01) {
1174 DEBUG(4, "Transmit buffers available, %x\n", status);
1178 /* Handled if we looped at least one time - Jean II */
1179 return IRQ_RETVAL(i);
1180 } /* netwave_interrupt */
1183 * Function netwave_watchdog (a)
1185 * Watchdog : when we start a transmission, we set a timer in the
1186 * kernel. If the transmission complete, this timer is disabled. If
1187 * it expire, we reset the card.
1190 static void netwave_watchdog(struct net_device *dev) {
1192 DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1194 dev->trans_start = jiffies;
1195 netif_wake_queue(dev);
1196 } /* netwave_watchdog */
1198 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1199 netwave_private *priv = netdev_priv(dev);
1203 DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1204 " %x tx %x %x %x %x\n",
1205 readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1206 readb(priv->ramBase + NETWAVE_EREG_SPU),
1207 readb(priv->ramBase + NETWAVE_EREG_LIF),
1208 readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1209 readb(priv->ramBase + NETWAVE_EREG_MHS),
1210 readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1211 readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1212 readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1213 readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1214 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1215 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1217 return &priv->stats;
1220 static void update_stats(struct net_device *dev) {
1221 //unsigned long flags;
1222 /* netwave_private *priv = netdev_priv(dev); */
1224 //spin_lock_irqsave(&priv->spinlock, flags);
1226 /* priv->stats.rx_packets = readb(priv->ramBase + 0x18e);
1227 priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1229 //spin_unlock_irqrestore(&priv->spinlock, flags);
1232 static int netwave_rx(struct net_device *dev)
1234 netwave_private *priv = netdev_priv(dev);
1235 u_char __iomem *ramBase = priv->ramBase;
1236 kio_addr_t iobase = dev->base_addr;
1238 struct sk_buff *skb = NULL;
1239 unsigned int curBuffer,
1243 int dataCount, dataOffset;
1247 DEBUG(3, "xinw_rx: Receiving ... \n");
1249 /* Receive max 10 packets for now. */
1250 for (i = 0; i < 10; i++) {
1253 rxStatus = readb(ramBase + NETWAVE_EREG_RSER);
1254 if ( !( rxStatus & 0x80)) /* No more packets */
1257 /* Check if multicast/broadcast or other */
1258 /* multicast = (rxStatus & 0x20); */
1260 /* The receive list pointer and length of the packet */
1262 rcvLen = get_int16( ramBase + NETWAVE_EREG_RDP);
1263 rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1266 printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n",
1271 skb = dev_alloc_skb(rcvLen+5);
1273 DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1274 "length %d\n", rcvLen);
1275 ++priv->stats.rx_dropped;
1276 /* Tell the adapter to skip the packet */
1278 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1279 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1283 skb_reserve( skb, 2); /* Align IP on 16 byte */
1284 skb_put( skb, rcvLen);
1286 /* Copy packet fragments to the skb data area */
1287 ptr = (u_char*) skb->data;
1288 curBuffer = rcvList;
1290 while ( tmpcount < rcvLen) {
1291 /* Get length and offset of current buffer */
1292 dataCount = get_uint16( ramBase+curBuffer+2);
1293 dataOffset = get_uint16( ramBase+curBuffer+4);
1295 copy_from_pc( ptr + tmpcount,
1296 ramBase+curBuffer+dataOffset, dataCount);
1298 tmpcount += dataCount;
1300 /* Point to next buffer */
1301 curBuffer = get_uint16(ramBase + curBuffer);
1304 skb->protocol = eth_type_trans(skb,dev);
1305 /* Queue packet for network layer */
1308 dev->last_rx = jiffies;
1309 priv->stats.rx_packets++;
1310 priv->stats.rx_bytes += rcvLen;
1312 /* Got the packet, tell the adapter to skip it */
1314 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1315 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1316 DEBUG(3, "Packet reception ok\n");
1321 static int netwave_open(struct net_device *dev) {
1322 netwave_private *priv = netdev_priv(dev);
1323 struct pcmcia_device *link = priv->p_dev;
1325 DEBUG(1, "netwave_open: starting.\n");
1327 if (!pcmcia_dev_present(link))
1332 netif_start_queue(dev);
1338 static int netwave_close(struct net_device *dev) {
1339 netwave_private *priv = netdev_priv(dev);
1340 struct pcmcia_device *link = priv->p_dev;
1342 DEBUG(1, "netwave_close: finishing.\n");
1345 netif_stop_queue(dev);
1350 static struct pcmcia_device_id netwave_ids[] = {
1351 PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1354 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1356 static struct pcmcia_driver netwave_driver = {
1357 .owner = THIS_MODULE,
1359 .name = "netwave_cs",
1361 .probe = netwave_probe,
1362 .remove = netwave_detach,
1363 .id_table = netwave_ids,
1364 .suspend = netwave_suspend,
1365 .resume = netwave_resume,
1368 static int __init init_netwave_cs(void)
1370 return pcmcia_register_driver(&netwave_driver);
1373 static void __exit exit_netwave_cs(void)
1375 pcmcia_unregister_driver(&netwave_driver);
1378 module_init(init_netwave_cs);
1379 module_exit(exit_netwave_cs);
1381 /* Set or clear the multicast filter for this adaptor.
1382 num_addrs == -1 Promiscuous mode, receive all packets
1383 num_addrs == 0 Normal mode, clear multicast list
1384 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
1385 best-effort filtering.
1387 static void set_multicast_list(struct net_device *dev)
1389 kio_addr_t iobase = dev->base_addr;
1390 netwave_private *priv = netdev_priv(dev);
1391 u_char __iomem * ramBase = priv->ramBase;
1397 if (old != dev->mc_count) {
1398 old = dev->mc_count;
1399 DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1400 dev->name, dev->mc_count);
1405 if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1406 /* Multicast Mode */
1407 rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1408 } else if (dev->flags & IFF_PROMISC) {
1409 /* Promiscous mode */
1410 rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1413 rcvMode = rxConfRxEna + rxConfBcast;
1416 /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1417 /* Now set receive mode */
1419 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1420 writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1421 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1423 MODULE_LICENSE("GPL");