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