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