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