?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[MTD] Remove gratuitous inclusion of ARM-only header from physmap.c
[linux-2.6/mini2440.git] / drivers / net / wireless / netwave_cs.c
blob9343d970537beca857ac12242580e099218d2689
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(struct pcmcia_device *link); /* Card removal */
194 static int netwave_pcmcia_config(struct pcmcia_device *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 struct pcmcia_device 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 struct pcmcia_device 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 struct pcmcia_device
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_probe(struct pcmcia_device *link)
380 {
381 struct net_device *dev;
382 netwave_private *priv;
383
384 DEBUG(0, "netwave_attach()\n");
385
386 /* Initialize the struct pcmcia_device structure */
387 dev = alloc_etherdev(sizeof(netwave_private));
388 if (!dev)
389 return -ENOMEM;
390 priv = netdev_priv(dev);
391 priv->p_dev = link;
392 link->priv = dev;
393
394 /* The io structure describes IO port mapping */
395 link->io.NumPorts1 = 16;
396 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
397 /* link->io.NumPorts2 = 16;
398 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
399 link->io.IOAddrLines = 5;
400
401 /* Interrupt setup */
402 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
403 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
404 link->irq.Handler = &netwave_interrupt;
405
406 /* General socket configuration */
407 link->conf.Attributes = CONF_ENABLE_IRQ;
408 link->conf.IntType = INT_MEMORY_AND_IO;
409 link->conf.ConfigIndex = 1;
410 link->conf.Present = PRESENT_OPTION;
411
412 /* Netwave private struct init. link/dev/node already taken care of,
413 * other stuff zero'd - Jean II */
414 spin_lock_init(&priv->spinlock);
415
416 /* Netwave specific entries in the device structure */
417 SET_MODULE_OWNER(dev);
418 dev->hard_start_xmit = &netwave_start_xmit;
419 dev->get_stats = &netwave_get_stats;
420 dev->set_multicast_list = &set_multicast_list;
421 /* wireless extensions */
422 dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
423
424 dev->tx_timeout = &netwave_watchdog;
425 dev->watchdog_timeo = TX_TIMEOUT;
426
427 dev->open = &netwave_open;
428 dev->stop = &netwave_close;
429 link->irq.Instance = dev;
430
431 return netwave_pcmcia_config( link);
432 } /* netwave_attach */
433
434 /*
435 * Function netwave_detach (link)
436 *
437 * This deletes a driver "instance". The device is de-registered
438 * with Card Services. If it has been released, all local data
439 * structures are freed. Otherwise, the structures will be freed
440 * when the device is released.
441 */
442 static void netwave_detach(struct pcmcia_device *link)
443 {
444 struct net_device *dev = link->priv;
445
446 DEBUG(0, "netwave_detach(0x%p)\n", link);
447
448 netwave_release(link);
449
450 if (link->dev_node)
451 unregister_netdev(dev);
452
453 free_netdev(dev);
454 } /* netwave_detach */
455
456 /*
457 * Wireless Handler : get protocol name
458 */
459 static int netwave_get_name(struct net_device *dev,
460 struct iw_request_info *info,
461 union iwreq_data *wrqu,
462 char *extra)
463 {
464 strcpy(wrqu->name, "Netwave");
465 return 0;
466 }
467
468 /*
469 * Wireless Handler : set Network ID
470 */
471 static int netwave_set_nwid(struct net_device *dev,
472 struct iw_request_info *info,
473 union iwreq_data *wrqu,
474 char *extra)
475 {
476 unsigned long flags;
477 kio_addr_t iobase = dev->base_addr;
478 netwave_private *priv = netdev_priv(dev);
479 u_char __iomem *ramBase = priv->ramBase;
480
481 /* Disable interrupts & save flags */
482 spin_lock_irqsave(&priv->spinlock, flags);
483
484 if(!wrqu->nwid.disabled) {
485 domain = wrqu->nwid.value;
486 printk( KERN_DEBUG "Setting domain to 0x%x%02x\n",
487 (domain >> 8) & 0x01, domain & 0xff);
488 wait_WOC(iobase);
489 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
490 writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
491 writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
492 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
493 }
494
495 /* ReEnable interrupts & restore flags */
496 spin_unlock_irqrestore(&priv->spinlock, flags);
497
498 return 0;
499 }
500
501 /*
502 * Wireless Handler : get Network ID
503 */
504 static int netwave_get_nwid(struct net_device *dev,
505 struct iw_request_info *info,
506 union iwreq_data *wrqu,
507 char *extra)
508 {
509 wrqu->nwid.value = domain;
510 wrqu->nwid.disabled = 0;
511 wrqu->nwid.fixed = 1;
512 return 0;
513 }
514
515 /*
516 * Wireless Handler : set scramble key
517 */
518 static int netwave_set_scramble(struct net_device *dev,
519 struct iw_request_info *info,
520 union iwreq_data *wrqu,
521 char *key)
522 {
523 unsigned long flags;
524 kio_addr_t iobase = dev->base_addr;
525 netwave_private *priv = netdev_priv(dev);
526 u_char __iomem *ramBase = priv->ramBase;
527
528 /* Disable interrupts & save flags */
529 spin_lock_irqsave(&priv->spinlock, flags);
530
531 scramble_key = (key[0] << 8) | key[1];
532 wait_WOC(iobase);
533 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
534 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
535 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
536 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
537
538 /* ReEnable interrupts & restore flags */
539 spin_unlock_irqrestore(&priv->spinlock, flags);
540
541 return 0;
542 }
543
544 /*
545 * Wireless Handler : get scramble key
546 */
547 static int netwave_get_scramble(struct net_device *dev,
548 struct iw_request_info *info,
549 union iwreq_data *wrqu,
550 char *key)
551 {
552 key[1] = scramble_key & 0xff;
553 key[0] = (scramble_key>>8) & 0xff;
554 wrqu->encoding.flags = IW_ENCODE_ENABLED;
555 wrqu->encoding.length = 2;
556 return 0;
557 }
558
559 /*
560 * Wireless Handler : get mode
561 */
562 static int netwave_get_mode(struct net_device *dev,
563 struct iw_request_info *info,
564 union iwreq_data *wrqu,
565 char *extra)
566 {
567 if(domain & 0x100)
568 wrqu->mode = IW_MODE_INFRA;
569 else
570 wrqu->mode = IW_MODE_ADHOC;
571
572 return 0;
573 }
574
575 /*
576 * Wireless Handler : get range info
577 */
578 static int netwave_get_range(struct net_device *dev,
579 struct iw_request_info *info,
580 union iwreq_data *wrqu,
581 char *extra)
582 {
583 struct iw_range *range = (struct iw_range *) extra;
584 int ret = 0;
585
586 /* Set the length (very important for backward compatibility) */
587 wrqu->data.length = sizeof(struct iw_range);
588
589 /* Set all the info we don't care or don't know about to zero */
590 memset(range, 0, sizeof(struct iw_range));
591
592 /* Set the Wireless Extension versions */
593 range->we_version_compiled = WIRELESS_EXT;
594 range->we_version_source = 9; /* Nothing for us in v10 and v11 */
595
596 /* Set information in the range struct */
597 range->throughput = 450 * 1000; /* don't argue on this ! */
598 range->min_nwid = 0x0000;
599 range->max_nwid = 0x01FF;
600
601 range->num_channels = range->num_frequency = 0;
602
603 range->sensitivity = 0x3F;
604 range->max_qual.qual = 255;
605 range->max_qual.level = 255;
606 range->max_qual.noise = 0;
607
608 range->num_bitrates = 1;
609 range->bitrate[0] = 1000000; /* 1 Mb/s */
610
611 range->encoding_size[0] = 2; /* 16 bits scrambling */
612 range->num_encoding_sizes = 1;
613 range->max_encoding_tokens = 1; /* Only one key possible */
614
615 return ret;
616 }
617
618 /*
619 * Wireless Private Handler : get snapshot
620 */
621 static int netwave_get_snap(struct net_device *dev,
622 struct iw_request_info *info,
623 union iwreq_data *wrqu,
624 char *extra)
625 {
626 unsigned long flags;
627 kio_addr_t iobase = dev->base_addr;
628 netwave_private *priv = netdev_priv(dev);
629 u_char __iomem *ramBase = priv->ramBase;
630
631 /* Disable interrupts & save flags */
632 spin_lock_irqsave(&priv->spinlock, flags);
633
634 /* Take snapshot of environment */
635 netwave_snapshot( priv, ramBase, iobase);
636 wrqu->data.length = priv->nss.length;
637 memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
638
639 priv->lastExec = jiffies;
640
641 /* ReEnable interrupts & restore flags */
642 spin_unlock_irqrestore(&priv->spinlock, flags);
643
644 return(0);
645 }
646
647 /*
648 * Structures to export the Wireless Handlers
649 * This is the stuff that are treated the wireless extensions (iwconfig)
650 */
651
652 static const struct iw_priv_args netwave_private_args[] = {
653 /*{ cmd, set_args, get_args, name } */
654 { SIOCGIPSNAP, 0,
655 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey),
656 "getsitesurvey" },
657 };
658
659 static const iw_handler netwave_handler[] =
660 {
661 NULL, /* SIOCSIWNAME */
662 netwave_get_name, /* SIOCGIWNAME */
663 netwave_set_nwid, /* SIOCSIWNWID */
664 netwave_get_nwid, /* SIOCGIWNWID */
665 NULL, /* SIOCSIWFREQ */
666 NULL, /* SIOCGIWFREQ */
667 NULL, /* SIOCSIWMODE */
668 netwave_get_mode, /* SIOCGIWMODE */
669 NULL, /* SIOCSIWSENS */
670 NULL, /* SIOCGIWSENS */
671 NULL, /* SIOCSIWRANGE */
672 netwave_get_range, /* SIOCGIWRANGE */
673 NULL, /* SIOCSIWPRIV */
674 NULL, /* SIOCGIWPRIV */
675 NULL, /* SIOCSIWSTATS */
676 NULL, /* SIOCGIWSTATS */
677 NULL, /* SIOCSIWSPY */
678 NULL, /* SIOCGIWSPY */
679 NULL, /* -- hole -- */
680 NULL, /* -- hole -- */
681 NULL, /* SIOCSIWAP */
682 NULL, /* SIOCGIWAP */
683 NULL, /* -- hole -- */
684 NULL, /* SIOCGIWAPLIST */
685 NULL, /* -- hole -- */
686 NULL, /* -- hole -- */
687 NULL, /* SIOCSIWESSID */
688 NULL, /* SIOCGIWESSID */
689 NULL, /* SIOCSIWNICKN */
690 NULL, /* SIOCGIWNICKN */
691 NULL, /* -- hole -- */
692 NULL, /* -- hole -- */
693 NULL, /* SIOCSIWRATE */
694 NULL, /* SIOCGIWRATE */
695 NULL, /* SIOCSIWRTS */
696 NULL, /* SIOCGIWRTS */
697 NULL, /* SIOCSIWFRAG */
698 NULL, /* SIOCGIWFRAG */
699 NULL, /* SIOCSIWTXPOW */
700 NULL, /* SIOCGIWTXPOW */
701 NULL, /* SIOCSIWRETRY */
702 NULL, /* SIOCGIWRETRY */
703 netwave_set_scramble, /* SIOCSIWENCODE */
704 netwave_get_scramble, /* SIOCGIWENCODE */
705 };
706
707 static const iw_handler netwave_private_handler[] =
708 {
709 NULL, /* SIOCIWFIRSTPRIV */
710 netwave_get_snap, /* SIOCIWFIRSTPRIV + 1 */
711 };
712
713 static const struct iw_handler_def netwave_handler_def =
714 {
715 .num_standard = sizeof(netwave_handler)/sizeof(iw_handler),
716 .num_private = sizeof(netwave_private_handler)/sizeof(iw_handler),
717 .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
718 .standard = (iw_handler *) netwave_handler,
719 .private = (iw_handler *) netwave_private_handler,
720 .private_args = (struct iw_priv_args *) netwave_private_args,
721 .get_wireless_stats = netwave_get_wireless_stats,
722 };
723
724 /*
725 * Function netwave_pcmcia_config (link)
726 *
727 * netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION
728 * event is received, to configure the PCMCIA socket, and to make the
729 * device available to the system.
730 *
731 */
732
733 #define CS_CHECK(fn, ret) \
734 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
735
736 static int netwave_pcmcia_config(struct pcmcia_device *link) {
737 struct net_device *dev = link->priv;
738 netwave_private *priv = netdev_priv(dev);
739 tuple_t tuple;
740 cisparse_t parse;
741 int i, j, last_ret, last_fn;
742 u_char buf[64];
743 win_req_t req;
744 memreq_t mem;
745 u_char __iomem *ramBase = NULL;
746
747 DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
748
749 /*
750 This reads the card's CONFIG tuple to find its configuration
751 registers.
752 */
753 tuple.Attributes = 0;
754 tuple.TupleData = (cisdata_t *) buf;
755 tuple.TupleDataMax = 64;
756 tuple.TupleOffset = 0;
757 tuple.DesiredTuple = CISTPL_CONFIG;
758 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
759 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
760 CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
761 link->conf.ConfigBase = parse.config.base;
762 link->conf.Present = parse.config.rmask[0];
763
764 /*
765 * Try allocating IO ports. This tries a few fixed addresses.
766 * If you want, you can also read the card's config table to
767 * pick addresses -- see the serial driver for an example.
768 */
769 for (i = j = 0x0; j < 0x400; j += 0x20) {
770 link->io.BasePort1 = j ^ 0x300;
771 i = pcmcia_request_io(link, &link->io);
772 if (i == CS_SUCCESS) break;
773 }
774 if (i != CS_SUCCESS) {
775 cs_error(link, RequestIO, i);
776 goto failed;
777 }
778
779 /*
780 * Now allocate an interrupt line. Note that this does not
781 * actually assign a handler to the interrupt.
782 */
783 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
784
785 /*
786 * This actually configures the PCMCIA socket -- setting up
787 * the I/O windows and the interrupt mapping.
788 */
789 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
790
791 /*
792 * Allocate a 32K memory window. Note that the struct pcmcia_device
793 * structure provides space for one window handle -- if your
794 * device needs several windows, you'll need to keep track of
795 * the handles in your private data structure, dev->priv.
796 */
797 DEBUG(1, "Setting mem speed of %d\n", mem_speed);
798
799 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
800 req.Base = 0; req.Size = 0x8000;
801 req.AccessSpeed = mem_speed;
802 CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
803 mem.CardOffset = 0x20000; mem.Page = 0;
804 CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
805
806 /* Store base address of the common window frame */
807 ramBase = ioremap(req.Base, 0x8000);
808 priv->ramBase = ramBase;
809
810 dev->irq = link->irq.AssignedIRQ;
811 dev->base_addr = link->io.BasePort1;
812 SET_NETDEV_DEV(dev, &handle_to_dev(link));
813
814 if (register_netdev(dev) != 0) {
815 printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
816 goto failed;
817 }
818
819 strcpy(priv->node.dev_name, dev->name);
820 link->dev_node = &priv->node;
821
822 /* Reset card before reading physical address */
823 netwave_doreset(dev->base_addr, ramBase);
824
825 /* Read the ethernet address and fill in the Netwave registers. */
826 for (i = 0; i < 6; i++)
827 dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
828
829 printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
830 "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
831 (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
832 (int) readb(ramBase+NETWAVE_EREG_NI+1));
833 for (i = 0; i < 6; i++)
834 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
835
836 /* get revision words */
837 printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n",
838 get_uint16(ramBase + NETWAVE_EREG_ARW),
839 get_uint16(ramBase + NETWAVE_EREG_ARW+2));
840 return 0;
841
842 cs_failed:
843 cs_error(link, last_fn, last_ret);
844 failed:
845 netwave_release(link);
846 return -ENODEV;
847 } /* netwave_pcmcia_config */
848
849 /*
850 * Function netwave_release (arg)
851 *
852 * After a card is removed, netwave_release() will unregister the net
853 * device, and release the PCMCIA configuration. If the device is
854 * still open, this will be postponed until it is closed.
855 */
856 static void netwave_release(struct pcmcia_device *link)
857 {
858 struct net_device *dev = link->priv;
859 netwave_private *priv = netdev_priv(dev);
860
861 DEBUG(0, "netwave_release(0x%p)\n", link);
862
863 pcmcia_disable_device(link);
864 if (link->win)
865 iounmap(priv->ramBase);
866 }
867
868 static int netwave_suspend(struct pcmcia_device *link)
869 {
870 struct net_device *dev = link->priv;
871
872 if (link->open)
873 netif_device_detach(dev);
874
875 return 0;
876 }
877
878 static int netwave_resume(struct pcmcia_device *link)
879 {
880 struct net_device *dev = link->priv;
881
882 if (link->open) {
883 netwave_reset(dev);
884 netif_device_attach(dev);
885 }
886
887 return 0;
888 }
889
890
891 /*
892 * Function netwave_doreset (ioBase, ramBase)
893 *
894 * Proper hardware reset of the card.
895 */
896 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
897 {
898 /* Reset card */
899 wait_WOC(ioBase);
900 outb(0x80, ioBase + NETWAVE_REG_PMR);
901 writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
902 outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
903 }
904
905 /*
906 * Function netwave_reset (dev)
907 *
908 * Reset and restore all of the netwave registers
909 */
910 static void netwave_reset(struct net_device *dev) {
911 /* u_char state; */
912 netwave_private *priv = netdev_priv(dev);
913 u_char __iomem *ramBase = priv->ramBase;
914 kio_addr_t iobase = dev->base_addr;
915
916 DEBUG(0, "netwave_reset: Done with hardware reset\n");
917
918 priv->timeoutCounter = 0;
919
920 /* Reset card */
921 netwave_doreset(iobase, ramBase);
922 printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
923
924 /* Write a NOP to check the card */
925 wait_WOC(iobase);
926 writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
927 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
928
929 /* Set receive conf */
930 wait_WOC(iobase);
931 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
932 writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
933 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
934
935 /* Set transmit conf */
936 wait_WOC(iobase);
937 writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
938 writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
939 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
940
941 /* Now set the MU Domain */
942 printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
943 wait_WOC(iobase);
944 writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
945 writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
946 writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
947 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
948
949 /* Set scramble key */
950 printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
951 wait_WOC(iobase);
952 writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
953 writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
954 writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
955 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
956
957 /* Enable interrupts, bit 4 high to keep unused
958 * source from interrupting us, bit 2 high to
959 * set interrupt enable, 567 to enable TxDN,
960 * RxErr and RxRdy
961 */
962 wait_WOC(iobase);
963 outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
964
965 /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
966 * waitWOC
967 * skriv 80 til d000:3688
968 * sjekk om det ble 80
969 */
970
971 /* Enable Receiver */
972 wait_WOC(iobase);
973 writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
974 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
975
976 /* Set the IENA bit in COR */
977 wait_WOC(iobase);
978 outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
979 }
980
981 /*
982 * Function netwave_hw_xmit (data, len, dev)
983 */
984 static int netwave_hw_xmit(unsigned char* data, int len,
985 struct net_device* dev) {
986 unsigned long flags;
987 unsigned int TxFreeList,
988 curBuff,
989 MaxData,
990 DataOffset;
991 int tmpcount;
992
993 netwave_private *priv = netdev_priv(dev);
994 u_char __iomem * ramBase = priv->ramBase;
995 kio_addr_t iobase = dev->base_addr;
996
997 /* Disable interrupts & save flags */
998 spin_lock_irqsave(&priv->spinlock, flags);
999
1000 /* Check if there are transmit buffers available */
1001 wait_WOC(iobase);
1002 if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
1003 /* No buffers available */
1004 printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
1005 dev->name);
1006 spin_unlock_irqrestore(&priv->spinlock, flags);
1007 return 1;
1008 }
1009
1010 priv->stats.tx_bytes += len;
1011
1012 DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
1013 readb(ramBase + NETWAVE_EREG_SPCQ),
1014 readb(ramBase + NETWAVE_EREG_SPU),
1015 readb(ramBase + NETWAVE_EREG_LIF),
1016 readb(ramBase + NETWAVE_EREG_ISPLQ));
1017
1018 /* Now try to insert it into the adapters free memory */
1019 wait_WOC(iobase);
1020 TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1021 MaxData = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1022 DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1023
1024 DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1025 TxFreeList, MaxData, DataOffset);
1026
1027 /* Copy packet to the adapter fragment buffers */
1028 curBuff = TxFreeList;
1029 tmpcount = 0;
1030 while (tmpcount < len) {
1031 int tmplen = len - tmpcount;
1032 copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount,
1033 (tmplen < MaxData) ? tmplen : MaxData);
1034 tmpcount += MaxData;
1035
1036 /* Advance to next buffer */
1037 curBuff = get_uint16(ramBase + curBuff);
1038 }
1039
1040 /* Now issue transmit list */
1041 wait_WOC(iobase);
1042 writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1043 writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1044 writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1045 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1046
1047 spin_unlock_irqrestore(&priv->spinlock, flags);
1048 return 0;
1049 }
1050
1051 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1052 /* This flag indicate that the hardware can't perform a transmission.
1053 * Theoritically, NET3 check it before sending a packet to the driver,
1054 * but in fact it never do that and pool continuously.
1055 * As the watchdog will abort too long transmissions, we are quite safe...
1056 */
1057
1058 netif_stop_queue(dev);
1059
1060 {
1061 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1062 unsigned char* buf = skb->data;
1063
1064 if (netwave_hw_xmit( buf, length, dev) == 1) {
1065 /* Some error, let's make them call us another time? */
1066 netif_start_queue(dev);
1067 }
1068 dev->trans_start = jiffies;
1069 }
1070 dev_kfree_skb(skb);
1071
1072 return 0;
1073 } /* netwave_start_xmit */
1074
1075 /*
1076 * Function netwave_interrupt (irq, dev_id, regs)
1077 *
1078 * This function is the interrupt handler for the Netwave card. This
1079 * routine will be called whenever:
1080 * 1. A packet is received.
1081 * 2. A packet has successfully been transferred and the unit is
1082 * ready to transmit another packet.
1083 * 3. A command has completed execution.
1084 */
1085 static irqreturn_t netwave_interrupt(int irq, void* dev_id, struct pt_regs *regs)
1086 {
1087 kio_addr_t iobase;
1088 u_char __iomem *ramBase;
1089 struct net_device *dev = (struct net_device *)dev_id;
1090 struct netwave_private *priv = netdev_priv(dev);
1091 struct pcmcia_device *link = priv->p_dev;
1092 int i;
1093
1094 if (!netif_device_present(dev))
1095 return IRQ_NONE;
1096
1097 iobase = dev->base_addr;
1098 ramBase = priv->ramBase;
1099
1100 /* Now find what caused the interrupt, check while interrupts ready */
1101 for (i = 0; i < 10; i++) {
1102 u_char status;
1103
1104 wait_WOC(iobase);
1105 if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1106 break; /* None of the interrupt sources asserted (normal exit) */
1107
1108 status = inb(iobase + NETWAVE_REG_ASR);
1109
1110 if (!pcmcia_dev_present(link)) {
1111 DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1112 "from removed or suspended card!\n", status);
1113 break;
1114 }
1115
1116 /* RxRdy */
1117 if (status & 0x80) {
1118 netwave_rx(dev);
1119 /* wait_WOC(iobase); */
1120 /* RxRdy cannot be reset directly by the host */
1121 }
1122 /* RxErr */
1123 if (status & 0x40) {
1124 u_char rser;
1125
1126 rser = readb(ramBase + NETWAVE_EREG_RSER);
1127
1128 if (rser & 0x04) {
1129 ++priv->stats.rx_dropped;
1130 ++priv->stats.rx_crc_errors;
1131 }
1132 if (rser & 0x02)
1133 ++priv->stats.rx_frame_errors;
1134
1135 /* Clear the RxErr bit in RSER. RSER+4 is the
1136 * write part. Also clear the RxCRC (0x04) and
1137 * RxBig (0x02) bits if present */
1138 wait_WOC(iobase);
1139 writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1140
1141 /* Write bit 6 high to ASCC to clear RxErr in ASR,
1142 * WOC must be set first!
1143 */
1144 wait_WOC(iobase);
1145 writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1146
1147 /* Remember to count up priv->stats on error packets */
1148 ++priv->stats.rx_errors;
1149 }
1150 /* TxDN */
1151 if (status & 0x20) {
1152 int txStatus;
1153
1154 txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1155 DEBUG(3, "Transmit done. TSER = %x id %x\n",
1156 txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1157
1158 if (txStatus & 0x20) {
1159 /* Transmitting was okay, clear bits */
1160 wait_WOC(iobase);
1161 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1162 ++priv->stats.tx_packets;
1163 }
1164
1165 if (txStatus & 0xd0) {
1166 if (txStatus & 0x80) {
1167 ++priv->stats.collisions; /* Because of /proc/net/dev*/
1168 /* ++priv->stats.tx_aborted_errors; */
1169 /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1170 }
1171 if (txStatus & 0x40)
1172 ++priv->stats.tx_carrier_errors;
1173 /* 0x80 TxGU Transmit giveup - nine times and no luck
1174 * 0x40 TxNOAP No access point. Discarded packet.
1175 * 0x10 TxErr Transmit error. Always set when
1176 * TxGU and TxNOAP is set. (Those are the only ones
1177 * to set TxErr).
1178 */
1179 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n",
1180 txStatus);
1181
1182 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1183 wait_WOC(iobase);
1184 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1185 ++priv->stats.tx_errors;
1186 }
1187 DEBUG(3, "New status is TSER %x ASR %x\n",
1188 readb(ramBase + NETWAVE_EREG_TSER),
1189 inb(iobase + NETWAVE_REG_ASR));
1190
1191 netif_wake_queue(dev);
1192 }
1193 /* TxBA, this would trigger on all error packets received */
1194 /* if (status & 0x01) {
1195 DEBUG(4, "Transmit buffers available, %x\n", status);
1196 }
1197 */
1198 }
1199 /* Handled if we looped at least one time - Jean II */
1200 return IRQ_RETVAL(i);
1201 } /* netwave_interrupt */
1202
1203 /*
1204 * Function netwave_watchdog (a)
1205 *
1206 * Watchdog : when we start a transmission, we set a timer in the
1207 * kernel. If the transmission complete, this timer is disabled. If
1208 * it expire, we reset the card.
1209 *
1210 */
1211 static void netwave_watchdog(struct net_device *dev) {
1212
1213 DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1214 netwave_reset(dev);
1215 dev->trans_start = jiffies;
1216 netif_wake_queue(dev);
1217 } /* netwave_watchdog */
1218
1219 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1220 netwave_private *priv = netdev_priv(dev);
1221
1222 update_stats(dev);
1223
1224 DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1225 " %x tx %x %x %x %x\n",
1226 readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1227 readb(priv->ramBase + NETWAVE_EREG_SPU),
1228 readb(priv->ramBase + NETWAVE_EREG_LIF),
1229 readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1230 readb(priv->ramBase + NETWAVE_EREG_MHS),
1231 readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1232 readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1233 readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1234 readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1235 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1236 readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1237
1238 return &priv->stats;
1239 }
1240
1241 static void update_stats(struct net_device *dev) {
1242 //unsigned long flags;
1243 /* netwave_private *priv = netdev_priv(dev); */
1244
1245 //spin_lock_irqsave(&priv->spinlock, flags);
1246
1247 /* priv->stats.rx_packets = readb(priv->ramBase + 0x18e);
1248 priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1249
1250 //spin_unlock_irqrestore(&priv->spinlock, flags);
1251 }
1252
1253 static int netwave_rx(struct net_device *dev)
1254 {
1255 netwave_private *priv = netdev_priv(dev);
1256 u_char __iomem *ramBase = priv->ramBase;
1257 kio_addr_t iobase = dev->base_addr;
1258 u_char rxStatus;
1259 struct sk_buff *skb = NULL;
1260 unsigned int curBuffer,
1261 rcvList;
1262 int rcvLen;
1263 int tmpcount = 0;
1264 int dataCount, dataOffset;
1265 int i;
1266 u_char *ptr;
1267
1268 DEBUG(3, "xinw_rx: Receiving ... \n");
1269
1270 /* Receive max 10 packets for now. */
1271 for (i = 0; i < 10; i++) {
1272 /* Any packets? */
1273 wait_WOC(iobase);
1274 rxStatus = readb(ramBase + NETWAVE_EREG_RSER);
1275 if ( !( rxStatus & 0x80)) /* No more packets */
1276 break;
1277
1278 /* Check if multicast/broadcast or other */
1279 /* multicast = (rxStatus & 0x20); */
1280
1281 /* The receive list pointer and length of the packet */
1282 wait_WOC(iobase);
1283 rcvLen = get_int16( ramBase + NETWAVE_EREG_RDP);
1284 rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1285
1286 if (rcvLen < 0) {
1287 printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n",
1288 rcvLen);
1289 return 0;
1290 }
1291
1292 skb = dev_alloc_skb(rcvLen+5);
1293 if (skb == NULL) {
1294 DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1295 "length %d\n", rcvLen);
1296 ++priv->stats.rx_dropped;
1297 /* Tell the adapter to skip the packet */
1298 wait_WOC(iobase);
1299 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1300 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1301 return 0;
1302 }
1303
1304 skb_reserve( skb, 2); /* Align IP on 16 byte */
1305 skb_put( skb, rcvLen);
1306 skb->dev = dev;
1307
1308 /* Copy packet fragments to the skb data area */
1309 ptr = (u_char*) skb->data;
1310 curBuffer = rcvList;
1311 tmpcount = 0;
1312 while ( tmpcount < rcvLen) {
1313 /* Get length and offset of current buffer */
1314 dataCount = get_uint16( ramBase+curBuffer+2);
1315 dataOffset = get_uint16( ramBase+curBuffer+4);
1316
1317 copy_from_pc( ptr + tmpcount,
1318 ramBase+curBuffer+dataOffset, dataCount);
1319
1320 tmpcount += dataCount;
1321
1322 /* Point to next buffer */
1323 curBuffer = get_uint16(ramBase + curBuffer);
1324 }
1325
1326 skb->protocol = eth_type_trans(skb,dev);
1327 /* Queue packet for network layer */
1328 netif_rx(skb);
1329
1330 dev->last_rx = jiffies;
1331 priv->stats.rx_packets++;
1332 priv->stats.rx_bytes += rcvLen;
1333
1334 /* Got the packet, tell the adapter to skip it */
1335 wait_WOC(iobase);
1336 writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1337 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1338 DEBUG(3, "Packet reception ok\n");
1339 }
1340 return 0;
1341 }
1342
1343 static int netwave_open(struct net_device *dev) {
1344 netwave_private *priv = netdev_priv(dev);
1345 struct pcmcia_device *link = priv->p_dev;
1346
1347 DEBUG(1, "netwave_open: starting.\n");
1348
1349 if (!pcmcia_dev_present(link))
1350 return -ENODEV;
1351
1352 link->open++;
1353
1354 netif_start_queue(dev);
1355 netwave_reset(dev);
1356
1357 return 0;
1358 }
1359
1360 static int netwave_close(struct net_device *dev) {
1361 netwave_private *priv = netdev_priv(dev);
1362 struct pcmcia_device *link = priv->p_dev;
1363
1364 DEBUG(1, "netwave_close: finishing.\n");
1365
1366 link->open--;
1367 netif_stop_queue(dev);
1368
1369 return 0;
1370 }
1371
1372 static struct pcmcia_device_id netwave_ids[] = {
1373 PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1374 PCMCIA_DEVICE_NULL,
1375 };
1376 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1377
1378 static struct pcmcia_driver netwave_driver = {
1379 .owner = THIS_MODULE,
1380 .drv = {
1381 .name = "netwave_cs",
1382 },
1383 .probe = netwave_probe,
1384 .remove = netwave_detach,
1385 .id_table = netwave_ids,
1386 .suspend = netwave_suspend,
1387 .resume = netwave_resume,
1388 };
1389
1390 static int __init init_netwave_cs(void)
1391 {
1392 return pcmcia_register_driver(&netwave_driver);
1393 }
1394
1395 static void __exit exit_netwave_cs(void)
1396 {
1397 pcmcia_unregister_driver(&netwave_driver);
1398 }
1399
1400 module_init(init_netwave_cs);
1401 module_exit(exit_netwave_cs);
1402
1403 /* Set or clear the multicast filter for this adaptor.
1404 num_addrs == -1 Promiscuous mode, receive all packets
1405 num_addrs == 0 Normal mode, clear multicast list
1406 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
1407 best-effort filtering.
1408 */
1409 static void set_multicast_list(struct net_device *dev)
1410 {
1411 kio_addr_t iobase = dev->base_addr;
1412 netwave_private *priv = netdev_priv(dev);
1413 u_char __iomem * ramBase = priv->ramBase;
1414 u_char rcvMode = 0;
1415
1416 #ifdef PCMCIA_DEBUG
1417 if (pc_debug > 2) {
1418 static int old;
1419 if (old != dev->mc_count) {
1420 old = dev->mc_count;
1421 DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1422 dev->name, dev->mc_count);
1423 }
1424 }
1425 #endif
1426
1427 if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1428 /* Multicast Mode */
1429 rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1430 } else if (dev->flags & IFF_PROMISC) {
1431 /* Promiscous mode */
1432 rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1433 } else {
1434 /* Normal mode */
1435 rcvMode = rxConfRxEna + rxConfBcast;
1436 }
1437
1438 /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1439 /* Now set receive mode */
1440 wait_WOC(iobase);
1441 writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1442 writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1443 writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1444 }
1445 MODULE_LICENSE("GPL");
Support for the Chinese Samsung S3C2440 based development boards