drivers/net/: all drivers/net/ cleanup with ARRAY_SIZE
[linux-2.6.git] / 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     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;
420
421     dev->tx_timeout = &netwave_watchdog;
422     dev->watchdog_timeo = TX_TIMEOUT;
423
424     dev->open = &netwave_open;
425     dev->stop = &netwave_close;
426     link->irq.Instance = dev;
427
428     return netwave_pcmcia_config( link);
429 } /* netwave_attach */
430
431 /*
432  * Function netwave_detach (link)
433  *
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.
438  */
439 static void netwave_detach(struct pcmcia_device *link)
440 {
441         struct net_device *dev = link->priv;
442
443         DEBUG(0, "netwave_detach(0x%p)\n", link);
444
445         netwave_release(link);
446
447         if (link->dev_node)
448                 unregister_netdev(dev);
449
450         free_netdev(dev);
451 } /* netwave_detach */
452
453 /*
454  * Wireless Handler : get protocol name
455  */
456 static int netwave_get_name(struct net_device *dev,
457                             struct iw_request_info *info,
458                             union iwreq_data *wrqu,
459                             char *extra)
460 {
461         strcpy(wrqu->name, "Netwave");
462         return 0;
463 }
464
465 /*
466  * Wireless Handler : set Network ID
467  */
468 static int netwave_set_nwid(struct net_device *dev,
469                             struct iw_request_info *info,
470                             union iwreq_data *wrqu,
471                             char *extra)
472 {
473         unsigned long flags;
474         kio_addr_t iobase = dev->base_addr;
475         netwave_private *priv = netdev_priv(dev);
476         u_char __iomem *ramBase = priv->ramBase;
477
478         /* Disable interrupts & save flags */
479         spin_lock_irqsave(&priv->spinlock, flags);
480
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);
485             wait_WOC(iobase);
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);
490         }
491
492         /* ReEnable interrupts & restore flags */
493         spin_unlock_irqrestore(&priv->spinlock, flags);
494     
495         return 0;
496 }
497
498 /*
499  * Wireless Handler : get Network ID
500  */
501 static int netwave_get_nwid(struct net_device *dev,
502                             struct iw_request_info *info,
503                             union iwreq_data *wrqu,
504                             char *extra)
505 {
506         wrqu->nwid.value = domain;
507         wrqu->nwid.disabled = 0;
508         wrqu->nwid.fixed = 1;
509         return 0;
510 }
511
512 /*
513  * Wireless Handler : set scramble key
514  */
515 static int netwave_set_scramble(struct net_device *dev,
516                                 struct iw_request_info *info,
517                                 union iwreq_data *wrqu,
518                                 char *key)
519 {
520         unsigned long flags;
521         kio_addr_t iobase = dev->base_addr;
522         netwave_private *priv = netdev_priv(dev);
523         u_char __iomem *ramBase = priv->ramBase;
524
525         /* Disable interrupts & save flags */
526         spin_lock_irqsave(&priv->spinlock, flags);
527
528         scramble_key = (key[0] << 8) | key[1];
529         wait_WOC(iobase);
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);
534
535         /* ReEnable interrupts & restore flags */
536         spin_unlock_irqrestore(&priv->spinlock, flags);
537     
538         return 0;
539 }
540
541 /*
542  * Wireless Handler : get scramble key
543  */
544 static int netwave_get_scramble(struct net_device *dev,
545                                 struct iw_request_info *info,
546                                 union iwreq_data *wrqu,
547                                 char *key)
548 {
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;
553         return 0;
554 }
555
556 /*
557  * Wireless Handler : get mode
558  */
559 static int netwave_get_mode(struct net_device *dev,
560                             struct iw_request_info *info,
561                             union iwreq_data *wrqu,
562                             char *extra)
563 {
564         if(domain & 0x100)
565                 wrqu->mode = IW_MODE_INFRA;
566         else
567                 wrqu->mode = IW_MODE_ADHOC;
568
569         return 0;
570 }
571
572 /*
573  * Wireless Handler : get range info
574  */
575 static int netwave_get_range(struct net_device *dev,
576                              struct iw_request_info *info,
577                              union iwreq_data *wrqu,
578                              char *extra)
579 {
580         struct iw_range *range = (struct iw_range *) extra;
581         int ret = 0;
582
583         /* Set the length (very important for backward compatibility) */
584         wrqu->data.length = sizeof(struct iw_range);
585
586         /* Set all the info we don't care or don't know about to zero */
587         memset(range, 0, sizeof(struct iw_range));
588
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 */
592                    
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;
597
598         range->num_channels = range->num_frequency = 0;
599                    
600         range->sensitivity = 0x3F;
601         range->max_qual.qual = 255;
602         range->max_qual.level = 255;
603         range->max_qual.noise = 0;
604                    
605         range->num_bitrates = 1;
606         range->bitrate[0] = 1000000;    /* 1 Mb/s */
607
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 */
611
612         return ret;
613 }
614
615 /*
616  * Wireless Private Handler : get snapshot
617  */
618 static int netwave_get_snap(struct net_device *dev,
619                             struct iw_request_info *info,
620                             union iwreq_data *wrqu,
621                             char *extra)
622 {
623         unsigned long flags;
624         kio_addr_t iobase = dev->base_addr;
625         netwave_private *priv = netdev_priv(dev);
626         u_char __iomem *ramBase = priv->ramBase;
627
628         /* Disable interrupts & save flags */
629         spin_lock_irqsave(&priv->spinlock, flags);
630
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));
635
636         priv->lastExec = jiffies;
637
638         /* ReEnable interrupts & restore flags */
639         spin_unlock_irqrestore(&priv->spinlock, flags);
640     
641         return(0);
642 }
643
644 /*
645  * Structures to export the Wireless Handlers
646  *     This is the stuff that are treated the wireless extensions (iwconfig)
647  */
648
649 static const struct iw_priv_args netwave_private_args[] = {
650 /*{ cmd,         set_args,                            get_args, name } */
651   { SIOCGIPSNAP, 0, 
652     IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey), 
653     "getsitesurvey" },
654 };
655
656 static const iw_handler         netwave_handler[] =
657 {
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 */
702 };
703
704 static const iw_handler         netwave_private_handler[] =
705 {
706         NULL,                           /* SIOCIWFIRSTPRIV */
707         netwave_get_snap,               /* SIOCIWFIRSTPRIV + 1 */
708 };
709
710 static const struct iw_handler_def      netwave_handler_def =
711 {
712         .num_standard   = ARRAY_SIZE(netwave_handler),
713         .num_private    = ARRAY_SIZE(netwave_private_handler),
714         .num_private_args = ARRAY_SIZE(netwave_private_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,
719 };
720
721 /*
722  * Function netwave_pcmcia_config (link)
723  *
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. 
727  *
728  */
729
730 #define CS_CHECK(fn, ret) \
731 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
732
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;
737     win_req_t req;
738     memreq_t mem;
739     u_char __iomem *ramBase = NULL;
740
741     DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
742
743     /*
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.
747      */
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;
752     }
753     if (i != CS_SUCCESS) {
754         cs_error(link, RequestIO, i);
755         goto failed;
756     }
757
758     /*
759      *  Now allocate an interrupt line.  Note that this does not
760      *  actually assign a handler to the interrupt.
761      */
762     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
763
764     /*
765      *  This actually configures the PCMCIA socket -- setting up
766      *  the I/O windows and the interrupt mapping.
767      */
768     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
769
770     /*
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.
775      */
776     DEBUG(1, "Setting mem speed of %d\n", mem_speed);
777
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));
784
785     /* Store base address of the common window frame */
786     ramBase = ioremap(req.Base, 0x8000);
787     priv->ramBase = ramBase;
788
789     dev->irq = link->irq.AssignedIRQ;
790     dev->base_addr = link->io.BasePort1;
791     SET_NETDEV_DEV(dev, &handle_to_dev(link));
792
793     if (register_netdev(dev) != 0) {
794         printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
795         goto failed;
796     }
797
798     strcpy(priv->node.dev_name, dev->name);
799     link->dev_node = &priv->node;
800
801     /* Reset card before reading physical address */
802     netwave_doreset(dev->base_addr, ramBase);
803
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);
807
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"));
814
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));
819     return 0;
820
821 cs_failed:
822     cs_error(link, last_fn, last_ret);
823 failed:
824     netwave_release(link);
825     return -ENODEV;
826 } /* netwave_pcmcia_config */
827
828 /*
829  * Function netwave_release (arg)
830  *
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.
834  */
835 static void netwave_release(struct pcmcia_device *link)
836 {
837         struct net_device *dev = link->priv;
838         netwave_private *priv = netdev_priv(dev);
839
840         DEBUG(0, "netwave_release(0x%p)\n", link);
841
842         pcmcia_disable_device(link);
843         if (link->win)
844                 iounmap(priv->ramBase);
845 }
846
847 static int netwave_suspend(struct pcmcia_device *link)
848 {
849         struct net_device *dev = link->priv;
850
851         if (link->open)
852                 netif_device_detach(dev);
853
854         return 0;
855 }
856
857 static int netwave_resume(struct pcmcia_device *link)
858 {
859         struct net_device *dev = link->priv;
860
861         if (link->open) {
862                 netwave_reset(dev);
863                 netif_device_attach(dev);
864         }
865
866         return 0;
867 }
868
869
870 /*
871  * Function netwave_doreset (ioBase, ramBase)
872  *
873  *    Proper hardware reset of the card.
874  */
875 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
876 {
877     /* Reset card */
878     wait_WOC(ioBase);
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 */
882 }
883
884 /*
885  * Function netwave_reset (dev)
886  *
887  *    Reset and restore all of the netwave registers 
888  */
889 static void netwave_reset(struct net_device *dev) {
890     /* u_char state; */
891     netwave_private *priv = netdev_priv(dev);
892     u_char __iomem *ramBase = priv->ramBase;
893     kio_addr_t iobase = dev->base_addr;
894
895     DEBUG(0, "netwave_reset: Done with hardware reset\n");
896
897     priv->timeoutCounter = 0;
898
899     /* Reset card */
900     netwave_doreset(iobase, ramBase);
901     printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
902         
903     /* Write a NOP to check the card */
904     wait_WOC(iobase);
905     writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
906     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
907         
908     /* Set receive conf */
909     wait_WOC(iobase);
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);
913     
914     /* Set transmit conf */
915     wait_WOC(iobase);
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);
919     
920     /* Now set the MU Domain */
921     printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
922     wait_WOC(iobase);
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);
927         
928     /* Set scramble key */
929     printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
930     wait_WOC(iobase);
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);
935
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, 
939      * RxErr and RxRdy
940      */
941     wait_WOC(iobase);
942     outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
943
944     /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
945      * waitWOC
946      * skriv 80 til d000:3688
947      * sjekk om det ble 80
948      */
949     
950     /* Enable Receiver */
951     wait_WOC(iobase);
952     writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
953     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
954         
955     /* Set the IENA bit in COR */
956     wait_WOC(iobase);
957     outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
958 }
959
960 /*
961  * Function netwave_hw_xmit (data, len, dev)    
962  */
963 static int netwave_hw_xmit(unsigned char* data, int len,
964                            struct net_device* dev) {
965     unsigned long flags;
966     unsigned int TxFreeList,
967                  curBuff,
968                  MaxData, 
969                  DataOffset;
970     int tmpcount; 
971         
972     netwave_private *priv = netdev_priv(dev);
973     u_char __iomem * ramBase = priv->ramBase;
974     kio_addr_t iobase = dev->base_addr;
975
976     /* Disable interrupts & save flags */
977     spin_lock_irqsave(&priv->spinlock, flags);
978
979     /* Check if there are transmit buffers available */
980     wait_WOC(iobase);
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",
984                dev->name);
985         spin_unlock_irqrestore(&priv->spinlock, flags);
986         return 1;
987     }
988
989     priv->stats.tx_bytes += len;
990
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));
996
997     /* Now try to insert it into the adapters free memory */
998     wait_WOC(iobase);
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);
1002         
1003     DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1004           TxFreeList, MaxData, DataOffset);
1005
1006     /* Copy packet to the adapter fragment buffers */
1007     curBuff = TxFreeList; 
1008     tmpcount = 0; 
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;
1014                         
1015         /* Advance to next buffer */
1016         curBuff = get_uint16(ramBase + curBuff);
1017     }
1018     
1019     /* Now issue transmit list */
1020     wait_WOC(iobase);
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);
1025
1026     spin_unlock_irqrestore(&priv->spinlock, flags);
1027     return 0;
1028 }
1029
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...
1035          */
1036
1037     netif_stop_queue(dev);
1038
1039     {
1040         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1041         unsigned char* buf = skb->data;
1042         
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);
1046         }
1047         dev->trans_start = jiffies;
1048     }
1049     dev_kfree_skb(skb);
1050     
1051     return 0;
1052 } /* netwave_start_xmit */
1053
1054 /*
1055  * Function netwave_interrupt (irq, dev_id)
1056  *
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.
1063  */
1064 static irqreturn_t netwave_interrupt(int irq, void* dev_id)
1065 {
1066     kio_addr_t iobase;
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;
1071     int i;
1072     
1073     if (!netif_device_present(dev))
1074         return IRQ_NONE;
1075     
1076     iobase = dev->base_addr;
1077     ramBase = priv->ramBase;
1078         
1079     /* Now find what caused the interrupt, check while interrupts ready */
1080     for (i = 0; i < 10; i++) {
1081         u_char status;
1082                 
1083         wait_WOC(iobase);       
1084         if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1085             break; /* None of the interrupt sources asserted (normal exit) */
1086         
1087         status = inb(iobase + NETWAVE_REG_ASR);
1088                 
1089         if (!pcmcia_dev_present(link)) {
1090             DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1091                   "from removed or suspended card!\n", status);
1092             break;
1093         }
1094                 
1095         /* RxRdy */
1096         if (status & 0x80) {
1097             netwave_rx(dev);
1098             /* wait_WOC(iobase); */
1099             /* RxRdy cannot be reset directly by the host */
1100         }
1101         /* RxErr */
1102         if (status & 0x40) {
1103             u_char rser;
1104                         
1105             rser = readb(ramBase + NETWAVE_EREG_RSER);                  
1106             
1107             if (rser & 0x04) {
1108                 ++priv->stats.rx_dropped; 
1109                 ++priv->stats.rx_crc_errors;
1110             }
1111             if (rser & 0x02)
1112                 ++priv->stats.rx_frame_errors;
1113                         
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 */
1117             wait_WOC(iobase);
1118             writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1119
1120             /* Write bit 6 high to ASCC to clear RxErr in ASR,
1121              * WOC must be set first! 
1122              */
1123             wait_WOC(iobase);
1124             writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1125
1126             /* Remember to count up priv->stats on error packets */
1127             ++priv->stats.rx_errors;
1128         }
1129         /* TxDN */
1130         if (status & 0x20) {
1131             int txStatus;
1132
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));
1136             
1137             if (txStatus & 0x20) {
1138                 /* Transmitting was okay, clear bits */
1139                 wait_WOC(iobase);
1140                 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1141                 ++priv->stats.tx_packets;
1142             }
1143                         
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); */
1149                 }
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
1156                  *      to set TxErr).
1157                  */
1158                 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n", 
1159                       txStatus);
1160                 
1161                 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1162                 wait_WOC(iobase);
1163                 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1164                 ++priv->stats.tx_errors;
1165             }
1166             DEBUG(3, "New status is TSER %x ASR %x\n",
1167                   readb(ramBase + NETWAVE_EREG_TSER),
1168                   inb(iobase + NETWAVE_REG_ASR));
1169
1170             netif_wake_queue(dev);
1171         }
1172         /* TxBA, this would trigger on all error packets received */
1173         /* if (status & 0x01) {
1174            DEBUG(4, "Transmit buffers available, %x\n", status);
1175            }
1176            */
1177     }
1178     /* Handled if we looped at least one time - Jean II */
1179     return IRQ_RETVAL(i);
1180 } /* netwave_interrupt */
1181
1182 /*
1183  * Function netwave_watchdog (a)
1184  *
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.
1188  *
1189  */
1190 static void netwave_watchdog(struct net_device *dev) {
1191
1192     DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1193     netwave_reset(dev);
1194     dev->trans_start = jiffies;
1195     netif_wake_queue(dev);
1196 } /* netwave_watchdog */
1197
1198 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1199     netwave_private *priv = netdev_priv(dev);
1200
1201     update_stats(dev);
1202
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));
1216
1217     return &priv->stats;
1218 }
1219
1220 static void update_stats(struct net_device *dev) {
1221     //unsigned long flags;
1222 /*     netwave_private *priv = netdev_priv(dev); */
1223
1224     //spin_lock_irqsave(&priv->spinlock, flags);
1225
1226 /*    priv->stats.rx_packets = readb(priv->ramBase + 0x18e); 
1227     priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1228
1229     //spin_unlock_irqrestore(&priv->spinlock, flags);
1230 }
1231
1232 static int netwave_rx(struct net_device *dev)
1233 {
1234     netwave_private *priv = netdev_priv(dev);
1235     u_char __iomem *ramBase = priv->ramBase;
1236     kio_addr_t iobase = dev->base_addr;
1237     u_char rxStatus;
1238     struct sk_buff *skb = NULL;
1239     unsigned int curBuffer,
1240                 rcvList;
1241     int rcvLen;
1242     int tmpcount = 0;
1243     int dataCount, dataOffset;
1244     int i;
1245     u_char *ptr;
1246         
1247     DEBUG(3, "xinw_rx: Receiving ... \n");
1248
1249     /* Receive max 10 packets for now. */
1250     for (i = 0; i < 10; i++) {
1251         /* Any packets? */
1252         wait_WOC(iobase);
1253         rxStatus = readb(ramBase + NETWAVE_EREG_RSER);          
1254         if ( !( rxStatus & 0x80)) /* No more packets */
1255             break;
1256                 
1257         /* Check if multicast/broadcast or other */
1258         /* multicast = (rxStatus & 0x20);  */
1259                 
1260         /* The receive list pointer and length of the packet */
1261         wait_WOC(iobase);
1262         rcvLen  = get_int16( ramBase + NETWAVE_EREG_RDP);
1263         rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1264                 
1265         if (rcvLen < 0) {
1266             printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n", 
1267                    rcvLen);
1268             return 0;
1269         }
1270                 
1271         skb = dev_alloc_skb(rcvLen+5);
1272         if (skb == NULL) {
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 */
1277             wait_WOC(iobase);
1278             writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1279             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1280             return 0;
1281         }
1282
1283         skb_reserve( skb, 2);  /* Align IP on 16 byte */
1284         skb_put( skb, rcvLen);
1285
1286         /* Copy packet fragments to the skb data area */
1287         ptr = (u_char*) skb->data;
1288         curBuffer = rcvList;
1289         tmpcount = 0; 
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);
1294                 
1295             copy_from_pc( ptr + tmpcount,
1296                           ramBase+curBuffer+dataOffset, dataCount);
1297
1298             tmpcount += dataCount;
1299                 
1300             /* Point to next buffer */
1301             curBuffer = get_uint16(ramBase + curBuffer);
1302         }
1303         
1304         skb->protocol = eth_type_trans(skb,dev);
1305         /* Queue packet for network layer */
1306         netif_rx(skb);
1307
1308         dev->last_rx = jiffies;
1309         priv->stats.rx_packets++;
1310         priv->stats.rx_bytes += rcvLen;
1311
1312         /* Got the packet, tell the adapter to skip it */
1313         wait_WOC(iobase);
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");
1317     }
1318     return 0;
1319 }
1320
1321 static int netwave_open(struct net_device *dev) {
1322     netwave_private *priv = netdev_priv(dev);
1323     struct pcmcia_device *link = priv->p_dev;
1324
1325     DEBUG(1, "netwave_open: starting.\n");
1326     
1327     if (!pcmcia_dev_present(link))
1328         return -ENODEV;
1329
1330     link->open++;
1331
1332     netif_start_queue(dev);
1333     netwave_reset(dev);
1334         
1335     return 0;
1336 }
1337
1338 static int netwave_close(struct net_device *dev) {
1339     netwave_private *priv = netdev_priv(dev);
1340     struct pcmcia_device *link = priv->p_dev;
1341
1342     DEBUG(1, "netwave_close: finishing.\n");
1343
1344     link->open--;
1345     netif_stop_queue(dev);
1346
1347     return 0;
1348 }
1349
1350 static struct pcmcia_device_id netwave_ids[] = {
1351         PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1352         PCMCIA_DEVICE_NULL,
1353 };
1354 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1355
1356 static struct pcmcia_driver netwave_driver = {
1357         .owner          = THIS_MODULE,
1358         .drv            = {
1359                 .name   = "netwave_cs",
1360         },
1361         .probe          = netwave_probe,
1362         .remove         = netwave_detach,
1363         .id_table       = netwave_ids,
1364         .suspend        = netwave_suspend,
1365         .resume         = netwave_resume,
1366 };
1367
1368 static int __init init_netwave_cs(void)
1369 {
1370         return pcmcia_register_driver(&netwave_driver);
1371 }
1372
1373 static void __exit exit_netwave_cs(void)
1374 {
1375         pcmcia_unregister_driver(&netwave_driver);
1376 }
1377
1378 module_init(init_netwave_cs);
1379 module_exit(exit_netwave_cs);
1380
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.
1386  */
1387 static void set_multicast_list(struct net_device *dev)
1388 {
1389     kio_addr_t iobase = dev->base_addr;
1390     netwave_private *priv = netdev_priv(dev);
1391     u_char __iomem * ramBase = priv->ramBase;
1392     u_char  rcvMode = 0;
1393    
1394 #ifdef PCMCIA_DEBUG
1395     if (pc_debug > 2) {
1396         static int old;
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);
1401         }
1402     }
1403 #endif
1404         
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;
1411     } else {
1412         /* Normal mode */
1413         rcvMode = rxConfRxEna + rxConfBcast;
1414     }
1415         
1416     /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1417     /* Now set receive mode */
1418     wait_WOC(iobase);
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);
1422 }
1423 MODULE_LICENSE("GPL");