1 /*********************************************************************
3 * Filename: netwave_cs.c
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>
14 * Copyright (c) 1997 University of Tromsø, Norway
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)
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
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 ********************************************************************/
37 /* To have statistics (just packets sent) define this */
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>
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 #include <net/iw_handler.h>
63 #include <pcmcia/cs_types.h>
64 #include <pcmcia/cs.h>
65 #include <pcmcia/cistpl.h>
66 #include <pcmcia/cisreg.h>
67 #include <pcmcia/ds.h>
68 #include <pcmcia/mem_op.h>
70 #include <asm/system.h>
74 #define NETWAVE_REGOFF 0x8000
75 /* The Netwave IO registers, offsets to iobase */
76 #define NETWAVE_REG_COR 0x0
77 #define NETWAVE_REG_CCSR 0x2
78 #define NETWAVE_REG_ASR 0x4
79 #define NETWAVE_REG_IMR 0xa
80 #define NETWAVE_REG_PMR 0xc
81 #define NETWAVE_REG_IOLOW 0x6
82 #define NETWAVE_REG_IOHI 0x7
83 #define NETWAVE_REG_IOCONTROL 0x8
84 #define NETWAVE_REG_DATA 0xf
85 /* The Netwave Extended IO registers, offsets to RamBase */
86 #define NETWAVE_EREG_ASCC 0x114
87 #define NETWAVE_EREG_RSER 0x120
88 #define NETWAVE_EREG_RSERW 0x124
89 #define NETWAVE_EREG_TSER 0x130
90 #define NETWAVE_EREG_TSERW 0x134
91 #define NETWAVE_EREG_CB 0x100
92 #define NETWAVE_EREG_SPCQ 0x154
93 #define NETWAVE_EREG_SPU 0x155
94 #define NETWAVE_EREG_LIF 0x14e
95 #define NETWAVE_EREG_ISPLQ 0x156
96 #define NETWAVE_EREG_HHC 0x158
97 #define NETWAVE_EREG_NI 0x16e
98 #define NETWAVE_EREG_MHS 0x16b
99 #define NETWAVE_EREG_TDP 0x140
100 #define NETWAVE_EREG_RDP 0x150
101 #define NETWAVE_EREG_PA 0x160
102 #define NETWAVE_EREG_EC 0x180
103 #define NETWAVE_EREG_CRBP 0x17a
104 #define NETWAVE_EREG_ARW 0x166
107 * Commands used in the extended command buffer
108 * NETWAVE_EREG_CB (0x100-0x10F)
110 #define NETWAVE_CMD_NOP 0x00
111 #define NETWAVE_CMD_SRC 0x01
112 #define NETWAVE_CMD_STC 0x02
113 #define NETWAVE_CMD_AMA 0x03
114 #define NETWAVE_CMD_DMA 0x04
115 #define NETWAVE_CMD_SAMA 0x05
116 #define NETWAVE_CMD_ER 0x06
117 #define NETWAVE_CMD_DR 0x07
118 #define NETWAVE_CMD_TL 0x08
119 #define NETWAVE_CMD_SRP 0x09
120 #define NETWAVE_CMD_SSK 0x0a
121 #define NETWAVE_CMD_SMD 0x0b
122 #define NETWAVE_CMD_SAPD 0x0c
123 #define NETWAVE_CMD_SSS 0x11
124 /* End of Command marker */
125 #define NETWAVE_CMD_EOC 0x00
127 /* ASR register bits */
128 #define NETWAVE_ASR_RXRDY 0x80
129 #define NETWAVE_ASR_TXBA 0x01
131 #define TX_TIMEOUT ((32*HZ)/100)
133 static const unsigned int imrConfRFU1
= 0x10; /* RFU interrupt mask, keep high */
134 static const unsigned int imrConfIENA
= 0x02; /* Interrupt enable */
136 static const unsigned int corConfIENA
= 0x01; /* Interrupt enable */
137 static const unsigned int corConfLVLREQ
= 0x40; /* Keep high */
139 static const unsigned int rxConfRxEna
= 0x80; /* Receive Enable */
140 static const unsigned int rxConfMAC
= 0x20; /* MAC host receive mode*/
141 static const unsigned int rxConfPro
= 0x10; /* Promiscuous */
142 static const unsigned int rxConfAMP
= 0x08; /* Accept Multicast Packets */
143 static const unsigned int rxConfBcast
= 0x04; /* Accept Broadcast Packets */
145 static const unsigned int txConfTxEna
= 0x80; /* Transmit Enable */
146 static const unsigned int txConfMAC
= 0x20; /* Host sends MAC mode */
147 static const unsigned int txConfEUD
= 0x10; /* Enable Uni-Data packets */
148 static const unsigned int txConfKey
= 0x02; /* Scramble data packets */
149 static const unsigned int txConfLoop
= 0x01; /* Loopback mode */
152 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
153 you do not define PCMCIA_DEBUG at all, all the debug code will be
154 left out. If you compile with PCMCIA_DEBUG=0, the debug code will
155 be present but disabled -- but it can then be enabled for specific
156 modules at load time with a 'pc_debug=#' option to insmod.
160 static int pc_debug
= PCMCIA_DEBUG
;
161 module_param(pc_debug
, int, 0);
162 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
163 static char *version
=
164 "netwave_cs.c 0.3.0 Thu Jul 17 14:36:02 1997 (John Markus Bjørndalen)\n";
166 #define DEBUG(n, args...)
169 static dev_info_t dev_info
= "netwave_cs";
171 /*====================================================================*/
173 /* Parameters that can be set with 'insmod' */
175 /* Choose the domain, default is 0x100 */
176 static u_int domain
= 0x100;
178 /* Scramble key, range from 0x0 to 0xffff.
179 * 0x0 is no scrambling.
181 static u_int scramble_key
= 0x0;
183 /* Shared memory speed, in ns. The documentation states that
184 * the card should not be read faster than every 400ns.
185 * This timing should be provided by the HBA. If it becomes a
186 * problem, try setting mem_speed to 400.
188 static int mem_speed
;
190 module_param(domain
, int, 0);
191 module_param(scramble_key
, int, 0);
192 module_param(mem_speed
, int, 0);
194 /*====================================================================*/
196 /* PCMCIA (Card Services) related functions */
197 static void netwave_release(dev_link_t
*link
); /* Card removal */
198 static int netwave_event(event_t event
, int priority
,
199 event_callback_args_t
*args
);
200 static void netwave_pcmcia_config(dev_link_t
*arg
); /* Runs after card
202 static dev_link_t
*netwave_attach(void); /* Create instance */
203 static void netwave_detach(struct pcmcia_device
*p_dev
); /* Destroy instance */
205 /* Hardware configuration */
206 static void netwave_doreset(kio_addr_t iobase
, u_char __iomem
*ramBase
);
207 static void netwave_reset(struct net_device
*dev
);
209 /* Misc device stuff */
210 static int netwave_open(struct net_device
*dev
); /* Open the device */
211 static int netwave_close(struct net_device
*dev
); /* Close the device */
213 /* Packet transmission and Packet reception */
214 static int netwave_start_xmit( struct sk_buff
*skb
, struct net_device
*dev
);
215 static int netwave_rx( struct net_device
*dev
);
217 /* Interrupt routines */
218 static irqreturn_t
netwave_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
);
219 static void netwave_watchdog(struct net_device
*);
222 static void update_stats(struct net_device
*dev
);
223 static struct net_device_stats
*netwave_get_stats(struct net_device
*dev
);
225 /* Wireless extensions */
226 static struct iw_statistics
* netwave_get_wireless_stats(struct net_device
*dev
);
228 static void set_multicast_list(struct net_device
*dev
);
231 A dev_link_t structure has fields for most things that are needed
232 to keep track of a socket, but there will usually be some device
233 specific information that also needs to be kept track of. The
234 'priv' pointer in a dev_link_t structure can be used to point to
235 a device-specific private data structure, like this.
237 A driver needs to provide a dev_node_t structure for each device
238 on a card. In some cases, there is only one device per card (for
239 example, ethernet cards, modems). In other cases, there may be
240 many actual or logical devices (SCSI adapters, memory cards with
241 multiple partitions). The dev_node_t structures need to be kept
242 in a linked list starting at the 'dev' field of a dev_link_t
243 structure. We allocate them in the card's private data structure,
244 because they generally can't be allocated dynamically.
247 static const struct iw_handler_def netwave_handler_def
;
249 #define SIOCGIPSNAP SIOCIWFIRSTPRIV + 1 /* Site Survey Snapshot */
253 typedef struct net_addr
{
259 u_char struct_revision
;
260 u_char roaming_state
;
262 u_char sp_existsFlag
;
263 u_char sp_link_quality
;
264 u_char sp_max_link_quality
;
265 u_char linkQualityGoodFairBoundary
;
266 u_char linkQualityFairPoorBoundary
;
267 u_char sp_utilization
;
269 u_char sp_hotheadcount
;
270 u_char roaming_condition
;
274 net_addr nearByAccessPoints
[MAX_ESA
];
277 typedef struct netwave_private
{
279 spinlock_t spinlock
; /* Serialize access to the hardware (SMP) */
281 u_char __iomem
*ramBase
;
284 struct timer_list watchdog
; /* To avoid blocking state */
285 struct site_survey nss
;
286 struct net_device_stats stats
;
287 struct iw_statistics iw_stats
; /* Wireless stats */
291 static struct net_device_stats
*netwave_get_stats(struct net_device
*dev
);
295 * The Netwave card is little-endian, so won't work for big endian
298 static inline unsigned short get_uint16(u_char __iomem
*staddr
)
300 return readw(staddr
); /* Return only 16 bits */
303 static inline short get_int16(u_char __iomem
* staddr
)
305 return readw(staddr
);
309 * Wait until the WOC (Write Operation Complete) bit in the
310 * ASR (Adapter Status Register) is asserted.
311 * This should have aborted if it takes too long time.
313 static inline void wait_WOC(unsigned int iobase
)
316 while ((inb(iobase
+ NETWAVE_REG_ASR
) & 0x8) != 0x8) ;
319 static void netwave_snapshot(netwave_private
*priv
, u_char __iomem
*ramBase
,
321 u_short resultBuffer
;
323 /* if time since last snapshot is > 1 sec. (100 jiffies?) then take
324 * new snapshot, else return cached data. This is the recommended rate.
326 if ( jiffies
- priv
->lastExec
> 100) {
327 /* Take site survey snapshot */
328 /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies -
331 writeb(NETWAVE_CMD_SSS
, ramBase
+ NETWAVE_EREG_CB
+ 0);
332 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 1);
335 /* Get result and copy to cach */
336 resultBuffer
= readw(ramBase
+ NETWAVE_EREG_CRBP
);
337 copy_from_pc( &priv
->nss
, ramBase
+resultBuffer
,
338 sizeof(struct site_survey
));
343 * Function netwave_get_wireless_stats (dev)
345 * Wireless extensions statistics
348 static struct iw_statistics
*netwave_get_wireless_stats(struct net_device
*dev
)
351 kio_addr_t iobase
= dev
->base_addr
;
352 netwave_private
*priv
= netdev_priv(dev
);
353 u_char __iomem
*ramBase
= priv
->ramBase
;
354 struct iw_statistics
* wstats
;
356 wstats
= &priv
->iw_stats
;
358 spin_lock_irqsave(&priv
->spinlock
, flags
);
360 netwave_snapshot( priv
, ramBase
, iobase
);
362 wstats
->status
= priv
->nss
.roaming_state
;
363 wstats
->qual
.qual
= readb( ramBase
+ NETWAVE_EREG_SPCQ
);
364 wstats
->qual
.level
= readb( ramBase
+ NETWAVE_EREG_ISPLQ
);
365 wstats
->qual
.noise
= readb( ramBase
+ NETWAVE_EREG_SPU
) & 0x3f;
366 wstats
->discard
.nwid
= 0L;
367 wstats
->discard
.code
= 0L;
368 wstats
->discard
.misc
= 0L;
370 spin_unlock_irqrestore(&priv
->spinlock
, flags
);
372 return &priv
->iw_stats
;
376 * Function netwave_attach (void)
378 * Creates an "instance" of the driver, allocating local data
379 * structures for one device. The device is registered with Card
382 * The dev_link structure is initialized, but we don't actually
383 * configure the card at this point -- we wait until we receive a
384 * card insertion event.
386 static dev_link_t
*netwave_attach(void)
388 client_reg_t client_reg
;
390 struct net_device
*dev
;
391 netwave_private
*priv
;
394 DEBUG(0, "netwave_attach()\n");
396 /* Initialize the dev_link_t structure */
397 dev
= alloc_etherdev(sizeof(netwave_private
));
400 priv
= netdev_priv(dev
);
404 /* The io structure describes IO port mapping */
405 link
->io
.NumPorts1
= 16;
406 link
->io
.Attributes1
= IO_DATA_PATH_WIDTH_16
;
407 /* link->io.NumPorts2 = 16;
408 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
409 link
->io
.IOAddrLines
= 5;
411 /* Interrupt setup */
412 link
->irq
.Attributes
= IRQ_TYPE_EXCLUSIVE
| IRQ_HANDLE_PRESENT
;
413 link
->irq
.IRQInfo1
= IRQ_LEVEL_ID
;
414 link
->irq
.Handler
= &netwave_interrupt
;
416 /* General socket configuration */
417 link
->conf
.Attributes
= CONF_ENABLE_IRQ
;
419 link
->conf
.IntType
= INT_MEMORY_AND_IO
;
420 link
->conf
.ConfigIndex
= 1;
421 link
->conf
.Present
= PRESENT_OPTION
;
423 /* Netwave private struct init. link/dev/node already taken care of,
424 * other stuff zero'd - Jean II */
425 spin_lock_init(&priv
->spinlock
);
427 /* Netwave specific entries in the device structure */
428 SET_MODULE_OWNER(dev
);
429 dev
->hard_start_xmit
= &netwave_start_xmit
;
430 dev
->get_stats
= &netwave_get_stats
;
431 dev
->set_multicast_list
= &set_multicast_list
;
432 /* wireless extensions */
433 dev
->wireless_handlers
= (struct iw_handler_def
*)&netwave_handler_def
;
435 dev
->tx_timeout
= &netwave_watchdog
;
436 dev
->watchdog_timeo
= TX_TIMEOUT
;
438 dev
->open
= &netwave_open
;
439 dev
->stop
= &netwave_close
;
440 link
->irq
.Instance
= dev
;
442 /* Register with Card Services */
444 client_reg
.dev_info
= &dev_info
;
445 client_reg
.Version
= 0x0210;
446 client_reg
.event_callback_args
.client_data
= link
;
447 ret
= pcmcia_register_client(&link
->handle
, &client_reg
);
449 cs_error(link
->handle
, RegisterClient
, ret
);
450 netwave_detach(link
->handle
);
455 } /* netwave_attach */
458 * Function netwave_detach (link)
460 * This deletes a driver "instance". The device is de-registered
461 * with Card Services. If it has been released, all local data
462 * structures are freed. Otherwise, the structures will be freed
463 * when the device is released.
465 static void netwave_detach(struct pcmcia_device
*p_dev
)
467 dev_link_t
*link
= dev_to_instance(p_dev
);
468 struct net_device
*dev
= link
->priv
;
470 DEBUG(0, "netwave_detach(0x%p)\n", link
);
472 if (link
->state
& DEV_CONFIG
)
473 netwave_release(link
);
476 unregister_netdev(dev
);
479 } /* netwave_detach */
482 * Wireless Handler : get protocol name
484 static int netwave_get_name(struct net_device
*dev
,
485 struct iw_request_info
*info
,
486 union iwreq_data
*wrqu
,
489 strcpy(wrqu
->name
, "Netwave");
494 * Wireless Handler : set Network ID
496 static int netwave_set_nwid(struct net_device
*dev
,
497 struct iw_request_info
*info
,
498 union iwreq_data
*wrqu
,
502 kio_addr_t iobase
= dev
->base_addr
;
503 netwave_private
*priv
= netdev_priv(dev
);
504 u_char __iomem
*ramBase
= priv
->ramBase
;
506 /* Disable interrupts & save flags */
507 spin_lock_irqsave(&priv
->spinlock
, flags
);
509 if(!wrqu
->nwid
.disabled
) {
510 domain
= wrqu
->nwid
.value
;
511 printk( KERN_DEBUG
"Setting domain to 0x%x%02x\n",
512 (domain
>> 8) & 0x01, domain
& 0xff);
514 writeb(NETWAVE_CMD_SMD
, ramBase
+ NETWAVE_EREG_CB
+ 0);
515 writeb( domain
& 0xff, ramBase
+ NETWAVE_EREG_CB
+ 1);
516 writeb((domain
>>8 ) & 0x01,ramBase
+ NETWAVE_EREG_CB
+2);
517 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 3);
520 /* ReEnable interrupts & restore flags */
521 spin_unlock_irqrestore(&priv
->spinlock
, flags
);
527 * Wireless Handler : get Network ID
529 static int netwave_get_nwid(struct net_device
*dev
,
530 struct iw_request_info
*info
,
531 union iwreq_data
*wrqu
,
534 wrqu
->nwid
.value
= domain
;
535 wrqu
->nwid
.disabled
= 0;
536 wrqu
->nwid
.fixed
= 1;
541 * Wireless Handler : set scramble key
543 static int netwave_set_scramble(struct net_device
*dev
,
544 struct iw_request_info
*info
,
545 union iwreq_data
*wrqu
,
549 kio_addr_t iobase
= dev
->base_addr
;
550 netwave_private
*priv
= netdev_priv(dev
);
551 u_char __iomem
*ramBase
= priv
->ramBase
;
553 /* Disable interrupts & save flags */
554 spin_lock_irqsave(&priv
->spinlock
, flags
);
556 scramble_key
= (key
[0] << 8) | key
[1];
558 writeb(NETWAVE_CMD_SSK
, ramBase
+ NETWAVE_EREG_CB
+ 0);
559 writeb(scramble_key
& 0xff, ramBase
+ NETWAVE_EREG_CB
+ 1);
560 writeb((scramble_key
>>8) & 0xff, ramBase
+ NETWAVE_EREG_CB
+ 2);
561 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 3);
563 /* ReEnable interrupts & restore flags */
564 spin_unlock_irqrestore(&priv
->spinlock
, flags
);
570 * Wireless Handler : get scramble key
572 static int netwave_get_scramble(struct net_device
*dev
,
573 struct iw_request_info
*info
,
574 union iwreq_data
*wrqu
,
577 key
[1] = scramble_key
& 0xff;
578 key
[0] = (scramble_key
>>8) & 0xff;
579 wrqu
->encoding
.flags
= IW_ENCODE_ENABLED
;
580 wrqu
->encoding
.length
= 2;
585 * Wireless Handler : get mode
587 static int netwave_get_mode(struct net_device
*dev
,
588 struct iw_request_info
*info
,
589 union iwreq_data
*wrqu
,
593 wrqu
->mode
= IW_MODE_INFRA
;
595 wrqu
->mode
= IW_MODE_ADHOC
;
601 * Wireless Handler : get range info
603 static int netwave_get_range(struct net_device
*dev
,
604 struct iw_request_info
*info
,
605 union iwreq_data
*wrqu
,
608 struct iw_range
*range
= (struct iw_range
*) extra
;
611 /* Set the length (very important for backward compatibility) */
612 wrqu
->data
.length
= sizeof(struct iw_range
);
614 /* Set all the info we don't care or don't know about to zero */
615 memset(range
, 0, sizeof(struct iw_range
));
617 /* Set the Wireless Extension versions */
618 range
->we_version_compiled
= WIRELESS_EXT
;
619 range
->we_version_source
= 9; /* Nothing for us in v10 and v11 */
621 /* Set information in the range struct */
622 range
->throughput
= 450 * 1000; /* don't argue on this ! */
623 range
->min_nwid
= 0x0000;
624 range
->max_nwid
= 0x01FF;
626 range
->num_channels
= range
->num_frequency
= 0;
628 range
->sensitivity
= 0x3F;
629 range
->max_qual
.qual
= 255;
630 range
->max_qual
.level
= 255;
631 range
->max_qual
.noise
= 0;
633 range
->num_bitrates
= 1;
634 range
->bitrate
[0] = 1000000; /* 1 Mb/s */
636 range
->encoding_size
[0] = 2; /* 16 bits scrambling */
637 range
->num_encoding_sizes
= 1;
638 range
->max_encoding_tokens
= 1; /* Only one key possible */
644 * Wireless Private Handler : get snapshot
646 static int netwave_get_snap(struct net_device
*dev
,
647 struct iw_request_info
*info
,
648 union iwreq_data
*wrqu
,
652 kio_addr_t iobase
= dev
->base_addr
;
653 netwave_private
*priv
= netdev_priv(dev
);
654 u_char __iomem
*ramBase
= priv
->ramBase
;
656 /* Disable interrupts & save flags */
657 spin_lock_irqsave(&priv
->spinlock
, flags
);
659 /* Take snapshot of environment */
660 netwave_snapshot( priv
, ramBase
, iobase
);
661 wrqu
->data
.length
= priv
->nss
.length
;
662 memcpy(extra
, (u_char
*) &priv
->nss
, sizeof( struct site_survey
));
664 priv
->lastExec
= jiffies
;
666 /* ReEnable interrupts & restore flags */
667 spin_unlock_irqrestore(&priv
->spinlock
, flags
);
673 * Structures to export the Wireless Handlers
674 * This is the stuff that are treated the wireless extensions (iwconfig)
677 static const struct iw_priv_args netwave_private_args
[] = {
678 /*{ cmd, set_args, get_args, name } */
680 IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| sizeof(struct site_survey
),
684 static const iw_handler netwave_handler
[] =
686 NULL
, /* SIOCSIWNAME */
687 netwave_get_name
, /* SIOCGIWNAME */
688 netwave_set_nwid
, /* SIOCSIWNWID */
689 netwave_get_nwid
, /* SIOCGIWNWID */
690 NULL
, /* SIOCSIWFREQ */
691 NULL
, /* SIOCGIWFREQ */
692 NULL
, /* SIOCSIWMODE */
693 netwave_get_mode
, /* SIOCGIWMODE */
694 NULL
, /* SIOCSIWSENS */
695 NULL
, /* SIOCGIWSENS */
696 NULL
, /* SIOCSIWRANGE */
697 netwave_get_range
, /* SIOCGIWRANGE */
698 NULL
, /* SIOCSIWPRIV */
699 NULL
, /* SIOCGIWPRIV */
700 NULL
, /* SIOCSIWSTATS */
701 NULL
, /* SIOCGIWSTATS */
702 NULL
, /* SIOCSIWSPY */
703 NULL
, /* SIOCGIWSPY */
704 NULL
, /* -- hole -- */
705 NULL
, /* -- hole -- */
706 NULL
, /* SIOCSIWAP */
707 NULL
, /* SIOCGIWAP */
708 NULL
, /* -- hole -- */
709 NULL
, /* SIOCGIWAPLIST */
710 NULL
, /* -- hole -- */
711 NULL
, /* -- hole -- */
712 NULL
, /* SIOCSIWESSID */
713 NULL
, /* SIOCGIWESSID */
714 NULL
, /* SIOCSIWNICKN */
715 NULL
, /* SIOCGIWNICKN */
716 NULL
, /* -- hole -- */
717 NULL
, /* -- hole -- */
718 NULL
, /* SIOCSIWRATE */
719 NULL
, /* SIOCGIWRATE */
720 NULL
, /* SIOCSIWRTS */
721 NULL
, /* SIOCGIWRTS */
722 NULL
, /* SIOCSIWFRAG */
723 NULL
, /* SIOCGIWFRAG */
724 NULL
, /* SIOCSIWTXPOW */
725 NULL
, /* SIOCGIWTXPOW */
726 NULL
, /* SIOCSIWRETRY */
727 NULL
, /* SIOCGIWRETRY */
728 netwave_set_scramble
, /* SIOCSIWENCODE */
729 netwave_get_scramble
, /* SIOCGIWENCODE */
732 static const iw_handler netwave_private_handler
[] =
734 NULL
, /* SIOCIWFIRSTPRIV */
735 netwave_get_snap
, /* SIOCIWFIRSTPRIV + 1 */
738 static const struct iw_handler_def netwave_handler_def
=
740 .num_standard
= sizeof(netwave_handler
)/sizeof(iw_handler
),
741 .num_private
= sizeof(netwave_private_handler
)/sizeof(iw_handler
),
742 .num_private_args
= sizeof(netwave_private_args
)/sizeof(struct iw_priv_args
),
743 .standard
= (iw_handler
*) netwave_handler
,
744 .private = (iw_handler
*) netwave_private_handler
,
745 .private_args
= (struct iw_priv_args
*) netwave_private_args
,
746 .get_wireless_stats
= netwave_get_wireless_stats
,
750 * Function netwave_pcmcia_config (link)
752 * netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION
753 * event is received, to configure the PCMCIA socket, and to make the
754 * device available to the system.
758 #define CS_CHECK(fn, ret) \
759 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
761 static void netwave_pcmcia_config(dev_link_t
*link
) {
762 client_handle_t handle
= link
->handle
;
763 struct net_device
*dev
= link
->priv
;
764 netwave_private
*priv
= netdev_priv(dev
);
767 int i
, j
, last_ret
, last_fn
;
771 u_char __iomem
*ramBase
= NULL
;
773 DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link
);
776 This reads the card's CONFIG tuple to find its configuration
779 tuple
.Attributes
= 0;
780 tuple
.TupleData
= (cisdata_t
*) buf
;
781 tuple
.TupleDataMax
= 64;
782 tuple
.TupleOffset
= 0;
783 tuple
.DesiredTuple
= CISTPL_CONFIG
;
784 CS_CHECK(GetFirstTuple
, pcmcia_get_first_tuple(handle
, &tuple
));
785 CS_CHECK(GetTupleData
, pcmcia_get_tuple_data(handle
, &tuple
));
786 CS_CHECK(ParseTuple
, pcmcia_parse_tuple(handle
, &tuple
, &parse
));
787 link
->conf
.ConfigBase
= parse
.config
.base
;
788 link
->conf
.Present
= parse
.config
.rmask
[0];
791 link
->state
|= DEV_CONFIG
;
794 * Try allocating IO ports. This tries a few fixed addresses.
795 * If you want, you can also read the card's config table to
796 * pick addresses -- see the serial driver for an example.
798 for (i
= j
= 0x0; j
< 0x400; j
+= 0x20) {
799 link
->io
.BasePort1
= j
^ 0x300;
800 i
= pcmcia_request_io(link
->handle
, &link
->io
);
801 if (i
== CS_SUCCESS
) break;
803 if (i
!= CS_SUCCESS
) {
804 cs_error(link
->handle
, RequestIO
, i
);
809 * Now allocate an interrupt line. Note that this does not
810 * actually assign a handler to the interrupt.
812 CS_CHECK(RequestIRQ
, pcmcia_request_irq(handle
, &link
->irq
));
815 * This actually configures the PCMCIA socket -- setting up
816 * the I/O windows and the interrupt mapping.
818 CS_CHECK(RequestConfiguration
, pcmcia_request_configuration(handle
, &link
->conf
));
821 * Allocate a 32K memory window. Note that the dev_link_t
822 * structure provides space for one window handle -- if your
823 * device needs several windows, you'll need to keep track of
824 * the handles in your private data structure, dev->priv.
826 DEBUG(1, "Setting mem speed of %d\n", mem_speed
);
828 req
.Attributes
= WIN_DATA_WIDTH_8
|WIN_MEMORY_TYPE_CM
|WIN_ENABLE
;
829 req
.Base
= 0; req
.Size
= 0x8000;
830 req
.AccessSpeed
= mem_speed
;
831 CS_CHECK(RequestWindow
, pcmcia_request_window(&link
->handle
, &req
, &link
->win
));
832 mem
.CardOffset
= 0x20000; mem
.Page
= 0;
833 CS_CHECK(MapMemPage
, pcmcia_map_mem_page(link
->win
, &mem
));
835 /* Store base address of the common window frame */
836 ramBase
= ioremap(req
.Base
, 0x8000);
837 priv
->ramBase
= ramBase
;
839 dev
->irq
= link
->irq
.AssignedIRQ
;
840 dev
->base_addr
= link
->io
.BasePort1
;
841 SET_NETDEV_DEV(dev
, &handle_to_dev(handle
));
843 if (register_netdev(dev
) != 0) {
844 printk(KERN_DEBUG
"netwave_cs: register_netdev() failed\n");
848 strcpy(priv
->node
.dev_name
, dev
->name
);
849 link
->dev
= &priv
->node
;
850 link
->state
&= ~DEV_CONFIG_PENDING
;
852 /* Reset card before reading physical address */
853 netwave_doreset(dev
->base_addr
, ramBase
);
855 /* Read the ethernet address and fill in the Netwave registers. */
856 for (i
= 0; i
< 6; i
++)
857 dev
->dev_addr
[i
] = readb(ramBase
+ NETWAVE_EREG_PA
+ i
);
859 printk(KERN_INFO
"%s: Netwave: port %#3lx, irq %d, mem %lx id "
860 "%c%c, hw_addr ", dev
->name
, dev
->base_addr
, dev
->irq
,
861 (u_long
) ramBase
, (int) readb(ramBase
+NETWAVE_EREG_NI
),
862 (int) readb(ramBase
+NETWAVE_EREG_NI
+1));
863 for (i
= 0; i
< 6; i
++)
864 printk("%02X%s", dev
->dev_addr
[i
], ((i
<5) ? ":" : "\n"));
866 /* get revision words */
867 printk(KERN_DEBUG
"Netwave_reset: revision %04x %04x\n",
868 get_uint16(ramBase
+ NETWAVE_EREG_ARW
),
869 get_uint16(ramBase
+ NETWAVE_EREG_ARW
+2));
873 cs_error(link
->handle
, last_fn
, last_ret
);
875 netwave_release(link
);
876 } /* netwave_pcmcia_config */
879 * Function netwave_release (arg)
881 * After a card is removed, netwave_release() will unregister the net
882 * device, and release the PCMCIA configuration. If the device is
883 * still open, this will be postponed until it is closed.
885 static void netwave_release(dev_link_t
*link
)
887 struct net_device
*dev
= link
->priv
;
888 netwave_private
*priv
= netdev_priv(dev
);
890 DEBUG(0, "netwave_release(0x%p)\n", link
);
892 /* Don't bother checking to see if these succeed or not */
894 iounmap(priv
->ramBase
);
895 pcmcia_release_window(link
->win
);
897 pcmcia_release_configuration(link
->handle
);
898 pcmcia_release_io(link
->handle
, &link
->io
);
899 pcmcia_release_irq(link
->handle
, &link
->irq
);
901 link
->state
&= ~DEV_CONFIG
;
904 static int netwave_suspend(struct pcmcia_device
*p_dev
)
906 dev_link_t
*link
= dev_to_instance(p_dev
);
907 struct net_device
*dev
= link
->priv
;
909 link
->state
|= DEV_SUSPEND
;
910 if (link
->state
& DEV_CONFIG
) {
912 netif_device_detach(dev
);
913 pcmcia_release_configuration(link
->handle
);
919 static int netwave_resume(struct pcmcia_device
*p_dev
)
921 dev_link_t
*link
= dev_to_instance(p_dev
);
922 struct net_device
*dev
= link
->priv
;
924 link
->state
&= ~DEV_SUSPEND
;
925 if (link
->state
& DEV_CONFIG
) {
926 pcmcia_request_configuration(link
->handle
, &link
->conf
);
929 netif_device_attach(dev
);
938 * Function netwave_event (event, priority, args)
940 * The card status event handler. Mostly, this schedules other
941 * stuff to run after an event is received. A CARD_REMOVAL event
942 * also sets some flags to discourage the net drivers from trying
943 * to talk to the card any more.
945 * When a CARD_REMOVAL event is received, we immediately set a flag
946 * to block future accesses to this device. All the functions that
947 * actually access the device should check this flag to make sure
948 * the card is still present.
951 static int netwave_event(event_t event
, int priority
,
952 event_callback_args_t
*args
)
954 dev_link_t
*link
= args
->client_data
;
956 DEBUG(1, "netwave_event(0x%06x)\n", event
);
959 case CS_EVENT_CARD_INSERTION
:
960 link
->state
|= DEV_PRESENT
| DEV_CONFIG_PENDING
;
961 netwave_pcmcia_config( link
);
965 } /* netwave_event */
968 * Function netwave_doreset (ioBase, ramBase)
970 * Proper hardware reset of the card.
972 static void netwave_doreset(kio_addr_t ioBase
, u_char __iomem
*ramBase
)
976 outb(0x80, ioBase
+ NETWAVE_REG_PMR
);
977 writeb(0x08, ramBase
+ NETWAVE_EREG_ASCC
); /* Bit 3 is WOC */
978 outb(0x0, ioBase
+ NETWAVE_REG_PMR
); /* release reset */
982 * Function netwave_reset (dev)
984 * Reset and restore all of the netwave registers
986 static void netwave_reset(struct net_device
*dev
) {
988 netwave_private
*priv
= netdev_priv(dev
);
989 u_char __iomem
*ramBase
= priv
->ramBase
;
990 kio_addr_t iobase
= dev
->base_addr
;
992 DEBUG(0, "netwave_reset: Done with hardware reset\n");
994 priv
->timeoutCounter
= 0;
997 netwave_doreset(iobase
, ramBase
);
998 printk(KERN_DEBUG
"netwave_reset: Done with hardware reset\n");
1000 /* Write a NOP to check the card */
1002 writeb(NETWAVE_CMD_NOP
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1003 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1005 /* Set receive conf */
1007 writeb(NETWAVE_CMD_SRC
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1008 writeb(rxConfRxEna
+ rxConfBcast
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1009 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 2);
1011 /* Set transmit conf */
1013 writeb(NETWAVE_CMD_STC
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1014 writeb(txConfTxEna
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1015 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 2);
1017 /* Now set the MU Domain */
1018 printk(KERN_DEBUG
"Setting domain to 0x%x%02x\n", (domain
>> 8) & 0x01, domain
& 0xff);
1020 writeb(NETWAVE_CMD_SMD
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1021 writeb(domain
& 0xff, ramBase
+ NETWAVE_EREG_CB
+ 1);
1022 writeb((domain
>>8) & 0x01, ramBase
+ NETWAVE_EREG_CB
+ 2);
1023 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 3);
1025 /* Set scramble key */
1026 printk(KERN_DEBUG
"Setting scramble key to 0x%x\n", scramble_key
);
1028 writeb(NETWAVE_CMD_SSK
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1029 writeb(scramble_key
& 0xff, ramBase
+ NETWAVE_EREG_CB
+ 1);
1030 writeb((scramble_key
>>8) & 0xff, ramBase
+ NETWAVE_EREG_CB
+ 2);
1031 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 3);
1033 /* Enable interrupts, bit 4 high to keep unused
1034 * source from interrupting us, bit 2 high to
1035 * set interrupt enable, 567 to enable TxDN,
1039 outb(imrConfIENA
+imrConfRFU1
, iobase
+ NETWAVE_REG_IMR
);
1041 /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
1043 * skriv 80 til d000:3688
1044 * sjekk om det ble 80
1047 /* Enable Receiver */
1049 writeb(NETWAVE_CMD_ER
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1050 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1052 /* Set the IENA bit in COR */
1054 outb(corConfIENA
+ corConfLVLREQ
, iobase
+ NETWAVE_REG_COR
);
1058 * Function netwave_hw_xmit (data, len, dev)
1060 static int netwave_hw_xmit(unsigned char* data
, int len
,
1061 struct net_device
* dev
) {
1062 unsigned long flags
;
1063 unsigned int TxFreeList
,
1069 netwave_private
*priv
= netdev_priv(dev
);
1070 u_char __iomem
* ramBase
= priv
->ramBase
;
1071 kio_addr_t iobase
= dev
->base_addr
;
1073 /* Disable interrupts & save flags */
1074 spin_lock_irqsave(&priv
->spinlock
, flags
);
1076 /* Check if there are transmit buffers available */
1078 if ((inb(iobase
+NETWAVE_REG_ASR
) & NETWAVE_ASR_TXBA
) == 0) {
1079 /* No buffers available */
1080 printk(KERN_DEBUG
"netwave_hw_xmit: %s - no xmit buffers available.\n",
1082 spin_unlock_irqrestore(&priv
->spinlock
, flags
);
1086 priv
->stats
.tx_bytes
+= len
;
1088 DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
1089 readb(ramBase
+ NETWAVE_EREG_SPCQ
),
1090 readb(ramBase
+ NETWAVE_EREG_SPU
),
1091 readb(ramBase
+ NETWAVE_EREG_LIF
),
1092 readb(ramBase
+ NETWAVE_EREG_ISPLQ
));
1094 /* Now try to insert it into the adapters free memory */
1096 TxFreeList
= get_uint16(ramBase
+ NETWAVE_EREG_TDP
);
1097 MaxData
= get_uint16(ramBase
+ NETWAVE_EREG_TDP
+2);
1098 DataOffset
= get_uint16(ramBase
+ NETWAVE_EREG_TDP
+4);
1100 DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1101 TxFreeList
, MaxData
, DataOffset
);
1103 /* Copy packet to the adapter fragment buffers */
1104 curBuff
= TxFreeList
;
1106 while (tmpcount
< len
) {
1107 int tmplen
= len
- tmpcount
;
1108 copy_to_pc(ramBase
+ curBuff
+ DataOffset
, data
+ tmpcount
,
1109 (tmplen
< MaxData
) ? tmplen
: MaxData
);
1110 tmpcount
+= MaxData
;
1112 /* Advance to next buffer */
1113 curBuff
= get_uint16(ramBase
+ curBuff
);
1116 /* Now issue transmit list */
1118 writeb(NETWAVE_CMD_TL
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1119 writeb(len
& 0xff, ramBase
+ NETWAVE_EREG_CB
+ 1);
1120 writeb((len
>>8) & 0xff, ramBase
+ NETWAVE_EREG_CB
+ 2);
1121 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 3);
1123 spin_unlock_irqrestore(&priv
->spinlock
, flags
);
1127 static int netwave_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
) {
1128 /* This flag indicate that the hardware can't perform a transmission.
1129 * Theoritically, NET3 check it before sending a packet to the driver,
1130 * but in fact it never do that and pool continuously.
1131 * As the watchdog will abort too long transmissions, we are quite safe...
1134 netif_stop_queue(dev
);
1137 short length
= ETH_ZLEN
< skb
->len
? skb
->len
: ETH_ZLEN
;
1138 unsigned char* buf
= skb
->data
;
1140 if (netwave_hw_xmit( buf
, length
, dev
) == 1) {
1141 /* Some error, let's make them call us another time? */
1142 netif_start_queue(dev
);
1144 dev
->trans_start
= jiffies
;
1149 } /* netwave_start_xmit */
1152 * Function netwave_interrupt (irq, dev_id, regs)
1154 * This function is the interrupt handler for the Netwave card. This
1155 * routine will be called whenever:
1156 * 1. A packet is received.
1157 * 2. A packet has successfully been transferred and the unit is
1158 * ready to transmit another packet.
1159 * 3. A command has completed execution.
1161 static irqreturn_t
netwave_interrupt(int irq
, void* dev_id
, struct pt_regs
*regs
)
1164 u_char __iomem
*ramBase
;
1165 struct net_device
*dev
= (struct net_device
*)dev_id
;
1166 struct netwave_private
*priv
= netdev_priv(dev
);
1167 dev_link_t
*link
= &priv
->link
;
1170 if (!netif_device_present(dev
))
1173 iobase
= dev
->base_addr
;
1174 ramBase
= priv
->ramBase
;
1176 /* Now find what caused the interrupt, check while interrupts ready */
1177 for (i
= 0; i
< 10; i
++) {
1181 if (!(inb(iobase
+NETWAVE_REG_CCSR
) & 0x02))
1182 break; /* None of the interrupt sources asserted (normal exit) */
1184 status
= inb(iobase
+ NETWAVE_REG_ASR
);
1186 if (!DEV_OK(link
)) {
1187 DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1188 "from removed or suspended card!\n", status
);
1193 if (status
& 0x80) {
1195 /* wait_WOC(iobase); */
1196 /* RxRdy cannot be reset directly by the host */
1199 if (status
& 0x40) {
1202 rser
= readb(ramBase
+ NETWAVE_EREG_RSER
);
1205 ++priv
->stats
.rx_dropped
;
1206 ++priv
->stats
.rx_crc_errors
;
1209 ++priv
->stats
.rx_frame_errors
;
1211 /* Clear the RxErr bit in RSER. RSER+4 is the
1212 * write part. Also clear the RxCRC (0x04) and
1213 * RxBig (0x02) bits if present */
1215 writeb(0x40 | (rser
& 0x06), ramBase
+ NETWAVE_EREG_RSER
+ 4);
1217 /* Write bit 6 high to ASCC to clear RxErr in ASR,
1218 * WOC must be set first!
1221 writeb(0x40, ramBase
+ NETWAVE_EREG_ASCC
);
1223 /* Remember to count up priv->stats on error packets */
1224 ++priv
->stats
.rx_errors
;
1227 if (status
& 0x20) {
1230 txStatus
= readb(ramBase
+ NETWAVE_EREG_TSER
);
1231 DEBUG(3, "Transmit done. TSER = %x id %x\n",
1232 txStatus
, readb(ramBase
+ NETWAVE_EREG_TSER
+ 1));
1234 if (txStatus
& 0x20) {
1235 /* Transmitting was okay, clear bits */
1237 writeb(0x2f, ramBase
+ NETWAVE_EREG_TSER
+ 4);
1238 ++priv
->stats
.tx_packets
;
1241 if (txStatus
& 0xd0) {
1242 if (txStatus
& 0x80) {
1243 ++priv
->stats
.collisions
; /* Because of /proc/net/dev*/
1244 /* ++priv->stats.tx_aborted_errors; */
1245 /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1247 if (txStatus
& 0x40)
1248 ++priv
->stats
.tx_carrier_errors
;
1249 /* 0x80 TxGU Transmit giveup - nine times and no luck
1250 * 0x40 TxNOAP No access point. Discarded packet.
1251 * 0x10 TxErr Transmit error. Always set when
1252 * TxGU and TxNOAP is set. (Those are the only ones
1255 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n",
1258 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1260 writeb(0xdf & txStatus
, ramBase
+NETWAVE_EREG_TSER
+4);
1261 ++priv
->stats
.tx_errors
;
1263 DEBUG(3, "New status is TSER %x ASR %x\n",
1264 readb(ramBase
+ NETWAVE_EREG_TSER
),
1265 inb(iobase
+ NETWAVE_REG_ASR
));
1267 netif_wake_queue(dev
);
1269 /* TxBA, this would trigger on all error packets received */
1270 /* if (status & 0x01) {
1271 DEBUG(4, "Transmit buffers available, %x\n", status);
1275 /* Handled if we looped at least one time - Jean II */
1276 return IRQ_RETVAL(i
);
1277 } /* netwave_interrupt */
1280 * Function netwave_watchdog (a)
1282 * Watchdog : when we start a transmission, we set a timer in the
1283 * kernel. If the transmission complete, this timer is disabled. If
1284 * it expire, we reset the card.
1287 static void netwave_watchdog(struct net_device
*dev
) {
1289 DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev
->name
);
1291 dev
->trans_start
= jiffies
;
1292 netif_wake_queue(dev
);
1293 } /* netwave_watchdog */
1295 static struct net_device_stats
*netwave_get_stats(struct net_device
*dev
) {
1296 netwave_private
*priv
= netdev_priv(dev
);
1300 DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1301 " %x tx %x %x %x %x\n",
1302 readb(priv
->ramBase
+ NETWAVE_EREG_SPCQ
),
1303 readb(priv
->ramBase
+ NETWAVE_EREG_SPU
),
1304 readb(priv
->ramBase
+ NETWAVE_EREG_LIF
),
1305 readb(priv
->ramBase
+ NETWAVE_EREG_ISPLQ
),
1306 readb(priv
->ramBase
+ NETWAVE_EREG_MHS
),
1307 readb(priv
->ramBase
+ NETWAVE_EREG_EC
+ 0xe),
1308 readb(priv
->ramBase
+ NETWAVE_EREG_EC
+ 0xf),
1309 readb(priv
->ramBase
+ NETWAVE_EREG_EC
+ 0x18),
1310 readb(priv
->ramBase
+ NETWAVE_EREG_EC
+ 0x19),
1311 readb(priv
->ramBase
+ NETWAVE_EREG_EC
+ 0x1a),
1312 readb(priv
->ramBase
+ NETWAVE_EREG_EC
+ 0x1b));
1314 return &priv
->stats
;
1317 static void update_stats(struct net_device
*dev
) {
1318 //unsigned long flags;
1319 /* netwave_private *priv = netdev_priv(dev); */
1321 //spin_lock_irqsave(&priv->spinlock, flags);
1323 /* priv->stats.rx_packets = readb(priv->ramBase + 0x18e);
1324 priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1326 //spin_unlock_irqrestore(&priv->spinlock, flags);
1329 static int netwave_rx(struct net_device
*dev
)
1331 netwave_private
*priv
= netdev_priv(dev
);
1332 u_char __iomem
*ramBase
= priv
->ramBase
;
1333 kio_addr_t iobase
= dev
->base_addr
;
1335 struct sk_buff
*skb
= NULL
;
1336 unsigned int curBuffer
,
1340 int dataCount
, dataOffset
;
1344 DEBUG(3, "xinw_rx: Receiving ... \n");
1346 /* Receive max 10 packets for now. */
1347 for (i
= 0; i
< 10; i
++) {
1350 rxStatus
= readb(ramBase
+ NETWAVE_EREG_RSER
);
1351 if ( !( rxStatus
& 0x80)) /* No more packets */
1354 /* Check if multicast/broadcast or other */
1355 /* multicast = (rxStatus & 0x20); */
1357 /* The receive list pointer and length of the packet */
1359 rcvLen
= get_int16( ramBase
+ NETWAVE_EREG_RDP
);
1360 rcvList
= get_uint16( ramBase
+ NETWAVE_EREG_RDP
+ 2);
1363 printk(KERN_DEBUG
"netwave_rx: Receive packet with len %d\n",
1368 skb
= dev_alloc_skb(rcvLen
+5);
1370 DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1371 "length %d\n", rcvLen
);
1372 ++priv
->stats
.rx_dropped
;
1373 /* Tell the adapter to skip the packet */
1375 writeb(NETWAVE_CMD_SRP
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1376 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1380 skb_reserve( skb
, 2); /* Align IP on 16 byte */
1381 skb_put( skb
, rcvLen
);
1384 /* Copy packet fragments to the skb data area */
1385 ptr
= (u_char
*) skb
->data
;
1386 curBuffer
= rcvList
;
1388 while ( tmpcount
< rcvLen
) {
1389 /* Get length and offset of current buffer */
1390 dataCount
= get_uint16( ramBase
+curBuffer
+2);
1391 dataOffset
= get_uint16( ramBase
+curBuffer
+4);
1393 copy_from_pc( ptr
+ tmpcount
,
1394 ramBase
+curBuffer
+dataOffset
, dataCount
);
1396 tmpcount
+= dataCount
;
1398 /* Point to next buffer */
1399 curBuffer
= get_uint16(ramBase
+ curBuffer
);
1402 skb
->protocol
= eth_type_trans(skb
,dev
);
1403 /* Queue packet for network layer */
1406 dev
->last_rx
= jiffies
;
1407 priv
->stats
.rx_packets
++;
1408 priv
->stats
.rx_bytes
+= rcvLen
;
1410 /* Got the packet, tell the adapter to skip it */
1412 writeb(NETWAVE_CMD_SRP
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1413 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1414 DEBUG(3, "Packet reception ok\n");
1419 static int netwave_open(struct net_device
*dev
) {
1420 netwave_private
*priv
= netdev_priv(dev
);
1421 dev_link_t
*link
= &priv
->link
;
1423 DEBUG(1, "netwave_open: starting.\n");
1430 netif_start_queue(dev
);
1436 static int netwave_close(struct net_device
*dev
) {
1437 netwave_private
*priv
= netdev_priv(dev
);
1438 dev_link_t
*link
= &priv
->link
;
1440 DEBUG(1, "netwave_close: finishing.\n");
1443 netif_stop_queue(dev
);
1448 static struct pcmcia_device_id netwave_ids
[] = {
1449 PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1452 MODULE_DEVICE_TABLE(pcmcia
, netwave_ids
);
1454 static struct pcmcia_driver netwave_driver
= {
1455 .owner
= THIS_MODULE
,
1457 .name
= "netwave_cs",
1459 .attach
= netwave_attach
,
1460 .event
= netwave_event
,
1461 .remove
= netwave_detach
,
1462 .id_table
= netwave_ids
,
1463 .suspend
= netwave_suspend
,
1464 .resume
= netwave_resume
,
1467 static int __init
init_netwave_cs(void)
1469 return pcmcia_register_driver(&netwave_driver
);
1472 static void __exit
exit_netwave_cs(void)
1474 pcmcia_unregister_driver(&netwave_driver
);
1477 module_init(init_netwave_cs
);
1478 module_exit(exit_netwave_cs
);
1480 /* Set or clear the multicast filter for this adaptor.
1481 num_addrs == -1 Promiscuous mode, receive all packets
1482 num_addrs == 0 Normal mode, clear multicast list
1483 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
1484 best-effort filtering.
1486 static void set_multicast_list(struct net_device
*dev
)
1488 kio_addr_t iobase
= dev
->base_addr
;
1489 netwave_private
*priv
= netdev_priv(dev
);
1490 u_char __iomem
* ramBase
= priv
->ramBase
;
1496 if (old
!= dev
->mc_count
) {
1497 old
= dev
->mc_count
;
1498 DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1499 dev
->name
, dev
->mc_count
);
1504 if (dev
->mc_count
|| (dev
->flags
& IFF_ALLMULTI
)) {
1505 /* Multicast Mode */
1506 rcvMode
= rxConfRxEna
+ rxConfAMP
+ rxConfBcast
;
1507 } else if (dev
->flags
& IFF_PROMISC
) {
1508 /* Promiscous mode */
1509 rcvMode
= rxConfRxEna
+ rxConfPro
+ rxConfAMP
+ rxConfBcast
;
1512 rcvMode
= rxConfRxEna
+ rxConfBcast
;
1515 /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1516 /* Now set receive mode */
1518 writeb(NETWAVE_CMD_SRC
, ramBase
+ NETWAVE_EREG_CB
+ 0);
1519 writeb(rcvMode
, ramBase
+ NETWAVE_EREG_CB
+ 1);
1520 writeb(NETWAVE_CMD_EOC
, ramBase
+ NETWAVE_EREG_CB
+ 2);
1522 MODULE_LICENSE("GPL");