[PATCH] libertas: keep mesh autostart enabled while asleep
[linux-2.6] / drivers / net / wireless / netwave_cs.c
1 /*********************************************************************
2  *                
3  * Filename:      netwave_cs.c
4  * Version:       0.4.1
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>
13  * 
14  *     Copyright (c) 1997 University of Tromsø, Norway
15  *
16  * Revision History:
17  *
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)
26  *   Others:
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
31  *      function
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  ********************************************************************/
36
37 /* To have statistics (just packets sent) define this */
38 #undef NETWAVE_STATS
39
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>
48 #include <linux/in.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>
59
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>
66
67 #include <asm/system.h>
68 #include <asm/io.h>
69 #include <asm/dma.h>
70
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
102
103 /*
104  * Commands used in the extended command buffer
105  * NETWAVE_EREG_CB (0x100-0x10F) 
106  */
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
123
124 /* ASR register bits */
125 #define NETWAVE_ASR_RXRDY   0x80
126 #define NETWAVE_ASR_TXBA    0x01
127
128 #define TX_TIMEOUT              ((32*HZ)/100)
129
130 static const unsigned int imrConfRFU1 = 0x10; /* RFU interrupt mask, keep high */
131 static const unsigned int imrConfIENA = 0x02; /* Interrupt enable */
132
133 static const unsigned int corConfIENA   = 0x01; /* Interrupt enable */
134 static const unsigned int corConfLVLREQ = 0x40; /* Keep high */
135
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 */
141
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 */
147
148 /*
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.
154 */
155
156 #ifdef PCMCIA_DEBUG
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";
162 #else
163 #define DEBUG(n, args...)
164 #endif
165
166 /*====================================================================*/
167
168 /* Parameters that can be set with 'insmod' */
169
170 /* Choose the domain, default is 0x100 */
171 static u_int  domain = 0x100;
172
173 /* Scramble key, range from 0x0 to 0xffff.  
174  * 0x0 is no scrambling. 
175  */
176 static u_int  scramble_key = 0x0;
177
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. 
182  */
183 static int mem_speed;
184
185 module_param(domain, int, 0);
186 module_param(scramble_key, int, 0);
187 module_param(mem_speed, int, 0);
188
189 /*====================================================================*/
190
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
194                                                                                                            insertion */
195 static void netwave_detach(struct pcmcia_device *p_dev);    /* Destroy instance */
196
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);
200
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 */
204
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);
208
209 /* Interrupt routines */
210 static irqreturn_t netwave_interrupt(int irq, void *dev_id);
211 static void netwave_watchdog(struct net_device *);
212
213 /* Statistics */
214 static void update_stats(struct net_device *dev);
215 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
216
217 /* Wireless extensions */
218 static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev);
219
220 static void set_multicast_list(struct net_device *dev);
221
222 /*
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.
228
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.
237 */
238
239 static const struct iw_handler_def      netwave_handler_def;
240
241 #define SIOCGIPSNAP     SIOCIWFIRSTPRIV + 1     /* Site Survey Snapshot */
242
243 #define MAX_ESA 10
244
245 typedef struct net_addr {
246     u_char addr48[6];
247 } net_addr;
248
249 struct site_survey {
250     u_short length;
251     u_char  struct_revision;
252     u_char  roaming_state;
253         
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;
260     u_char  sp_goodness;
261     u_char  sp_hotheadcount;
262     u_char  roaming_condition;
263         
264     net_addr sp;
265     u_char   numAPs;
266     net_addr nearByAccessPoints[MAX_ESA];
267 };      
268    
269 typedef struct netwave_private {
270         struct pcmcia_device    *p_dev;
271     spinlock_t  spinlock;       /* Serialize access to the hardware (SMP) */
272     dev_node_t node;
273     u_char     __iomem *ramBase;
274     int        timeoutCounter;
275     int        lastExec;
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 */
280 } netwave_private;
281
282 #ifdef NETWAVE_STATS
283 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
284 #endif
285
286 /*
287  * The Netwave card is little-endian, so won't work for big endian
288  * systems.
289  */
290 static inline unsigned short get_uint16(u_char __iomem *staddr) 
291 {
292     return readw(staddr); /* Return only 16 bits */
293 }
294
295 static inline short get_int16(u_char __iomem * staddr)
296 {
297     return readw(staddr);
298 }
299
300 /* 
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. 
304  */
305 static inline void wait_WOC(unsigned int iobase)
306 {
307     /* Spin lock */
308     while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ; 
309 }
310
311 static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase, 
312                              kio_addr_t iobase) {
313     u_short resultBuffer;
314
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.  
317      */
318     if ( jiffies - priv->lastExec > 100) { 
319         /* Take site survey  snapshot */ 
320         /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies -
321           priv->lastExec); */
322         wait_WOC(iobase); 
323         writeb(NETWAVE_CMD_SSS, ramBase + NETWAVE_EREG_CB + 0); 
324         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); 
325         wait_WOC(iobase); 
326
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)); 
331     } 
332 }
333
334 /*
335  * Function netwave_get_wireless_stats (dev)
336  *
337  *    Wireless extensions statistics
338  *
339  */
340 static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev)
341 {       
342     unsigned long flags;
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;
347         
348     wstats = &priv->iw_stats;
349
350     spin_lock_irqsave(&priv->spinlock, flags);
351         
352     netwave_snapshot( priv, ramBase, iobase);
353
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;
361
362     spin_unlock_irqrestore(&priv->spinlock, flags);
363     
364     return &priv->iw_stats;
365 }
366
367 /*
368  * Function netwave_attach (void)
369  *
370  *     Creates an "instance" of the driver, allocating local data 
371  *     structures for one device.  The device is registered with Card 
372  *     Services.
373  *
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.
377  */
378 static int netwave_probe(struct pcmcia_device *link)
379 {
380     struct net_device *dev;
381     netwave_private *priv;
382
383     DEBUG(0, "netwave_attach()\n");
384
385     /* Initialize the struct pcmcia_device structure */
386     dev = alloc_etherdev(sizeof(netwave_private));
387     if (!dev)
388         return -ENOMEM;
389     priv = netdev_priv(dev);
390     priv->p_dev = link;
391     link->priv = dev;
392
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;
399     
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;
404     
405     /* General socket configuration */
406     link->conf.Attributes = CONF_ENABLE_IRQ;
407     link->conf.IntType = INT_MEMORY_AND_IO;
408     link->conf.ConfigIndex = 1;
409
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);
413
414     /* Netwave specific entries in the device structure */
415     SET_MODULE_OWNER(dev);
416     dev->hard_start_xmit = &netwave_start_xmit;
417     dev->get_stats  = &netwave_get_stats;
418     dev->set_multicast_list = &set_multicast_list;
419     /* wireless extensions */
420     dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
421
422     dev->tx_timeout = &netwave_watchdog;
423     dev->watchdog_timeo = TX_TIMEOUT;
424
425     dev->open = &netwave_open;
426     dev->stop = &netwave_close;
427     link->irq.Instance = dev;
428
429     return netwave_pcmcia_config( link);
430 } /* netwave_attach */
431
432 /*
433  * Function netwave_detach (link)
434  *
435  *    This deletes a driver "instance".  The device is de-registered
436  *    with Card Services.  If it has been released, all local data
437  *    structures are freed.  Otherwise, the structures will be freed
438  *    when the device is released.
439  */
440 static void netwave_detach(struct pcmcia_device *link)
441 {
442         struct net_device *dev = link->priv;
443
444         DEBUG(0, "netwave_detach(0x%p)\n", link);
445
446         netwave_release(link);
447
448         if (link->dev_node)
449                 unregister_netdev(dev);
450
451         free_netdev(dev);
452 } /* netwave_detach */
453
454 /*
455  * Wireless Handler : get protocol name
456  */
457 static int netwave_get_name(struct net_device *dev,
458                             struct iw_request_info *info,
459                             union iwreq_data *wrqu,
460                             char *extra)
461 {
462         strcpy(wrqu->name, "Netwave");
463         return 0;
464 }
465
466 /*
467  * Wireless Handler : set Network ID
468  */
469 static int netwave_set_nwid(struct net_device *dev,
470                             struct iw_request_info *info,
471                             union iwreq_data *wrqu,
472                             char *extra)
473 {
474         unsigned long flags;
475         kio_addr_t iobase = dev->base_addr;
476         netwave_private *priv = netdev_priv(dev);
477         u_char __iomem *ramBase = priv->ramBase;
478
479         /* Disable interrupts & save flags */
480         spin_lock_irqsave(&priv->spinlock, flags);
481
482         if(!wrqu->nwid.disabled) {
483             domain = wrqu->nwid.value;
484             printk( KERN_DEBUG "Setting domain to 0x%x%02x\n", 
485                     (domain >> 8) & 0x01, domain & 0xff);
486             wait_WOC(iobase);
487             writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
488             writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
489             writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
490             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
491         }
492
493         /* ReEnable interrupts & restore flags */
494         spin_unlock_irqrestore(&priv->spinlock, flags);
495     
496         return 0;
497 }
498
499 /*
500  * Wireless Handler : get Network ID
501  */
502 static int netwave_get_nwid(struct net_device *dev,
503                             struct iw_request_info *info,
504                             union iwreq_data *wrqu,
505                             char *extra)
506 {
507         wrqu->nwid.value = domain;
508         wrqu->nwid.disabled = 0;
509         wrqu->nwid.fixed = 1;
510         return 0;
511 }
512
513 /*
514  * Wireless Handler : set scramble key
515  */
516 static int netwave_set_scramble(struct net_device *dev,
517                                 struct iw_request_info *info,
518                                 union iwreq_data *wrqu,
519                                 char *key)
520 {
521         unsigned long flags;
522         kio_addr_t iobase = dev->base_addr;
523         netwave_private *priv = netdev_priv(dev);
524         u_char __iomem *ramBase = priv->ramBase;
525
526         /* Disable interrupts & save flags */
527         spin_lock_irqsave(&priv->spinlock, flags);
528
529         scramble_key = (key[0] << 8) | key[1];
530         wait_WOC(iobase);
531         writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
532         writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
533         writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
534         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
535
536         /* ReEnable interrupts & restore flags */
537         spin_unlock_irqrestore(&priv->spinlock, flags);
538     
539         return 0;
540 }
541
542 /*
543  * Wireless Handler : get scramble key
544  */
545 static int netwave_get_scramble(struct net_device *dev,
546                                 struct iw_request_info *info,
547                                 union iwreq_data *wrqu,
548                                 char *key)
549 {
550         key[1] = scramble_key & 0xff;
551         key[0] = (scramble_key>>8) & 0xff;
552         wrqu->encoding.flags = IW_ENCODE_ENABLED;
553         wrqu->encoding.length = 2;
554         return 0;
555 }
556
557 /*
558  * Wireless Handler : get mode
559  */
560 static int netwave_get_mode(struct net_device *dev,
561                             struct iw_request_info *info,
562                             union iwreq_data *wrqu,
563                             char *extra)
564 {
565         if(domain & 0x100)
566                 wrqu->mode = IW_MODE_INFRA;
567         else
568                 wrqu->mode = IW_MODE_ADHOC;
569
570         return 0;
571 }
572
573 /*
574  * Wireless Handler : get range info
575  */
576 static int netwave_get_range(struct net_device *dev,
577                              struct iw_request_info *info,
578                              union iwreq_data *wrqu,
579                              char *extra)
580 {
581         struct iw_range *range = (struct iw_range *) extra;
582         int ret = 0;
583
584         /* Set the length (very important for backward compatibility) */
585         wrqu->data.length = sizeof(struct iw_range);
586
587         /* Set all the info we don't care or don't know about to zero */
588         memset(range, 0, sizeof(struct iw_range));
589
590         /* Set the Wireless Extension versions */
591         range->we_version_compiled = WIRELESS_EXT;
592         range->we_version_source = 9;   /* Nothing for us in v10 and v11 */
593                    
594         /* Set information in the range struct */
595         range->throughput = 450 * 1000; /* don't argue on this ! */
596         range->min_nwid = 0x0000;
597         range->max_nwid = 0x01FF;
598
599         range->num_channels = range->num_frequency = 0;
600                    
601         range->sensitivity = 0x3F;
602         range->max_qual.qual = 255;
603         range->max_qual.level = 255;
604         range->max_qual.noise = 0;
605                    
606         range->num_bitrates = 1;
607         range->bitrate[0] = 1000000;    /* 1 Mb/s */
608
609         range->encoding_size[0] = 2;            /* 16 bits scrambling */
610         range->num_encoding_sizes = 1;
611         range->max_encoding_tokens = 1; /* Only one key possible */
612
613         return ret;
614 }
615
616 /*
617  * Wireless Private Handler : get snapshot
618  */
619 static int netwave_get_snap(struct net_device *dev,
620                             struct iw_request_info *info,
621                             union iwreq_data *wrqu,
622                             char *extra)
623 {
624         unsigned long flags;
625         kio_addr_t iobase = dev->base_addr;
626         netwave_private *priv = netdev_priv(dev);
627         u_char __iomem *ramBase = priv->ramBase;
628
629         /* Disable interrupts & save flags */
630         spin_lock_irqsave(&priv->spinlock, flags);
631
632         /* Take snapshot of environment */
633         netwave_snapshot( priv, ramBase, iobase);
634         wrqu->data.length = priv->nss.length;
635         memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
636
637         priv->lastExec = jiffies;
638
639         /* ReEnable interrupts & restore flags */
640         spin_unlock_irqrestore(&priv->spinlock, flags);
641     
642         return(0);
643 }
644
645 /*
646  * Structures to export the Wireless Handlers
647  *     This is the stuff that are treated the wireless extensions (iwconfig)
648  */
649
650 static const struct iw_priv_args netwave_private_args[] = {
651 /*{ cmd,         set_args,                            get_args, name } */
652   { SIOCGIPSNAP, 0, 
653     IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey), 
654     "getsitesurvey" },
655 };
656
657 static const iw_handler         netwave_handler[] =
658 {
659         NULL,                           /* SIOCSIWNAME */
660         netwave_get_name,               /* SIOCGIWNAME */
661         netwave_set_nwid,               /* SIOCSIWNWID */
662         netwave_get_nwid,               /* SIOCGIWNWID */
663         NULL,                           /* SIOCSIWFREQ */
664         NULL,                           /* SIOCGIWFREQ */
665         NULL,                           /* SIOCSIWMODE */
666         netwave_get_mode,               /* SIOCGIWMODE */
667         NULL,                           /* SIOCSIWSENS */
668         NULL,                           /* SIOCGIWSENS */
669         NULL,                           /* SIOCSIWRANGE */
670         netwave_get_range,              /* SIOCGIWRANGE */
671         NULL,                           /* SIOCSIWPRIV */
672         NULL,                           /* SIOCGIWPRIV */
673         NULL,                           /* SIOCSIWSTATS */
674         NULL,                           /* SIOCGIWSTATS */
675         NULL,                           /* SIOCSIWSPY */
676         NULL,                           /* SIOCGIWSPY */
677         NULL,                           /* -- hole -- */
678         NULL,                           /* -- hole -- */
679         NULL,                           /* SIOCSIWAP */
680         NULL,                           /* SIOCGIWAP */
681         NULL,                           /* -- hole -- */
682         NULL,                           /* SIOCGIWAPLIST */
683         NULL,                           /* -- hole -- */
684         NULL,                           /* -- hole -- */
685         NULL,                           /* SIOCSIWESSID */
686         NULL,                           /* SIOCGIWESSID */
687         NULL,                           /* SIOCSIWNICKN */
688         NULL,                           /* SIOCGIWNICKN */
689         NULL,                           /* -- hole -- */
690         NULL,                           /* -- hole -- */
691         NULL,                           /* SIOCSIWRATE */
692         NULL,                           /* SIOCGIWRATE */
693         NULL,                           /* SIOCSIWRTS */
694         NULL,                           /* SIOCGIWRTS */
695         NULL,                           /* SIOCSIWFRAG */
696         NULL,                           /* SIOCGIWFRAG */
697         NULL,                           /* SIOCSIWTXPOW */
698         NULL,                           /* SIOCGIWTXPOW */
699         NULL,                           /* SIOCSIWRETRY */
700         NULL,                           /* SIOCGIWRETRY */
701         netwave_set_scramble,           /* SIOCSIWENCODE */
702         netwave_get_scramble,           /* SIOCGIWENCODE */
703 };
704
705 static const iw_handler         netwave_private_handler[] =
706 {
707         NULL,                           /* SIOCIWFIRSTPRIV */
708         netwave_get_snap,               /* SIOCIWFIRSTPRIV + 1 */
709 };
710
711 static const struct iw_handler_def      netwave_handler_def =
712 {
713         .num_standard   = sizeof(netwave_handler)/sizeof(iw_handler),
714         .num_private    = sizeof(netwave_private_handler)/sizeof(iw_handler),
715         .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
716         .standard       = (iw_handler *) netwave_handler,
717         .private        = (iw_handler *) netwave_private_handler,
718         .private_args   = (struct iw_priv_args *) netwave_private_args,
719         .get_wireless_stats = netwave_get_wireless_stats,
720 };
721
722 /*
723  * Function netwave_pcmcia_config (link)
724  *
725  *     netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION 
726  *     event is received, to configure the PCMCIA socket, and to make the
727  *     device available to the system. 
728  *
729  */
730
731 #define CS_CHECK(fn, ret) \
732 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
733
734 static int netwave_pcmcia_config(struct pcmcia_device *link) {
735     struct net_device *dev = link->priv;
736     netwave_private *priv = netdev_priv(dev);
737     int i, j, last_ret, last_fn;
738     win_req_t req;
739     memreq_t mem;
740     u_char __iomem *ramBase = NULL;
741
742     DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
743
744     /*
745      *  Try allocating IO ports.  This tries a few fixed addresses.
746      *  If you want, you can also read the card's config table to
747      *  pick addresses -- see the serial driver for an example.
748      */
749     for (i = j = 0x0; j < 0x400; j += 0x20) {
750         link->io.BasePort1 = j ^ 0x300;
751         i = pcmcia_request_io(link, &link->io);
752         if (i == CS_SUCCESS) break;
753     }
754     if (i != CS_SUCCESS) {
755         cs_error(link, RequestIO, i);
756         goto failed;
757     }
758
759     /*
760      *  Now allocate an interrupt line.  Note that this does not
761      *  actually assign a handler to the interrupt.
762      */
763     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
764
765     /*
766      *  This actually configures the PCMCIA socket -- setting up
767      *  the I/O windows and the interrupt mapping.
768      */
769     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
770
771     /*
772      *  Allocate a 32K memory window.  Note that the struct pcmcia_device
773      *  structure provides space for one window handle -- if your
774      *  device needs several windows, you'll need to keep track of
775      *  the handles in your private data structure, dev->priv.
776      */
777     DEBUG(1, "Setting mem speed of %d\n", mem_speed);
778
779     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
780     req.Base = 0; req.Size = 0x8000;
781     req.AccessSpeed = mem_speed;
782     CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
783     mem.CardOffset = 0x20000; mem.Page = 0; 
784     CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
785
786     /* Store base address of the common window frame */
787     ramBase = ioremap(req.Base, 0x8000);
788     priv->ramBase = ramBase;
789
790     dev->irq = link->irq.AssignedIRQ;
791     dev->base_addr = link->io.BasePort1;
792     SET_NETDEV_DEV(dev, &handle_to_dev(link));
793
794     if (register_netdev(dev) != 0) {
795         printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
796         goto failed;
797     }
798
799     strcpy(priv->node.dev_name, dev->name);
800     link->dev_node = &priv->node;
801
802     /* Reset card before reading physical address */
803     netwave_doreset(dev->base_addr, ramBase);
804
805     /* Read the ethernet address and fill in the Netwave registers. */
806     for (i = 0; i < 6; i++) 
807         dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
808
809     printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
810            "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
811            (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
812            (int) readb(ramBase+NETWAVE_EREG_NI+1));
813     for (i = 0; i < 6; i++)
814         printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
815
816     /* get revision words */
817     printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n", 
818            get_uint16(ramBase + NETWAVE_EREG_ARW),
819            get_uint16(ramBase + NETWAVE_EREG_ARW+2));
820     return 0;
821
822 cs_failed:
823     cs_error(link, last_fn, last_ret);
824 failed:
825     netwave_release(link);
826     return -ENODEV;
827 } /* netwave_pcmcia_config */
828
829 /*
830  * Function netwave_release (arg)
831  *
832  *    After a card is removed, netwave_release() will unregister the net
833  *    device, and release the PCMCIA configuration.  If the device is
834  *    still open, this will be postponed until it is closed.
835  */
836 static void netwave_release(struct pcmcia_device *link)
837 {
838         struct net_device *dev = link->priv;
839         netwave_private *priv = netdev_priv(dev);
840
841         DEBUG(0, "netwave_release(0x%p)\n", link);
842
843         pcmcia_disable_device(link);
844         if (link->win)
845                 iounmap(priv->ramBase);
846 }
847
848 static int netwave_suspend(struct pcmcia_device *link)
849 {
850         struct net_device *dev = link->priv;
851
852         if (link->open)
853                 netif_device_detach(dev);
854
855         return 0;
856 }
857
858 static int netwave_resume(struct pcmcia_device *link)
859 {
860         struct net_device *dev = link->priv;
861
862         if (link->open) {
863                 netwave_reset(dev);
864                 netif_device_attach(dev);
865         }
866
867         return 0;
868 }
869
870
871 /*
872  * Function netwave_doreset (ioBase, ramBase)
873  *
874  *    Proper hardware reset of the card.
875  */
876 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
877 {
878     /* Reset card */
879     wait_WOC(ioBase);
880     outb(0x80, ioBase + NETWAVE_REG_PMR);
881     writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
882     outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
883 }
884
885 /*
886  * Function netwave_reset (dev)
887  *
888  *    Reset and restore all of the netwave registers 
889  */
890 static void netwave_reset(struct net_device *dev) {
891     /* u_char state; */
892     netwave_private *priv = netdev_priv(dev);
893     u_char __iomem *ramBase = priv->ramBase;
894     kio_addr_t iobase = dev->base_addr;
895
896     DEBUG(0, "netwave_reset: Done with hardware reset\n");
897
898     priv->timeoutCounter = 0;
899
900     /* Reset card */
901     netwave_doreset(iobase, ramBase);
902     printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
903         
904     /* Write a NOP to check the card */
905     wait_WOC(iobase);
906     writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
907     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
908         
909     /* Set receive conf */
910     wait_WOC(iobase);
911     writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
912     writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
913     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
914     
915     /* Set transmit conf */
916     wait_WOC(iobase);
917     writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
918     writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
919     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
920     
921     /* Now set the MU Domain */
922     printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
923     wait_WOC(iobase);
924     writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
925     writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
926     writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
927     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
928         
929     /* Set scramble key */
930     printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
931     wait_WOC(iobase);
932     writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
933     writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
934     writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
935     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
936
937     /* Enable interrupts, bit 4 high to keep unused
938      * source from interrupting us, bit 2 high to 
939      * set interrupt enable, 567 to enable TxDN, 
940      * RxErr and RxRdy
941      */
942     wait_WOC(iobase);
943     outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
944
945     /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
946      * waitWOC
947      * skriv 80 til d000:3688
948      * sjekk om det ble 80
949      */
950     
951     /* Enable Receiver */
952     wait_WOC(iobase);
953     writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
954     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
955         
956     /* Set the IENA bit in COR */
957     wait_WOC(iobase);
958     outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
959 }
960
961 /*
962  * Function netwave_hw_xmit (data, len, dev)    
963  */
964 static int netwave_hw_xmit(unsigned char* data, int len,
965                            struct net_device* dev) {
966     unsigned long flags;
967     unsigned int TxFreeList,
968                  curBuff,
969                  MaxData, 
970                  DataOffset;
971     int tmpcount; 
972         
973     netwave_private *priv = netdev_priv(dev);
974     u_char __iomem * ramBase = priv->ramBase;
975     kio_addr_t iobase = dev->base_addr;
976
977     /* Disable interrupts & save flags */
978     spin_lock_irqsave(&priv->spinlock, flags);
979
980     /* Check if there are transmit buffers available */
981     wait_WOC(iobase);
982     if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
983         /* No buffers available */
984         printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
985                dev->name);
986         spin_unlock_irqrestore(&priv->spinlock, flags);
987         return 1;
988     }
989
990     priv->stats.tx_bytes += len;
991
992     DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
993           readb(ramBase + NETWAVE_EREG_SPCQ),
994           readb(ramBase + NETWAVE_EREG_SPU),
995           readb(ramBase + NETWAVE_EREG_LIF),
996           readb(ramBase + NETWAVE_EREG_ISPLQ));
997
998     /* Now try to insert it into the adapters free memory */
999     wait_WOC(iobase);
1000     TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1001     MaxData    = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1002     DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1003         
1004     DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1005           TxFreeList, MaxData, DataOffset);
1006
1007     /* Copy packet to the adapter fragment buffers */
1008     curBuff = TxFreeList; 
1009     tmpcount = 0; 
1010     while (tmpcount < len) {
1011         int tmplen = len - tmpcount; 
1012         copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount, 
1013                    (tmplen < MaxData) ? tmplen : MaxData);
1014         tmpcount += MaxData;
1015                         
1016         /* Advance to next buffer */
1017         curBuff = get_uint16(ramBase + curBuff);
1018     }
1019     
1020     /* Now issue transmit list */
1021     wait_WOC(iobase);
1022     writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1023     writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1024     writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1025     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1026
1027     spin_unlock_irqrestore(&priv->spinlock, flags);
1028     return 0;
1029 }
1030
1031 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1032         /* This flag indicate that the hardware can't perform a transmission.
1033          * Theoritically, NET3 check it before sending a packet to the driver,
1034          * but in fact it never do that and pool continuously.
1035          * As the watchdog will abort too long transmissions, we are quite safe...
1036          */
1037
1038     netif_stop_queue(dev);
1039
1040     {
1041         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1042         unsigned char* buf = skb->data;
1043         
1044         if (netwave_hw_xmit( buf, length, dev) == 1) {
1045             /* Some error, let's make them call us another time? */
1046             netif_start_queue(dev);
1047         }
1048         dev->trans_start = jiffies;
1049     }
1050     dev_kfree_skb(skb);
1051     
1052     return 0;
1053 } /* netwave_start_xmit */
1054
1055 /*
1056  * Function netwave_interrupt (irq, dev_id)
1057  *
1058  *    This function is the interrupt handler for the Netwave card. This
1059  *    routine will be called whenever: 
1060  *        1. A packet is received.
1061  *        2. A packet has successfully been transferred and the unit is
1062  *           ready to transmit another packet.
1063  *        3. A command has completed execution.
1064  */
1065 static irqreturn_t netwave_interrupt(int irq, void* dev_id)
1066 {
1067     kio_addr_t iobase;
1068     u_char __iomem *ramBase;
1069     struct net_device *dev = (struct net_device *)dev_id;
1070     struct netwave_private *priv = netdev_priv(dev);
1071     struct pcmcia_device *link = priv->p_dev;
1072     int i;
1073     
1074     if (!netif_device_present(dev))
1075         return IRQ_NONE;
1076     
1077     iobase = dev->base_addr;
1078     ramBase = priv->ramBase;
1079         
1080     /* Now find what caused the interrupt, check while interrupts ready */
1081     for (i = 0; i < 10; i++) {
1082         u_char status;
1083                 
1084         wait_WOC(iobase);       
1085         if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1086             break; /* None of the interrupt sources asserted (normal exit) */
1087         
1088         status = inb(iobase + NETWAVE_REG_ASR);
1089                 
1090         if (!pcmcia_dev_present(link)) {
1091             DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1092                   "from removed or suspended card!\n", status);
1093             break;
1094         }
1095                 
1096         /* RxRdy */
1097         if (status & 0x80) {
1098             netwave_rx(dev);
1099             /* wait_WOC(iobase); */
1100             /* RxRdy cannot be reset directly by the host */
1101         }
1102         /* RxErr */
1103         if (status & 0x40) {
1104             u_char rser;
1105                         
1106             rser = readb(ramBase + NETWAVE_EREG_RSER);                  
1107             
1108             if (rser & 0x04) {
1109                 ++priv->stats.rx_dropped; 
1110                 ++priv->stats.rx_crc_errors;
1111             }
1112             if (rser & 0x02)
1113                 ++priv->stats.rx_frame_errors;
1114                         
1115             /* Clear the RxErr bit in RSER. RSER+4 is the
1116              * write part. Also clear the RxCRC (0x04) and 
1117              * RxBig (0x02) bits if present */
1118             wait_WOC(iobase);
1119             writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1120
1121             /* Write bit 6 high to ASCC to clear RxErr in ASR,
1122              * WOC must be set first! 
1123              */
1124             wait_WOC(iobase);
1125             writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1126
1127             /* Remember to count up priv->stats on error packets */
1128             ++priv->stats.rx_errors;
1129         }
1130         /* TxDN */
1131         if (status & 0x20) {
1132             int txStatus;
1133
1134             txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1135             DEBUG(3, "Transmit done. TSER = %x id %x\n", 
1136                   txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1137             
1138             if (txStatus & 0x20) {
1139                 /* Transmitting was okay, clear bits */
1140                 wait_WOC(iobase);
1141                 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1142                 ++priv->stats.tx_packets;
1143             }
1144                         
1145             if (txStatus & 0xd0) {
1146                 if (txStatus & 0x80) {
1147                     ++priv->stats.collisions; /* Because of /proc/net/dev*/
1148                     /* ++priv->stats.tx_aborted_errors; */
1149                     /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1150                 }
1151                 if (txStatus & 0x40) 
1152                     ++priv->stats.tx_carrier_errors;
1153                 /* 0x80 TxGU Transmit giveup - nine times and no luck
1154                  * 0x40 TxNOAP No access point. Discarded packet.
1155                  * 0x10 TxErr Transmit error. Always set when 
1156                  *      TxGU and TxNOAP is set. (Those are the only ones
1157                  *      to set TxErr).
1158                  */
1159                 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n", 
1160                       txStatus);
1161                 
1162                 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1163                 wait_WOC(iobase);
1164                 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1165                 ++priv->stats.tx_errors;
1166             }
1167             DEBUG(3, "New status is TSER %x ASR %x\n",
1168                   readb(ramBase + NETWAVE_EREG_TSER),
1169                   inb(iobase + NETWAVE_REG_ASR));
1170
1171             netif_wake_queue(dev);
1172         }
1173         /* TxBA, this would trigger on all error packets received */
1174         /* if (status & 0x01) {
1175            DEBUG(4, "Transmit buffers available, %x\n", status);
1176            }
1177            */
1178     }
1179     /* Handled if we looped at least one time - Jean II */
1180     return IRQ_RETVAL(i);
1181 } /* netwave_interrupt */
1182
1183 /*
1184  * Function netwave_watchdog (a)
1185  *
1186  *    Watchdog : when we start a transmission, we set a timer in the
1187  *    kernel.  If the transmission complete, this timer is disabled. If
1188  *    it expire, we reset the card.
1189  *
1190  */
1191 static void netwave_watchdog(struct net_device *dev) {
1192
1193     DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1194     netwave_reset(dev);
1195     dev->trans_start = jiffies;
1196     netif_wake_queue(dev);
1197 } /* netwave_watchdog */
1198
1199 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1200     netwave_private *priv = netdev_priv(dev);
1201
1202     update_stats(dev);
1203
1204     DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1205           " %x tx %x %x %x %x\n", 
1206           readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1207           readb(priv->ramBase + NETWAVE_EREG_SPU),
1208           readb(priv->ramBase + NETWAVE_EREG_LIF),
1209           readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1210           readb(priv->ramBase + NETWAVE_EREG_MHS),
1211           readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1212           readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1213           readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1214           readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1215           readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1216           readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1217
1218     return &priv->stats;
1219 }
1220
1221 static void update_stats(struct net_device *dev) {
1222     //unsigned long flags;
1223 /*     netwave_private *priv = netdev_priv(dev); */
1224
1225     //spin_lock_irqsave(&priv->spinlock, flags);
1226
1227 /*    priv->stats.rx_packets = readb(priv->ramBase + 0x18e); 
1228     priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1229
1230     //spin_unlock_irqrestore(&priv->spinlock, flags);
1231 }
1232
1233 static int netwave_rx(struct net_device *dev)
1234 {
1235     netwave_private *priv = netdev_priv(dev);
1236     u_char __iomem *ramBase = priv->ramBase;
1237     kio_addr_t iobase = dev->base_addr;
1238     u_char rxStatus;
1239     struct sk_buff *skb = NULL;
1240     unsigned int curBuffer,
1241                 rcvList;
1242     int rcvLen;
1243     int tmpcount = 0;
1244     int dataCount, dataOffset;
1245     int i;
1246     u_char *ptr;
1247         
1248     DEBUG(3, "xinw_rx: Receiving ... \n");
1249
1250     /* Receive max 10 packets for now. */
1251     for (i = 0; i < 10; i++) {
1252         /* Any packets? */
1253         wait_WOC(iobase);
1254         rxStatus = readb(ramBase + NETWAVE_EREG_RSER);          
1255         if ( !( rxStatus & 0x80)) /* No more packets */
1256             break;
1257                 
1258         /* Check if multicast/broadcast or other */
1259         /* multicast = (rxStatus & 0x20);  */
1260                 
1261         /* The receive list pointer and length of the packet */
1262         wait_WOC(iobase);
1263         rcvLen  = get_int16( ramBase + NETWAVE_EREG_RDP);
1264         rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1265                 
1266         if (rcvLen < 0) {
1267             printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n", 
1268                    rcvLen);
1269             return 0;
1270         }
1271                 
1272         skb = dev_alloc_skb(rcvLen+5);
1273         if (skb == NULL) {
1274             DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1275                   "length %d\n", rcvLen);
1276             ++priv->stats.rx_dropped; 
1277             /* Tell the adapter to skip the packet */
1278             wait_WOC(iobase);
1279             writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1280             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1281             return 0;
1282         }
1283
1284         skb_reserve( skb, 2);  /* Align IP on 16 byte */
1285         skb_put( skb, rcvLen);
1286
1287         /* Copy packet fragments to the skb data area */
1288         ptr = (u_char*) skb->data;
1289         curBuffer = rcvList;
1290         tmpcount = 0; 
1291         while ( tmpcount < rcvLen) {
1292             /* Get length and offset of current buffer */
1293             dataCount  = get_uint16( ramBase+curBuffer+2);
1294             dataOffset = get_uint16( ramBase+curBuffer+4);
1295                 
1296             copy_from_pc( ptr + tmpcount,
1297                           ramBase+curBuffer+dataOffset, dataCount);
1298
1299             tmpcount += dataCount;
1300                 
1301             /* Point to next buffer */
1302             curBuffer = get_uint16(ramBase + curBuffer);
1303         }
1304         
1305         skb->protocol = eth_type_trans(skb,dev);
1306         /* Queue packet for network layer */
1307         netif_rx(skb);
1308
1309         dev->last_rx = jiffies;
1310         priv->stats.rx_packets++;
1311         priv->stats.rx_bytes += rcvLen;
1312
1313         /* Got the packet, tell the adapter to skip it */
1314         wait_WOC(iobase);
1315         writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1316         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1317         DEBUG(3, "Packet reception ok\n");
1318     }
1319     return 0;
1320 }
1321
1322 static int netwave_open(struct net_device *dev) {
1323     netwave_private *priv = netdev_priv(dev);
1324     struct pcmcia_device *link = priv->p_dev;
1325
1326     DEBUG(1, "netwave_open: starting.\n");
1327     
1328     if (!pcmcia_dev_present(link))
1329         return -ENODEV;
1330
1331     link->open++;
1332
1333     netif_start_queue(dev);
1334     netwave_reset(dev);
1335         
1336     return 0;
1337 }
1338
1339 static int netwave_close(struct net_device *dev) {
1340     netwave_private *priv = netdev_priv(dev);
1341     struct pcmcia_device *link = priv->p_dev;
1342
1343     DEBUG(1, "netwave_close: finishing.\n");
1344
1345     link->open--;
1346     netif_stop_queue(dev);
1347
1348     return 0;
1349 }
1350
1351 static struct pcmcia_device_id netwave_ids[] = {
1352         PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1353         PCMCIA_DEVICE_NULL,
1354 };
1355 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1356
1357 static struct pcmcia_driver netwave_driver = {
1358         .owner          = THIS_MODULE,
1359         .drv            = {
1360                 .name   = "netwave_cs",
1361         },
1362         .probe          = netwave_probe,
1363         .remove         = netwave_detach,
1364         .id_table       = netwave_ids,
1365         .suspend        = netwave_suspend,
1366         .resume         = netwave_resume,
1367 };
1368
1369 static int __init init_netwave_cs(void)
1370 {
1371         return pcmcia_register_driver(&netwave_driver);
1372 }
1373
1374 static void __exit exit_netwave_cs(void)
1375 {
1376         pcmcia_unregister_driver(&netwave_driver);
1377 }
1378
1379 module_init(init_netwave_cs);
1380 module_exit(exit_netwave_cs);
1381
1382 /* Set or clear the multicast filter for this adaptor.
1383    num_addrs == -1      Promiscuous mode, receive all packets
1384    num_addrs == 0       Normal mode, clear multicast list
1385    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
1386    best-effort filtering.
1387  */
1388 static void set_multicast_list(struct net_device *dev)
1389 {
1390     kio_addr_t iobase = dev->base_addr;
1391     netwave_private *priv = netdev_priv(dev);
1392     u_char __iomem * ramBase = priv->ramBase;
1393     u_char  rcvMode = 0;
1394    
1395 #ifdef PCMCIA_DEBUG
1396     if (pc_debug > 2) {
1397         static int old;
1398         if (old != dev->mc_count) {
1399             old = dev->mc_count;
1400             DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1401                   dev->name, dev->mc_count);
1402         }
1403     }
1404 #endif
1405         
1406     if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1407         /* Multicast Mode */
1408         rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1409     } else if (dev->flags & IFF_PROMISC) {
1410         /* Promiscous mode */
1411         rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1412     } else {
1413         /* Normal mode */
1414         rcvMode = rxConfRxEna + rxConfBcast;
1415     }
1416         
1417     /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1418     /* Now set receive mode */
1419     wait_WOC(iobase);
1420     writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1421     writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1422     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1423 }
1424 MODULE_LICENSE("GPL");