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