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