]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/wireless/netwave_cs.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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