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