[Bug 455] Fix frequent channel change generates firmware fatal error.
[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/config.h>
41 #include <linux/module.h>
42 #include <linux/kernel.h>
43 #include <linux/init.h>
44 #include <linux/types.h>
45 #include <linux/fcntl.h>
46 #include <linux/interrupt.h>
47 #include <linux/ptrace.h>
48 #include <linux/ioport.h>
49 #include <linux/in.h>
50 #include <linux/slab.h>
51 #include <linux/string.h>
52 #include <linux/timer.h>
53 #include <linux/errno.h>
54 #include <linux/netdevice.h>
55 #include <linux/etherdevice.h>
56 #include <linux/skbuff.h>
57 #include <linux/bitops.h>
58 #ifdef CONFIG_NET_RADIO
59 #include <linux/wireless.h>
60 #include <net/iw_handler.h>
61 #endif
62
63 #include <pcmcia/cs_types.h>
64 #include <pcmcia/cs.h>
65 #include <pcmcia/cistpl.h>
66 #include <pcmcia/cisreg.h>
67 #include <pcmcia/ds.h>
68 #include <pcmcia/mem_op.h>
69
70 #include <asm/system.h>
71 #include <asm/io.h>
72 #include <asm/dma.h>
73
74 #define NETWAVE_REGOFF         0x8000
75 /* The Netwave IO registers, offsets to iobase */
76 #define NETWAVE_REG_COR        0x0
77 #define NETWAVE_REG_CCSR       0x2
78 #define NETWAVE_REG_ASR        0x4
79 #define NETWAVE_REG_IMR        0xa
80 #define NETWAVE_REG_PMR        0xc
81 #define NETWAVE_REG_IOLOW      0x6
82 #define NETWAVE_REG_IOHI       0x7
83 #define NETWAVE_REG_IOCONTROL  0x8
84 #define NETWAVE_REG_DATA       0xf
85 /* The Netwave Extended IO registers, offsets to RamBase */
86 #define NETWAVE_EREG_ASCC      0x114
87 #define NETWAVE_EREG_RSER      0x120
88 #define NETWAVE_EREG_RSERW     0x124
89 #define NETWAVE_EREG_TSER      0x130
90 #define NETWAVE_EREG_TSERW     0x134
91 #define NETWAVE_EREG_CB        0x100
92 #define NETWAVE_EREG_SPCQ      0x154
93 #define NETWAVE_EREG_SPU       0x155
94 #define NETWAVE_EREG_LIF       0x14e
95 #define NETWAVE_EREG_ISPLQ     0x156
96 #define NETWAVE_EREG_HHC       0x158
97 #define NETWAVE_EREG_NI        0x16e
98 #define NETWAVE_EREG_MHS       0x16b
99 #define NETWAVE_EREG_TDP       0x140
100 #define NETWAVE_EREG_RDP       0x150
101 #define NETWAVE_EREG_PA        0x160
102 #define NETWAVE_EREG_EC        0x180
103 #define NETWAVE_EREG_CRBP      0x17a
104 #define NETWAVE_EREG_ARW       0x166
105
106 /*
107  * Commands used in the extended command buffer
108  * NETWAVE_EREG_CB (0x100-0x10F) 
109  */
110 #define NETWAVE_CMD_NOP        0x00
111 #define NETWAVE_CMD_SRC        0x01
112 #define NETWAVE_CMD_STC        0x02
113 #define NETWAVE_CMD_AMA        0x03
114 #define NETWAVE_CMD_DMA        0x04
115 #define NETWAVE_CMD_SAMA       0x05
116 #define NETWAVE_CMD_ER         0x06
117 #define NETWAVE_CMD_DR         0x07
118 #define NETWAVE_CMD_TL         0x08
119 #define NETWAVE_CMD_SRP        0x09
120 #define NETWAVE_CMD_SSK        0x0a
121 #define NETWAVE_CMD_SMD        0x0b
122 #define NETWAVE_CMD_SAPD       0x0c
123 #define NETWAVE_CMD_SSS        0x11
124 /* End of Command marker */
125 #define NETWAVE_CMD_EOC        0x00
126
127 /* ASR register bits */
128 #define NETWAVE_ASR_RXRDY   0x80
129 #define NETWAVE_ASR_TXBA    0x01
130
131 #define TX_TIMEOUT              ((32*HZ)/100)
132
133 static const unsigned int imrConfRFU1 = 0x10; /* RFU interrupt mask, keep high */
134 static const unsigned int imrConfIENA = 0x02; /* Interrupt enable */
135
136 static const unsigned int corConfIENA   = 0x01; /* Interrupt enable */
137 static const unsigned int corConfLVLREQ = 0x40; /* Keep high */
138
139 static const unsigned int rxConfRxEna  = 0x80; /* Receive Enable */
140 static const unsigned int rxConfMAC    = 0x20; /* MAC host receive mode*/ 
141 static const unsigned int rxConfPro    = 0x10; /* Promiscuous */
142 static const unsigned int rxConfAMP    = 0x08; /* Accept Multicast Packets */
143 static const unsigned int rxConfBcast  = 0x04; /* Accept Broadcast Packets */
144
145 static const unsigned int txConfTxEna  = 0x80; /* Transmit Enable */
146 static const unsigned int txConfMAC    = 0x20; /* Host sends MAC mode */
147 static const unsigned int txConfEUD    = 0x10; /* Enable Uni-Data packets */
148 static const unsigned int txConfKey    = 0x02; /* Scramble data packets */
149 static const unsigned int txConfLoop   = 0x01; /* Loopback mode */
150
151 /*
152    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
153    you do not define PCMCIA_DEBUG at all, all the debug code will be
154    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
155    be present but disabled -- but it can then be enabled for specific
156    modules at load time with a 'pc_debug=#' option to insmod.
157 */
158
159 #ifdef PCMCIA_DEBUG
160 static int pc_debug = PCMCIA_DEBUG;
161 module_param(pc_debug, int, 0);
162 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
163 static char *version =
164 "netwave_cs.c 0.3.0 Thu Jul 17 14:36:02 1997 (John Markus Bjørndalen)\n";
165 #else
166 #define DEBUG(n, args...)
167 #endif
168
169 static dev_info_t dev_info = "netwave_cs";
170
171 /*====================================================================*/
172
173 /* Parameters that can be set with 'insmod' */
174
175 /* Choose the domain, default is 0x100 */
176 static u_int  domain = 0x100;
177
178 /* Scramble key, range from 0x0 to 0xffff.  
179  * 0x0 is no scrambling. 
180  */
181 static u_int  scramble_key = 0x0;
182
183 /* Shared memory speed, in ns. The documentation states that 
184  * the card should not be read faster than every 400ns. 
185  * This timing should be provided by the HBA. If it becomes a 
186  * problem, try setting mem_speed to 400. 
187  */
188 static int mem_speed;
189
190 module_param(domain, int, 0);
191 module_param(scramble_key, int, 0);
192 module_param(mem_speed, int, 0);
193
194 /*====================================================================*/
195
196 /* PCMCIA (Card Services) related functions */
197 static void netwave_release(dev_link_t *link);     /* Card removal */
198 static int  netwave_event(event_t event, int priority, 
199                                               event_callback_args_t *args);
200 static void netwave_pcmcia_config(dev_link_t *arg); /* Runs after card 
201                                                                                                            insertion */
202 static dev_link_t *netwave_attach(void);     /* Create instance */
203 static void netwave_detach(dev_link_t *);    /* Destroy instance */
204
205 /* Hardware configuration */
206 static void netwave_doreset(kio_addr_t iobase, u_char __iomem *ramBase);
207 static void netwave_reset(struct net_device *dev);
208
209 /* Misc device stuff */
210 static int netwave_open(struct net_device *dev);  /* Open the device */
211 static int netwave_close(struct net_device *dev); /* Close the device */
212
213 /* Packet transmission and Packet reception */
214 static int netwave_start_xmit( struct sk_buff *skb, struct net_device *dev);
215 static int netwave_rx( struct net_device *dev);
216
217 /* Interrupt routines */
218 static irqreturn_t netwave_interrupt(int irq, void *dev_id, struct pt_regs *regs);
219 static void netwave_watchdog(struct net_device *);
220
221 /* Statistics */
222 static void update_stats(struct net_device *dev);
223 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
224
225 /* Wireless extensions */
226 static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev);
227
228 static void set_multicast_list(struct net_device *dev);
229
230 /*
231    A linked list of "instances" of the skeleton device.  Each actual
232    PCMCIA card corresponds to one device instance, and is described
233    by one dev_link_t structure (defined in ds.h).
234
235    You may not want to use a linked list for this -- for example, the
236    memory card driver uses an array of dev_link_t pointers, where minor
237    device numbers are used to derive the corresponding array index.
238 */
239 static dev_link_t *dev_list;
240
241 /*
242    A dev_link_t structure has fields for most things that are needed
243    to keep track of a socket, but there will usually be some device
244    specific information that also needs to be kept track of.  The
245    'priv' pointer in a dev_link_t structure can be used to point to
246    a device-specific private data structure, like this.
247
248    A driver needs to provide a dev_node_t structure for each device
249    on a card.  In some cases, there is only one device per card (for
250    example, ethernet cards, modems).  In other cases, there may be
251    many actual or logical devices (SCSI adapters, memory cards with
252    multiple partitions).  The dev_node_t structures need to be kept
253    in a linked list starting at the 'dev' field of a dev_link_t
254    structure.  We allocate them in the card's private data structure,
255    because they generally can't be allocated dynamically.
256 */
257
258 static const struct iw_handler_def      netwave_handler_def;
259
260 #define SIOCGIPSNAP     SIOCIWFIRSTPRIV + 1     /* Site Survey Snapshot */
261
262 #define MAX_ESA 10
263
264 typedef struct net_addr {
265     u_char addr48[6];
266 } net_addr;
267
268 struct site_survey {
269     u_short length;
270     u_char  struct_revision;
271     u_char  roaming_state;
272         
273     u_char  sp_existsFlag;
274     u_char  sp_link_quality;
275     u_char  sp_max_link_quality;
276     u_char  linkQualityGoodFairBoundary;
277     u_char  linkQualityFairPoorBoundary;
278     u_char  sp_utilization;
279     u_char  sp_goodness;
280     u_char  sp_hotheadcount;
281     u_char  roaming_condition;
282         
283     net_addr sp;
284     u_char   numAPs;
285     net_addr nearByAccessPoints[MAX_ESA];
286 };      
287    
288 typedef struct netwave_private {
289     dev_link_t link;
290     spinlock_t  spinlock;       /* Serialize access to the hardware (SMP) */
291     dev_node_t node;
292     u_char     __iomem *ramBase;
293     int        timeoutCounter;
294     int        lastExec;
295     struct timer_list      watchdog;    /* To avoid blocking state */
296     struct site_survey     nss;
297     struct net_device_stats stats;
298     struct iw_statistics   iw_stats;    /* Wireless stats */
299 } netwave_private;
300
301 #ifdef NETWAVE_STATS
302 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
303 #endif
304
305 /*
306  * The Netwave card is little-endian, so won't work for big endian
307  * systems.
308  */
309 static inline unsigned short get_uint16(u_char __iomem *staddr) 
310 {
311     return readw(staddr); /* Return only 16 bits */
312 }
313
314 static inline short get_int16(u_char __iomem * staddr)
315 {
316     return readw(staddr);
317 }
318
319 /* 
320  * Wait until the WOC (Write Operation Complete) bit in the 
321  * ASR (Adapter Status Register) is asserted. 
322  * This should have aborted if it takes too long time. 
323  */
324 static inline void wait_WOC(unsigned int iobase)
325 {
326     /* Spin lock */
327     while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ; 
328 }
329
330 static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase, 
331                              kio_addr_t iobase) {
332     u_short resultBuffer;
333
334     /* if time since last snapshot is > 1 sec. (100 jiffies?)  then take 
335      * new snapshot, else return cached data. This is the recommended rate.  
336      */
337     if ( jiffies - priv->lastExec > 100) { 
338         /* Take site survey  snapshot */ 
339         /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies -
340           priv->lastExec); */
341         wait_WOC(iobase); 
342         writeb(NETWAVE_CMD_SSS, ramBase + NETWAVE_EREG_CB + 0); 
343         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); 
344         wait_WOC(iobase); 
345
346         /* Get result and copy to cach */ 
347         resultBuffer = readw(ramBase + NETWAVE_EREG_CRBP); 
348         copy_from_pc( &priv->nss, ramBase+resultBuffer, 
349                       sizeof(struct site_survey)); 
350     } 
351 }
352
353 /*
354  * Function netwave_get_wireless_stats (dev)
355  *
356  *    Wireless extensions statistics
357  *
358  */
359 static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev)
360 {       
361     unsigned long flags;
362     kio_addr_t iobase = dev->base_addr;
363     netwave_private *priv = netdev_priv(dev);
364     u_char __iomem *ramBase = priv->ramBase;
365     struct iw_statistics* wstats;
366         
367     wstats = &priv->iw_stats;
368
369     spin_lock_irqsave(&priv->spinlock, flags);
370         
371     netwave_snapshot( priv, ramBase, iobase);
372
373     wstats->status = priv->nss.roaming_state;
374     wstats->qual.qual = readb( ramBase + NETWAVE_EREG_SPCQ); 
375     wstats->qual.level = readb( ramBase + NETWAVE_EREG_ISPLQ);
376     wstats->qual.noise = readb( ramBase + NETWAVE_EREG_SPU) & 0x3f;
377     wstats->discard.nwid = 0L;
378     wstats->discard.code = 0L;
379     wstats->discard.misc = 0L;
380
381     spin_unlock_irqrestore(&priv->spinlock, flags);
382     
383     return &priv->iw_stats;
384 }
385
386 /*
387  * Function netwave_attach (void)
388  *
389  *     Creates an "instance" of the driver, allocating local data 
390  *     structures for one device.  The device is registered with Card 
391  *     Services.
392  *
393  *     The dev_link structure is initialized, but we don't actually
394  *     configure the card at this point -- we wait until we receive a
395  *     card insertion event.
396  */
397 static dev_link_t *netwave_attach(void)
398 {
399     client_reg_t client_reg;
400     dev_link_t *link;
401     struct net_device *dev;
402     netwave_private *priv;
403     int ret;
404     
405     DEBUG(0, "netwave_attach()\n");
406     
407     /* Initialize the dev_link_t structure */
408     dev = alloc_etherdev(sizeof(netwave_private));
409     if (!dev)
410         return NULL;
411     priv = netdev_priv(dev);
412     link = &priv->link;
413     link->priv = dev;
414
415     /* The io structure describes IO port mapping */
416     link->io.NumPorts1 = 16;
417     link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
418     /* link->io.NumPorts2 = 16; 
419        link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
420     link->io.IOAddrLines = 5;
421     
422     /* Interrupt setup */
423     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
424     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
425     link->irq.Handler = &netwave_interrupt;
426     
427     /* General socket configuration */
428     link->conf.Attributes = CONF_ENABLE_IRQ;
429     link->conf.Vcc = 50;
430     link->conf.IntType = INT_MEMORY_AND_IO;
431     link->conf.ConfigIndex = 1;
432     link->conf.Present = PRESENT_OPTION;
433
434     /* Netwave private struct init. link/dev/node already taken care of,
435      * other stuff zero'd - Jean II */
436     spin_lock_init(&priv->spinlock);
437
438     /* Netwave specific entries in the device structure */
439     SET_MODULE_OWNER(dev);
440     dev->hard_start_xmit = &netwave_start_xmit;
441     dev->get_stats  = &netwave_get_stats;
442     dev->set_multicast_list = &set_multicast_list;
443     /* wireless extensions */
444     dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
445
446     dev->tx_timeout = &netwave_watchdog;
447     dev->watchdog_timeo = TX_TIMEOUT;
448
449     dev->open = &netwave_open;
450     dev->stop = &netwave_close;
451     link->irq.Instance = dev;
452     
453     /* Register with Card Services */
454     link->next = dev_list;
455     dev_list = link;
456     client_reg.dev_info = &dev_info;
457     client_reg.Version = 0x0210;
458     client_reg.event_callback_args.client_data = link;
459     ret = pcmcia_register_client(&link->handle, &client_reg);
460     if (ret != 0) {
461         cs_error(link->handle, RegisterClient, ret);
462         netwave_detach(link);
463         return NULL;
464     }
465
466     return link;
467 } /* netwave_attach */
468
469 /*
470  * Function netwave_detach (link)
471  *
472  *    This deletes a driver "instance".  The device is de-registered
473  *    with Card Services.  If it has been released, all local data
474  *    structures are freed.  Otherwise, the structures will be freed
475  *    when the device is released.
476  */
477 static void netwave_detach(dev_link_t *link)
478 {
479     struct net_device *dev = link->priv;
480     dev_link_t **linkp;
481
482     DEBUG(0, "netwave_detach(0x%p)\n", link);
483   
484     /*
485           If the device is currently configured and active, we won't
486           actually delete it yet.  Instead, it is marked so that when
487           the release() function is called, that will trigger a proper
488           detach().
489         */
490     if (link->state & DEV_CONFIG)
491         netwave_release(link);
492         
493     /* Break the link with Card Services */
494     if (link->handle)
495         pcmcia_deregister_client(link->handle);
496     
497     /* Locate device structure */
498     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
499         if (*linkp == link) break;
500     if (*linkp == NULL)
501       {
502         DEBUG(1, "netwave_cs: detach fail, '%s' not in list\n",
503               link->dev->dev_name);
504         return;
505       }
506
507     /* Unlink device structure, free pieces */
508     *linkp = link->next;
509     if (link->dev) 
510         unregister_netdev(dev);
511     free_netdev(dev);
512     
513 } /* netwave_detach */
514
515 /*
516  * Wireless Handler : get protocol name
517  */
518 static int netwave_get_name(struct net_device *dev,
519                             struct iw_request_info *info,
520                             union iwreq_data *wrqu,
521                             char *extra)
522 {
523         strcpy(wrqu->name, "Netwave");
524         return 0;
525 }
526
527 /*
528  * Wireless Handler : set Network ID
529  */
530 static int netwave_set_nwid(struct net_device *dev,
531                             struct iw_request_info *info,
532                             union iwreq_data *wrqu,
533                             char *extra)
534 {
535         unsigned long flags;
536         kio_addr_t iobase = dev->base_addr;
537         netwave_private *priv = netdev_priv(dev);
538         u_char __iomem *ramBase = priv->ramBase;
539
540         /* Disable interrupts & save flags */
541         spin_lock_irqsave(&priv->spinlock, flags);
542
543         if(!wrqu->nwid.disabled) {
544             domain = wrqu->nwid.value;
545             printk( KERN_DEBUG "Setting domain to 0x%x%02x\n", 
546                     (domain >> 8) & 0x01, domain & 0xff);
547             wait_WOC(iobase);
548             writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
549             writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
550             writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
551             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
552         }
553
554         /* ReEnable interrupts & restore flags */
555         spin_unlock_irqrestore(&priv->spinlock, flags);
556     
557         return 0;
558 }
559
560 /*
561  * Wireless Handler : get Network ID
562  */
563 static int netwave_get_nwid(struct net_device *dev,
564                             struct iw_request_info *info,
565                             union iwreq_data *wrqu,
566                             char *extra)
567 {
568         wrqu->nwid.value = domain;
569         wrqu->nwid.disabled = 0;
570         wrqu->nwid.fixed = 1;
571         return 0;
572 }
573
574 /*
575  * Wireless Handler : set scramble key
576  */
577 static int netwave_set_scramble(struct net_device *dev,
578                                 struct iw_request_info *info,
579                                 union iwreq_data *wrqu,
580                                 char *key)
581 {
582         unsigned long flags;
583         kio_addr_t iobase = dev->base_addr;
584         netwave_private *priv = netdev_priv(dev);
585         u_char __iomem *ramBase = priv->ramBase;
586
587         /* Disable interrupts & save flags */
588         spin_lock_irqsave(&priv->spinlock, flags);
589
590         scramble_key = (key[0] << 8) | key[1];
591         wait_WOC(iobase);
592         writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
593         writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
594         writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
595         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
596
597         /* ReEnable interrupts & restore flags */
598         spin_unlock_irqrestore(&priv->spinlock, flags);
599     
600         return 0;
601 }
602
603 /*
604  * Wireless Handler : get scramble key
605  */
606 static int netwave_get_scramble(struct net_device *dev,
607                                 struct iw_request_info *info,
608                                 union iwreq_data *wrqu,
609                                 char *key)
610 {
611         key[1] = scramble_key & 0xff;
612         key[0] = (scramble_key>>8) & 0xff;
613         wrqu->encoding.flags = IW_ENCODE_ENABLED;
614         wrqu->encoding.length = 2;
615         return 0;
616 }
617
618 /*
619  * Wireless Handler : get mode
620  */
621 static int netwave_get_mode(struct net_device *dev,
622                             struct iw_request_info *info,
623                             union iwreq_data *wrqu,
624                             char *extra)
625 {
626         if(domain & 0x100)
627                 wrqu->mode = IW_MODE_INFRA;
628         else
629                 wrqu->mode = IW_MODE_ADHOC;
630
631         return 0;
632 }
633
634 /*
635  * Wireless Handler : get range info
636  */
637 static int netwave_get_range(struct net_device *dev,
638                              struct iw_request_info *info,
639                              union iwreq_data *wrqu,
640                              char *extra)
641 {
642         struct iw_range *range = (struct iw_range *) extra;
643         int ret = 0;
644
645         /* Set the length (very important for backward compatibility) */
646         wrqu->data.length = sizeof(struct iw_range);
647
648         /* Set all the info we don't care or don't know about to zero */
649         memset(range, 0, sizeof(struct iw_range));
650
651         /* Set the Wireless Extension versions */
652         range->we_version_compiled = WIRELESS_EXT;
653         range->we_version_source = 9;   /* Nothing for us in v10 and v11 */
654                    
655         /* Set information in the range struct */
656         range->throughput = 450 * 1000; /* don't argue on this ! */
657         range->min_nwid = 0x0000;
658         range->max_nwid = 0x01FF;
659
660         range->num_channels = range->num_frequency = 0;
661                    
662         range->sensitivity = 0x3F;
663         range->max_qual.qual = 255;
664         range->max_qual.level = 255;
665         range->max_qual.noise = 0;
666                    
667         range->num_bitrates = 1;
668         range->bitrate[0] = 1000000;    /* 1 Mb/s */
669
670         range->encoding_size[0] = 2;            /* 16 bits scrambling */
671         range->num_encoding_sizes = 1;
672         range->max_encoding_tokens = 1; /* Only one key possible */
673
674         return ret;
675 }
676
677 /*
678  * Wireless Private Handler : get snapshot
679  */
680 static int netwave_get_snap(struct net_device *dev,
681                             struct iw_request_info *info,
682                             union iwreq_data *wrqu,
683                             char *extra)
684 {
685         unsigned long flags;
686         kio_addr_t iobase = dev->base_addr;
687         netwave_private *priv = netdev_priv(dev);
688         u_char __iomem *ramBase = priv->ramBase;
689
690         /* Disable interrupts & save flags */
691         spin_lock_irqsave(&priv->spinlock, flags);
692
693         /* Take snapshot of environment */
694         netwave_snapshot( priv, ramBase, iobase);
695         wrqu->data.length = priv->nss.length;
696         memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
697
698         priv->lastExec = jiffies;
699
700         /* ReEnable interrupts & restore flags */
701         spin_unlock_irqrestore(&priv->spinlock, flags);
702     
703         return(0);
704 }
705
706 /*
707  * Structures to export the Wireless Handlers
708  *     This is the stuff that are treated the wireless extensions (iwconfig)
709  */
710
711 static const struct iw_priv_args netwave_private_args[] = {
712 /*{ cmd,         set_args,                            get_args, name } */
713   { SIOCGIPSNAP, 0, 
714     IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey), 
715     "getsitesurvey" },
716 };
717
718 static const iw_handler         netwave_handler[] =
719 {
720         NULL,                           /* SIOCSIWNAME */
721         netwave_get_name,               /* SIOCGIWNAME */
722         netwave_set_nwid,               /* SIOCSIWNWID */
723         netwave_get_nwid,               /* SIOCGIWNWID */
724         NULL,                           /* SIOCSIWFREQ */
725         NULL,                           /* SIOCGIWFREQ */
726         NULL,                           /* SIOCSIWMODE */
727         netwave_get_mode,               /* SIOCGIWMODE */
728         NULL,                           /* SIOCSIWSENS */
729         NULL,                           /* SIOCGIWSENS */
730         NULL,                           /* SIOCSIWRANGE */
731         netwave_get_range,              /* SIOCGIWRANGE */
732         NULL,                           /* SIOCSIWPRIV */
733         NULL,                           /* SIOCGIWPRIV */
734         NULL,                           /* SIOCSIWSTATS */
735         NULL,                           /* SIOCGIWSTATS */
736         NULL,                           /* SIOCSIWSPY */
737         NULL,                           /* SIOCGIWSPY */
738         NULL,                           /* -- hole -- */
739         NULL,                           /* -- hole -- */
740         NULL,                           /* SIOCSIWAP */
741         NULL,                           /* SIOCGIWAP */
742         NULL,                           /* -- hole -- */
743         NULL,                           /* SIOCGIWAPLIST */
744         NULL,                           /* -- hole -- */
745         NULL,                           /* -- hole -- */
746         NULL,                           /* SIOCSIWESSID */
747         NULL,                           /* SIOCGIWESSID */
748         NULL,                           /* SIOCSIWNICKN */
749         NULL,                           /* SIOCGIWNICKN */
750         NULL,                           /* -- hole -- */
751         NULL,                           /* -- hole -- */
752         NULL,                           /* SIOCSIWRATE */
753         NULL,                           /* SIOCGIWRATE */
754         NULL,                           /* SIOCSIWRTS */
755         NULL,                           /* SIOCGIWRTS */
756         NULL,                           /* SIOCSIWFRAG */
757         NULL,                           /* SIOCGIWFRAG */
758         NULL,                           /* SIOCSIWTXPOW */
759         NULL,                           /* SIOCGIWTXPOW */
760         NULL,                           /* SIOCSIWRETRY */
761         NULL,                           /* SIOCGIWRETRY */
762         netwave_set_scramble,           /* SIOCSIWENCODE */
763         netwave_get_scramble,           /* SIOCGIWENCODE */
764 };
765
766 static const iw_handler         netwave_private_handler[] =
767 {
768         NULL,                           /* SIOCIWFIRSTPRIV */
769         netwave_get_snap,               /* SIOCIWFIRSTPRIV + 1 */
770 };
771
772 static const struct iw_handler_def      netwave_handler_def =
773 {
774         .num_standard   = sizeof(netwave_handler)/sizeof(iw_handler),
775         .num_private    = sizeof(netwave_private_handler)/sizeof(iw_handler),
776         .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
777         .standard       = (iw_handler *) netwave_handler,
778         .private        = (iw_handler *) netwave_private_handler,
779         .private_args   = (struct iw_priv_args *) netwave_private_args,
780         .get_wireless_stats = netwave_get_wireless_stats,
781 };
782
783 /*
784  * Function netwave_pcmcia_config (link)
785  *
786  *     netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION 
787  *     event is received, to configure the PCMCIA socket, and to make the
788  *     device available to the system. 
789  *
790  */
791
792 #define CS_CHECK(fn, ret) \
793 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
794
795 static void netwave_pcmcia_config(dev_link_t *link) {
796     client_handle_t handle = link->handle;
797     struct net_device *dev = link->priv;
798     netwave_private *priv = netdev_priv(dev);
799     tuple_t tuple;
800     cisparse_t parse;
801     int i, j, last_ret, last_fn;
802     u_char buf[64];
803     win_req_t req;
804     memreq_t mem;
805     u_char __iomem *ramBase = NULL;
806
807     DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
808
809     /*
810       This reads the card's CONFIG tuple to find its configuration
811       registers.
812     */
813     tuple.Attributes = 0;
814     tuple.TupleData = (cisdata_t *) buf;
815     tuple.TupleDataMax = 64;
816     tuple.TupleOffset = 0;
817     tuple.DesiredTuple = CISTPL_CONFIG;
818     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
819     CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
820     CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
821     link->conf.ConfigBase = parse.config.base;
822     link->conf.Present = parse.config.rmask[0];
823
824     /* Configure card */
825     link->state |= DEV_CONFIG;
826
827     /*
828      *  Try allocating IO ports.  This tries a few fixed addresses.
829      *  If you want, you can also read the card's config table to
830      *  pick addresses -- see the serial driver for an example.
831      */
832     for (i = j = 0x0; j < 0x400; j += 0x20) {
833         link->io.BasePort1 = j ^ 0x300;
834         i = pcmcia_request_io(link->handle, &link->io);
835         if (i == CS_SUCCESS) break;
836     }
837     if (i != CS_SUCCESS) {
838         cs_error(link->handle, RequestIO, i);
839         goto failed;
840     }
841
842     /*
843      *  Now allocate an interrupt line.  Note that this does not
844      *  actually assign a handler to the interrupt.
845      */
846     CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
847
848     /*
849      *  This actually configures the PCMCIA socket -- setting up
850      *  the I/O windows and the interrupt mapping.
851      */
852     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
853
854     /*
855      *  Allocate a 32K memory window.  Note that the dev_link_t
856      *  structure provides space for one window handle -- if your
857      *  device needs several windows, you'll need to keep track of
858      *  the handles in your private data structure, dev->priv.
859      */
860     DEBUG(1, "Setting mem speed of %d\n", mem_speed);
861
862     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
863     req.Base = 0; req.Size = 0x8000;
864     req.AccessSpeed = mem_speed;
865     CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &link->win));
866     mem.CardOffset = 0x20000; mem.Page = 0; 
867     CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
868
869     /* Store base address of the common window frame */
870     ramBase = ioremap(req.Base, 0x8000);
871     priv->ramBase = ramBase;
872
873     dev->irq = link->irq.AssignedIRQ;
874     dev->base_addr = link->io.BasePort1;
875     SET_NETDEV_DEV(dev, &handle_to_dev(handle));
876
877     if (register_netdev(dev) != 0) {
878         printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
879         goto failed;
880     }
881
882     strcpy(priv->node.dev_name, dev->name);
883     link->dev = &priv->node;
884     link->state &= ~DEV_CONFIG_PENDING;
885
886     /* Reset card before reading physical address */
887     netwave_doreset(dev->base_addr, ramBase);
888
889     /* Read the ethernet address and fill in the Netwave registers. */
890     for (i = 0; i < 6; i++) 
891         dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
892
893     printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
894            "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
895            (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
896            (int) readb(ramBase+NETWAVE_EREG_NI+1));
897     for (i = 0; i < 6; i++)
898         printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
899
900     /* get revision words */
901     printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n", 
902            get_uint16(ramBase + NETWAVE_EREG_ARW),
903            get_uint16(ramBase + NETWAVE_EREG_ARW+2));
904     return;
905
906 cs_failed:
907     cs_error(link->handle, last_fn, last_ret);
908 failed:
909     netwave_release(link);
910 } /* netwave_pcmcia_config */
911
912 /*
913  * Function netwave_release (arg)
914  *
915  *    After a card is removed, netwave_release() will unregister the net
916  *    device, and release the PCMCIA configuration.  If the device is
917  *    still open, this will be postponed until it is closed.
918  */
919 static void netwave_release(dev_link_t *link)
920 {
921     struct net_device *dev = link->priv;
922     netwave_private *priv = netdev_priv(dev);
923
924     DEBUG(0, "netwave_release(0x%p)\n", link);
925
926     /* Don't bother checking to see if these succeed or not */
927     if (link->win) {
928         iounmap(priv->ramBase);
929         pcmcia_release_window(link->win);
930     }
931     pcmcia_release_configuration(link->handle);
932     pcmcia_release_io(link->handle, &link->io);
933     pcmcia_release_irq(link->handle, &link->irq);
934
935     link->state &= ~DEV_CONFIG;
936 }
937
938 /*
939  * Function netwave_event (event, priority, args)
940  *
941  *    The card status event handler.  Mostly, this schedules other
942  *    stuff to run after an event is received.  A CARD_REMOVAL event
943  *    also sets some flags to discourage the net drivers from trying
944  *    to talk to the card any more.
945  *
946  *    When a CARD_REMOVAL event is received, we immediately set a flag
947  *    to block future accesses to this device.  All the functions that
948  *    actually access the device should check this flag to make sure
949  *    the card is still present.
950  *
951  */
952 static int netwave_event(event_t event, int priority,
953                          event_callback_args_t *args)
954 {
955     dev_link_t *link = args->client_data;
956     struct net_device *dev = link->priv;
957         
958     DEBUG(1, "netwave_event(0x%06x)\n", event);
959   
960     switch (event) {
961     case CS_EVENT_REGISTRATION_COMPLETE:
962         DEBUG(0, "netwave_cs: registration complete\n");
963         break;
964
965     case CS_EVENT_CARD_REMOVAL:
966         link->state &= ~DEV_PRESENT;
967         if (link->state & DEV_CONFIG) {
968             netif_device_detach(dev);
969             netwave_release(link);
970         }
971         break;
972     case CS_EVENT_CARD_INSERTION:
973         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
974         netwave_pcmcia_config( link);
975         break;
976     case CS_EVENT_PM_SUSPEND:
977         link->state |= DEV_SUSPEND;
978         /* Fall through... */
979     case CS_EVENT_RESET_PHYSICAL:
980         if (link->state & DEV_CONFIG) {
981             if (link->open)
982                 netif_device_detach(dev);
983             pcmcia_release_configuration(link->handle);
984         }
985         break;
986     case CS_EVENT_PM_RESUME:
987         link->state &= ~DEV_SUSPEND;
988         /* Fall through... */
989     case CS_EVENT_CARD_RESET:
990         if (link->state & DEV_CONFIG) {
991             pcmcia_request_configuration(link->handle, &link->conf);
992             if (link->open) {
993                 netwave_reset(dev);
994                 netif_device_attach(dev);
995             }
996         }
997         break;
998     }
999     return 0;
1000 } /* netwave_event */
1001
1002 /*
1003  * Function netwave_doreset (ioBase, ramBase)
1004  *
1005  *    Proper hardware reset of the card.
1006  */
1007 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
1008 {
1009     /* Reset card */
1010     wait_WOC(ioBase);
1011     outb(0x80, ioBase + NETWAVE_REG_PMR);
1012     writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
1013     outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
1014 }
1015
1016 /*
1017  * Function netwave_reset (dev)
1018  *
1019  *    Reset and restore all of the netwave registers 
1020  */
1021 static void netwave_reset(struct net_device *dev) {
1022     /* u_char state; */
1023     netwave_private *priv = netdev_priv(dev);
1024     u_char __iomem *ramBase = priv->ramBase;
1025     kio_addr_t iobase = dev->base_addr;
1026
1027     DEBUG(0, "netwave_reset: Done with hardware reset\n");
1028
1029     priv->timeoutCounter = 0;
1030
1031     /* Reset card */
1032     netwave_doreset(iobase, ramBase);
1033     printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
1034         
1035     /* Write a NOP to check the card */
1036     wait_WOC(iobase);
1037     writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
1038     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1039         
1040     /* Set receive conf */
1041     wait_WOC(iobase);
1042     writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1043     writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
1044     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1045     
1046     /* Set transmit conf */
1047     wait_WOC(iobase);
1048     writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
1049     writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
1050     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1051     
1052     /* Now set the MU Domain */
1053     printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
1054     wait_WOC(iobase);
1055     writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
1056     writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1057     writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
1058     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1059         
1060     /* Set scramble key */
1061     printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
1062     wait_WOC(iobase);
1063     writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
1064     writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1065     writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1066     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1067
1068     /* Enable interrupts, bit 4 high to keep unused
1069      * source from interrupting us, bit 2 high to 
1070      * set interrupt enable, 567 to enable TxDN, 
1071      * RxErr and RxRdy
1072      */
1073     wait_WOC(iobase);
1074     outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
1075
1076     /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
1077      * waitWOC
1078      * skriv 80 til d000:3688
1079      * sjekk om det ble 80
1080      */
1081     
1082     /* Enable Receiver */
1083     wait_WOC(iobase);
1084     writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
1085     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1086         
1087     /* Set the IENA bit in COR */
1088     wait_WOC(iobase);
1089     outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
1090 }
1091
1092 /*
1093  * Function netwave_hw_xmit (data, len, dev)    
1094  */
1095 static int netwave_hw_xmit(unsigned char* data, int len,
1096                            struct net_device* dev) {
1097     unsigned long flags;
1098     unsigned int TxFreeList,
1099                  curBuff,
1100                  MaxData, 
1101                  DataOffset;
1102     int tmpcount; 
1103         
1104     netwave_private *priv = netdev_priv(dev);
1105     u_char __iomem * ramBase = priv->ramBase;
1106     kio_addr_t iobase = dev->base_addr;
1107
1108     /* Disable interrupts & save flags */
1109     spin_lock_irqsave(&priv->spinlock, flags);
1110
1111     /* Check if there are transmit buffers available */
1112     wait_WOC(iobase);
1113     if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
1114         /* No buffers available */
1115         printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
1116                dev->name);
1117         spin_unlock_irqrestore(&priv->spinlock, flags);
1118         return 1;
1119     }
1120
1121     priv->stats.tx_bytes += len;
1122
1123     DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
1124           readb(ramBase + NETWAVE_EREG_SPCQ),
1125           readb(ramBase + NETWAVE_EREG_SPU),
1126           readb(ramBase + NETWAVE_EREG_LIF),
1127           readb(ramBase + NETWAVE_EREG_ISPLQ));
1128
1129     /* Now try to insert it into the adapters free memory */
1130     wait_WOC(iobase);
1131     TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1132     MaxData    = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1133     DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1134         
1135     DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1136           TxFreeList, MaxData, DataOffset);
1137
1138     /* Copy packet to the adapter fragment buffers */
1139     curBuff = TxFreeList; 
1140     tmpcount = 0; 
1141     while (tmpcount < len) {
1142         int tmplen = len - tmpcount; 
1143         copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount, 
1144                    (tmplen < MaxData) ? tmplen : MaxData);
1145         tmpcount += MaxData;
1146                         
1147         /* Advance to next buffer */
1148         curBuff = get_uint16(ramBase + curBuff);
1149     }
1150     
1151     /* Now issue transmit list */
1152     wait_WOC(iobase);
1153     writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1154     writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1155     writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1156     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1157
1158     spin_unlock_irqrestore(&priv->spinlock, flags);
1159     return 0;
1160 }
1161
1162 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1163         /* This flag indicate that the hardware can't perform a transmission.
1164          * Theoritically, NET3 check it before sending a packet to the driver,
1165          * but in fact it never do that and pool continuously.
1166          * As the watchdog will abort too long transmissions, we are quite safe...
1167          */
1168
1169     netif_stop_queue(dev);
1170
1171     {
1172         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1173         unsigned char* buf = skb->data;
1174         
1175         if (netwave_hw_xmit( buf, length, dev) == 1) {
1176             /* Some error, let's make them call us another time? */
1177             netif_start_queue(dev);
1178         }
1179         dev->trans_start = jiffies;
1180     }
1181     dev_kfree_skb(skb);
1182     
1183     return 0;
1184 } /* netwave_start_xmit */
1185
1186 /*
1187  * Function netwave_interrupt (irq, dev_id, regs)
1188  *
1189  *    This function is the interrupt handler for the Netwave card. This
1190  *    routine will be called whenever: 
1191  *        1. A packet is received.
1192  *        2. A packet has successfully been transferred and the unit is
1193  *           ready to transmit another packet.
1194  *        3. A command has completed execution.
1195  */
1196 static irqreturn_t netwave_interrupt(int irq, void* dev_id, struct pt_regs *regs)
1197 {
1198     kio_addr_t iobase;
1199     u_char __iomem *ramBase;
1200     struct net_device *dev = (struct net_device *)dev_id;
1201     struct netwave_private *priv = netdev_priv(dev);
1202     dev_link_t *link = &priv->link;
1203     int i;
1204     
1205     if (!netif_device_present(dev))
1206         return IRQ_NONE;
1207     
1208     iobase = dev->base_addr;
1209     ramBase = priv->ramBase;
1210         
1211     /* Now find what caused the interrupt, check while interrupts ready */
1212     for (i = 0; i < 10; i++) {
1213         u_char status;
1214                 
1215         wait_WOC(iobase);       
1216         if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1217             break; /* None of the interrupt sources asserted (normal exit) */
1218         
1219         status = inb(iobase + NETWAVE_REG_ASR);
1220                 
1221         if (!DEV_OK(link)) {
1222             DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1223                   "from removed or suspended card!\n", status);
1224             break;
1225         }
1226                 
1227         /* RxRdy */
1228         if (status & 0x80) {
1229             netwave_rx(dev);
1230             /* wait_WOC(iobase); */
1231             /* RxRdy cannot be reset directly by the host */
1232         }
1233         /* RxErr */
1234         if (status & 0x40) {
1235             u_char rser;
1236                         
1237             rser = readb(ramBase + NETWAVE_EREG_RSER);                  
1238             
1239             if (rser & 0x04) {
1240                 ++priv->stats.rx_dropped; 
1241                 ++priv->stats.rx_crc_errors;
1242             }
1243             if (rser & 0x02)
1244                 ++priv->stats.rx_frame_errors;
1245                         
1246             /* Clear the RxErr bit in RSER. RSER+4 is the
1247              * write part. Also clear the RxCRC (0x04) and 
1248              * RxBig (0x02) bits if present */
1249             wait_WOC(iobase);
1250             writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1251
1252             /* Write bit 6 high to ASCC to clear RxErr in ASR,
1253              * WOC must be set first! 
1254              */
1255             wait_WOC(iobase);
1256             writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1257
1258             /* Remember to count up priv->stats on error packets */
1259             ++priv->stats.rx_errors;
1260         }
1261         /* TxDN */
1262         if (status & 0x20) {
1263             int txStatus;
1264
1265             txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1266             DEBUG(3, "Transmit done. TSER = %x id %x\n", 
1267                   txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1268             
1269             if (txStatus & 0x20) {
1270                 /* Transmitting was okay, clear bits */
1271                 wait_WOC(iobase);
1272                 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1273                 ++priv->stats.tx_packets;
1274             }
1275                         
1276             if (txStatus & 0xd0) {
1277                 if (txStatus & 0x80) {
1278                     ++priv->stats.collisions; /* Because of /proc/net/dev*/
1279                     /* ++priv->stats.tx_aborted_errors; */
1280                     /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1281                 }
1282                 if (txStatus & 0x40) 
1283                     ++priv->stats.tx_carrier_errors;
1284                 /* 0x80 TxGU Transmit giveup - nine times and no luck
1285                  * 0x40 TxNOAP No access point. Discarded packet.
1286                  * 0x10 TxErr Transmit error. Always set when 
1287                  *      TxGU and TxNOAP is set. (Those are the only ones
1288                  *      to set TxErr).
1289                  */
1290                 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n", 
1291                       txStatus);
1292                 
1293                 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1294                 wait_WOC(iobase);
1295                 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1296                 ++priv->stats.tx_errors;
1297             }
1298             DEBUG(3, "New status is TSER %x ASR %x\n",
1299                   readb(ramBase + NETWAVE_EREG_TSER),
1300                   inb(iobase + NETWAVE_REG_ASR));
1301
1302             netif_wake_queue(dev);
1303         }
1304         /* TxBA, this would trigger on all error packets received */
1305         /* if (status & 0x01) {
1306            DEBUG(4, "Transmit buffers available, %x\n", status);
1307            }
1308            */
1309     }
1310     /* Handled if we looped at least one time - Jean II */
1311     return IRQ_RETVAL(i);
1312 } /* netwave_interrupt */
1313
1314 /*
1315  * Function netwave_watchdog (a)
1316  *
1317  *    Watchdog : when we start a transmission, we set a timer in the
1318  *    kernel.  If the transmission complete, this timer is disabled. If
1319  *    it expire, we reset the card.
1320  *
1321  */
1322 static void netwave_watchdog(struct net_device *dev) {
1323
1324     DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1325     netwave_reset(dev);
1326     dev->trans_start = jiffies;
1327     netif_wake_queue(dev);
1328 } /* netwave_watchdog */
1329
1330 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1331     netwave_private *priv = netdev_priv(dev);
1332
1333     update_stats(dev);
1334
1335     DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1336           " %x tx %x %x %x %x\n", 
1337           readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1338           readb(priv->ramBase + NETWAVE_EREG_SPU),
1339           readb(priv->ramBase + NETWAVE_EREG_LIF),
1340           readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1341           readb(priv->ramBase + NETWAVE_EREG_MHS),
1342           readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1343           readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1344           readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1345           readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1346           readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1347           readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1348
1349     return &priv->stats;
1350 }
1351
1352 static void update_stats(struct net_device *dev) {
1353     //unsigned long flags;
1354 /*     netwave_private *priv = netdev_priv(dev); */
1355
1356     //spin_lock_irqsave(&priv->spinlock, flags);
1357
1358 /*    priv->stats.rx_packets = readb(priv->ramBase + 0x18e); 
1359     priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1360
1361     //spin_unlock_irqrestore(&priv->spinlock, flags);
1362 }
1363
1364 static int netwave_rx(struct net_device *dev)
1365 {
1366     netwave_private *priv = netdev_priv(dev);
1367     u_char __iomem *ramBase = priv->ramBase;
1368     kio_addr_t iobase = dev->base_addr;
1369     u_char rxStatus;
1370     struct sk_buff *skb = NULL;
1371     unsigned int curBuffer,
1372                 rcvList;
1373     int rcvLen;
1374     int tmpcount = 0;
1375     int dataCount, dataOffset;
1376     int i;
1377     u_char *ptr;
1378         
1379     DEBUG(3, "xinw_rx: Receiving ... \n");
1380
1381     /* Receive max 10 packets for now. */
1382     for (i = 0; i < 10; i++) {
1383         /* Any packets? */
1384         wait_WOC(iobase);
1385         rxStatus = readb(ramBase + NETWAVE_EREG_RSER);          
1386         if ( !( rxStatus & 0x80)) /* No more packets */
1387             break;
1388                 
1389         /* Check if multicast/broadcast or other */
1390         /* multicast = (rxStatus & 0x20);  */
1391                 
1392         /* The receive list pointer and length of the packet */
1393         wait_WOC(iobase);
1394         rcvLen  = get_int16( ramBase + NETWAVE_EREG_RDP);
1395         rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1396                 
1397         if (rcvLen < 0) {
1398             printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n", 
1399                    rcvLen);
1400             return 0;
1401         }
1402                 
1403         skb = dev_alloc_skb(rcvLen+5);
1404         if (skb == NULL) {
1405             DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1406                   "length %d\n", rcvLen);
1407             ++priv->stats.rx_dropped; 
1408             /* Tell the adapter to skip the packet */
1409             wait_WOC(iobase);
1410             writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1411             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1412             return 0;
1413         }
1414
1415         skb_reserve( skb, 2);  /* Align IP on 16 byte */
1416         skb_put( skb, rcvLen);
1417         skb->dev = dev;
1418
1419         /* Copy packet fragments to the skb data area */
1420         ptr = (u_char*) skb->data;
1421         curBuffer = rcvList;
1422         tmpcount = 0; 
1423         while ( tmpcount < rcvLen) {
1424             /* Get length and offset of current buffer */
1425             dataCount  = get_uint16( ramBase+curBuffer+2);
1426             dataOffset = get_uint16( ramBase+curBuffer+4);
1427                 
1428             copy_from_pc( ptr + tmpcount,
1429                           ramBase+curBuffer+dataOffset, dataCount);
1430
1431             tmpcount += dataCount;
1432                 
1433             /* Point to next buffer */
1434             curBuffer = get_uint16(ramBase + curBuffer);
1435         }
1436         
1437         skb->protocol = eth_type_trans(skb,dev);
1438         /* Queue packet for network layer */
1439         netif_rx(skb);
1440
1441         dev->last_rx = jiffies;
1442         priv->stats.rx_packets++;
1443         priv->stats.rx_bytes += rcvLen;
1444
1445         /* Got the packet, tell the adapter to skip it */
1446         wait_WOC(iobase);
1447         writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1448         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1449         DEBUG(3, "Packet reception ok\n");
1450     }
1451     return 0;
1452 }
1453
1454 static int netwave_open(struct net_device *dev) {
1455     netwave_private *priv = netdev_priv(dev);
1456     dev_link_t *link = &priv->link;
1457
1458     DEBUG(1, "netwave_open: starting.\n");
1459     
1460     if (!DEV_OK(link))
1461         return -ENODEV;
1462
1463     link->open++;
1464
1465     netif_start_queue(dev);
1466     netwave_reset(dev);
1467         
1468     return 0;
1469 }
1470
1471 static int netwave_close(struct net_device *dev) {
1472     netwave_private *priv = netdev_priv(dev);
1473     dev_link_t *link = &priv->link;
1474
1475     DEBUG(1, "netwave_close: finishing.\n");
1476
1477     link->open--;
1478     netif_stop_queue(dev);
1479
1480     return 0;
1481 }
1482
1483 static struct pcmcia_device_id netwave_ids[] = {
1484         PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1485         PCMCIA_DEVICE_NULL,
1486 };
1487 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1488
1489 static struct pcmcia_driver netwave_driver = {
1490         .owner          = THIS_MODULE,
1491         .drv            = {
1492                 .name   = "netwave_cs",
1493         },
1494         .attach         = netwave_attach,
1495         .event          = netwave_event,
1496         .detach         = netwave_detach,
1497         .id_table       = netwave_ids,
1498 };
1499
1500 static int __init init_netwave_cs(void)
1501 {
1502         return pcmcia_register_driver(&netwave_driver);
1503 }
1504
1505 static void __exit exit_netwave_cs(void)
1506 {
1507         pcmcia_unregister_driver(&netwave_driver);
1508         BUG_ON(dev_list != NULL);
1509 }
1510
1511 module_init(init_netwave_cs);
1512 module_exit(exit_netwave_cs);
1513
1514 /* Set or clear the multicast filter for this adaptor.
1515    num_addrs == -1      Promiscuous mode, receive all packets
1516    num_addrs == 0       Normal mode, clear multicast list
1517    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
1518    best-effort filtering.
1519  */
1520 static void set_multicast_list(struct net_device *dev)
1521 {
1522     kio_addr_t iobase = dev->base_addr;
1523     netwave_private *priv = netdev_priv(dev);
1524     u_char __iomem * ramBase = priv->ramBase;
1525     u_char  rcvMode = 0;
1526    
1527 #ifdef PCMCIA_DEBUG
1528     if (pc_debug > 2) {
1529         static int old;
1530         if (old != dev->mc_count) {
1531             old = dev->mc_count;
1532             DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1533                   dev->name, dev->mc_count);
1534         }
1535     }
1536 #endif
1537         
1538     if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1539         /* Multicast Mode */
1540         rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1541     } else if (dev->flags & IFF_PROMISC) {
1542         /* Promiscous mode */
1543         rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1544     } else {
1545         /* Normal mode */
1546         rcvMode = rxConfRxEna + rxConfBcast;
1547     }
1548         
1549     /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1550     /* Now set receive mode */
1551     wait_WOC(iobase);
1552     writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1553     writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1554     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1555 }
1556 MODULE_LICENSE("GPL");