blob: f7724eb2fa7ee35373e41d5f6128612c0dc8a073 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Wavelan Pcmcia driver
3 *
4 * Jean II - HPLB '96
5 *
6 * Reorganisation and extension of the driver.
7 * Original copyright follow. See wavelan_cs.p.h for details.
8 *
9 * This code is derived from Anthony D. Joseph's code and all the changes here
10 * are also under the original copyright below.
11 *
12 * This code supports version 2.00 of WaveLAN/PCMCIA cards (2.4GHz), and
13 * can work on Linux 2.0.36 with support of David Hinds' PCMCIA Card Services
14 *
15 * Joe Finney (joe@comp.lancs.ac.uk) at Lancaster University in UK added
16 * critical code in the routine to initialize the Modem Management Controller.
17 *
18 * Thanks to Alan Cox and Bruce Janson for their advice.
19 *
20 * -- Yunzhou Li (scip4166@nus.sg)
21 *
22#ifdef WAVELAN_ROAMING
23 * Roaming support added 07/22/98 by Justin Seger (jseger@media.mit.edu)
24 * based on patch by Joe Finney from Lancaster University.
25#endif
26 *
27 * Lucent (formerly AT&T GIS, formerly NCR) WaveLAN PCMCIA card: An
28 * Ethernet-like radio transceiver controlled by an Intel 82593 coprocessor.
29 *
30 * A non-shared memory PCMCIA ethernet driver for linux
31 *
32 * ISA version modified to support PCMCIA by Anthony Joseph (adj@lcs.mit.edu)
33 *
34 *
35 * Joseph O'Sullivan & John Langford (josullvn@cs.cmu.edu & jcl@cs.cmu.edu)
36 *
37 * Apr 2 '98 made changes to bring the i82593 control/int handling in line
38 * with offical specs...
39 *
40 ****************************************************************************
41 * Copyright 1995
42 * Anthony D. Joseph
43 * Massachusetts Institute of Technology
44 *
45 * Permission to use, copy, modify, and distribute this program
46 * for any purpose and without fee is hereby granted, provided
47 * that this copyright and permission notice appear on all copies
48 * and supporting documentation, the name of M.I.T. not be used
49 * in advertising or publicity pertaining to distribution of the
50 * program without specific prior permission, and notice be given
51 * in supporting documentation that copying and distribution is
52 * by permission of M.I.T. M.I.T. makes no representations about
53 * the suitability of this software for any purpose. It is pro-
54 * vided "as is" without express or implied warranty.
55 ****************************************************************************
56 *
57 */
58
59/* Do *NOT* add other headers here, you are guaranteed to be wrong - Jean II */
60#include "wavelan_cs.p.h" /* Private header */
61
Jouni Malinenff1d2762005-05-12 22:54:16 -040062#ifdef WAVELAN_ROAMING
63static void wl_cell_expiry(unsigned long data);
64static void wl_del_wavepoint(wavepoint_history *wavepoint, struct net_local *lp);
65static void wv_nwid_filter(unsigned char mode, net_local *lp);
66#endif /* WAVELAN_ROAMING */
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068/************************* MISC SUBROUTINES **************************/
69/*
70 * Subroutines which won't fit in one of the following category
71 * (wavelan modem or i82593)
72 */
73
74#ifdef STRUCT_CHECK
75/*------------------------------------------------------------------*/
76/*
77 * Sanity routine to verify the sizes of the various WaveLAN interface
78 * structures.
79 */
80static char *
81wv_structuct_check(void)
82{
83#define SC(t,s,n) if (sizeof(t) != s) return(n);
84
85 SC(psa_t, PSA_SIZE, "psa_t");
86 SC(mmw_t, MMW_SIZE, "mmw_t");
87 SC(mmr_t, MMR_SIZE, "mmr_t");
88
89#undef SC
90
91 return((char *) NULL);
92} /* wv_structuct_check */
93#endif /* STRUCT_CHECK */
94
95/******************* MODEM MANAGEMENT SUBROUTINES *******************/
96/*
97 * Useful subroutines to manage the modem of the wavelan
98 */
99
100/*------------------------------------------------------------------*/
101/*
102 * Read from card's Host Adaptor Status Register.
103 */
104static inline u_char
105hasr_read(u_long base)
106{
107 return(inb(HASR(base)));
108} /* hasr_read */
109
110/*------------------------------------------------------------------*/
111/*
112 * Write to card's Host Adapter Command Register.
113 */
114static inline void
115hacr_write(u_long base,
116 u_char hacr)
117{
118 outb(hacr, HACR(base));
119} /* hacr_write */
120
121/*------------------------------------------------------------------*/
122/*
123 * Write to card's Host Adapter Command Register. Include a delay for
124 * those times when it is needed.
125 */
126static inline void
127hacr_write_slow(u_long base,
128 u_char hacr)
129{
130 hacr_write(base, hacr);
131 /* delay might only be needed sometimes */
132 mdelay(1);
133} /* hacr_write_slow */
134
135/*------------------------------------------------------------------*/
136/*
137 * Read the Parameter Storage Area from the WaveLAN card's memory
138 */
139static void
140psa_read(struct net_device * dev,
141 int o, /* offset in PSA */
142 u_char * b, /* buffer to fill */
143 int n) /* size to read */
144{
145 net_local *lp = netdev_priv(dev);
146 u_char __iomem *ptr = lp->mem + PSA_ADDR + (o << 1);
147
148 while(n-- > 0)
149 {
150 *b++ = readb(ptr);
151 /* Due to a lack of address decode pins, the WaveLAN PCMCIA card
152 * only supports reading even memory addresses. That means the
153 * increment here MUST be two.
154 * Because of that, we can't use memcpy_fromio()...
155 */
156 ptr += 2;
157 }
158} /* psa_read */
159
160/*------------------------------------------------------------------*/
161/*
162 * Write the Paramter Storage Area to the WaveLAN card's memory
163 */
164static void
165psa_write(struct net_device * dev,
166 int o, /* Offset in psa */
167 u_char * b, /* Buffer in memory */
168 int n) /* Length of buffer */
169{
170 net_local *lp = netdev_priv(dev);
171 u_char __iomem *ptr = lp->mem + PSA_ADDR + (o << 1);
172 int count = 0;
173 kio_addr_t base = dev->base_addr;
174 /* As there seem to have no flag PSA_BUSY as in the ISA model, we are
175 * oblige to verify this address to know when the PSA is ready... */
176 volatile u_char __iomem *verify = lp->mem + PSA_ADDR +
177 (psaoff(0, psa_comp_number) << 1);
178
179 /* Authorize writting to PSA */
180 hacr_write(base, HACR_PWR_STAT | HACR_ROM_WEN);
181
182 while(n-- > 0)
183 {
184 /* write to PSA */
185 writeb(*b++, ptr);
186 ptr += 2;
187
188 /* I don't have the spec, so I don't know what the correct
189 * sequence to write is. This hack seem to work for me... */
190 count = 0;
191 while((readb(verify) != PSA_COMP_PCMCIA_915) && (count++ < 100))
192 mdelay(1);
193 }
194
195 /* Put the host interface back in standard state */
196 hacr_write(base, HACR_DEFAULT);
197} /* psa_write */
198
199#ifdef SET_PSA_CRC
200/*------------------------------------------------------------------*/
201/*
202 * Calculate the PSA CRC
203 * Thanks to Valster, Nico <NVALSTER@wcnd.nl.lucent.com> for the code
204 * NOTE: By specifying a length including the CRC position the
205 * returned value should be zero. (i.e. a correct checksum in the PSA)
206 *
207 * The Windows drivers don't use the CRC, but the AP and the PtP tool
208 * depend on it.
209 */
210static u_short
211psa_crc(unsigned char * psa, /* The PSA */
212 int size) /* Number of short for CRC */
213{
214 int byte_cnt; /* Loop on the PSA */
215 u_short crc_bytes = 0; /* Data in the PSA */
216 int bit_cnt; /* Loop on the bits of the short */
217
218 for(byte_cnt = 0; byte_cnt < size; byte_cnt++ )
219 {
220 crc_bytes ^= psa[byte_cnt]; /* Its an xor */
221
222 for(bit_cnt = 1; bit_cnt < 9; bit_cnt++ )
223 {
224 if(crc_bytes & 0x0001)
225 crc_bytes = (crc_bytes >> 1) ^ 0xA001;
226 else
227 crc_bytes >>= 1 ;
228 }
229 }
230
231 return crc_bytes;
232} /* psa_crc */
233#endif /* SET_PSA_CRC */
234
235/*------------------------------------------------------------------*/
236/*
237 * update the checksum field in the Wavelan's PSA
238 */
239static void
240update_psa_checksum(struct net_device * dev)
241{
242#ifdef SET_PSA_CRC
243 psa_t psa;
244 u_short crc;
245
246 /* read the parameter storage area */
247 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
248
249 /* update the checksum */
250 crc = psa_crc((unsigned char *) &psa,
251 sizeof(psa) - sizeof(psa.psa_crc[0]) - sizeof(psa.psa_crc[1])
252 - sizeof(psa.psa_crc_status));
253
254 psa.psa_crc[0] = crc & 0xFF;
255 psa.psa_crc[1] = (crc & 0xFF00) >> 8;
256
257 /* Write it ! */
258 psa_write(dev, (char *)&psa.psa_crc - (char *)&psa,
259 (unsigned char *)&psa.psa_crc, 2);
260
261#ifdef DEBUG_IOCTL_INFO
262 printk (KERN_DEBUG "%s: update_psa_checksum(): crc = 0x%02x%02x\n",
263 dev->name, psa.psa_crc[0], psa.psa_crc[1]);
264
265 /* Check again (luxury !) */
266 crc = psa_crc((unsigned char *) &psa,
267 sizeof(psa) - sizeof(psa.psa_crc_status));
268
269 if(crc != 0)
270 printk(KERN_WARNING "%s: update_psa_checksum(): CRC does not agree with PSA data (even after recalculating)\n", dev->name);
271#endif /* DEBUG_IOCTL_INFO */
272#endif /* SET_PSA_CRC */
273} /* update_psa_checksum */
274
275/*------------------------------------------------------------------*/
276/*
277 * Write 1 byte to the MMC.
278 */
279static inline void
280mmc_out(u_long base,
281 u_short o,
282 u_char d)
283{
284 int count = 0;
285
286 /* Wait for MMC to go idle */
287 while((count++ < 100) && (inb(HASR(base)) & HASR_MMI_BUSY))
288 udelay(10);
289
290 outb((u_char)((o << 1) | MMR_MMI_WR), MMR(base));
291 outb(d, MMD(base));
292}
293
294/*------------------------------------------------------------------*/
295/*
296 * Routine to write bytes to the Modem Management Controller.
297 * We start by the end because it is the way it should be !
298 */
299static inline void
300mmc_write(u_long base,
301 u_char o,
302 u_char * b,
303 int n)
304{
305 o += n;
306 b += n;
307
308 while(n-- > 0 )
309 mmc_out(base, --o, *(--b));
310} /* mmc_write */
311
312/*------------------------------------------------------------------*/
313/*
314 * Read 1 byte from the MMC.
315 * Optimised version for 1 byte, avoid using memory...
316 */
317static inline u_char
318mmc_in(u_long base,
319 u_short o)
320{
321 int count = 0;
322
323 while((count++ < 100) && (inb(HASR(base)) & HASR_MMI_BUSY))
324 udelay(10);
325 outb(o << 1, MMR(base)); /* Set the read address */
326
327 outb(0, MMD(base)); /* Required dummy write */
328
329 while((count++ < 100) && (inb(HASR(base)) & HASR_MMI_BUSY))
330 udelay(10);
331 return (u_char) (inb(MMD(base))); /* Now do the actual read */
332}
333
334/*------------------------------------------------------------------*/
335/*
336 * Routine to read bytes from the Modem Management Controller.
337 * The implementation is complicated by a lack of address lines,
338 * which prevents decoding of the low-order bit.
339 * (code has just been moved in the above function)
340 * We start by the end because it is the way it should be !
341 */
342static inline void
343mmc_read(u_long base,
344 u_char o,
345 u_char * b,
346 int n)
347{
348 o += n;
349 b += n;
350
351 while(n-- > 0)
352 *(--b) = mmc_in(base, --o);
353} /* mmc_read */
354
355/*------------------------------------------------------------------*/
356/*
357 * Get the type of encryption available...
358 */
359static inline int
360mmc_encr(u_long base) /* i/o port of the card */
361{
362 int temp;
363
364 temp = mmc_in(base, mmroff(0, mmr_des_avail));
365 if((temp != MMR_DES_AVAIL_DES) && (temp != MMR_DES_AVAIL_AES))
366 return 0;
367 else
368 return temp;
369}
370
371/*------------------------------------------------------------------*/
372/*
373 * Wait for the frequency EEprom to complete a command...
374 * I hope this one will be optimally inlined...
375 */
376static inline void
377fee_wait(u_long base, /* i/o port of the card */
378 int delay, /* Base delay to wait for */
379 int number) /* Number of time to wait */
380{
381 int count = 0; /* Wait only a limited time */
382
383 while((count++ < number) &&
384 (mmc_in(base, mmroff(0, mmr_fee_status)) & MMR_FEE_STATUS_BUSY))
385 udelay(delay);
386}
387
388/*------------------------------------------------------------------*/
389/*
390 * Read bytes from the Frequency EEprom (frequency select cards).
391 */
392static void
393fee_read(u_long base, /* i/o port of the card */
394 u_short o, /* destination offset */
395 u_short * b, /* data buffer */
396 int n) /* number of registers */
397{
398 b += n; /* Position at the end of the area */
399
400 /* Write the address */
401 mmc_out(base, mmwoff(0, mmw_fee_addr), o + n - 1);
402
403 /* Loop on all buffer */
404 while(n-- > 0)
405 {
406 /* Write the read command */
407 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_READ);
408
409 /* Wait until EEprom is ready (should be quick !) */
410 fee_wait(base, 10, 100);
411
412 /* Read the value */
413 *--b = ((mmc_in(base, mmroff(0, mmr_fee_data_h)) << 8) |
414 mmc_in(base, mmroff(0, mmr_fee_data_l)));
415 }
416}
417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419/*------------------------------------------------------------------*/
420/*
421 * Write bytes from the Frequency EEprom (frequency select cards).
422 * This is a bit complicated, because the frequency eeprom has to
423 * be unprotected and the write enabled.
424 * Jean II
425 */
426static void
427fee_write(u_long base, /* i/o port of the card */
428 u_short o, /* destination offset */
429 u_short * b, /* data buffer */
430 int n) /* number of registers */
431{
432 b += n; /* Position at the end of the area */
433
434#ifdef EEPROM_IS_PROTECTED /* disabled */
435#ifdef DOESNT_SEEM_TO_WORK /* disabled */
436 /* Ask to read the protected register */
437 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRREAD);
438
439 fee_wait(base, 10, 100);
440
441 /* Read the protected register */
442 printk("Protected 2 : %02X-%02X\n",
443 mmc_in(base, mmroff(0, mmr_fee_data_h)),
444 mmc_in(base, mmroff(0, mmr_fee_data_l)));
445#endif /* DOESNT_SEEM_TO_WORK */
446
447 /* Enable protected register */
448 mmc_out(base, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN);
449 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PREN);
450
451 fee_wait(base, 10, 100);
452
453 /* Unprotect area */
454 mmc_out(base, mmwoff(0, mmw_fee_addr), o + n);
455 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
456#ifdef DOESNT_SEEM_TO_WORK /* disabled */
457 /* Or use : */
458 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRCLEAR);
459#endif /* DOESNT_SEEM_TO_WORK */
460
461 fee_wait(base, 10, 100);
462#endif /* EEPROM_IS_PROTECTED */
463
464 /* Write enable */
465 mmc_out(base, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN);
466 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WREN);
467
468 fee_wait(base, 10, 100);
469
470 /* Write the EEprom address */
471 mmc_out(base, mmwoff(0, mmw_fee_addr), o + n - 1);
472
473 /* Loop on all buffer */
474 while(n-- > 0)
475 {
476 /* Write the value */
477 mmc_out(base, mmwoff(0, mmw_fee_data_h), (*--b) >> 8);
478 mmc_out(base, mmwoff(0, mmw_fee_data_l), *b & 0xFF);
479
480 /* Write the write command */
481 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WRITE);
482
483 /* Wavelan doc says : wait at least 10 ms for EEBUSY = 0 */
484 mdelay(10);
485 fee_wait(base, 10, 100);
486 }
487
488 /* Write disable */
489 mmc_out(base, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_DS);
490 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WDS);
491
492 fee_wait(base, 10, 100);
493
494#ifdef EEPROM_IS_PROTECTED /* disabled */
495 /* Reprotect EEprom */
496 mmc_out(base, mmwoff(0, mmw_fee_addr), 0x00);
497 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
498
499 fee_wait(base, 10, 100);
500#endif /* EEPROM_IS_PROTECTED */
501}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503/******************* WaveLAN Roaming routines... ********************/
504
505#ifdef WAVELAN_ROAMING /* Conditional compile, see wavelan_cs.h */
506
Jouni Malinenff1d2762005-05-12 22:54:16 -0400507static unsigned char WAVELAN_BEACON_ADDRESS[] = {0x09,0x00,0x0e,0x20,0x03,0x00};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Jouni Malinenff1d2762005-05-12 22:54:16 -0400509static void wv_roam_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
511 net_local *lp= netdev_priv(dev);
512
513 /* Do not remove this unless you have a good reason */
514 printk(KERN_NOTICE "%s: Warning, you have enabled roaming on"
515 " device %s !\n", dev->name, dev->name);
516 printk(KERN_NOTICE "Roaming is currently an experimental unsupported feature"
517 " of the Wavelan driver.\n");
518 printk(KERN_NOTICE "It may work, but may also make the driver behave in"
519 " erratic ways or crash.\n");
520
521 lp->wavepoint_table.head=NULL; /* Initialise WavePoint table */
522 lp->wavepoint_table.num_wavepoints=0;
523 lp->wavepoint_table.locked=0;
524 lp->curr_point=NULL; /* No default WavePoint */
525 lp->cell_search=0;
526
527 lp->cell_timer.data=(long)lp; /* Start cell expiry timer */
528 lp->cell_timer.function=wl_cell_expiry;
529 lp->cell_timer.expires=jiffies+CELL_TIMEOUT;
530 add_timer(&lp->cell_timer);
531
532 wv_nwid_filter(NWID_PROMISC,lp) ; /* Enter NWID promiscuous mode */
533 /* to build up a good WavePoint */
534 /* table... */
535 printk(KERN_DEBUG "WaveLAN: Roaming enabled on device %s\n",dev->name);
536}
537
Jouni Malinenff1d2762005-05-12 22:54:16 -0400538static void wv_roam_cleanup(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
540 wavepoint_history *ptr,*old_ptr;
541 net_local *lp= netdev_priv(dev);
542
543 printk(KERN_DEBUG "WaveLAN: Roaming Disabled on device %s\n",dev->name);
544
545 /* Fixme : maybe we should check that the timer exist before deleting it */
546 del_timer(&lp->cell_timer); /* Remove cell expiry timer */
547 ptr=lp->wavepoint_table.head; /* Clear device's WavePoint table */
548 while(ptr!=NULL)
549 {
550 old_ptr=ptr;
551 ptr=ptr->next;
552 wl_del_wavepoint(old_ptr,lp);
553 }
554}
555
556/* Enable/Disable NWID promiscuous mode on a given device */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400557static void wv_nwid_filter(unsigned char mode, net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 mm_t m;
560 unsigned long flags;
561
562#ifdef WAVELAN_ROAMING_DEBUG
563 printk(KERN_DEBUG "WaveLAN: NWID promisc %s, device %s\n",(mode==NWID_PROMISC) ? "on" : "off", lp->dev->name);
564#endif
565
566 /* Disable interrupts & save flags */
567 spin_lock_irqsave(&lp->spinlock, flags);
568
569 m.w.mmw_loopt_sel = (mode==NWID_PROMISC) ? MMW_LOOPT_SEL_DIS_NWID : 0x00;
570 mmc_write(lp->dev->base_addr, (char *)&m.w.mmw_loopt_sel - (char *)&m, (unsigned char *)&m.w.mmw_loopt_sel, 1);
571
572 if(mode==NWID_PROMISC)
573 lp->cell_search=1;
574 else
575 lp->cell_search=0;
576
577 /* ReEnable interrupts & restore flags */
578 spin_unlock_irqrestore(&lp->spinlock, flags);
579}
580
581/* Find a record in the WavePoint table matching a given NWID */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400582static wavepoint_history *wl_roam_check(unsigned short nwid, net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
584 wavepoint_history *ptr=lp->wavepoint_table.head;
585
586 while(ptr!=NULL){
587 if(ptr->nwid==nwid)
588 return ptr;
589 ptr=ptr->next;
590 }
591 return NULL;
592}
593
594/* Create a new wavepoint table entry */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400595static wavepoint_history *wl_new_wavepoint(unsigned short nwid, unsigned char seq, net_local* lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
597 wavepoint_history *new_wavepoint;
598
599#ifdef WAVELAN_ROAMING_DEBUG
600 printk(KERN_DEBUG "WaveLAN: New Wavepoint, NWID:%.4X\n",nwid);
601#endif
602
603 if(lp->wavepoint_table.num_wavepoints==MAX_WAVEPOINTS)
604 return NULL;
605
606 new_wavepoint=(wavepoint_history *) kmalloc(sizeof(wavepoint_history),GFP_ATOMIC);
607 if(new_wavepoint==NULL)
608 return NULL;
609
610 new_wavepoint->nwid=nwid; /* New WavePoints NWID */
611 new_wavepoint->average_fast=0; /* Running Averages..*/
612 new_wavepoint->average_slow=0;
613 new_wavepoint->qualptr=0; /* Start of ringbuffer */
614 new_wavepoint->last_seq=seq-1; /* Last sequence no.seen */
615 memset(new_wavepoint->sigqual,0,WAVEPOINT_HISTORY);/* Empty ringbuffer */
616
617 new_wavepoint->next=lp->wavepoint_table.head;/* Add to wavepoint table */
618 new_wavepoint->prev=NULL;
619
620 if(lp->wavepoint_table.head!=NULL)
621 lp->wavepoint_table.head->prev=new_wavepoint;
622
623 lp->wavepoint_table.head=new_wavepoint;
624
625 lp->wavepoint_table.num_wavepoints++; /* no. of visible wavepoints */
626
627 return new_wavepoint;
628}
629
630/* Remove a wavepoint entry from WavePoint table */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400631static void wl_del_wavepoint(wavepoint_history *wavepoint, struct net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632{
633 if(wavepoint==NULL)
634 return;
635
636 if(lp->curr_point==wavepoint)
637 lp->curr_point=NULL;
638
639 if(wavepoint->prev!=NULL)
640 wavepoint->prev->next=wavepoint->next;
641
642 if(wavepoint->next!=NULL)
643 wavepoint->next->prev=wavepoint->prev;
644
645 if(lp->wavepoint_table.head==wavepoint)
646 lp->wavepoint_table.head=wavepoint->next;
647
648 lp->wavepoint_table.num_wavepoints--;
649 kfree(wavepoint);
650}
651
652/* Timer callback function - checks WavePoint table for stale entries */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400653static void wl_cell_expiry(unsigned long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
655 net_local *lp=(net_local *)data;
656 wavepoint_history *wavepoint=lp->wavepoint_table.head,*old_point;
657
658#if WAVELAN_ROAMING_DEBUG > 1
659 printk(KERN_DEBUG "WaveLAN: Wavepoint timeout, dev %s\n",lp->dev->name);
660#endif
661
662 if(lp->wavepoint_table.locked)
663 {
664#if WAVELAN_ROAMING_DEBUG > 1
665 printk(KERN_DEBUG "WaveLAN: Wavepoint table locked...\n");
666#endif
667
668 lp->cell_timer.expires=jiffies+1; /* If table in use, come back later */
669 add_timer(&lp->cell_timer);
670 return;
671 }
672
673 while(wavepoint!=NULL)
674 {
675 if(time_after(jiffies, wavepoint->last_seen + CELL_TIMEOUT))
676 {
677#ifdef WAVELAN_ROAMING_DEBUG
678 printk(KERN_DEBUG "WaveLAN: Bye bye %.4X\n",wavepoint->nwid);
679#endif
680
681 old_point=wavepoint;
682 wavepoint=wavepoint->next;
683 wl_del_wavepoint(old_point,lp);
684 }
685 else
686 wavepoint=wavepoint->next;
687 }
688 lp->cell_timer.expires=jiffies+CELL_TIMEOUT;
689 add_timer(&lp->cell_timer);
690}
691
692/* Update SNR history of a wavepoint */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400693static void wl_update_history(wavepoint_history *wavepoint, unsigned char sigqual, unsigned char seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
695 int i=0,num_missed=0,ptr=0;
696 int average_fast=0,average_slow=0;
697
698 num_missed=(seq-wavepoint->last_seq)%WAVEPOINT_HISTORY;/* Have we missed
699 any beacons? */
700 if(num_missed)
701 for(i=0;i<num_missed;i++)
702 {
703 wavepoint->sigqual[wavepoint->qualptr++]=0; /* If so, enter them as 0's */
704 wavepoint->qualptr %=WAVEPOINT_HISTORY; /* in the ringbuffer. */
705 }
706 wavepoint->last_seen=jiffies; /* Add beacon to history */
707 wavepoint->last_seq=seq;
708 wavepoint->sigqual[wavepoint->qualptr++]=sigqual;
709 wavepoint->qualptr %=WAVEPOINT_HISTORY;
710 ptr=(wavepoint->qualptr-WAVEPOINT_FAST_HISTORY+WAVEPOINT_HISTORY)%WAVEPOINT_HISTORY;
711
712 for(i=0;i<WAVEPOINT_FAST_HISTORY;i++) /* Update running averages */
713 {
714 average_fast+=wavepoint->sigqual[ptr++];
715 ptr %=WAVEPOINT_HISTORY;
716 }
717
718 average_slow=average_fast;
719 for(i=WAVEPOINT_FAST_HISTORY;i<WAVEPOINT_HISTORY;i++)
720 {
721 average_slow+=wavepoint->sigqual[ptr++];
722 ptr %=WAVEPOINT_HISTORY;
723 }
724
725 wavepoint->average_fast=average_fast/WAVEPOINT_FAST_HISTORY;
726 wavepoint->average_slow=average_slow/WAVEPOINT_HISTORY;
727}
728
729/* Perform a handover to a new WavePoint */
Jouni Malinenff1d2762005-05-12 22:54:16 -0400730static void wv_roam_handover(wavepoint_history *wavepoint, net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 kio_addr_t base = lp->dev->base_addr;
733 mm_t m;
734 unsigned long flags;
735
736 if(wavepoint==lp->curr_point) /* Sanity check... */
737 {
738 wv_nwid_filter(!NWID_PROMISC,lp);
739 return;
740 }
741
742#ifdef WAVELAN_ROAMING_DEBUG
743 printk(KERN_DEBUG "WaveLAN: Doing handover to %.4X, dev %s\n",wavepoint->nwid,lp->dev->name);
744#endif
745
746 /* Disable interrupts & save flags */
747 spin_lock_irqsave(&lp->spinlock, flags);
748
749 m.w.mmw_netw_id_l = wavepoint->nwid & 0xFF;
750 m.w.mmw_netw_id_h = (wavepoint->nwid & 0xFF00) >> 8;
751
752 mmc_write(base, (char *)&m.w.mmw_netw_id_l - (char *)&m, (unsigned char *)&m.w.mmw_netw_id_l, 2);
753
754 /* ReEnable interrupts & restore flags */
755 spin_unlock_irqrestore(&lp->spinlock, flags);
756
757 wv_nwid_filter(!NWID_PROMISC,lp);
758 lp->curr_point=wavepoint;
759}
760
761/* Called when a WavePoint beacon is received */
762static inline void wl_roam_gather(struct net_device * dev,
763 u_char * hdr, /* Beacon header */
764 u_char * stats) /* SNR, Signal quality
765 of packet */
766{
767 wavepoint_beacon *beacon= (wavepoint_beacon *)hdr; /* Rcvd. Beacon */
768 unsigned short nwid=ntohs(beacon->nwid);
769 unsigned short sigqual=stats[2] & MMR_SGNL_QUAL; /* SNR of beacon */
770 wavepoint_history *wavepoint=NULL; /* WavePoint table entry */
771 net_local *lp = netdev_priv(dev); /* Device info */
772
773#ifdef I_NEED_THIS_FEATURE
774 /* Some people don't need this, some other may need it */
775 nwid=nwid^ntohs(beacon->domain_id);
776#endif
777
778#if WAVELAN_ROAMING_DEBUG > 1
779 printk(KERN_DEBUG "WaveLAN: beacon, dev %s:\n",dev->name);
780 printk(KERN_DEBUG "Domain: %.4X NWID: %.4X SigQual=%d\n",ntohs(beacon->domain_id),nwid,sigqual);
781#endif
782
783 lp->wavepoint_table.locked=1; /* <Mutex> */
784
785 wavepoint=wl_roam_check(nwid,lp); /* Find WavePoint table entry */
786 if(wavepoint==NULL) /* If no entry, Create a new one... */
787 {
788 wavepoint=wl_new_wavepoint(nwid,beacon->seq,lp);
789 if(wavepoint==NULL)
790 goto out;
791 }
792 if(lp->curr_point==NULL) /* If this is the only WavePoint, */
793 wv_roam_handover(wavepoint, lp); /* Jump on it! */
794
795 wl_update_history(wavepoint, sigqual, beacon->seq); /* Update SNR history
796 stats. */
797
798 if(lp->curr_point->average_slow < SEARCH_THRESH_LOW) /* If our current */
799 if(!lp->cell_search) /* WavePoint is getting faint, */
800 wv_nwid_filter(NWID_PROMISC,lp); /* start looking for a new one */
801
802 if(wavepoint->average_slow >
803 lp->curr_point->average_slow + WAVELAN_ROAMING_DELTA)
804 wv_roam_handover(wavepoint, lp); /* Handover to a better WavePoint */
805
806 if(lp->curr_point->average_slow > SEARCH_THRESH_HIGH) /* If our SNR is */
807 if(lp->cell_search) /* getting better, drop out of cell search mode */
808 wv_nwid_filter(!NWID_PROMISC,lp);
809
810out:
811 lp->wavepoint_table.locked=0; /* </MUTEX> :-) */
812}
813
814/* Test this MAC frame a WavePoint beacon */
815static inline int WAVELAN_BEACON(unsigned char *data)
816{
817 wavepoint_beacon *beacon= (wavepoint_beacon *)data;
818 static wavepoint_beacon beacon_template={0xaa,0xaa,0x03,0x08,0x00,0x0e,0x20,0x03,0x00};
819
820 if(memcmp(beacon,&beacon_template,9)==0)
821 return 1;
822 else
823 return 0;
824}
825#endif /* WAVELAN_ROAMING */
826
827/************************ I82593 SUBROUTINES *************************/
828/*
829 * Useful subroutines to manage the Ethernet controller
830 */
831
832/*------------------------------------------------------------------*/
833/*
834 * Routine to synchronously send a command to the i82593 chip.
835 * Should be called with interrupts disabled.
836 * (called by wv_packet_write(), wv_ru_stop(), wv_ru_start(),
837 * wv_82593_config() & wv_diag())
838 */
839static int
840wv_82593_cmd(struct net_device * dev,
841 char * str,
842 int cmd,
843 int result)
844{
845 kio_addr_t base = dev->base_addr;
846 int status;
847 int wait_completed;
848 long spin;
849
850 /* Spin until the chip finishes executing its current command (if any) */
851 spin = 1000;
852 do
853 {
854 /* Time calibration of the loop */
855 udelay(10);
856
857 /* Read the interrupt register */
858 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
859 status = inb(LCSR(base));
860 }
861 while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin-- > 0));
862
863 /* If the interrupt hasn't be posted */
864 if(spin <= 0)
865 {
866#ifdef DEBUG_INTERRUPT_ERROR
867 printk(KERN_INFO "wv_82593_cmd: %s timeout (previous command), status 0x%02x\n",
868 str, status);
869#endif
870 return(FALSE);
871 }
872
873 /* Issue the command to the controller */
874 outb(cmd, LCCR(base));
875
876 /* If we don't have to check the result of the command
877 * Note : this mean that the irq handler will deal with that */
878 if(result == SR0_NO_RESULT)
879 return(TRUE);
880
881 /* We are waiting for command completion */
882 wait_completed = TRUE;
883
884 /* Busy wait while the LAN controller executes the command. */
885 spin = 1000;
886 do
887 {
888 /* Time calibration of the loop */
889 udelay(10);
890
891 /* Read the interrupt register */
892 outb(CR0_STATUS_0 | OP0_NOP, LCCR(base));
893 status = inb(LCSR(base));
894
895 /* Check if there was an interrupt posted */
896 if((status & SR0_INTERRUPT))
897 {
898 /* Acknowledge the interrupt */
899 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
900
901 /* Check if interrupt is a command completion */
902 if(((status & SR0_BOTH_RX_TX) != SR0_BOTH_RX_TX) &&
903 ((status & SR0_BOTH_RX_TX) != 0x0) &&
904 !(status & SR0_RECEPTION))
905 {
906 /* Signal command completion */
907 wait_completed = FALSE;
908 }
909 else
910 {
911 /* Note : Rx interrupts will be handled later, because we can
912 * handle multiple Rx packets at once */
913#ifdef DEBUG_INTERRUPT_INFO
914 printk(KERN_INFO "wv_82593_cmd: not our interrupt\n");
915#endif
916 }
917 }
918 }
919 while(wait_completed && (spin-- > 0));
920
921 /* If the interrupt hasn't be posted */
922 if(wait_completed)
923 {
924#ifdef DEBUG_INTERRUPT_ERROR
925 printk(KERN_INFO "wv_82593_cmd: %s timeout, status 0x%02x\n",
926 str, status);
927#endif
928 return(FALSE);
929 }
930
931 /* Check the return code returned by the card (see above) against
932 * the expected return code provided by the caller */
933 if((status & SR0_EVENT_MASK) != result)
934 {
935#ifdef DEBUG_INTERRUPT_ERROR
936 printk(KERN_INFO "wv_82593_cmd: %s failed, status = 0x%x\n",
937 str, status);
938#endif
939 return(FALSE);
940 }
941
942 return(TRUE);
943} /* wv_82593_cmd */
944
945/*------------------------------------------------------------------*/
946/*
947 * This routine does a 593 op-code number 7, and obtains the diagnose
948 * status for the WaveLAN.
949 */
950static inline int
951wv_diag(struct net_device * dev)
952{
Jean Tourrilhesaca0b512006-02-16 17:44:54 -0800953 return(wv_82593_cmd(dev, "wv_diag(): diagnose",
954 OP0_DIAGNOSE, SR0_DIAGNOSE_PASSED));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955} /* wv_diag */
956
957/*------------------------------------------------------------------*/
958/*
959 * Routine to read len bytes from the i82593's ring buffer, starting at
960 * chip address addr. The results read from the chip are stored in buf.
961 * The return value is the address to use for next the call.
962 */
963static int
964read_ringbuf(struct net_device * dev,
965 int addr,
966 char * buf,
967 int len)
968{
969 kio_addr_t base = dev->base_addr;
970 int ring_ptr = addr;
971 int chunk_len;
972 char * buf_ptr = buf;
973
974 /* Get all the buffer */
975 while(len > 0)
976 {
977 /* Position the Program I/O Register at the ring buffer pointer */
978 outb(ring_ptr & 0xff, PIORL(base));
979 outb(((ring_ptr >> 8) & PIORH_MASK), PIORH(base));
980
981 /* First, determine how much we can read without wrapping around the
982 ring buffer */
983 if((addr + len) < (RX_BASE + RX_SIZE))
984 chunk_len = len;
985 else
986 chunk_len = RX_BASE + RX_SIZE - addr;
987 insb(PIOP(base), buf_ptr, chunk_len);
988 buf_ptr += chunk_len;
989 len -= chunk_len;
990 ring_ptr = (ring_ptr - RX_BASE + chunk_len) % RX_SIZE + RX_BASE;
991 }
992 return(ring_ptr);
993} /* read_ringbuf */
994
995/*------------------------------------------------------------------*/
996/*
997 * Reconfigure the i82593, or at least ask for it...
998 * Because wv_82593_config use the transmission buffer, we must do it
999 * when we are sure that there is no transmission, so we do it now
1000 * or in wavelan_packet_xmit() (I can't find any better place,
1001 * wavelan_interrupt is not an option...), so you may experience
1002 * some delay sometime...
1003 */
1004static inline void
1005wv_82593_reconfig(struct net_device * dev)
1006{
1007 net_local * lp = netdev_priv(dev);
Dominik Brodowskifba395e2006-03-31 17:21:06 +02001008 struct pcmcia_device * link = lp->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 unsigned long flags;
1010
1011 /* Arm the flag, will be cleard in wv_82593_config() */
1012 lp->reconfig_82593 = TRUE;
1013
1014 /* Check if we can do it now ! */
1015 if((link->open) && (netif_running(dev)) && !(netif_queue_stopped(dev)))
1016 {
1017 spin_lock_irqsave(&lp->spinlock, flags); /* Disable interrupts */
1018 wv_82593_config(dev);
1019 spin_unlock_irqrestore(&lp->spinlock, flags); /* Re-enable interrupts */
1020 }
1021 else
1022 {
1023#ifdef DEBUG_IOCTL_INFO
1024 printk(KERN_DEBUG
1025 "%s: wv_82593_reconfig(): delayed (state = %lX, link = %d)\n",
1026 dev->name, dev->state, link->open);
1027#endif
1028 }
1029}
1030
1031/********************* DEBUG & INFO SUBROUTINES *********************/
1032/*
1033 * This routines are used in the code to show debug informations.
1034 * Most of the time, it dump the content of hardware structures...
1035 */
1036
1037#ifdef DEBUG_PSA_SHOW
1038/*------------------------------------------------------------------*/
1039/*
1040 * Print the formatted contents of the Parameter Storage Area.
1041 */
1042static void
1043wv_psa_show(psa_t * p)
1044{
1045 printk(KERN_DEBUG "##### wavelan psa contents: #####\n");
1046 printk(KERN_DEBUG "psa_io_base_addr_1: 0x%02X %02X %02X %02X\n",
1047 p->psa_io_base_addr_1,
1048 p->psa_io_base_addr_2,
1049 p->psa_io_base_addr_3,
1050 p->psa_io_base_addr_4);
1051 printk(KERN_DEBUG "psa_rem_boot_addr_1: 0x%02X %02X %02X\n",
1052 p->psa_rem_boot_addr_1,
1053 p->psa_rem_boot_addr_2,
1054 p->psa_rem_boot_addr_3);
1055 printk(KERN_DEBUG "psa_holi_params: 0x%02x, ", p->psa_holi_params);
1056 printk("psa_int_req_no: %d\n", p->psa_int_req_no);
1057#ifdef DEBUG_SHOW_UNUSED
1058 printk(KERN_DEBUG "psa_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1059 p->psa_unused0[0],
1060 p->psa_unused0[1],
1061 p->psa_unused0[2],
1062 p->psa_unused0[3],
1063 p->psa_unused0[4],
1064 p->psa_unused0[5],
1065 p->psa_unused0[6]);
1066#endif /* DEBUG_SHOW_UNUSED */
1067 printk(KERN_DEBUG "psa_univ_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
1068 p->psa_univ_mac_addr[0],
1069 p->psa_univ_mac_addr[1],
1070 p->psa_univ_mac_addr[2],
1071 p->psa_univ_mac_addr[3],
1072 p->psa_univ_mac_addr[4],
1073 p->psa_univ_mac_addr[5]);
1074 printk(KERN_DEBUG "psa_local_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
1075 p->psa_local_mac_addr[0],
1076 p->psa_local_mac_addr[1],
1077 p->psa_local_mac_addr[2],
1078 p->psa_local_mac_addr[3],
1079 p->psa_local_mac_addr[4],
1080 p->psa_local_mac_addr[5]);
1081 printk(KERN_DEBUG "psa_univ_local_sel: %d, ", p->psa_univ_local_sel);
1082 printk("psa_comp_number: %d, ", p->psa_comp_number);
1083 printk("psa_thr_pre_set: 0x%02x\n", p->psa_thr_pre_set);
1084 printk(KERN_DEBUG "psa_feature_select/decay_prm: 0x%02x, ",
1085 p->psa_feature_select);
1086 printk("psa_subband/decay_update_prm: %d\n", p->psa_subband);
1087 printk(KERN_DEBUG "psa_quality_thr: 0x%02x, ", p->psa_quality_thr);
1088 printk("psa_mod_delay: 0x%02x\n", p->psa_mod_delay);
1089 printk(KERN_DEBUG "psa_nwid: 0x%02x%02x, ", p->psa_nwid[0], p->psa_nwid[1]);
1090 printk("psa_nwid_select: %d\n", p->psa_nwid_select);
1091 printk(KERN_DEBUG "psa_encryption_select: %d, ", p->psa_encryption_select);
1092 printk("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
1093 p->psa_encryption_key[0],
1094 p->psa_encryption_key[1],
1095 p->psa_encryption_key[2],
1096 p->psa_encryption_key[3],
1097 p->psa_encryption_key[4],
1098 p->psa_encryption_key[5],
1099 p->psa_encryption_key[6],
1100 p->psa_encryption_key[7]);
1101 printk(KERN_DEBUG "psa_databus_width: %d\n", p->psa_databus_width);
1102 printk(KERN_DEBUG "psa_call_code/auto_squelch: 0x%02x, ",
1103 p->psa_call_code[0]);
1104 printk("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1105 p->psa_call_code[0],
1106 p->psa_call_code[1],
1107 p->psa_call_code[2],
1108 p->psa_call_code[3],
1109 p->psa_call_code[4],
1110 p->psa_call_code[5],
1111 p->psa_call_code[6],
1112 p->psa_call_code[7]);
1113#ifdef DEBUG_SHOW_UNUSED
1114 printk(KERN_DEBUG "psa_reserved[]: %02X:%02X:%02X:%02X\n",
1115 p->psa_reserved[0],
1116 p->psa_reserved[1],
1117 p->psa_reserved[2],
1118 p->psa_reserved[3]);
1119#endif /* DEBUG_SHOW_UNUSED */
1120 printk(KERN_DEBUG "psa_conf_status: %d, ", p->psa_conf_status);
1121 printk("psa_crc: 0x%02x%02x, ", p->psa_crc[0], p->psa_crc[1]);
1122 printk("psa_crc_status: 0x%02x\n", p->psa_crc_status);
1123} /* wv_psa_show */
1124#endif /* DEBUG_PSA_SHOW */
1125
1126#ifdef DEBUG_MMC_SHOW
1127/*------------------------------------------------------------------*/
1128/*
1129 * Print the formatted status of the Modem Management Controller.
1130 * This function need to be completed...
1131 */
1132static void
1133wv_mmc_show(struct net_device * dev)
1134{
1135 kio_addr_t base = dev->base_addr;
1136 net_local * lp = netdev_priv(dev);
1137 mmr_t m;
1138
1139 /* Basic check */
1140 if(hasr_read(base) & HASR_NO_CLK)
1141 {
1142 printk(KERN_WARNING "%s: wv_mmc_show: modem not connected\n",
1143 dev->name);
1144 return;
1145 }
1146
1147 spin_lock_irqsave(&lp->spinlock, flags);
1148
1149 /* Read the mmc */
1150 mmc_out(base, mmwoff(0, mmw_freeze), 1);
1151 mmc_read(base, 0, (u_char *)&m, sizeof(m));
1152 mmc_out(base, mmwoff(0, mmw_freeze), 0);
1153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 /* Don't forget to update statistics */
1155 lp->wstats.discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
1157 spin_unlock_irqrestore(&lp->spinlock, flags);
1158
1159 printk(KERN_DEBUG "##### wavelan modem status registers: #####\n");
1160#ifdef DEBUG_SHOW_UNUSED
1161 printk(KERN_DEBUG "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1162 m.mmr_unused0[0],
1163 m.mmr_unused0[1],
1164 m.mmr_unused0[2],
1165 m.mmr_unused0[3],
1166 m.mmr_unused0[4],
1167 m.mmr_unused0[5],
1168 m.mmr_unused0[6],
1169 m.mmr_unused0[7]);
1170#endif /* DEBUG_SHOW_UNUSED */
1171 printk(KERN_DEBUG "Encryption algorythm: %02X - Status: %02X\n",
1172 m.mmr_des_avail, m.mmr_des_status);
1173#ifdef DEBUG_SHOW_UNUSED
1174 printk(KERN_DEBUG "mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n",
1175 m.mmr_unused1[0],
1176 m.mmr_unused1[1],
1177 m.mmr_unused1[2],
1178 m.mmr_unused1[3],
1179 m.mmr_unused1[4]);
1180#endif /* DEBUG_SHOW_UNUSED */
1181 printk(KERN_DEBUG "dce_status: 0x%x [%s%s%s%s]\n",
1182 m.mmr_dce_status,
1183 (m.mmr_dce_status & MMR_DCE_STATUS_RX_BUSY) ? "energy detected,":"",
1184 (m.mmr_dce_status & MMR_DCE_STATUS_LOOPT_IND) ?
1185 "loop test indicated," : "",
1186 (m.mmr_dce_status & MMR_DCE_STATUS_TX_BUSY) ? "transmitter on," : "",
1187 (m.mmr_dce_status & MMR_DCE_STATUS_JBR_EXPIRED) ?
1188 "jabber timer expired," : "");
1189 printk(KERN_DEBUG "Dsp ID: %02X\n",
1190 m.mmr_dsp_id);
1191#ifdef DEBUG_SHOW_UNUSED
1192 printk(KERN_DEBUG "mmc_unused2[]: %02X:%02X\n",
1193 m.mmr_unused2[0],
1194 m.mmr_unused2[1]);
1195#endif /* DEBUG_SHOW_UNUSED */
1196 printk(KERN_DEBUG "# correct_nwid: %d, # wrong_nwid: %d\n",
1197 (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l,
1198 (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l);
1199 printk(KERN_DEBUG "thr_pre_set: 0x%x [current signal %s]\n",
1200 m.mmr_thr_pre_set & MMR_THR_PRE_SET,
1201 (m.mmr_thr_pre_set & MMR_THR_PRE_SET_CUR) ? "above" : "below");
1202 printk(KERN_DEBUG "signal_lvl: %d [%s], ",
1203 m.mmr_signal_lvl & MMR_SIGNAL_LVL,
1204 (m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) ? "new msg" : "no new msg");
1205 printk("silence_lvl: %d [%s], ", m.mmr_silence_lvl & MMR_SILENCE_LVL,
1206 (m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) ? "update done" : "no new update");
1207 printk("sgnl_qual: 0x%x [%s]\n", m.mmr_sgnl_qual & MMR_SGNL_QUAL,
1208 (m.mmr_sgnl_qual & MMR_SGNL_QUAL_ANT) ? "Antenna 1" : "Antenna 0");
1209#ifdef DEBUG_SHOW_UNUSED
1210 printk(KERN_DEBUG "netw_id_l: %x\n", m.mmr_netw_id_l);
1211#endif /* DEBUG_SHOW_UNUSED */
1212} /* wv_mmc_show */
1213#endif /* DEBUG_MMC_SHOW */
1214
1215#ifdef DEBUG_I82593_SHOW
1216/*------------------------------------------------------------------*/
1217/*
1218 * Print the formatted status of the i82593's receive unit.
1219 */
1220static void
1221wv_ru_show(struct net_device * dev)
1222{
1223 net_local *lp = netdev_priv(dev);
1224
1225 printk(KERN_DEBUG "##### wavelan i82593 receiver status: #####\n");
1226 printk(KERN_DEBUG "ru: rfp %d stop %d", lp->rfp, lp->stop);
1227 /*
1228 * Not implemented yet...
1229 */
1230 printk("\n");
1231} /* wv_ru_show */
1232#endif /* DEBUG_I82593_SHOW */
1233
1234#ifdef DEBUG_DEVICE_SHOW
1235/*------------------------------------------------------------------*/
1236/*
1237 * Print the formatted status of the WaveLAN PCMCIA device driver.
1238 */
1239static void
1240wv_dev_show(struct net_device * dev)
1241{
1242 printk(KERN_DEBUG "dev:");
1243 printk(" state=%lX,", dev->state);
1244 printk(" trans_start=%ld,", dev->trans_start);
1245 printk(" flags=0x%x,", dev->flags);
1246 printk("\n");
1247} /* wv_dev_show */
1248
1249/*------------------------------------------------------------------*/
1250/*
1251 * Print the formatted status of the WaveLAN PCMCIA device driver's
1252 * private information.
1253 */
1254static void
1255wv_local_show(struct net_device * dev)
1256{
1257 net_local *lp = netdev_priv(dev);
1258
1259 printk(KERN_DEBUG "local:");
1260 /*
1261 * Not implemented yet...
1262 */
1263 printk("\n");
1264} /* wv_local_show */
1265#endif /* DEBUG_DEVICE_SHOW */
1266
1267#if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO)
1268/*------------------------------------------------------------------*/
1269/*
1270 * Dump packet header (and content if necessary) on the screen
1271 */
1272static inline void
1273wv_packet_info(u_char * p, /* Packet to dump */
1274 int length, /* Length of the packet */
1275 char * msg1, /* Name of the device */
1276 char * msg2) /* Name of the function */
1277{
1278 int i;
1279 int maxi;
1280
1281 printk(KERN_DEBUG "%s: %s(): dest %02X:%02X:%02X:%02X:%02X:%02X, length %d\n",
1282 msg1, msg2, p[0], p[1], p[2], p[3], p[4], p[5], length);
1283 printk(KERN_DEBUG "%s: %s(): src %02X:%02X:%02X:%02X:%02X:%02X, type 0x%02X%02X\n",
1284 msg1, msg2, p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13]);
1285
1286#ifdef DEBUG_PACKET_DUMP
1287
1288 printk(KERN_DEBUG "data=\"");
1289
1290 if((maxi = length) > DEBUG_PACKET_DUMP)
1291 maxi = DEBUG_PACKET_DUMP;
1292 for(i = 14; i < maxi; i++)
1293 if(p[i] >= ' ' && p[i] <= '~')
1294 printk(" %c", p[i]);
1295 else
1296 printk("%02X", p[i]);
1297 if(maxi < length)
1298 printk("..");
1299 printk("\"\n");
1300 printk(KERN_DEBUG "\n");
1301#endif /* DEBUG_PACKET_DUMP */
1302}
1303#endif /* defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) */
1304
1305/*------------------------------------------------------------------*/
1306/*
1307 * This is the information which is displayed by the driver at startup
1308 * There is a lot of flag to configure it at your will...
1309 */
1310static inline void
1311wv_init_info(struct net_device * dev)
1312{
1313 kio_addr_t base = dev->base_addr;
1314 psa_t psa;
1315 int i;
1316
1317 /* Read the parameter storage area */
1318 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
1319
1320#ifdef DEBUG_PSA_SHOW
1321 wv_psa_show(&psa);
1322#endif
1323#ifdef DEBUG_MMC_SHOW
1324 wv_mmc_show(dev);
1325#endif
1326#ifdef DEBUG_I82593_SHOW
1327 wv_ru_show(dev);
1328#endif
1329
1330#ifdef DEBUG_BASIC_SHOW
1331 /* Now, let's go for the basic stuff */
1332 printk(KERN_NOTICE "%s: WaveLAN: port %#lx, irq %d, hw_addr",
1333 dev->name, base, dev->irq);
1334 for(i = 0; i < WAVELAN_ADDR_SIZE; i++)
1335 printk("%s%02X", (i == 0) ? " " : ":", dev->dev_addr[i]);
1336
1337 /* Print current network id */
1338 if(psa.psa_nwid_select)
1339 printk(", nwid 0x%02X-%02X", psa.psa_nwid[0], psa.psa_nwid[1]);
1340 else
1341 printk(", nwid off");
1342
1343 /* If 2.00 card */
1344 if(!(mmc_in(base, mmroff(0, mmr_fee_status)) &
1345 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
1346 {
1347 unsigned short freq;
1348
1349 /* Ask the EEprom to read the frequency from the first area */
1350 fee_read(base, 0x00 /* 1st area - frequency... */,
1351 &freq, 1);
1352
1353 /* Print frequency */
1354 printk(", 2.00, %ld", (freq >> 6) + 2400L);
1355
1356 /* Hack !!! */
1357 if(freq & 0x20)
1358 printk(".5");
1359 }
1360 else
1361 {
1362 printk(", PCMCIA, ");
1363 switch (psa.psa_subband)
1364 {
1365 case PSA_SUBBAND_915:
1366 printk("915");
1367 break;
1368 case PSA_SUBBAND_2425:
1369 printk("2425");
1370 break;
1371 case PSA_SUBBAND_2460:
1372 printk("2460");
1373 break;
1374 case PSA_SUBBAND_2484:
1375 printk("2484");
1376 break;
1377 case PSA_SUBBAND_2430_5:
1378 printk("2430.5");
1379 break;
1380 default:
1381 printk("unknown");
1382 }
1383 }
1384
1385 printk(" MHz\n");
1386#endif /* DEBUG_BASIC_SHOW */
1387
1388#ifdef DEBUG_VERSION_SHOW
1389 /* Print version information */
1390 printk(KERN_NOTICE "%s", version);
1391#endif
1392} /* wv_init_info */
1393
1394/********************* IOCTL, STATS & RECONFIG *********************/
1395/*
1396 * We found here routines that are called by Linux on differents
1397 * occasions after the configuration and not for transmitting data
1398 * These may be called when the user use ifconfig, /proc/net/dev
1399 * or wireless extensions
1400 */
1401
1402/*------------------------------------------------------------------*/
1403/*
1404 * Get the current ethernet statistics. This may be called with the
1405 * card open or closed.
1406 * Used when the user read /proc/net/dev
1407 */
1408static en_stats *
1409wavelan_get_stats(struct net_device * dev)
1410{
1411#ifdef DEBUG_IOCTL_TRACE
1412 printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name);
1413#endif
1414
1415 return(&((net_local *)netdev_priv(dev))->stats);
1416}
1417
1418/*------------------------------------------------------------------*/
1419/*
1420 * Set or clear the multicast filter for this adaptor.
1421 * num_addrs == -1 Promiscuous mode, receive all packets
1422 * num_addrs == 0 Normal mode, clear multicast list
1423 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1424 * and do best-effort filtering.
1425 */
1426
1427static void
1428wavelan_set_multicast_list(struct net_device * dev)
1429{
1430 net_local * lp = netdev_priv(dev);
1431
1432#ifdef DEBUG_IOCTL_TRACE
1433 printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n", dev->name);
1434#endif
1435
1436#ifdef DEBUG_IOCTL_INFO
1437 printk(KERN_DEBUG "%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
1438 dev->name, dev->flags, dev->mc_count);
1439#endif
1440
1441 if(dev->flags & IFF_PROMISC)
1442 {
1443 /*
1444 * Enable promiscuous mode: receive all packets.
1445 */
1446 if(!lp->promiscuous)
1447 {
1448 lp->promiscuous = 1;
1449 lp->allmulticast = 0;
1450 lp->mc_count = 0;
1451
1452 wv_82593_reconfig(dev);
1453
1454 /* Tell the kernel that we are doing a really bad job... */
1455 dev->flags |= IFF_PROMISC;
1456 }
1457 }
1458 else
1459 /* If all multicast addresses
1460 * or too much multicast addresses for the hardware filter */
1461 if((dev->flags & IFF_ALLMULTI) ||
1462 (dev->mc_count > I82593_MAX_MULTICAST_ADDRESSES))
1463 {
1464 /*
1465 * Disable promiscuous mode, but active the all multicast mode
1466 */
1467 if(!lp->allmulticast)
1468 {
1469 lp->promiscuous = 0;
1470 lp->allmulticast = 1;
1471 lp->mc_count = 0;
1472
1473 wv_82593_reconfig(dev);
1474
1475 /* Tell the kernel that we are doing a really bad job... */
1476 dev->flags |= IFF_ALLMULTI;
1477 }
1478 }
1479 else
1480 /* If there is some multicast addresses to send */
1481 if(dev->mc_list != (struct dev_mc_list *) NULL)
1482 {
1483 /*
1484 * Disable promiscuous mode, but receive all packets
1485 * in multicast list
1486 */
1487#ifdef MULTICAST_AVOID
1488 if(lp->promiscuous || lp->allmulticast ||
1489 (dev->mc_count != lp->mc_count))
1490#endif
1491 {
1492 lp->promiscuous = 0;
1493 lp->allmulticast = 0;
1494 lp->mc_count = dev->mc_count;
1495
1496 wv_82593_reconfig(dev);
1497 }
1498 }
1499 else
1500 {
1501 /*
1502 * Switch to normal mode: disable promiscuous mode and
1503 * clear the multicast list.
1504 */
1505 if(lp->promiscuous || lp->mc_count == 0)
1506 {
1507 lp->promiscuous = 0;
1508 lp->allmulticast = 0;
1509 lp->mc_count = 0;
1510
1511 wv_82593_reconfig(dev);
1512 }
1513 }
1514#ifdef DEBUG_IOCTL_TRACE
1515 printk(KERN_DEBUG "%s: <-wavelan_set_multicast_list()\n", dev->name);
1516#endif
1517}
1518
1519/*------------------------------------------------------------------*/
1520/*
1521 * This function doesn't exist...
1522 * (Note : it was a nice way to test the reconfigure stuff...)
1523 */
1524#ifdef SET_MAC_ADDRESS
1525static int
1526wavelan_set_mac_address(struct net_device * dev,
1527 void * addr)
1528{
1529 struct sockaddr * mac = addr;
1530
1531 /* Copy the address */
1532 memcpy(dev->dev_addr, mac->sa_data, WAVELAN_ADDR_SIZE);
1533
1534 /* Reconfig the beast */
1535 wv_82593_reconfig(dev);
1536
1537 return 0;
1538}
1539#endif /* SET_MAC_ADDRESS */
1540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
1542/*------------------------------------------------------------------*/
1543/*
1544 * Frequency setting (for hardware able of it)
1545 * It's a bit complicated and you don't really want to look into it...
1546 */
1547static inline int
1548wv_set_frequency(u_long base, /* i/o port of the card */
1549 iw_freq * frequency)
1550{
1551 const int BAND_NUM = 10; /* Number of bands */
1552 long freq = 0L; /* offset to 2.4 GHz in .5 MHz */
1553#ifdef DEBUG_IOCTL_INFO
1554 int i;
1555#endif
1556
1557 /* Setting by frequency */
1558 /* Theoritically, you may set any frequency between
1559 * the two limits with a 0.5 MHz precision. In practice,
1560 * I don't want you to have trouble with local
1561 * regulations... */
1562 if((frequency->e == 1) &&
1563 (frequency->m >= (int) 2.412e8) && (frequency->m <= (int) 2.487e8))
1564 {
1565 freq = ((frequency->m / 10000) - 24000L) / 5;
1566 }
1567
1568 /* Setting by channel (same as wfreqsel) */
1569 /* Warning : each channel is 22MHz wide, so some of the channels
1570 * will interfere... */
1571 if((frequency->e == 0) &&
1572 (frequency->m >= 0) && (frequency->m < BAND_NUM))
1573 {
1574 /* Get frequency offset. */
1575 freq = channel_bands[frequency->m] >> 1;
1576 }
1577
1578 /* Verify if the frequency is allowed */
1579 if(freq != 0L)
1580 {
1581 u_short table[10]; /* Authorized frequency table */
1582
1583 /* Read the frequency table */
1584 fee_read(base, 0x71 /* frequency table */,
1585 table, 10);
1586
1587#ifdef DEBUG_IOCTL_INFO
1588 printk(KERN_DEBUG "Frequency table :");
1589 for(i = 0; i < 10; i++)
1590 {
1591 printk(" %04X",
1592 table[i]);
1593 }
1594 printk("\n");
1595#endif
1596
1597 /* Look in the table if the frequency is allowed */
1598 if(!(table[9 - ((freq - 24) / 16)] &
1599 (1 << ((freq - 24) % 16))))
1600 return -EINVAL; /* not allowed */
1601 }
1602 else
1603 return -EINVAL;
1604
1605 /* If we get a usable frequency */
1606 if(freq != 0L)
1607 {
1608 unsigned short area[16];
1609 unsigned short dac[2];
1610 unsigned short area_verify[16];
1611 unsigned short dac_verify[2];
1612 /* Corresponding gain (in the power adjust value table)
1613 * see AT&T Wavelan Data Manual, REF 407-024689/E, page 3-8
1614 * & WCIN062D.DOC, page 6.2.9 */
1615 unsigned short power_limit[] = { 40, 80, 120, 160, 0 };
1616 int power_band = 0; /* Selected band */
1617 unsigned short power_adjust; /* Correct value */
1618
1619 /* Search for the gain */
1620 power_band = 0;
1621 while((freq > power_limit[power_band]) &&
1622 (power_limit[++power_band] != 0))
1623 ;
1624
1625 /* Read the first area */
1626 fee_read(base, 0x00,
1627 area, 16);
1628
1629 /* Read the DAC */
1630 fee_read(base, 0x60,
1631 dac, 2);
1632
1633 /* Read the new power adjust value */
1634 fee_read(base, 0x6B - (power_band >> 1),
1635 &power_adjust, 1);
1636 if(power_band & 0x1)
1637 power_adjust >>= 8;
1638 else
1639 power_adjust &= 0xFF;
1640
1641#ifdef DEBUG_IOCTL_INFO
1642 printk(KERN_DEBUG "Wavelan EEprom Area 1 :");
1643 for(i = 0; i < 16; i++)
1644 {
1645 printk(" %04X",
1646 area[i]);
1647 }
1648 printk("\n");
1649
1650 printk(KERN_DEBUG "Wavelan EEprom DAC : %04X %04X\n",
1651 dac[0], dac[1]);
1652#endif
1653
1654 /* Frequency offset (for info only...) */
1655 area[0] = ((freq << 5) & 0xFFE0) | (area[0] & 0x1F);
1656
1657 /* Receiver Principle main divider coefficient */
1658 area[3] = (freq >> 1) + 2400L - 352L;
1659 area[2] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1660
1661 /* Transmitter Main divider coefficient */
1662 area[13] = (freq >> 1) + 2400L;
1663 area[12] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1664
1665 /* Others part of the area are flags, bit streams or unused... */
1666
1667 /* Set the value in the DAC */
1668 dac[1] = ((power_adjust >> 1) & 0x7F) | (dac[1] & 0xFF80);
1669 dac[0] = ((power_adjust & 0x1) << 4) | (dac[0] & 0xFFEF);
1670
1671 /* Write the first area */
1672 fee_write(base, 0x00,
1673 area, 16);
1674
1675 /* Write the DAC */
1676 fee_write(base, 0x60,
1677 dac, 2);
1678
1679 /* We now should verify here that the EEprom writting was ok */
1680
1681 /* ReRead the first area */
1682 fee_read(base, 0x00,
1683 area_verify, 16);
1684
1685 /* ReRead the DAC */
1686 fee_read(base, 0x60,
1687 dac_verify, 2);
1688
1689 /* Compare */
1690 if(memcmp(area, area_verify, 16 * 2) ||
1691 memcmp(dac, dac_verify, 2 * 2))
1692 {
1693#ifdef DEBUG_IOCTL_ERROR
1694 printk(KERN_INFO "Wavelan: wv_set_frequency : unable to write new frequency to EEprom (?)\n");
1695#endif
1696 return -EOPNOTSUPP;
1697 }
1698
1699 /* We must download the frequency parameters to the
1700 * synthetisers (from the EEprom - area 1)
1701 * Note : as the EEprom is auto decremented, we set the end
1702 * if the area... */
1703 mmc_out(base, mmwoff(0, mmw_fee_addr), 0x0F);
1704 mmc_out(base, mmwoff(0, mmw_fee_ctrl),
1705 MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1706
1707 /* Wait until the download is finished */
1708 fee_wait(base, 100, 100);
1709
1710 /* We must now download the power adjust value (gain) to
1711 * the synthetisers (from the EEprom - area 7 - DAC) */
1712 mmc_out(base, mmwoff(0, mmw_fee_addr), 0x61);
1713 mmc_out(base, mmwoff(0, mmw_fee_ctrl),
1714 MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1715
1716 /* Wait until the download is finished */
1717 fee_wait(base, 100, 100);
1718
1719#ifdef DEBUG_IOCTL_INFO
1720 /* Verification of what we have done... */
1721
1722 printk(KERN_DEBUG "Wavelan EEprom Area 1 :");
1723 for(i = 0; i < 16; i++)
1724 {
1725 printk(" %04X",
1726 area_verify[i]);
1727 }
1728 printk("\n");
1729
1730 printk(KERN_DEBUG "Wavelan EEprom DAC : %04X %04X\n",
1731 dac_verify[0], dac_verify[1]);
1732#endif
1733
1734 return 0;
1735 }
1736 else
1737 return -EINVAL; /* Bah, never get there... */
1738}
1739
1740/*------------------------------------------------------------------*/
1741/*
1742 * Give the list of available frequencies
1743 */
1744static inline int
1745wv_frequency_list(u_long base, /* i/o port of the card */
1746 iw_freq * list, /* List of frequency to fill */
1747 int max) /* Maximum number of frequencies */
1748{
1749 u_short table[10]; /* Authorized frequency table */
1750 long freq = 0L; /* offset to 2.4 GHz in .5 MHz + 12 MHz */
1751 int i; /* index in the table */
1752 const int BAND_NUM = 10; /* Number of bands */
1753 int c = 0; /* Channel number */
1754
1755 /* Read the frequency table */
1756 fee_read(base, 0x71 /* frequency table */,
1757 table, 10);
1758
1759 /* Look all frequencies */
1760 i = 0;
1761 for(freq = 0; freq < 150; freq++)
1762 /* Look in the table if the frequency is allowed */
1763 if(table[9 - (freq / 16)] & (1 << (freq % 16)))
1764 {
1765 /* Compute approximate channel number */
1766 while((((channel_bands[c] >> 1) - 24) < freq) &&
1767 (c < BAND_NUM))
1768 c++;
1769 list[i].i = c; /* Set the list index */
1770
1771 /* put in the list */
1772 list[i].m = (((freq + 24) * 5) + 24000L) * 10000;
1773 list[i++].e = 1;
1774
1775 /* Check number */
1776 if(i >= max)
1777 return(i);
1778 }
1779
1780 return(i);
1781}
1782
1783#ifdef IW_WIRELESS_SPY
1784/*------------------------------------------------------------------*/
1785/*
1786 * Gather wireless spy statistics : for each packet, compare the source
1787 * address with out list, and if match, get the stats...
1788 * Sorry, but this function really need wireless extensions...
1789 */
1790static inline void
1791wl_spy_gather(struct net_device * dev,
1792 u_char * mac, /* MAC address */
1793 u_char * stats) /* Statistics to gather */
1794{
1795 struct iw_quality wstats;
1796
1797 wstats.qual = stats[2] & MMR_SGNL_QUAL;
1798 wstats.level = stats[0] & MMR_SIGNAL_LVL;
1799 wstats.noise = stats[1] & MMR_SILENCE_LVL;
1800 wstats.updated = 0x7;
1801
1802 /* Update spy records */
1803 wireless_spy_update(dev, mac, &wstats);
1804}
1805#endif /* IW_WIRELESS_SPY */
1806
1807#ifdef HISTOGRAM
1808/*------------------------------------------------------------------*/
1809/*
1810 * This function calculate an histogram on the signal level.
1811 * As the noise is quite constant, it's like doing it on the SNR.
1812 * We have defined a set of interval (lp->his_range), and each time
1813 * the level goes in that interval, we increment the count (lp->his_sum).
1814 * With this histogram you may detect if one wavelan is really weak,
1815 * or you may also calculate the mean and standard deviation of the level...
1816 */
1817static inline void
1818wl_his_gather(struct net_device * dev,
1819 u_char * stats) /* Statistics to gather */
1820{
1821 net_local * lp = netdev_priv(dev);
1822 u_char level = stats[0] & MMR_SIGNAL_LVL;
1823 int i;
1824
1825 /* Find the correct interval */
1826 i = 0;
1827 while((i < (lp->his_number - 1)) && (level >= lp->his_range[i++]))
1828 ;
1829
1830 /* Increment interval counter */
1831 (lp->his_sum[i])++;
1832}
1833#endif /* HISTOGRAM */
1834
1835static void wl_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1836{
1837 strncpy(info->driver, "wavelan_cs", sizeof(info->driver)-1);
1838}
1839
1840static struct ethtool_ops ops = {
1841 .get_drvinfo = wl_get_drvinfo
1842};
1843
1844/*------------------------------------------------------------------*/
1845/*
1846 * Wireless Handler : get protocol name
1847 */
1848static int wavelan_get_name(struct net_device *dev,
1849 struct iw_request_info *info,
1850 union iwreq_data *wrqu,
1851 char *extra)
1852{
1853 strcpy(wrqu->name, "WaveLAN");
1854 return 0;
1855}
1856
1857/*------------------------------------------------------------------*/
1858/*
1859 * Wireless Handler : set NWID
1860 */
1861static int wavelan_set_nwid(struct net_device *dev,
1862 struct iw_request_info *info,
1863 union iwreq_data *wrqu,
1864 char *extra)
1865{
1866 kio_addr_t base = dev->base_addr;
1867 net_local *lp = netdev_priv(dev);
1868 psa_t psa;
1869 mm_t m;
1870 unsigned long flags;
1871 int ret = 0;
1872
1873 /* Disable interrupts and save flags. */
1874 spin_lock_irqsave(&lp->spinlock, flags);
1875
1876 /* Set NWID in WaveLAN. */
1877 if (!wrqu->nwid.disabled) {
1878 /* Set NWID in psa */
1879 psa.psa_nwid[0] = (wrqu->nwid.value & 0xFF00) >> 8;
1880 psa.psa_nwid[1] = wrqu->nwid.value & 0xFF;
1881 psa.psa_nwid_select = 0x01;
1882 psa_write(dev,
1883 (char *) psa.psa_nwid - (char *) &psa,
1884 (unsigned char *) psa.psa_nwid, 3);
1885
1886 /* Set NWID in mmc. */
1887 m.w.mmw_netw_id_l = psa.psa_nwid[1];
1888 m.w.mmw_netw_id_h = psa.psa_nwid[0];
1889 mmc_write(base,
1890 (char *) &m.w.mmw_netw_id_l -
1891 (char *) &m,
1892 (unsigned char *) &m.w.mmw_netw_id_l, 2);
1893 mmc_out(base, mmwoff(0, mmw_loopt_sel), 0x00);
1894 } else {
1895 /* Disable NWID in the psa. */
1896 psa.psa_nwid_select = 0x00;
1897 psa_write(dev,
1898 (char *) &psa.psa_nwid_select -
1899 (char *) &psa,
1900 (unsigned char *) &psa.psa_nwid_select,
1901 1);
1902
1903 /* Disable NWID in the mmc (no filtering). */
1904 mmc_out(base, mmwoff(0, mmw_loopt_sel),
1905 MMW_LOOPT_SEL_DIS_NWID);
1906 }
1907 /* update the Wavelan checksum */
1908 update_psa_checksum(dev);
1909
1910 /* Enable interrupts and restore flags. */
1911 spin_unlock_irqrestore(&lp->spinlock, flags);
1912
1913 return ret;
1914}
1915
1916/*------------------------------------------------------------------*/
1917/*
1918 * Wireless Handler : get NWID
1919 */
1920static int wavelan_get_nwid(struct net_device *dev,
1921 struct iw_request_info *info,
1922 union iwreq_data *wrqu,
1923 char *extra)
1924{
1925 net_local *lp = netdev_priv(dev);
1926 psa_t psa;
1927 unsigned long flags;
1928 int ret = 0;
1929
1930 /* Disable interrupts and save flags. */
1931 spin_lock_irqsave(&lp->spinlock, flags);
1932
1933 /* Read the NWID. */
1934 psa_read(dev,
1935 (char *) psa.psa_nwid - (char *) &psa,
1936 (unsigned char *) psa.psa_nwid, 3);
1937 wrqu->nwid.value = (psa.psa_nwid[0] << 8) + psa.psa_nwid[1];
1938 wrqu->nwid.disabled = !(psa.psa_nwid_select);
1939 wrqu->nwid.fixed = 1; /* Superfluous */
1940
1941 /* Enable interrupts and restore flags. */
1942 spin_unlock_irqrestore(&lp->spinlock, flags);
1943
1944 return ret;
1945}
1946
1947/*------------------------------------------------------------------*/
1948/*
1949 * Wireless Handler : set frequency
1950 */
1951static int wavelan_set_freq(struct net_device *dev,
1952 struct iw_request_info *info,
1953 union iwreq_data *wrqu,
1954 char *extra)
1955{
1956 kio_addr_t base = dev->base_addr;
1957 net_local *lp = netdev_priv(dev);
1958 unsigned long flags;
1959 int ret;
1960
1961 /* Disable interrupts and save flags. */
1962 spin_lock_irqsave(&lp->spinlock, flags);
1963
1964 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
1965 if (!(mmc_in(base, mmroff(0, mmr_fee_status)) &
1966 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
1967 ret = wv_set_frequency(base, &(wrqu->freq));
1968 else
1969 ret = -EOPNOTSUPP;
1970
1971 /* Enable interrupts and restore flags. */
1972 spin_unlock_irqrestore(&lp->spinlock, flags);
1973
1974 return ret;
1975}
1976
1977/*------------------------------------------------------------------*/
1978/*
1979 * Wireless Handler : get frequency
1980 */
1981static int wavelan_get_freq(struct net_device *dev,
1982 struct iw_request_info *info,
1983 union iwreq_data *wrqu,
1984 char *extra)
1985{
1986 kio_addr_t base = dev->base_addr;
1987 net_local *lp = netdev_priv(dev);
1988 psa_t psa;
1989 unsigned long flags;
1990 int ret = 0;
1991
1992 /* Disable interrupts and save flags. */
1993 spin_lock_irqsave(&lp->spinlock, flags);
1994
1995 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable).
1996 * Does it work for everybody, especially old cards? */
1997 if (!(mmc_in(base, mmroff(0, mmr_fee_status)) &
1998 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
1999 unsigned short freq;
2000
2001 /* Ask the EEPROM to read the frequency from the first area. */
2002 fee_read(base, 0x00, &freq, 1);
2003 wrqu->freq.m = ((freq >> 5) * 5 + 24000L) * 10000;
2004 wrqu->freq.e = 1;
2005 } else {
2006 psa_read(dev,
2007 (char *) &psa.psa_subband - (char *) &psa,
2008 (unsigned char *) &psa.psa_subband, 1);
2009
2010 if (psa.psa_subband <= 4) {
2011 wrqu->freq.m = fixed_bands[psa.psa_subband];
2012 wrqu->freq.e = (psa.psa_subband != 0);
2013 } else
2014 ret = -EOPNOTSUPP;
2015 }
2016
2017 /* Enable interrupts and restore flags. */
2018 spin_unlock_irqrestore(&lp->spinlock, flags);
2019
2020 return ret;
2021}
2022
2023/*------------------------------------------------------------------*/
2024/*
2025 * Wireless Handler : set level threshold
2026 */
2027static int wavelan_set_sens(struct net_device *dev,
2028 struct iw_request_info *info,
2029 union iwreq_data *wrqu,
2030 char *extra)
2031{
2032 kio_addr_t base = dev->base_addr;
2033 net_local *lp = netdev_priv(dev);
2034 psa_t psa;
2035 unsigned long flags;
2036 int ret = 0;
2037
2038 /* Disable interrupts and save flags. */
2039 spin_lock_irqsave(&lp->spinlock, flags);
2040
2041 /* Set the level threshold. */
2042 /* We should complain loudly if wrqu->sens.fixed = 0, because we
2043 * can't set auto mode... */
2044 psa.psa_thr_pre_set = wrqu->sens.value & 0x3F;
2045 psa_write(dev,
2046 (char *) &psa.psa_thr_pre_set - (char *) &psa,
2047 (unsigned char *) &psa.psa_thr_pre_set, 1);
2048 /* update the Wavelan checksum */
2049 update_psa_checksum(dev);
2050 mmc_out(base, mmwoff(0, mmw_thr_pre_set),
2051 psa.psa_thr_pre_set);
2052
2053 /* Enable interrupts and restore flags. */
2054 spin_unlock_irqrestore(&lp->spinlock, flags);
2055
2056 return ret;
2057}
2058
2059/*------------------------------------------------------------------*/
2060/*
2061 * Wireless Handler : get level threshold
2062 */
2063static int wavelan_get_sens(struct net_device *dev,
2064 struct iw_request_info *info,
2065 union iwreq_data *wrqu,
2066 char *extra)
2067{
2068 net_local *lp = netdev_priv(dev);
2069 psa_t psa;
2070 unsigned long flags;
2071 int ret = 0;
2072
2073 /* Disable interrupts and save flags. */
2074 spin_lock_irqsave(&lp->spinlock, flags);
2075
2076 /* Read the level threshold. */
2077 psa_read(dev,
2078 (char *) &psa.psa_thr_pre_set - (char *) &psa,
2079 (unsigned char *) &psa.psa_thr_pre_set, 1);
2080 wrqu->sens.value = psa.psa_thr_pre_set & 0x3F;
2081 wrqu->sens.fixed = 1;
2082
2083 /* Enable interrupts and restore flags. */
2084 spin_unlock_irqrestore(&lp->spinlock, flags);
2085
2086 return ret;
2087}
2088
2089/*------------------------------------------------------------------*/
2090/*
2091 * Wireless Handler : set encryption key
2092 */
2093static int wavelan_set_encode(struct net_device *dev,
2094 struct iw_request_info *info,
2095 union iwreq_data *wrqu,
2096 char *extra)
2097{
2098 kio_addr_t base = dev->base_addr;
2099 net_local *lp = netdev_priv(dev);
2100 unsigned long flags;
2101 psa_t psa;
2102 int ret = 0;
2103
2104 /* Disable interrupts and save flags. */
2105 spin_lock_irqsave(&lp->spinlock, flags);
2106
2107 /* Check if capable of encryption */
2108 if (!mmc_encr(base)) {
2109 ret = -EOPNOTSUPP;
2110 }
2111
2112 /* Check the size of the key */
2113 if((wrqu->encoding.length != 8) && (wrqu->encoding.length != 0)) {
2114 ret = -EINVAL;
2115 }
2116
2117 if(!ret) {
2118 /* Basic checking... */
2119 if (wrqu->encoding.length == 8) {
2120 /* Copy the key in the driver */
2121 memcpy(psa.psa_encryption_key, extra,
2122 wrqu->encoding.length);
2123 psa.psa_encryption_select = 1;
2124
2125 psa_write(dev,
2126 (char *) &psa.psa_encryption_select -
2127 (char *) &psa,
2128 (unsigned char *) &psa.
2129 psa_encryption_select, 8 + 1);
2130
2131 mmc_out(base, mmwoff(0, mmw_encr_enable),
2132 MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE);
2133 mmc_write(base, mmwoff(0, mmw_encr_key),
2134 (unsigned char *) &psa.
2135 psa_encryption_key, 8);
2136 }
2137
2138 /* disable encryption */
2139 if (wrqu->encoding.flags & IW_ENCODE_DISABLED) {
2140 psa.psa_encryption_select = 0;
2141 psa_write(dev,
2142 (char *) &psa.psa_encryption_select -
2143 (char *) &psa,
2144 (unsigned char *) &psa.
2145 psa_encryption_select, 1);
2146
2147 mmc_out(base, mmwoff(0, mmw_encr_enable), 0);
2148 }
2149 /* update the Wavelan checksum */
2150 update_psa_checksum(dev);
2151 }
2152
2153 /* Enable interrupts and restore flags. */
2154 spin_unlock_irqrestore(&lp->spinlock, flags);
2155
2156 return ret;
2157}
2158
2159/*------------------------------------------------------------------*/
2160/*
2161 * Wireless Handler : get encryption key
2162 */
2163static int wavelan_get_encode(struct net_device *dev,
2164 struct iw_request_info *info,
2165 union iwreq_data *wrqu,
2166 char *extra)
2167{
2168 kio_addr_t base = dev->base_addr;
2169 net_local *lp = netdev_priv(dev);
2170 psa_t psa;
2171 unsigned long flags;
2172 int ret = 0;
2173
2174 /* Disable interrupts and save flags. */
2175 spin_lock_irqsave(&lp->spinlock, flags);
2176
2177 /* Check if encryption is available */
2178 if (!mmc_encr(base)) {
2179 ret = -EOPNOTSUPP;
2180 } else {
2181 /* Read the encryption key */
2182 psa_read(dev,
2183 (char *) &psa.psa_encryption_select -
2184 (char *) &psa,
2185 (unsigned char *) &psa.
2186 psa_encryption_select, 1 + 8);
2187
2188 /* encryption is enabled ? */
2189 if (psa.psa_encryption_select)
2190 wrqu->encoding.flags = IW_ENCODE_ENABLED;
2191 else
2192 wrqu->encoding.flags = IW_ENCODE_DISABLED;
2193 wrqu->encoding.flags |= mmc_encr(base);
2194
2195 /* Copy the key to the user buffer */
2196 wrqu->encoding.length = 8;
2197 memcpy(extra, psa.psa_encryption_key, wrqu->encoding.length);
2198 }
2199
2200 /* Enable interrupts and restore flags. */
2201 spin_unlock_irqrestore(&lp->spinlock, flags);
2202
2203 return ret;
2204}
2205
2206#ifdef WAVELAN_ROAMING_EXT
2207/*------------------------------------------------------------------*/
2208/*
2209 * Wireless Handler : set ESSID (domain)
2210 */
2211static int wavelan_set_essid(struct net_device *dev,
2212 struct iw_request_info *info,
2213 union iwreq_data *wrqu,
2214 char *extra)
2215{
2216 net_local *lp = netdev_priv(dev);
2217 unsigned long flags;
2218 int ret = 0;
2219
2220 /* Disable interrupts and save flags. */
2221 spin_lock_irqsave(&lp->spinlock, flags);
2222
2223 /* Check if disable */
2224 if(wrqu->data.flags == 0)
2225 lp->filter_domains = 0;
2226 else {
2227 char essid[IW_ESSID_MAX_SIZE + 1];
2228 char * endp;
2229
2230 /* Terminate the string */
2231 memcpy(essid, extra, wrqu->data.length);
2232 essid[IW_ESSID_MAX_SIZE] = '\0';
2233
2234#ifdef DEBUG_IOCTL_INFO
2235 printk(KERN_DEBUG "SetEssid : ``%s''\n", essid);
2236#endif /* DEBUG_IOCTL_INFO */
2237
2238 /* Convert to a number (note : Wavelan specific) */
2239 lp->domain_id = simple_strtoul(essid, &endp, 16);
2240 /* Has it worked ? */
2241 if(endp > essid)
2242 lp->filter_domains = 1;
2243 else {
2244 lp->filter_domains = 0;
2245 ret = -EINVAL;
2246 }
2247 }
2248
2249 /* Enable interrupts and restore flags. */
2250 spin_unlock_irqrestore(&lp->spinlock, flags);
2251
2252 return ret;
2253}
2254
2255/*------------------------------------------------------------------*/
2256/*
2257 * Wireless Handler : get ESSID (domain)
2258 */
2259static int wavelan_get_essid(struct net_device *dev,
2260 struct iw_request_info *info,
2261 union iwreq_data *wrqu,
2262 char *extra)
2263{
2264 net_local *lp = netdev_priv(dev);
2265
2266 /* Is the domain ID active ? */
2267 wrqu->data.flags = lp->filter_domains;
2268
2269 /* Copy Domain ID into a string (Wavelan specific) */
2270 /* Sound crazy, be we can't have a snprintf in the kernel !!! */
2271 sprintf(extra, "%lX", lp->domain_id);
2272 extra[IW_ESSID_MAX_SIZE] = '\0';
2273
2274 /* Set the length */
Dan Williamsd6a13a22006-01-12 15:00:58 -05002275 wrqu->data.length = strlen(extra);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276
2277 return 0;
2278}
2279
2280/*------------------------------------------------------------------*/
2281/*
2282 * Wireless Handler : set AP address
2283 */
2284static int wavelan_set_wap(struct net_device *dev,
2285 struct iw_request_info *info,
2286 union iwreq_data *wrqu,
2287 char *extra)
2288{
2289#ifdef DEBUG_IOCTL_INFO
2290 printk(KERN_DEBUG "Set AP to : %02X:%02X:%02X:%02X:%02X:%02X\n",
2291 wrqu->ap_addr.sa_data[0],
2292 wrqu->ap_addr.sa_data[1],
2293 wrqu->ap_addr.sa_data[2],
2294 wrqu->ap_addr.sa_data[3],
2295 wrqu->ap_addr.sa_data[4],
2296 wrqu->ap_addr.sa_data[5]);
2297#endif /* DEBUG_IOCTL_INFO */
2298
2299 return -EOPNOTSUPP;
2300}
2301
2302/*------------------------------------------------------------------*/
2303/*
2304 * Wireless Handler : get AP address
2305 */
2306static int wavelan_get_wap(struct net_device *dev,
2307 struct iw_request_info *info,
2308 union iwreq_data *wrqu,
2309 char *extra)
2310{
2311 /* Should get the real McCoy instead of own Ethernet address */
2312 memcpy(wrqu->ap_addr.sa_data, dev->dev_addr, WAVELAN_ADDR_SIZE);
2313 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
2314
2315 return -EOPNOTSUPP;
2316}
2317#endif /* WAVELAN_ROAMING_EXT */
2318
2319#ifdef WAVELAN_ROAMING
2320/*------------------------------------------------------------------*/
2321/*
2322 * Wireless Handler : set mode
2323 */
2324static int wavelan_set_mode(struct net_device *dev,
2325 struct iw_request_info *info,
2326 union iwreq_data *wrqu,
2327 char *extra)
2328{
2329 net_local *lp = netdev_priv(dev);
2330 unsigned long flags;
2331 int ret = 0;
2332
2333 /* Disable interrupts and save flags. */
2334 spin_lock_irqsave(&lp->spinlock, flags);
2335
2336 /* Check mode */
2337 switch(wrqu->mode) {
2338 case IW_MODE_ADHOC:
2339 if(do_roaming) {
2340 wv_roam_cleanup(dev);
2341 do_roaming = 0;
2342 }
2343 break;
2344 case IW_MODE_INFRA:
2345 if(!do_roaming) {
2346 wv_roam_init(dev);
2347 do_roaming = 1;
2348 }
2349 break;
2350 default:
2351 ret = -EINVAL;
2352 }
2353
2354 /* Enable interrupts and restore flags. */
2355 spin_unlock_irqrestore(&lp->spinlock, flags);
2356
2357 return ret;
2358}
2359
2360/*------------------------------------------------------------------*/
2361/*
2362 * Wireless Handler : get mode
2363 */
2364static int wavelan_get_mode(struct net_device *dev,
2365 struct iw_request_info *info,
2366 union iwreq_data *wrqu,
2367 char *extra)
2368{
2369 if(do_roaming)
2370 wrqu->mode = IW_MODE_INFRA;
2371 else
2372 wrqu->mode = IW_MODE_ADHOC;
2373
2374 return 0;
2375}
2376#endif /* WAVELAN_ROAMING */
2377
2378/*------------------------------------------------------------------*/
2379/*
2380 * Wireless Handler : get range info
2381 */
2382static int wavelan_get_range(struct net_device *dev,
2383 struct iw_request_info *info,
2384 union iwreq_data *wrqu,
2385 char *extra)
2386{
2387 kio_addr_t base = dev->base_addr;
2388 net_local *lp = netdev_priv(dev);
2389 struct iw_range *range = (struct iw_range *) extra;
2390 unsigned long flags;
2391 int ret = 0;
2392
2393 /* Set the length (very important for backward compatibility) */
2394 wrqu->data.length = sizeof(struct iw_range);
2395
2396 /* Set all the info we don't care or don't know about to zero */
2397 memset(range, 0, sizeof(struct iw_range));
2398
2399 /* Set the Wireless Extension versions */
2400 range->we_version_compiled = WIRELESS_EXT;
2401 range->we_version_source = 9;
2402
2403 /* Set information in the range struct. */
2404 range->throughput = 1.4 * 1000 * 1000; /* don't argue on this ! */
2405 range->min_nwid = 0x0000;
2406 range->max_nwid = 0xFFFF;
2407
2408 range->sensitivity = 0x3F;
2409 range->max_qual.qual = MMR_SGNL_QUAL;
2410 range->max_qual.level = MMR_SIGNAL_LVL;
2411 range->max_qual.noise = MMR_SILENCE_LVL;
2412 range->avg_qual.qual = MMR_SGNL_QUAL; /* Always max */
2413 /* Need to get better values for those two */
2414 range->avg_qual.level = 30;
2415 range->avg_qual.noise = 8;
2416
2417 range->num_bitrates = 1;
2418 range->bitrate[0] = 2000000; /* 2 Mb/s */
2419
2420 /* Event capability (kernel + driver) */
2421 range->event_capa[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2422 IW_EVENT_CAPA_MASK(0x8B04) |
2423 IW_EVENT_CAPA_MASK(0x8B06));
2424 range->event_capa[1] = IW_EVENT_CAPA_K_1;
2425
2426 /* Disable interrupts and save flags. */
2427 spin_lock_irqsave(&lp->spinlock, flags);
2428
2429 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
2430 if (!(mmc_in(base, mmroff(0, mmr_fee_status)) &
2431 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
2432 range->num_channels = 10;
2433 range->num_frequency = wv_frequency_list(base, range->freq,
2434 IW_MAX_FREQUENCIES);
2435 } else
2436 range->num_channels = range->num_frequency = 0;
2437
2438 /* Encryption supported ? */
2439 if (mmc_encr(base)) {
2440 range->encoding_size[0] = 8; /* DES = 64 bits key */
2441 range->num_encoding_sizes = 1;
2442 range->max_encoding_tokens = 1; /* Only one key possible */
2443 } else {
2444 range->num_encoding_sizes = 0;
2445 range->max_encoding_tokens = 0;
2446 }
2447
2448 /* Enable interrupts and restore flags. */
2449 spin_unlock_irqrestore(&lp->spinlock, flags);
2450
2451 return ret;
2452}
2453
2454/*------------------------------------------------------------------*/
2455/*
2456 * Wireless Private Handler : set quality threshold
2457 */
2458static int wavelan_set_qthr(struct net_device *dev,
2459 struct iw_request_info *info,
2460 union iwreq_data *wrqu,
2461 char *extra)
2462{
2463 kio_addr_t base = dev->base_addr;
2464 net_local *lp = netdev_priv(dev);
2465 psa_t psa;
2466 unsigned long flags;
2467
2468 /* Disable interrupts and save flags. */
2469 spin_lock_irqsave(&lp->spinlock, flags);
2470
2471 psa.psa_quality_thr = *(extra) & 0x0F;
2472 psa_write(dev,
2473 (char *) &psa.psa_quality_thr - (char *) &psa,
2474 (unsigned char *) &psa.psa_quality_thr, 1);
2475 /* update the Wavelan checksum */
2476 update_psa_checksum(dev);
2477 mmc_out(base, mmwoff(0, mmw_quality_thr),
2478 psa.psa_quality_thr);
2479
2480 /* Enable interrupts and restore flags. */
2481 spin_unlock_irqrestore(&lp->spinlock, flags);
2482
2483 return 0;
2484}
2485
2486/*------------------------------------------------------------------*/
2487/*
2488 * Wireless Private Handler : get quality threshold
2489 */
2490static int wavelan_get_qthr(struct net_device *dev,
2491 struct iw_request_info *info,
2492 union iwreq_data *wrqu,
2493 char *extra)
2494{
2495 net_local *lp = netdev_priv(dev);
2496 psa_t psa;
2497 unsigned long flags;
2498
2499 /* Disable interrupts and save flags. */
2500 spin_lock_irqsave(&lp->spinlock, flags);
2501
2502 psa_read(dev,
2503 (char *) &psa.psa_quality_thr - (char *) &psa,
2504 (unsigned char *) &psa.psa_quality_thr, 1);
2505 *(extra) = psa.psa_quality_thr & 0x0F;
2506
2507 /* Enable interrupts and restore flags. */
2508 spin_unlock_irqrestore(&lp->spinlock, flags);
2509
2510 return 0;
2511}
2512
2513#ifdef WAVELAN_ROAMING
2514/*------------------------------------------------------------------*/
2515/*
2516 * Wireless Private Handler : set roaming
2517 */
2518static int wavelan_set_roam(struct net_device *dev,
2519 struct iw_request_info *info,
2520 union iwreq_data *wrqu,
2521 char *extra)
2522{
2523 net_local *lp = netdev_priv(dev);
2524 unsigned long flags;
2525
2526 /* Disable interrupts and save flags. */
2527 spin_lock_irqsave(&lp->spinlock, flags);
2528
2529 /* Note : should check if user == root */
2530 if(do_roaming && (*extra)==0)
2531 wv_roam_cleanup(dev);
2532 else if(do_roaming==0 && (*extra)!=0)
2533 wv_roam_init(dev);
2534
2535 do_roaming = (*extra);
2536
2537 /* Enable interrupts and restore flags. */
2538 spin_unlock_irqrestore(&lp->spinlock, flags);
2539
2540 return 0;
2541}
2542
2543/*------------------------------------------------------------------*/
2544/*
2545 * Wireless Private Handler : get quality threshold
2546 */
2547static int wavelan_get_roam(struct net_device *dev,
2548 struct iw_request_info *info,
2549 union iwreq_data *wrqu,
2550 char *extra)
2551{
2552 *(extra) = do_roaming;
2553
2554 return 0;
2555}
2556#endif /* WAVELAN_ROAMING */
2557
2558#ifdef HISTOGRAM
2559/*------------------------------------------------------------------*/
2560/*
2561 * Wireless Private Handler : set histogram
2562 */
2563static int wavelan_set_histo(struct net_device *dev,
2564 struct iw_request_info *info,
2565 union iwreq_data *wrqu,
2566 char *extra)
2567{
2568 net_local *lp = netdev_priv(dev);
2569
2570 /* Check the number of intervals. */
2571 if (wrqu->data.length > 16) {
2572 return(-E2BIG);
2573 }
2574
2575 /* Disable histo while we copy the addresses.
2576 * As we don't disable interrupts, we need to do this */
2577 lp->his_number = 0;
2578
2579 /* Are there ranges to copy? */
2580 if (wrqu->data.length > 0) {
2581 /* Copy interval ranges to the driver */
2582 memcpy(lp->his_range, extra, wrqu->data.length);
2583
2584 {
2585 int i;
2586 printk(KERN_DEBUG "Histo :");
2587 for(i = 0; i < wrqu->data.length; i++)
2588 printk(" %d", lp->his_range[i]);
2589 printk("\n");
2590 }
2591
2592 /* Reset result structure. */
2593 memset(lp->his_sum, 0x00, sizeof(long) * 16);
2594 }
2595
2596 /* Now we can set the number of ranges */
2597 lp->his_number = wrqu->data.length;
2598
2599 return(0);
2600}
2601
2602/*------------------------------------------------------------------*/
2603/*
2604 * Wireless Private Handler : get histogram
2605 */
2606static int wavelan_get_histo(struct net_device *dev,
2607 struct iw_request_info *info,
2608 union iwreq_data *wrqu,
2609 char *extra)
2610{
2611 net_local *lp = netdev_priv(dev);
2612
2613 /* Set the number of intervals. */
2614 wrqu->data.length = lp->his_number;
2615
2616 /* Give back the distribution statistics */
2617 if(lp->his_number > 0)
2618 memcpy(extra, lp->his_sum, sizeof(long) * lp->his_number);
2619
2620 return(0);
2621}
2622#endif /* HISTOGRAM */
2623
2624/*------------------------------------------------------------------*/
2625/*
2626 * Structures to export the Wireless Handlers
2627 */
2628
2629static const struct iw_priv_args wavelan_private_args[] = {
2630/*{ cmd, set_args, get_args, name } */
2631 { SIOCSIPQTHR, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setqualthr" },
2632 { SIOCGIPQTHR, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getqualthr" },
2633 { SIOCSIPROAM, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setroam" },
2634 { SIOCGIPROAM, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getroam" },
2635 { SIOCSIPHISTO, IW_PRIV_TYPE_BYTE | 16, 0, "sethisto" },
2636 { SIOCGIPHISTO, 0, IW_PRIV_TYPE_INT | 16, "gethisto" },
2637};
2638
2639static const iw_handler wavelan_handler[] =
2640{
2641 NULL, /* SIOCSIWNAME */
2642 wavelan_get_name, /* SIOCGIWNAME */
2643 wavelan_set_nwid, /* SIOCSIWNWID */
2644 wavelan_get_nwid, /* SIOCGIWNWID */
2645 wavelan_set_freq, /* SIOCSIWFREQ */
2646 wavelan_get_freq, /* SIOCGIWFREQ */
2647#ifdef WAVELAN_ROAMING
2648 wavelan_set_mode, /* SIOCSIWMODE */
2649 wavelan_get_mode, /* SIOCGIWMODE */
2650#else /* WAVELAN_ROAMING */
2651 NULL, /* SIOCSIWMODE */
2652 NULL, /* SIOCGIWMODE */
2653#endif /* WAVELAN_ROAMING */
2654 wavelan_set_sens, /* SIOCSIWSENS */
2655 wavelan_get_sens, /* SIOCGIWSENS */
2656 NULL, /* SIOCSIWRANGE */
2657 wavelan_get_range, /* SIOCGIWRANGE */
2658 NULL, /* SIOCSIWPRIV */
2659 NULL, /* SIOCGIWPRIV */
2660 NULL, /* SIOCSIWSTATS */
2661 NULL, /* SIOCGIWSTATS */
2662 iw_handler_set_spy, /* SIOCSIWSPY */
2663 iw_handler_get_spy, /* SIOCGIWSPY */
2664 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
2665 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
2666#ifdef WAVELAN_ROAMING_EXT
2667 wavelan_set_wap, /* SIOCSIWAP */
2668 wavelan_get_wap, /* SIOCGIWAP */
2669 NULL, /* -- hole -- */
2670 NULL, /* SIOCGIWAPLIST */
2671 NULL, /* -- hole -- */
2672 NULL, /* -- hole -- */
2673 wavelan_set_essid, /* SIOCSIWESSID */
2674 wavelan_get_essid, /* SIOCGIWESSID */
2675#else /* WAVELAN_ROAMING_EXT */
2676 NULL, /* SIOCSIWAP */
2677 NULL, /* SIOCGIWAP */
2678 NULL, /* -- hole -- */
2679 NULL, /* SIOCGIWAPLIST */
2680 NULL, /* -- hole -- */
2681 NULL, /* -- hole -- */
2682 NULL, /* SIOCSIWESSID */
2683 NULL, /* SIOCGIWESSID */
2684#endif /* WAVELAN_ROAMING_EXT */
2685 NULL, /* SIOCSIWNICKN */
2686 NULL, /* SIOCGIWNICKN */
2687 NULL, /* -- hole -- */
2688 NULL, /* -- hole -- */
2689 NULL, /* SIOCSIWRATE */
2690 NULL, /* SIOCGIWRATE */
2691 NULL, /* SIOCSIWRTS */
2692 NULL, /* SIOCGIWRTS */
2693 NULL, /* SIOCSIWFRAG */
2694 NULL, /* SIOCGIWFRAG */
2695 NULL, /* SIOCSIWTXPOW */
2696 NULL, /* SIOCGIWTXPOW */
2697 NULL, /* SIOCSIWRETRY */
2698 NULL, /* SIOCGIWRETRY */
2699 wavelan_set_encode, /* SIOCSIWENCODE */
2700 wavelan_get_encode, /* SIOCGIWENCODE */
2701};
2702
2703static const iw_handler wavelan_private_handler[] =
2704{
2705 wavelan_set_qthr, /* SIOCIWFIRSTPRIV */
2706 wavelan_get_qthr, /* SIOCIWFIRSTPRIV + 1 */
2707#ifdef WAVELAN_ROAMING
2708 wavelan_set_roam, /* SIOCIWFIRSTPRIV + 2 */
2709 wavelan_get_roam, /* SIOCIWFIRSTPRIV + 3 */
2710#else /* WAVELAN_ROAMING */
2711 NULL, /* SIOCIWFIRSTPRIV + 2 */
2712 NULL, /* SIOCIWFIRSTPRIV + 3 */
2713#endif /* WAVELAN_ROAMING */
2714#ifdef HISTOGRAM
2715 wavelan_set_histo, /* SIOCIWFIRSTPRIV + 4 */
2716 wavelan_get_histo, /* SIOCIWFIRSTPRIV + 5 */
2717#endif /* HISTOGRAM */
2718};
2719
2720static const struct iw_handler_def wavelan_handler_def =
2721{
2722 .num_standard = sizeof(wavelan_handler)/sizeof(iw_handler),
2723 .num_private = sizeof(wavelan_private_handler)/sizeof(iw_handler),
2724 .num_private_args = sizeof(wavelan_private_args)/sizeof(struct iw_priv_args),
2725 .standard = wavelan_handler,
2726 .private = wavelan_private_handler,
2727 .private_args = wavelan_private_args,
2728 .get_wireless_stats = wavelan_get_wireless_stats,
2729};
2730
2731/*------------------------------------------------------------------*/
2732/*
2733 * Get wireless statistics
2734 * Called by /proc/net/wireless...
2735 */
2736static iw_stats *
2737wavelan_get_wireless_stats(struct net_device * dev)
2738{
2739 kio_addr_t base = dev->base_addr;
2740 net_local * lp = netdev_priv(dev);
2741 mmr_t m;
2742 iw_stats * wstats;
2743 unsigned long flags;
2744
2745#ifdef DEBUG_IOCTL_TRACE
2746 printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n", dev->name);
2747#endif
2748
2749 /* Disable interrupts & save flags */
2750 spin_lock_irqsave(&lp->spinlock, flags);
2751
2752 wstats = &lp->wstats;
2753
2754 /* Get data from the mmc */
2755 mmc_out(base, mmwoff(0, mmw_freeze), 1);
2756
2757 mmc_read(base, mmroff(0, mmr_dce_status), &m.mmr_dce_status, 1);
2758 mmc_read(base, mmroff(0, mmr_wrong_nwid_l), &m.mmr_wrong_nwid_l, 2);
2759 mmc_read(base, mmroff(0, mmr_thr_pre_set), &m.mmr_thr_pre_set, 4);
2760
2761 mmc_out(base, mmwoff(0, mmw_freeze), 0);
2762
2763 /* Copy data to wireless stuff */
2764 wstats->status = m.mmr_dce_status & MMR_DCE_STATUS;
2765 wstats->qual.qual = m.mmr_sgnl_qual & MMR_SGNL_QUAL;
2766 wstats->qual.level = m.mmr_signal_lvl & MMR_SIGNAL_LVL;
2767 wstats->qual.noise = m.mmr_silence_lvl & MMR_SILENCE_LVL;
2768 wstats->qual.updated = (((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 7) |
2769 ((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 6) |
2770 ((m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) >> 5));
2771 wstats->discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
2772 wstats->discard.code = 0L;
2773 wstats->discard.misc = 0L;
2774
2775 /* ReEnable interrupts & restore flags */
2776 spin_unlock_irqrestore(&lp->spinlock, flags);
2777
2778#ifdef DEBUG_IOCTL_TRACE
2779 printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n", dev->name);
2780#endif
2781 return &lp->wstats;
2782}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783
2784/************************* PACKET RECEPTION *************************/
2785/*
2786 * This part deal with receiving the packets.
2787 * The interrupt handler get an interrupt when a packet has been
2788 * successfully received and called this part...
2789 */
2790
2791/*------------------------------------------------------------------*/
2792/*
2793 * Calculate the starting address of the frame pointed to by the receive
2794 * frame pointer and verify that the frame seem correct
2795 * (called by wv_packet_rcv())
2796 */
2797static inline int
2798wv_start_of_frame(struct net_device * dev,
2799 int rfp, /* end of frame */
2800 int wrap) /* start of buffer */
2801{
2802 kio_addr_t base = dev->base_addr;
2803 int rp;
2804 int len;
2805
2806 rp = (rfp - 5 + RX_SIZE) % RX_SIZE;
2807 outb(rp & 0xff, PIORL(base));
2808 outb(((rp >> 8) & PIORH_MASK), PIORH(base));
2809 len = inb(PIOP(base));
2810 len |= inb(PIOP(base)) << 8;
2811
2812 /* Sanity checks on size */
2813 /* Frame too big */
2814 if(len > MAXDATAZ + 100)
2815 {
2816#ifdef DEBUG_RX_ERROR
2817 printk(KERN_INFO "%s: wv_start_of_frame: Received frame too large, rfp %d len 0x%x\n",
2818 dev->name, rfp, len);
2819#endif
2820 return(-1);
2821 }
2822
2823 /* Frame too short */
2824 if(len < 7)
2825 {
2826#ifdef DEBUG_RX_ERROR
2827 printk(KERN_INFO "%s: wv_start_of_frame: Received null frame, rfp %d len 0x%x\n",
2828 dev->name, rfp, len);
2829#endif
2830 return(-1);
2831 }
2832
2833 /* Wrap around buffer */
2834 if(len > ((wrap - (rfp - len) + RX_SIZE) % RX_SIZE)) /* magic formula ! */
2835 {
2836#ifdef DEBUG_RX_ERROR
2837 printk(KERN_INFO "%s: wv_start_of_frame: wrap around buffer, wrap %d rfp %d len 0x%x\n",
2838 dev->name, wrap, rfp, len);
2839#endif
2840 return(-1);
2841 }
2842
2843 return((rp - len + RX_SIZE) % RX_SIZE);
2844} /* wv_start_of_frame */
2845
2846/*------------------------------------------------------------------*/
2847/*
2848 * This routine does the actual copy of data (including the ethernet
2849 * header structure) from the WaveLAN card to an sk_buff chain that
2850 * will be passed up to the network interface layer. NOTE: We
2851 * currently don't handle trailer protocols (neither does the rest of
2852 * the network interface), so if that is needed, it will (at least in
2853 * part) be added here. The contents of the receive ring buffer are
2854 * copied to a message chain that is then passed to the kernel.
2855 *
2856 * Note: if any errors occur, the packet is "dropped on the floor"
2857 * (called by wv_packet_rcv())
2858 */
2859static inline void
2860wv_packet_read(struct net_device * dev,
2861 int fd_p,
2862 int sksize)
2863{
2864 net_local * lp = netdev_priv(dev);
2865 struct sk_buff * skb;
2866
2867#ifdef DEBUG_RX_TRACE
2868 printk(KERN_DEBUG "%s: ->wv_packet_read(0x%X, %d)\n",
2869 dev->name, fd_p, sksize);
2870#endif
2871
2872 /* Allocate some buffer for the new packet */
2873 if((skb = dev_alloc_skb(sksize+2)) == (struct sk_buff *) NULL)
2874 {
2875#ifdef DEBUG_RX_ERROR
2876 printk(KERN_INFO "%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC)\n",
2877 dev->name, sksize);
2878#endif
2879 lp->stats.rx_dropped++;
2880 /*
2881 * Not only do we want to return here, but we also need to drop the
2882 * packet on the floor to clear the interrupt.
2883 */
2884 return;
2885 }
2886
2887 skb->dev = dev;
2888
2889 skb_reserve(skb, 2);
2890 fd_p = read_ringbuf(dev, fd_p, (char *) skb_put(skb, sksize), sksize);
2891 skb->protocol = eth_type_trans(skb, dev);
2892
2893#ifdef DEBUG_RX_INFO
2894 wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read");
2895#endif /* DEBUG_RX_INFO */
2896
2897 /* Statistics gathering & stuff associated.
2898 * It seem a bit messy with all the define, but it's really simple... */
2899 if(
2900#ifdef IW_WIRELESS_SPY
2901 (lp->spy_data.spy_number > 0) ||
2902#endif /* IW_WIRELESS_SPY */
2903#ifdef HISTOGRAM
2904 (lp->his_number > 0) ||
2905#endif /* HISTOGRAM */
2906#ifdef WAVELAN_ROAMING
2907 (do_roaming) ||
2908#endif /* WAVELAN_ROAMING */
2909 0)
2910 {
2911 u_char stats[3]; /* Signal level, Noise level, Signal quality */
2912
2913 /* read signal level, silence level and signal quality bytes */
2914 fd_p = read_ringbuf(dev, (fd_p + 4) % RX_SIZE + RX_BASE,
2915 stats, 3);
2916#ifdef DEBUG_RX_INFO
2917 printk(KERN_DEBUG "%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2918 dev->name, stats[0] & 0x3F, stats[1] & 0x3F, stats[2] & 0x0F);
2919#endif
2920
2921#ifdef WAVELAN_ROAMING
2922 if(do_roaming)
2923 if(WAVELAN_BEACON(skb->data))
2924 wl_roam_gather(dev, skb->data, stats);
2925#endif /* WAVELAN_ROAMING */
2926
2927#ifdef WIRELESS_SPY
2928 wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE, stats);
2929#endif /* WIRELESS_SPY */
2930#ifdef HISTOGRAM
2931 wl_his_gather(dev, stats);
2932#endif /* HISTOGRAM */
2933 }
2934
2935 /*
2936 * Hand the packet to the Network Module
2937 */
2938 netif_rx(skb);
2939
2940 /* Keep stats up to date */
2941 dev->last_rx = jiffies;
2942 lp->stats.rx_packets++;
2943 lp->stats.rx_bytes += sksize;
2944
2945#ifdef DEBUG_RX_TRACE
2946 printk(KERN_DEBUG "%s: <-wv_packet_read()\n", dev->name);
2947#endif
2948 return;
2949}
2950
2951/*------------------------------------------------------------------*/
2952/*
2953 * This routine is called by the interrupt handler to initiate a
2954 * packet transfer from the card to the network interface layer above
2955 * this driver. This routine checks if a buffer has been successfully
2956 * received by the WaveLAN card. If so, the routine wv_packet_read is
2957 * called to do the actual transfer of the card's data including the
2958 * ethernet header into a packet consisting of an sk_buff chain.
2959 * (called by wavelan_interrupt())
2960 * Note : the spinlock is already grabbed for us and irq are disabled.
2961 */
2962static inline void
2963wv_packet_rcv(struct net_device * dev)
2964{
2965 kio_addr_t base = dev->base_addr;
2966 net_local * lp = netdev_priv(dev);
2967 int newrfp;
2968 int rp;
2969 int len;
2970 int f_start;
2971 int status;
2972 int i593_rfp;
2973 int stat_ptr;
2974 u_char c[4];
2975
2976#ifdef DEBUG_RX_TRACE
2977 printk(KERN_DEBUG "%s: ->wv_packet_rcv()\n", dev->name);
2978#endif
2979
2980 /* Get the new receive frame pointer from the i82593 chip */
2981 outb(CR0_STATUS_2 | OP0_NOP, LCCR(base));
2982 i593_rfp = inb(LCSR(base));
2983 i593_rfp |= inb(LCSR(base)) << 8;
2984 i593_rfp %= RX_SIZE;
2985
2986 /* Get the new receive frame pointer from the WaveLAN card.
2987 * It is 3 bytes more than the increment of the i82593 receive
2988 * frame pointer, for each packet. This is because it includes the
2989 * 3 roaming bytes added by the mmc.
2990 */
2991 newrfp = inb(RPLL(base));
2992 newrfp |= inb(RPLH(base)) << 8;
2993 newrfp %= RX_SIZE;
2994
2995#ifdef DEBUG_RX_INFO
2996 printk(KERN_DEBUG "%s: wv_packet_rcv(): i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2997 dev->name, i593_rfp, lp->stop, newrfp, lp->rfp);
2998#endif
2999
3000#ifdef DEBUG_RX_ERROR
3001 /* If no new frame pointer... */
3002 if(lp->overrunning || newrfp == lp->rfp)
3003 printk(KERN_INFO "%s: wv_packet_rcv(): no new frame: i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
3004 dev->name, i593_rfp, lp->stop, newrfp, lp->rfp);
3005#endif
3006
3007 /* Read all frames (packets) received */
3008 while(newrfp != lp->rfp)
3009 {
3010 /* A frame is composed of the packet, followed by a status word,
3011 * the length of the frame (word) and the mmc info (SNR & qual).
3012 * It's because the length is at the end that we can only scan
3013 * frames backward. */
3014
3015 /* Find the first frame by skipping backwards over the frames */
3016 rp = newrfp; /* End of last frame */
3017 while(((f_start = wv_start_of_frame(dev, rp, newrfp)) != lp->rfp) &&
3018 (f_start != -1))
3019 rp = f_start;
3020
3021 /* If we had a problem */
3022 if(f_start == -1)
3023 {
3024#ifdef DEBUG_RX_ERROR
3025 printk(KERN_INFO "wavelan_cs: cannot find start of frame ");
3026 printk(" i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
3027 i593_rfp, lp->stop, newrfp, lp->rfp);
3028#endif
3029 lp->rfp = rp; /* Get to the last usable frame */
3030 continue;
3031 }
3032
3033 /* f_start point to the beggining of the first frame received
3034 * and rp to the beggining of the next one */
3035
3036 /* Read status & length of the frame */
3037 stat_ptr = (rp - 7 + RX_SIZE) % RX_SIZE;
3038 stat_ptr = read_ringbuf(dev, stat_ptr, c, 4);
3039 status = c[0] | (c[1] << 8);
3040 len = c[2] | (c[3] << 8);
3041
3042 /* Check status */
3043 if((status & RX_RCV_OK) != RX_RCV_OK)
3044 {
3045 lp->stats.rx_errors++;
3046 if(status & RX_NO_SFD)
3047 lp->stats.rx_frame_errors++;
3048 if(status & RX_CRC_ERR)
3049 lp->stats.rx_crc_errors++;
3050 if(status & RX_OVRRUN)
3051 lp->stats.rx_over_errors++;
3052
3053#ifdef DEBUG_RX_FAIL
3054 printk(KERN_DEBUG "%s: wv_packet_rcv(): packet not received ok, status = 0x%x\n",
3055 dev->name, status);
3056#endif
3057 }
3058 else
3059 /* Read the packet and transmit to Linux */
3060 wv_packet_read(dev, f_start, len - 2);
3061
3062 /* One frame has been processed, skip it */
3063 lp->rfp = rp;
3064 }
3065
3066 /*
3067 * Update the frame stop register, but set it to less than
3068 * the full 8K to allow space for 3 bytes of signal strength
3069 * per packet.
3070 */
3071 lp->stop = (i593_rfp + RX_SIZE - ((RX_SIZE / 64) * 3)) % RX_SIZE;
3072 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, LCCR(base));
3073 outb(CR1_STOP_REG_UPDATE | (lp->stop >> RX_SIZE_SHIFT), LCCR(base));
3074 outb(OP1_SWIT_TO_PORT_0, LCCR(base));
3075
3076#ifdef DEBUG_RX_TRACE
3077 printk(KERN_DEBUG "%s: <-wv_packet_rcv()\n", dev->name);
3078#endif
3079}
3080
3081/*********************** PACKET TRANSMISSION ***********************/
3082/*
3083 * This part deal with sending packet through the wavelan
3084 * We copy the packet to the send buffer and then issue the send
3085 * command to the i82593. The result of this operation will be
3086 * checked in wavelan_interrupt()
3087 */
3088
3089/*------------------------------------------------------------------*/
3090/*
3091 * This routine fills in the appropriate registers and memory
3092 * locations on the WaveLAN card and starts the card off on
3093 * the transmit.
3094 * (called in wavelan_packet_xmit())
3095 */
3096static inline void
3097wv_packet_write(struct net_device * dev,
3098 void * buf,
3099 short length)
3100{
3101 net_local * lp = netdev_priv(dev);
3102 kio_addr_t base = dev->base_addr;
3103 unsigned long flags;
3104 int clen = length;
3105 register u_short xmtdata_base = TX_BASE;
3106
3107#ifdef DEBUG_TX_TRACE
3108 printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name, length);
3109#endif
3110
3111 spin_lock_irqsave(&lp->spinlock, flags);
3112
3113 /* Write the length of data buffer followed by the buffer */
3114 outb(xmtdata_base & 0xff, PIORL(base));
3115 outb(((xmtdata_base >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3116 outb(clen & 0xff, PIOP(base)); /* lsb */
3117 outb(clen >> 8, PIOP(base)); /* msb */
3118
3119 /* Send the data */
3120 outsb(PIOP(base), buf, clen);
3121
3122 /* Indicate end of transmit chain */
3123 outb(OP0_NOP, PIOP(base));
3124 /* josullvn@cs.cmu.edu: need to send a second NOP for alignment... */
3125 outb(OP0_NOP, PIOP(base));
3126
3127 /* Reset the transmit DMA pointer */
3128 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3129 hacr_write(base, HACR_DEFAULT);
3130 /* Send the transmit command */
3131 wv_82593_cmd(dev, "wv_packet_write(): transmit",
3132 OP0_TRANSMIT, SR0_NO_RESULT);
3133
3134 /* Make sure the watchdog will keep quiet for a while */
3135 dev->trans_start = jiffies;
3136
3137 /* Keep stats up to date */
3138 lp->stats.tx_bytes += length;
3139
3140 spin_unlock_irqrestore(&lp->spinlock, flags);
3141
3142#ifdef DEBUG_TX_INFO
3143 wv_packet_info((u_char *) buf, length, dev->name, "wv_packet_write");
3144#endif /* DEBUG_TX_INFO */
3145
3146#ifdef DEBUG_TX_TRACE
3147 printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name);
3148#endif
3149}
3150
3151/*------------------------------------------------------------------*/
3152/*
3153 * This routine is called when we want to send a packet (NET3 callback)
3154 * In this routine, we check if the harware is ready to accept
3155 * the packet. We also prevent reentrance. Then, we call the function
3156 * to send the packet...
3157 */
3158static int
3159wavelan_packet_xmit(struct sk_buff * skb,
3160 struct net_device * dev)
3161{
3162 net_local * lp = netdev_priv(dev);
3163 unsigned long flags;
3164
3165#ifdef DEBUG_TX_TRACE
3166 printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
3167 (unsigned) skb);
3168#endif
3169
3170 /*
3171 * Block a timer-based transmit from overlapping a previous transmit.
3172 * In other words, prevent reentering this routine.
3173 */
3174 netif_stop_queue(dev);
3175
3176 /* If somebody has asked to reconfigure the controller,
3177 * we can do it now */
3178 if(lp->reconfig_82593)
3179 {
3180 spin_lock_irqsave(&lp->spinlock, flags); /* Disable interrupts */
3181 wv_82593_config(dev);
3182 spin_unlock_irqrestore(&lp->spinlock, flags); /* Re-enable interrupts */
3183 /* Note : the configure procedure was totally synchronous,
3184 * so the Tx buffer is now free */
3185 }
3186
3187#ifdef DEBUG_TX_ERROR
3188 if (skb->next)
3189 printk(KERN_INFO "skb has next\n");
3190#endif
3191
3192 /* Check if we need some padding */
3193 /* Note : on wireless the propagation time is in the order of 1us,
3194 * and we don't have the Ethernet specific requirement of beeing
3195 * able to detect collisions, therefore in theory we don't really
3196 * need to pad. Jean II */
3197 if (skb->len < ETH_ZLEN) {
3198 skb = skb_padto(skb, ETH_ZLEN);
3199 if (skb == NULL)
3200 return 0;
3201 }
3202
3203 wv_packet_write(dev, skb->data, skb->len);
3204
3205 dev_kfree_skb(skb);
3206
3207#ifdef DEBUG_TX_TRACE
3208 printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
3209#endif
3210 return(0);
3211}
3212
3213/********************** HARDWARE CONFIGURATION **********************/
3214/*
3215 * This part do the real job of starting and configuring the hardware.
3216 */
3217
3218/*------------------------------------------------------------------*/
3219/*
3220 * Routine to initialize the Modem Management Controller.
3221 * (called by wv_hw_config())
3222 */
3223static inline int
3224wv_mmc_init(struct net_device * dev)
3225{
3226 kio_addr_t base = dev->base_addr;
3227 psa_t psa;
3228 mmw_t m;
3229 int configured;
3230 int i; /* Loop counter */
3231
3232#ifdef DEBUG_CONFIG_TRACE
3233 printk(KERN_DEBUG "%s: ->wv_mmc_init()\n", dev->name);
3234#endif
3235
3236 /* Read the parameter storage area */
3237 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
3238
3239 /*
3240 * Check the first three octets of the MAC addr for the manufacturer's code.
3241 * Note: If you get the error message below, you've got a
3242 * non-NCR/AT&T/Lucent PCMCIA cards, see wavelan_cs.h for detail on
3243 * how to configure your card...
3244 */
3245 for(i = 0; i < (sizeof(MAC_ADDRESSES) / sizeof(char) / 3); i++)
3246 if((psa.psa_univ_mac_addr[0] == MAC_ADDRESSES[i][0]) &&
3247 (psa.psa_univ_mac_addr[1] == MAC_ADDRESSES[i][1]) &&
3248 (psa.psa_univ_mac_addr[2] == MAC_ADDRESSES[i][2]))
3249 break;
3250
3251 /* If we have not found it... */
3252 if(i == (sizeof(MAC_ADDRESSES) / sizeof(char) / 3))
3253 {
3254#ifdef DEBUG_CONFIG_ERRORS
3255 printk(KERN_WARNING "%s: wv_mmc_init(): Invalid MAC address: %02X:%02X:%02X:...\n",
3256 dev->name, psa.psa_univ_mac_addr[0],
3257 psa.psa_univ_mac_addr[1], psa.psa_univ_mac_addr[2]);
3258#endif
3259 return FALSE;
3260 }
3261
3262 /* Get the MAC address */
3263 memcpy(&dev->dev_addr[0], &psa.psa_univ_mac_addr[0], WAVELAN_ADDR_SIZE);
3264
3265#ifdef USE_PSA_CONFIG
3266 configured = psa.psa_conf_status & 1;
3267#else
3268 configured = 0;
3269#endif
3270
3271 /* Is the PSA is not configured */
3272 if(!configured)
3273 {
3274 /* User will be able to configure NWID after (with iwconfig) */
3275 psa.psa_nwid[0] = 0;
3276 psa.psa_nwid[1] = 0;
3277
3278 /* As NWID is not set : no NWID checking */
3279 psa.psa_nwid_select = 0;
3280
3281 /* Disable encryption */
3282 psa.psa_encryption_select = 0;
3283
3284 /* Set to standard values
3285 * 0x04 for AT,
3286 * 0x01 for MCA,
3287 * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
3288 */
3289 if (psa.psa_comp_number & 1)
3290 psa.psa_thr_pre_set = 0x01;
3291 else
3292 psa.psa_thr_pre_set = 0x04;
3293 psa.psa_quality_thr = 0x03;
3294
3295 /* It is configured */
3296 psa.psa_conf_status |= 1;
3297
3298#ifdef USE_PSA_CONFIG
3299 /* Write the psa */
3300 psa_write(dev, (char *)psa.psa_nwid - (char *)&psa,
3301 (unsigned char *)psa.psa_nwid, 4);
3302 psa_write(dev, (char *)&psa.psa_thr_pre_set - (char *)&psa,
3303 (unsigned char *)&psa.psa_thr_pre_set, 1);
3304 psa_write(dev, (char *)&psa.psa_quality_thr - (char *)&psa,
3305 (unsigned char *)&psa.psa_quality_thr, 1);
3306 psa_write(dev, (char *)&psa.psa_conf_status - (char *)&psa,
3307 (unsigned char *)&psa.psa_conf_status, 1);
3308 /* update the Wavelan checksum */
3309 update_psa_checksum(dev);
3310#endif /* USE_PSA_CONFIG */
3311 }
3312
3313 /* Zero the mmc structure */
3314 memset(&m, 0x00, sizeof(m));
3315
3316 /* Copy PSA info to the mmc */
3317 m.mmw_netw_id_l = psa.psa_nwid[1];
3318 m.mmw_netw_id_h = psa.psa_nwid[0];
3319
3320 if(psa.psa_nwid_select & 1)
3321 m.mmw_loopt_sel = 0x00;
3322 else
3323 m.mmw_loopt_sel = MMW_LOOPT_SEL_DIS_NWID;
3324
3325 memcpy(&m.mmw_encr_key, &psa.psa_encryption_key,
3326 sizeof(m.mmw_encr_key));
3327
3328 if(psa.psa_encryption_select)
3329 m.mmw_encr_enable = MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE;
3330 else
3331 m.mmw_encr_enable = 0;
3332
3333 m.mmw_thr_pre_set = psa.psa_thr_pre_set & 0x3F;
3334 m.mmw_quality_thr = psa.psa_quality_thr & 0x0F;
3335
3336 /*
3337 * Set default modem control parameters.
3338 * See NCR document 407-0024326 Rev. A.
3339 */
3340 m.mmw_jabber_enable = 0x01;
3341 m.mmw_anten_sel = MMW_ANTEN_SEL_ALG_EN;
3342 m.mmw_ifs = 0x20;
3343 m.mmw_mod_delay = 0x04;
3344 m.mmw_jam_time = 0x38;
3345
3346 m.mmw_des_io_invert = 0;
3347 m.mmw_freeze = 0;
3348 m.mmw_decay_prm = 0;
3349 m.mmw_decay_updat_prm = 0;
3350
3351 /* Write all info to mmc */
3352 mmc_write(base, 0, (u_char *)&m, sizeof(m));
3353
3354 /* The following code start the modem of the 2.00 frequency
3355 * selectable cards at power on. It's not strictly needed for the
3356 * following boots...
3357 * The original patch was by Joe Finney for the PCMCIA driver, but
3358 * I've cleaned it a bit and add documentation.
3359 * Thanks to Loeke Brederveld from Lucent for the info.
3360 */
3361
3362 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
3363 * (does it work for everybody ? - especially old cards...) */
3364 /* Note : WFREQSEL verify that it is able to read from EEprom
3365 * a sensible frequency (address 0x00) + that MMR_FEE_STATUS_ID
3366 * is 0xA (Xilinx version) or 0xB (Ariadne version).
3367 * My test is more crude but do work... */
3368 if(!(mmc_in(base, mmroff(0, mmr_fee_status)) &
3369 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
3370 {
3371 /* We must download the frequency parameters to the
3372 * synthetisers (from the EEprom - area 1)
3373 * Note : as the EEprom is auto decremented, we set the end
3374 * if the area... */
3375 m.mmw_fee_addr = 0x0F;
3376 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3377 mmc_write(base, (char *)&m.mmw_fee_ctrl - (char *)&m,
3378 (unsigned char *)&m.mmw_fee_ctrl, 2);
3379
3380 /* Wait until the download is finished */
3381 fee_wait(base, 100, 100);
3382
3383#ifdef DEBUG_CONFIG_INFO
3384 /* The frequency was in the last word downloaded... */
3385 mmc_read(base, (char *)&m.mmw_fee_data_l - (char *)&m,
3386 (unsigned char *)&m.mmw_fee_data_l, 2);
3387
3388 /* Print some info for the user */
3389 printk(KERN_DEBUG "%s: Wavelan 2.00 recognised (frequency select) : Current frequency = %ld\n",
3390 dev->name,
3391 ((m.mmw_fee_data_h << 4) |
3392 (m.mmw_fee_data_l >> 4)) * 5 / 2 + 24000L);
3393#endif
3394
3395 /* We must now download the power adjust value (gain) to
3396 * the synthetisers (from the EEprom - area 7 - DAC) */
3397 m.mmw_fee_addr = 0x61;
3398 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3399 mmc_write(base, (char *)&m.mmw_fee_ctrl - (char *)&m,
3400 (unsigned char *)&m.mmw_fee_ctrl, 2);
3401
3402 /* Wait until the download is finished */
3403 } /* if 2.00 card */
3404
3405#ifdef DEBUG_CONFIG_TRACE
3406 printk(KERN_DEBUG "%s: <-wv_mmc_init()\n", dev->name);
3407#endif
3408 return TRUE;
3409}
3410
3411/*------------------------------------------------------------------*/
3412/*
3413 * Routine to gracefully turn off reception, and wait for any commands
3414 * to complete.
3415 * (called in wv_ru_start() and wavelan_close() and wavelan_event())
3416 */
3417static int
3418wv_ru_stop(struct net_device * dev)
3419{
3420 kio_addr_t base = dev->base_addr;
3421 net_local * lp = netdev_priv(dev);
3422 unsigned long flags;
3423 int status;
3424 int spin;
3425
3426#ifdef DEBUG_CONFIG_TRACE
3427 printk(KERN_DEBUG "%s: ->wv_ru_stop()\n", dev->name);
3428#endif
3429
3430 spin_lock_irqsave(&lp->spinlock, flags);
3431
3432 /* First, send the LAN controller a stop receive command */
3433 wv_82593_cmd(dev, "wv_graceful_shutdown(): stop-rcv",
3434 OP0_STOP_RCV, SR0_NO_RESULT);
3435
3436 /* Then, spin until the receive unit goes idle */
3437 spin = 300;
3438 do
3439 {
3440 udelay(10);
3441 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
3442 status = inb(LCSR(base));
3443 }
3444 while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_IDLE) && (spin-- > 0));
3445
3446 /* Now, spin until the chip finishes executing its current command */
3447 do
3448 {
3449 udelay(10);
3450 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
3451 status = inb(LCSR(base));
3452 }
3453 while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin-- > 0));
3454
3455 spin_unlock_irqrestore(&lp->spinlock, flags);
3456
3457 /* If there was a problem */
3458 if(spin <= 0)
3459 {
3460#ifdef DEBUG_CONFIG_ERRORS
3461 printk(KERN_INFO "%s: wv_ru_stop(): The chip doesn't want to stop...\n",
3462 dev->name);
3463#endif
3464 return FALSE;
3465 }
3466
3467#ifdef DEBUG_CONFIG_TRACE
3468 printk(KERN_DEBUG "%s: <-wv_ru_stop()\n", dev->name);
3469#endif
3470 return TRUE;
3471} /* wv_ru_stop */
3472
3473/*------------------------------------------------------------------*/
3474/*
3475 * This routine starts the receive unit running. First, it checks if
3476 * the card is actually ready. Then the card is instructed to receive
3477 * packets again.
3478 * (called in wv_hw_reset() & wavelan_open())
3479 */
3480static int
3481wv_ru_start(struct net_device * dev)
3482{
3483 kio_addr_t base = dev->base_addr;
3484 net_local * lp = netdev_priv(dev);
3485 unsigned long flags;
3486
3487#ifdef DEBUG_CONFIG_TRACE
3488 printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name);
3489#endif
3490
3491 /*
3492 * We need to start from a quiescent state. To do so, we could check
3493 * if the card is already running, but instead we just try to shut
3494 * it down. First, we disable reception (in case it was already enabled).
3495 */
3496 if(!wv_ru_stop(dev))
3497 return FALSE;
3498
3499 spin_lock_irqsave(&lp->spinlock, flags);
3500
3501 /* Now we know that no command is being executed. */
3502
3503 /* Set the receive frame pointer and stop pointer */
3504 lp->rfp = 0;
3505 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, LCCR(base));
3506
3507 /* Reset ring management. This sets the receive frame pointer to 1 */
3508 outb(OP1_RESET_RING_MNGMT, LCCR(base));
3509
3510#if 0
3511 /* XXX the i82593 manual page 6-4 seems to indicate that the stop register
3512 should be set as below */
3513 /* outb(CR1_STOP_REG_UPDATE|((RX_SIZE - 0x40)>> RX_SIZE_SHIFT),LCCR(base));*/
3514#elif 0
3515 /* but I set it 0 instead */
3516 lp->stop = 0;
3517#else
3518 /* but I set it to 3 bytes per packet less than 8K */
3519 lp->stop = (0 + RX_SIZE - ((RX_SIZE / 64) * 3)) % RX_SIZE;
3520#endif
3521 outb(CR1_STOP_REG_UPDATE | (lp->stop >> RX_SIZE_SHIFT), LCCR(base));
3522 outb(OP1_INT_ENABLE, LCCR(base));
3523 outb(OP1_SWIT_TO_PORT_0, LCCR(base));
3524
3525 /* Reset receive DMA pointer */
3526 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3527 hacr_write_slow(base, HACR_DEFAULT);
3528
3529 /* Receive DMA on channel 1 */
3530 wv_82593_cmd(dev, "wv_ru_start(): rcv-enable",
3531 CR0_CHNL | OP0_RCV_ENABLE, SR0_NO_RESULT);
3532
3533#ifdef DEBUG_I82593_SHOW
3534 {
3535 int status;
3536 int opri;
3537 int spin = 10000;
3538
3539 /* spin until the chip starts receiving */
3540 do
3541 {
3542 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
3543 status = inb(LCSR(base));
3544 if(spin-- <= 0)
3545 break;
3546 }
3547 while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_ACTIVE) &&
3548 ((status & SR3_RCV_STATE_MASK) != SR3_RCV_READY));
3549 printk(KERN_DEBUG "rcv status is 0x%x [i:%d]\n",
3550 (status & SR3_RCV_STATE_MASK), i);
3551 }
3552#endif
3553
3554 spin_unlock_irqrestore(&lp->spinlock, flags);
3555
3556#ifdef DEBUG_CONFIG_TRACE
3557 printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name);
3558#endif
3559 return TRUE;
3560}
3561
3562/*------------------------------------------------------------------*/
3563/*
3564 * This routine does a standard config of the WaveLAN controller (i82593).
3565 * In the ISA driver, this is integrated in wavelan_hardware_reset()
3566 * (called by wv_hw_config(), wv_82593_reconfig() & wavelan_packet_xmit())
3567 */
3568static int
3569wv_82593_config(struct net_device * dev)
3570{
3571 kio_addr_t base = dev->base_addr;
3572 net_local * lp = netdev_priv(dev);
3573 struct i82593_conf_block cfblk;
3574 int ret = TRUE;
3575
3576#ifdef DEBUG_CONFIG_TRACE
3577 printk(KERN_DEBUG "%s: ->wv_82593_config()\n", dev->name);
3578#endif
3579
3580 /* Create & fill i82593 config block
3581 *
3582 * Now conform to Wavelan document WCIN085B
3583 */
3584 memset(&cfblk, 0x00, sizeof(struct i82593_conf_block));
3585 cfblk.d6mod = FALSE; /* Run in i82593 advanced mode */
3586 cfblk.fifo_limit = 5; /* = 56 B rx and 40 B tx fifo thresholds */
3587 cfblk.forgnesi = FALSE; /* 0=82C501, 1=AMD7992B compatibility */
3588 cfblk.fifo_32 = 1;
3589 cfblk.throttle_enb = FALSE;
3590 cfblk.contin = TRUE; /* enable continuous mode */
3591 cfblk.cntrxint = FALSE; /* enable continuous mode receive interrupts */
3592 cfblk.addr_len = WAVELAN_ADDR_SIZE;
3593 cfblk.acloc = TRUE; /* Disable source addr insertion by i82593 */
3594 cfblk.preamb_len = 0; /* 2 bytes preamble (SFD) */
3595 cfblk.loopback = FALSE;
3596 cfblk.lin_prio = 0; /* conform to 802.3 backoff algoritm */
3597 cfblk.exp_prio = 5; /* conform to 802.3 backoff algoritm */
3598 cfblk.bof_met = 1; /* conform to 802.3 backoff algoritm */
Jean Tourrilhesaca0b512006-02-16 17:44:54 -08003599 cfblk.ifrm_spc = 0x20 >> 4; /* 32 bit times interframe spacing */
3600 cfblk.slottim_low = 0x20 >> 5; /* 32 bit times slot time */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 cfblk.slottim_hi = 0x0;
3602 cfblk.max_retr = 15;
3603 cfblk.prmisc = ((lp->promiscuous) ? TRUE: FALSE); /* Promiscuous mode */
3604 cfblk.bc_dis = FALSE; /* Enable broadcast reception */
3605 cfblk.crs_1 = TRUE; /* Transmit without carrier sense */
3606 cfblk.nocrc_ins = FALSE; /* i82593 generates CRC */
3607 cfblk.crc_1632 = FALSE; /* 32-bit Autodin-II CRC */
3608 cfblk.crs_cdt = FALSE; /* CD not to be interpreted as CS */
3609 cfblk.cs_filter = 0; /* CS is recognized immediately */
3610 cfblk.crs_src = FALSE; /* External carrier sense */
3611 cfblk.cd_filter = 0; /* CD is recognized immediately */
3612 cfblk.min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length 64 bytes */
3613 cfblk.lng_typ = FALSE; /* Length field > 1500 = type field */
3614 cfblk.lng_fld = TRUE; /* Disable 802.3 length field check */
3615 cfblk.rxcrc_xf = TRUE; /* Don't transfer CRC to memory */
3616 cfblk.artx = TRUE; /* Disable automatic retransmission */
3617 cfblk.sarec = TRUE; /* Disable source addr trig of CD */
3618 cfblk.tx_jabber = TRUE; /* Disable jabber jam sequence */
3619 cfblk.hash_1 = FALSE; /* Use bits 0-5 in mc address hash */
3620 cfblk.lbpkpol = TRUE; /* Loopback pin active high */
3621 cfblk.fdx = FALSE; /* Disable full duplex operation */
3622 cfblk.dummy_6 = 0x3f; /* all ones */
3623 cfblk.mult_ia = FALSE; /* No multiple individual addresses */
3624 cfblk.dis_bof = FALSE; /* Disable the backoff algorithm ?! */
3625 cfblk.dummy_1 = TRUE; /* set to 1 */
3626 cfblk.tx_ifs_retrig = 3; /* Hmm... Disabled */
3627#ifdef MULTICAST_ALL
3628 cfblk.mc_all = (lp->allmulticast ? TRUE: FALSE); /* Allow all multicasts */
3629#else
3630 cfblk.mc_all = FALSE; /* No multicast all mode */
3631#endif
3632 cfblk.rcv_mon = 0; /* Monitor mode disabled */
3633 cfblk.frag_acpt = TRUE; /* Do not accept fragments */
3634 cfblk.tstrttrs = FALSE; /* No start transmission threshold */
3635 cfblk.fretx = TRUE; /* FIFO automatic retransmission */
3636 cfblk.syncrqs = FALSE; /* Synchronous DRQ deassertion... */
3637 cfblk.sttlen = TRUE; /* 6 byte status registers */
3638 cfblk.rx_eop = TRUE; /* Signal EOP on packet reception */
3639 cfblk.tx_eop = TRUE; /* Signal EOP on packet transmission */
3640 cfblk.rbuf_size = RX_SIZE>>11; /* Set receive buffer size */
3641 cfblk.rcvstop = TRUE; /* Enable Receive Stop Register */
3642
3643#ifdef DEBUG_I82593_SHOW
3644 {
3645 u_char *c = (u_char *) &cfblk;
3646 int i;
3647 printk(KERN_DEBUG "wavelan_cs: config block:");
3648 for(i = 0; i < sizeof(struct i82593_conf_block); i++,c++)
3649 {
3650 if((i % 16) == 0) printk("\n" KERN_DEBUG);
3651 printk("%02x ", *c);
3652 }
3653 printk("\n");
3654 }
3655#endif
3656
3657 /* Copy the config block to the i82593 */
3658 outb(TX_BASE & 0xff, PIORL(base));
3659 outb(((TX_BASE >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3660 outb(sizeof(struct i82593_conf_block) & 0xff, PIOP(base)); /* lsb */
3661 outb(sizeof(struct i82593_conf_block) >> 8, PIOP(base)); /* msb */
3662 outsb(PIOP(base), (char *) &cfblk, sizeof(struct i82593_conf_block));
3663
3664 /* reset transmit DMA pointer */
3665 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3666 hacr_write(base, HACR_DEFAULT);
3667 if(!wv_82593_cmd(dev, "wv_82593_config(): configure",
3668 OP0_CONFIGURE, SR0_CONFIGURE_DONE))
3669 ret = FALSE;
3670
3671 /* Initialize adapter's ethernet MAC address */
3672 outb(TX_BASE & 0xff, PIORL(base));
3673 outb(((TX_BASE >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3674 outb(WAVELAN_ADDR_SIZE, PIOP(base)); /* byte count lsb */
3675 outb(0, PIOP(base)); /* byte count msb */
3676 outsb(PIOP(base), &dev->dev_addr[0], WAVELAN_ADDR_SIZE);
3677
3678 /* reset transmit DMA pointer */
3679 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3680 hacr_write(base, HACR_DEFAULT);
3681 if(!wv_82593_cmd(dev, "wv_82593_config(): ia-setup",
3682 OP0_IA_SETUP, SR0_IA_SETUP_DONE))
3683 ret = FALSE;
3684
3685#ifdef WAVELAN_ROAMING
3686 /* If roaming is enabled, join the "Beacon Request" multicast group... */
3687 /* But only if it's not in there already! */
3688 if(do_roaming)
3689 dev_mc_add(dev,WAVELAN_BEACON_ADDRESS, WAVELAN_ADDR_SIZE, 1);
3690#endif /* WAVELAN_ROAMING */
3691
3692 /* If any multicast address to set */
3693 if(lp->mc_count)
3694 {
3695 struct dev_mc_list * dmi;
3696 int addrs_len = WAVELAN_ADDR_SIZE * lp->mc_count;
3697
3698#ifdef DEBUG_CONFIG_INFO
3699 printk(KERN_DEBUG "%s: wv_hw_config(): set %d multicast addresses:\n",
3700 dev->name, lp->mc_count);
3701 for(dmi=dev->mc_list; dmi; dmi=dmi->next)
3702 printk(KERN_DEBUG " %02x:%02x:%02x:%02x:%02x:%02x\n",
3703 dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2],
3704 dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5] );
3705#endif
3706
3707 /* Initialize adapter's ethernet multicast addresses */
3708 outb(TX_BASE & 0xff, PIORL(base));
3709 outb(((TX_BASE >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3710 outb(addrs_len & 0xff, PIOP(base)); /* byte count lsb */
3711 outb((addrs_len >> 8), PIOP(base)); /* byte count msb */
3712 for(dmi=dev->mc_list; dmi; dmi=dmi->next)
3713 outsb(PIOP(base), dmi->dmi_addr, dmi->dmi_addrlen);
3714
3715 /* reset transmit DMA pointer */
3716 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3717 hacr_write(base, HACR_DEFAULT);
3718 if(!wv_82593_cmd(dev, "wv_82593_config(): mc-setup",
3719 OP0_MC_SETUP, SR0_MC_SETUP_DONE))
3720 ret = FALSE;
3721 lp->mc_count = dev->mc_count; /* remember to avoid repeated reset */
3722 }
3723
3724 /* Job done, clear the flag */
3725 lp->reconfig_82593 = FALSE;
3726
3727#ifdef DEBUG_CONFIG_TRACE
3728 printk(KERN_DEBUG "%s: <-wv_82593_config()\n", dev->name);
3729#endif
3730 return(ret);
3731}
3732
3733/*------------------------------------------------------------------*/
3734/*
3735 * Read the Access Configuration Register, perform a software reset,
3736 * and then re-enable the card's software.
3737 *
3738 * If I understand correctly : reset the pcmcia interface of the
3739 * wavelan.
3740 * (called by wv_config())
3741 */
3742static inline int
3743wv_pcmcia_reset(struct net_device * dev)
3744{
3745 int i;
3746 conf_reg_t reg = { 0, CS_READ, CISREG_COR, 0 };
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003747 struct pcmcia_device * link = ((net_local *)netdev_priv(dev))->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003748
3749#ifdef DEBUG_CONFIG_TRACE
3750 printk(KERN_DEBUG "%s: ->wv_pcmcia_reset()\n", dev->name);
3751#endif
3752
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003753 i = pcmcia_access_configuration_register(link, &reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003754 if(i != CS_SUCCESS)
3755 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003756 cs_error(link, AccessConfigurationRegister, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003757 return FALSE;
3758 }
3759
3760#ifdef DEBUG_CONFIG_INFO
3761 printk(KERN_DEBUG "%s: wavelan_pcmcia_reset(): Config reg is 0x%x\n",
3762 dev->name, (u_int) reg.Value);
3763#endif
3764
3765 reg.Action = CS_WRITE;
3766 reg.Value = reg.Value | COR_SW_RESET;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003767 i = pcmcia_access_configuration_register(link, &reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003768 if(i != CS_SUCCESS)
3769 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003770 cs_error(link, AccessConfigurationRegister, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003771 return FALSE;
3772 }
3773
3774 reg.Action = CS_WRITE;
3775 reg.Value = COR_LEVEL_IRQ | COR_CONFIG;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003776 i = pcmcia_access_configuration_register(link, &reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003777 if(i != CS_SUCCESS)
3778 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003779 cs_error(link, AccessConfigurationRegister, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003780 return FALSE;
3781 }
3782
3783#ifdef DEBUG_CONFIG_TRACE
3784 printk(KERN_DEBUG "%s: <-wv_pcmcia_reset()\n", dev->name);
3785#endif
3786 return TRUE;
3787}
3788
3789/*------------------------------------------------------------------*/
3790/*
3791 * wavelan_hw_config() is called after a CARD_INSERTION event is
3792 * received, to configure the wavelan hardware.
3793 * Note that the reception will be enabled in wavelan->open(), so the
3794 * device is configured but idle...
3795 * Performs the following actions:
3796 * 1. A pcmcia software reset (using wv_pcmcia_reset())
3797 * 2. A power reset (reset DMA)
3798 * 3. Reset the LAN controller
3799 * 4. Initialize the radio modem (using wv_mmc_init)
3800 * 5. Configure LAN controller (using wv_82593_config)
3801 * 6. Perform a diagnostic on the LAN controller
3802 * (called by wavelan_event() & wv_hw_reset())
3803 */
3804static int
3805wv_hw_config(struct net_device * dev)
3806{
3807 net_local * lp = netdev_priv(dev);
3808 kio_addr_t base = dev->base_addr;
3809 unsigned long flags;
3810 int ret = FALSE;
3811
3812#ifdef DEBUG_CONFIG_TRACE
3813 printk(KERN_DEBUG "%s: ->wv_hw_config()\n", dev->name);
3814#endif
3815
3816#ifdef STRUCT_CHECK
3817 if(wv_structuct_check() != (char *) NULL)
3818 {
3819 printk(KERN_WARNING "%s: wv_hw_config: structure/compiler botch: \"%s\"\n",
3820 dev->name, wv_structuct_check());
3821 return FALSE;
3822 }
3823#endif /* STRUCT_CHECK == 1 */
3824
3825 /* Reset the pcmcia interface */
3826 if(wv_pcmcia_reset(dev) == FALSE)
3827 return FALSE;
3828
3829 /* Disable interrupts */
3830 spin_lock_irqsave(&lp->spinlock, flags);
3831
3832 /* Disguised goto ;-) */
3833 do
3834 {
3835 /* Power UP the module + reset the modem + reset host adapter
3836 * (in fact, reset DMA channels) */
3837 hacr_write_slow(base, HACR_RESET);
3838 hacr_write(base, HACR_DEFAULT);
3839
3840 /* Check if the module has been powered up... */
3841 if(hasr_read(base) & HASR_NO_CLK)
3842 {
3843#ifdef DEBUG_CONFIG_ERRORS
3844 printk(KERN_WARNING "%s: wv_hw_config(): modem not connected or not a wavelan card\n",
3845 dev->name);
3846#endif
3847 break;
3848 }
3849
3850 /* initialize the modem */
3851 if(wv_mmc_init(dev) == FALSE)
3852 {
3853#ifdef DEBUG_CONFIG_ERRORS
3854 printk(KERN_WARNING "%s: wv_hw_config(): Can't configure the modem\n",
3855 dev->name);
3856#endif
3857 break;
3858 }
3859
3860 /* reset the LAN controller (i82593) */
3861 outb(OP0_RESET, LCCR(base));
3862 mdelay(1); /* A bit crude ! */
3863
3864 /* Initialize the LAN controller */
3865 if(wv_82593_config(dev) == FALSE)
3866 {
3867#ifdef DEBUG_CONFIG_ERRORS
3868 printk(KERN_INFO "%s: wv_hw_config(): i82593 init failed\n",
3869 dev->name);
3870#endif
3871 break;
3872 }
3873
3874 /* Diagnostic */
3875 if(wv_diag(dev) == FALSE)
3876 {
3877#ifdef DEBUG_CONFIG_ERRORS
3878 printk(KERN_INFO "%s: wv_hw_config(): i82593 diagnostic failed\n",
3879 dev->name);
3880#endif
3881 break;
3882 }
3883
3884 /*
3885 * insert code for loopback test here
3886 */
3887
3888 /* The device is now configured */
3889 lp->configured = 1;
3890 ret = TRUE;
3891 }
3892 while(0);
3893
3894 /* Re-enable interrupts */
3895 spin_unlock_irqrestore(&lp->spinlock, flags);
3896
3897#ifdef DEBUG_CONFIG_TRACE
3898 printk(KERN_DEBUG "%s: <-wv_hw_config()\n", dev->name);
3899#endif
3900 return(ret);
3901}
3902
3903/*------------------------------------------------------------------*/
3904/*
3905 * Totally reset the wavelan and restart it.
3906 * Performs the following actions:
3907 * 1. Call wv_hw_config()
3908 * 2. Start the LAN controller's receive unit
3909 * (called by wavelan_event(), wavelan_watchdog() and wavelan_open())
3910 */
3911static inline void
3912wv_hw_reset(struct net_device * dev)
3913{
3914 net_local * lp = netdev_priv(dev);
3915
3916#ifdef DEBUG_CONFIG_TRACE
3917 printk(KERN_DEBUG "%s: ->wv_hw_reset()\n", dev->name);
3918#endif
3919
3920 lp->nresets++;
3921 lp->configured = 0;
3922
3923 /* Call wv_hw_config() for most of the reset & init stuff */
3924 if(wv_hw_config(dev) == FALSE)
3925 return;
3926
3927 /* start receive unit */
3928 wv_ru_start(dev);
3929
3930#ifdef DEBUG_CONFIG_TRACE
3931 printk(KERN_DEBUG "%s: <-wv_hw_reset()\n", dev->name);
3932#endif
3933}
3934
3935/*------------------------------------------------------------------*/
3936/*
3937 * wv_pcmcia_config() is called after a CARD_INSERTION event is
3938 * received, to configure the PCMCIA socket, and to make the ethernet
3939 * device available to the system.
3940 * (called by wavelan_event())
3941 */
3942static inline int
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003943wv_pcmcia_config(struct pcmcia_device * link)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003944{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945 tuple_t tuple;
3946 cisparse_t parse;
3947 struct net_device * dev = (struct net_device *) link->priv;
3948 int i;
3949 u_char buf[64];
3950 win_req_t req;
3951 memreq_t mem;
3952 net_local * lp = netdev_priv(dev);
3953
3954
3955#ifdef DEBUG_CONFIG_TRACE
3956 printk(KERN_DEBUG "->wv_pcmcia_config(0x%p)\n", link);
3957#endif
3958
3959 /*
3960 * This reads the card's CONFIG tuple to find its configuration
3961 * registers.
3962 */
3963 do
3964 {
3965 tuple.Attributes = 0;
3966 tuple.DesiredTuple = CISTPL_CONFIG;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003967 i = pcmcia_get_first_tuple(link, &tuple);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003968 if(i != CS_SUCCESS)
3969 break;
3970 tuple.TupleData = (cisdata_t *)buf;
3971 tuple.TupleDataMax = 64;
3972 tuple.TupleOffset = 0;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003973 i = pcmcia_get_tuple_data(link, &tuple);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003974 if(i != CS_SUCCESS)
3975 break;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003976 i = pcmcia_parse_tuple(link, &tuple, &parse);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977 if(i != CS_SUCCESS)
3978 break;
3979 link->conf.ConfigBase = parse.config.base;
3980 link->conf.Present = parse.config.rmask[0];
3981 }
3982 while(0);
3983 if(i != CS_SUCCESS)
3984 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003985 cs_error(link, ParseTuple, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003986 return FALSE;
3987 }
Dominik Brodowskie2d40962006-03-02 00:09:29 +01003988
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989 do
3990 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003991 i = pcmcia_request_io(link, &link->io);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003992 if(i != CS_SUCCESS)
3993 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02003994 cs_error(link, RequestIO, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003995 break;
3996 }
3997
3998 /*
3999 * Now allocate an interrupt line. Note that this does not
4000 * actually assign a handler to the interrupt.
4001 */
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004002 i = pcmcia_request_irq(link, &link->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004003 if(i != CS_SUCCESS)
4004 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004005 cs_error(link, RequestIRQ, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004006 break;
4007 }
4008
4009 /*
4010 * This actually configures the PCMCIA socket -- setting up
4011 * the I/O windows and the interrupt mapping.
4012 */
4013 link->conf.ConfigIndex = 1;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004014 i = pcmcia_request_configuration(link, &link->conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004015 if(i != CS_SUCCESS)
4016 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004017 cs_error(link, RequestConfiguration, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004018 break;
4019 }
4020
4021 /*
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004022 * Allocate a small memory window. Note that the struct pcmcia_device
Linus Torvalds1da177e2005-04-16 15:20:36 -07004023 * structure provides space for one window handle -- if your
4024 * device needs several windows, you'll need to keep track of
4025 * the handles in your private data structure, link->priv.
4026 */
4027 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
4028 req.Base = req.Size = 0;
4029 req.AccessSpeed = mem_speed;
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004030 i = pcmcia_request_window(&link, &req, &link->win);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004031 if(i != CS_SUCCESS)
4032 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004033 cs_error(link, RequestWindow, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034 break;
4035 }
4036
4037 lp->mem = ioremap(req.Base, req.Size);
4038 dev->mem_start = (u_long)lp->mem;
4039 dev->mem_end = dev->mem_start + req.Size;
4040
4041 mem.CardOffset = 0; mem.Page = 0;
4042 i = pcmcia_map_mem_page(link->win, &mem);
4043 if(i != CS_SUCCESS)
4044 {
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004045 cs_error(link, MapMemPage, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046 break;
4047 }
4048
4049 /* Feed device with this info... */
4050 dev->irq = link->irq.AssignedIRQ;
4051 dev->base_addr = link->io.BasePort1;
4052 netif_start_queue(dev);
4053
4054#ifdef DEBUG_CONFIG_INFO
4055 printk(KERN_DEBUG "wv_pcmcia_config: MEMSTART %p IRQ %d IOPORT 0x%x\n",
4056 lp->mem, dev->irq, (u_int) dev->base_addr);
4057#endif
4058
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004059 SET_NETDEV_DEV(dev, &handle_to_dev(link));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004060 i = register_netdev(dev);
4061 if(i != 0)
4062 {
4063#ifdef DEBUG_CONFIG_ERRORS
4064 printk(KERN_INFO "wv_pcmcia_config(): register_netdev() failed\n");
4065#endif
4066 break;
4067 }
4068 }
4069 while(0); /* Humm... Disguised goto !!! */
4070
Linus Torvalds1da177e2005-04-16 15:20:36 -07004071 /* If any step failed, release any partially configured state */
4072 if(i != 0)
4073 {
4074 wv_pcmcia_release(link);
4075 return FALSE;
4076 }
4077
4078 strcpy(((net_local *) netdev_priv(dev))->node.dev_name, dev->name);
Dominik Brodowskifd238232006-03-05 10:45:09 +01004079 link->dev_node = &((net_local *) netdev_priv(dev))->node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004080
4081#ifdef DEBUG_CONFIG_TRACE
4082 printk(KERN_DEBUG "<-wv_pcmcia_config()\n");
4083#endif
4084 return TRUE;
4085}
4086
4087/*------------------------------------------------------------------*/
4088/*
4089 * After a card is removed, wv_pcmcia_release() will unregister the net
4090 * device, and release the PCMCIA configuration. If the device is
4091 * still open, this will be postponed until it is closed.
4092 */
4093static void
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004094wv_pcmcia_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004095{
Dominik Brodowski5f2a71f2006-01-15 09:32:39 +01004096 struct net_device * dev = (struct net_device *) link->priv;
4097 net_local * lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098
4099#ifdef DEBUG_CONFIG_TRACE
Dominik Brodowski5f2a71f2006-01-15 09:32:39 +01004100 printk(KERN_DEBUG "%s: -> wv_pcmcia_release(0x%p)\n", dev->name, link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004101#endif
4102
Dominik Brodowski5f2a71f2006-01-15 09:32:39 +01004103 iounmap(lp->mem);
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004104 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004105
4106#ifdef DEBUG_CONFIG_TRACE
Dominik Brodowski5f2a71f2006-01-15 09:32:39 +01004107 printk(KERN_DEBUG "%s: <- wv_pcmcia_release()\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004108#endif
4109}
4110
4111/************************ INTERRUPT HANDLING ************************/
4112
4113/*
4114 * This function is the interrupt handler for the WaveLAN card. This
4115 * routine will be called whenever:
4116 * 1. A packet is received.
4117 * 2. A packet has successfully been transferred and the unit is
4118 * ready to transmit another packet.
4119 * 3. A command has completed execution.
4120 */
4121static irqreturn_t
4122wavelan_interrupt(int irq,
4123 void * dev_id,
4124 struct pt_regs * regs)
4125{
4126 struct net_device * dev;
4127 net_local * lp;
4128 kio_addr_t base;
4129 int status0;
4130 u_int tx_status;
4131
4132 if ((dev = dev_id) == NULL)
4133 {
4134#ifdef DEBUG_INTERRUPT_ERROR
4135 printk(KERN_WARNING "wavelan_interrupt(): irq %d for unknown device.\n",
4136 irq);
4137#endif
4138 return IRQ_NONE;
4139 }
4140
4141#ifdef DEBUG_INTERRUPT_TRACE
4142 printk(KERN_DEBUG "%s: ->wavelan_interrupt()\n", dev->name);
4143#endif
4144
4145 lp = netdev_priv(dev);
4146 base = dev->base_addr;
4147
4148#ifdef DEBUG_INTERRUPT_INFO
4149 /* Check state of our spinlock (it should be cleared) */
4150 if(spin_is_locked(&lp->spinlock))
4151 printk(KERN_DEBUG
4152 "%s: wavelan_interrupt(): spinlock is already locked !!!\n",
4153 dev->name);
4154#endif
4155
4156 /* Prevent reentrancy. We need to do that because we may have
4157 * multiple interrupt handler running concurently.
4158 * It is safe because interrupts are disabled before aquiring
4159 * the spinlock. */
4160 spin_lock(&lp->spinlock);
4161
4162 /* Treat all pending interrupts */
4163 while(1)
4164 {
4165 /* ---------------- INTERRUPT CHECKING ---------------- */
4166 /*
4167 * Look for the interrupt and verify the validity
4168 */
4169 outb(CR0_STATUS_0 | OP0_NOP, LCCR(base));
4170 status0 = inb(LCSR(base));
4171
4172#ifdef DEBUG_INTERRUPT_INFO
4173 printk(KERN_DEBUG "status0 0x%x [%s => 0x%x]", status0,
4174 (status0&SR0_INTERRUPT)?"int":"no int",status0&~SR0_INTERRUPT);
4175 if(status0&SR0_INTERRUPT)
4176 {
4177 printk(" [%s => %d]\n", (status0 & SR0_CHNL) ? "chnl" :
4178 ((status0 & SR0_EXECUTION) ? "cmd" :
4179 ((status0 & SR0_RECEPTION) ? "recv" : "unknown")),
4180 (status0 & SR0_EVENT_MASK));
4181 }
4182 else
4183 printk("\n");
4184#endif
4185
4186 /* Return if no actual interrupt from i82593 (normal exit) */
4187 if(!(status0 & SR0_INTERRUPT))
4188 break;
4189
4190 /* If interrupt is both Rx and Tx or none...
4191 * This code in fact is there to catch the spurious interrupt
4192 * when you remove the wavelan pcmcia card from the socket */
4193 if(((status0 & SR0_BOTH_RX_TX) == SR0_BOTH_RX_TX) ||
4194 ((status0 & SR0_BOTH_RX_TX) == 0x0))
4195 {
4196#ifdef DEBUG_INTERRUPT_INFO
4197 printk(KERN_INFO "%s: wv_interrupt(): bogus interrupt (or from dead card) : %X\n",
4198 dev->name, status0);
4199#endif
4200 /* Acknowledge the interrupt */
4201 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
4202 break;
4203 }
4204
4205 /* ----------------- RECEIVING PACKET ----------------- */
4206 /*
4207 * When the wavelan signal the reception of a new packet,
4208 * we call wv_packet_rcv() to copy if from the buffer and
4209 * send it to NET3
4210 */
4211 if(status0 & SR0_RECEPTION)
4212 {
4213#ifdef DEBUG_INTERRUPT_INFO
4214 printk(KERN_DEBUG "%s: wv_interrupt(): receive\n", dev->name);
4215#endif
4216
4217 if((status0 & SR0_EVENT_MASK) == SR0_STOP_REG_HIT)
4218 {
4219#ifdef DEBUG_INTERRUPT_ERROR
4220 printk(KERN_INFO "%s: wv_interrupt(): receive buffer overflow\n",
4221 dev->name);
4222#endif
4223 lp->stats.rx_over_errors++;
4224 lp->overrunning = 1;
4225 }
4226
4227 /* Get the packet */
4228 wv_packet_rcv(dev);
4229 lp->overrunning = 0;
4230
4231 /* Acknowledge the interrupt */
4232 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
4233 continue;
4234 }
4235
4236 /* ---------------- COMMAND COMPLETION ---------------- */
4237 /*
4238 * Interrupts issued when the i82593 has completed a command.
4239 * Most likely : transmission done
4240 */
4241
4242 /* If a transmission has been done */
4243 if((status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
4244 (status0 & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
4245 (status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE)
4246 {
4247#ifdef DEBUG_TX_ERROR
4248 if((status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE)
4249 printk(KERN_INFO "%s: wv_interrupt(): packet transmitted without CRC.\n",
4250 dev->name);
4251#endif
4252
4253 /* Get transmission status */
4254 tx_status = inb(LCSR(base));
4255 tx_status |= (inb(LCSR(base)) << 8);
4256#ifdef DEBUG_INTERRUPT_INFO
4257 printk(KERN_DEBUG "%s: wv_interrupt(): transmission done\n",
4258 dev->name);
4259 {
4260 u_int rcv_bytes;
4261 u_char status3;
4262 rcv_bytes = inb(LCSR(base));
4263 rcv_bytes |= (inb(LCSR(base)) << 8);
4264 status3 = inb(LCSR(base));
4265 printk(KERN_DEBUG "tx_status 0x%02x rcv_bytes 0x%02x status3 0x%x\n",
4266 tx_status, rcv_bytes, (u_int) status3);
4267 }
4268#endif
4269 /* Check for possible errors */
4270 if((tx_status & TX_OK) != TX_OK)
4271 {
4272 lp->stats.tx_errors++;
4273
4274 if(tx_status & TX_FRTL)
4275 {
4276#ifdef DEBUG_TX_ERROR
4277 printk(KERN_INFO "%s: wv_interrupt(): frame too long\n",
4278 dev->name);
4279#endif
4280 }
4281 if(tx_status & TX_UND_RUN)
4282 {
4283#ifdef DEBUG_TX_FAIL
4284 printk(KERN_DEBUG "%s: wv_interrupt(): DMA underrun\n",
4285 dev->name);
4286#endif
4287 lp->stats.tx_aborted_errors++;
4288 }
4289 if(tx_status & TX_LOST_CTS)
4290 {
4291#ifdef DEBUG_TX_FAIL
4292 printk(KERN_DEBUG "%s: wv_interrupt(): no CTS\n", dev->name);
4293#endif
4294 lp->stats.tx_carrier_errors++;
4295 }
4296 if(tx_status & TX_LOST_CRS)
4297 {
4298#ifdef DEBUG_TX_FAIL
4299 printk(KERN_DEBUG "%s: wv_interrupt(): no carrier\n",
4300 dev->name);
4301#endif
4302 lp->stats.tx_carrier_errors++;
4303 }
4304 if(tx_status & TX_HRT_BEAT)
4305 {
4306#ifdef DEBUG_TX_FAIL
4307 printk(KERN_DEBUG "%s: wv_interrupt(): heart beat\n", dev->name);
4308#endif
4309 lp->stats.tx_heartbeat_errors++;
4310 }
4311 if(tx_status & TX_DEFER)
4312 {
4313#ifdef DEBUG_TX_FAIL
4314 printk(KERN_DEBUG "%s: wv_interrupt(): channel jammed\n",
4315 dev->name);
4316#endif
4317 }
4318 /* Ignore late collisions since they're more likely to happen
4319 * here (the WaveLAN design prevents the LAN controller from
4320 * receiving while it is transmitting). We take action only when
4321 * the maximum retransmit attempts is exceeded.
4322 */
4323 if(tx_status & TX_COLL)
4324 {
4325 if(tx_status & TX_MAX_COL)
4326 {
4327#ifdef DEBUG_TX_FAIL
4328 printk(KERN_DEBUG "%s: wv_interrupt(): channel congestion\n",
4329 dev->name);
4330#endif
4331 if(!(tx_status & TX_NCOL_MASK))
4332 {
4333 lp->stats.collisions += 0x10;
4334 }
4335 }
4336 }
4337 } /* if(!(tx_status & TX_OK)) */
4338
4339 lp->stats.collisions += (tx_status & TX_NCOL_MASK);
4340 lp->stats.tx_packets++;
4341
4342 netif_wake_queue(dev);
4343 outb(CR0_INT_ACK | OP0_NOP, LCCR(base)); /* Acknowledge the interrupt */
4344 }
4345 else /* if interrupt = transmit done or retransmit done */
4346 {
4347#ifdef DEBUG_INTERRUPT_ERROR
4348 printk(KERN_INFO "wavelan_cs: unknown interrupt, status0 = %02x\n",
4349 status0);
4350#endif
4351 outb(CR0_INT_ACK | OP0_NOP, LCCR(base)); /* Acknowledge the interrupt */
4352 }
4353 } /* while(1) */
4354
4355 spin_unlock(&lp->spinlock);
4356
4357#ifdef DEBUG_INTERRUPT_TRACE
4358 printk(KERN_DEBUG "%s: <-wavelan_interrupt()\n", dev->name);
4359#endif
4360
4361 /* We always return IRQ_HANDLED, because we will receive empty
4362 * interrupts under normal operations. Anyway, it doesn't matter
4363 * as we are dealing with an ISA interrupt that can't be shared.
4364 *
4365 * Explanation : under heavy receive, the following happens :
4366 * ->wavelan_interrupt()
4367 * (status0 & SR0_INTERRUPT) != 0
4368 * ->wv_packet_rcv()
4369 * (status0 & SR0_INTERRUPT) != 0
4370 * ->wv_packet_rcv()
4371 * (status0 & SR0_INTERRUPT) == 0 // i.e. no more event
4372 * <-wavelan_interrupt()
4373 * ->wavelan_interrupt()
4374 * (status0 & SR0_INTERRUPT) == 0 // i.e. empty interrupt
4375 * <-wavelan_interrupt()
4376 * Jean II */
4377 return IRQ_HANDLED;
4378} /* wv_interrupt */
4379
4380/*------------------------------------------------------------------*/
4381/*
4382 * Watchdog: when we start a transmission, a timer is set for us in the
4383 * kernel. If the transmission completes, this timer is disabled. If
4384 * the timer expires, we are called and we try to unlock the hardware.
4385 *
4386 * Note : This watchdog is move clever than the one in the ISA driver,
4387 * because it try to abort the current command before reseting
4388 * everything...
4389 * On the other hand, it's a bit simpler, because we don't have to
4390 * deal with the multiple Tx buffers...
4391 */
4392static void
4393wavelan_watchdog(struct net_device * dev)
4394{
4395 net_local * lp = netdev_priv(dev);
4396 kio_addr_t base = dev->base_addr;
4397 unsigned long flags;
4398 int aborted = FALSE;
4399
4400#ifdef DEBUG_INTERRUPT_TRACE
4401 printk(KERN_DEBUG "%s: ->wavelan_watchdog()\n", dev->name);
4402#endif
4403
4404#ifdef DEBUG_INTERRUPT_ERROR
4405 printk(KERN_INFO "%s: wavelan_watchdog: watchdog timer expired\n",
4406 dev->name);
4407#endif
4408
4409 spin_lock_irqsave(&lp->spinlock, flags);
4410
4411 /* Ask to abort the current command */
4412 outb(OP0_ABORT, LCCR(base));
4413
4414 /* Wait for the end of the command (a bit hackish) */
4415 if(wv_82593_cmd(dev, "wavelan_watchdog(): abort",
4416 OP0_NOP | CR0_STATUS_3, SR0_EXECUTION_ABORTED))
4417 aborted = TRUE;
4418
4419 /* Release spinlock here so that wv_hw_reset() can grab it */
4420 spin_unlock_irqrestore(&lp->spinlock, flags);
4421
4422 /* Check if we were successful in aborting it */
4423 if(!aborted)
4424 {
4425 /* It seem that it wasn't enough */
4426#ifdef DEBUG_INTERRUPT_ERROR
4427 printk(KERN_INFO "%s: wavelan_watchdog: abort failed, trying reset\n",
4428 dev->name);
4429#endif
4430 wv_hw_reset(dev);
4431 }
4432
4433#ifdef DEBUG_PSA_SHOW
4434 {
4435 psa_t psa;
4436 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
4437 wv_psa_show(&psa);
4438 }
4439#endif
4440#ifdef DEBUG_MMC_SHOW
4441 wv_mmc_show(dev);
4442#endif
4443#ifdef DEBUG_I82593_SHOW
4444 wv_ru_show(dev);
4445#endif
4446
4447 /* We are no more waiting for something... */
4448 netif_wake_queue(dev);
4449
4450#ifdef DEBUG_INTERRUPT_TRACE
4451 printk(KERN_DEBUG "%s: <-wavelan_watchdog()\n", dev->name);
4452#endif
4453}
4454
4455/********************* CONFIGURATION CALLBACKS *********************/
4456/*
4457 * Here are the functions called by the pcmcia package (cardmgr) and
4458 * linux networking (NET3) for initialization, configuration and
4459 * deinstallations of the Wavelan Pcmcia Hardware.
4460 */
4461
4462/*------------------------------------------------------------------*/
4463/*
4464 * Configure and start up the WaveLAN PCMCIA adaptor.
4465 * Called by NET3 when it "open" the device.
4466 */
4467static int
4468wavelan_open(struct net_device * dev)
4469{
4470 net_local * lp = netdev_priv(dev);
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004471 struct pcmcia_device * link = lp->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004472 kio_addr_t base = dev->base_addr;
4473
4474#ifdef DEBUG_CALLBACK_TRACE
4475 printk(KERN_DEBUG "%s: ->wavelan_open(dev=0x%x)\n", dev->name,
4476 (unsigned int) dev);
4477#endif
4478
4479 /* Check if the modem is powered up (wavelan_close() power it down */
4480 if(hasr_read(base) & HASR_NO_CLK)
4481 {
4482 /* Power up (power up time is 250us) */
4483 hacr_write(base, HACR_DEFAULT);
4484
4485 /* Check if the module has been powered up... */
4486 if(hasr_read(base) & HASR_NO_CLK)
4487 {
4488#ifdef DEBUG_CONFIG_ERRORS
4489 printk(KERN_WARNING "%s: wavelan_open(): modem not connected\n",
4490 dev->name);
4491#endif
4492 return FALSE;
4493 }
4494 }
4495
4496 /* Start reception and declare the driver ready */
4497 if(!lp->configured)
4498 return FALSE;
4499 if(!wv_ru_start(dev))
4500 wv_hw_reset(dev); /* If problem : reset */
4501 netif_start_queue(dev);
4502
4503 /* Mark the device as used */
4504 link->open++;
4505
4506#ifdef WAVELAN_ROAMING
4507 if(do_roaming)
4508 wv_roam_init(dev);
4509#endif /* WAVELAN_ROAMING */
4510
4511#ifdef DEBUG_CALLBACK_TRACE
4512 printk(KERN_DEBUG "%s: <-wavelan_open()\n", dev->name);
4513#endif
4514 return 0;
4515}
4516
4517/*------------------------------------------------------------------*/
4518/*
4519 * Shutdown the WaveLAN PCMCIA adaptor.
4520 * Called by NET3 when it "close" the device.
4521 */
4522static int
4523wavelan_close(struct net_device * dev)
4524{
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004525 struct pcmcia_device * link = ((net_local *)netdev_priv(dev))->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004526 kio_addr_t base = dev->base_addr;
4527
4528#ifdef DEBUG_CALLBACK_TRACE
4529 printk(KERN_DEBUG "%s: ->wavelan_close(dev=0x%x)\n", dev->name,
4530 (unsigned int) dev);
4531#endif
4532
4533 /* If the device isn't open, then nothing to do */
4534 if(!link->open)
4535 {
4536#ifdef DEBUG_CONFIG_INFO
4537 printk(KERN_DEBUG "%s: wavelan_close(): device not open\n", dev->name);
4538#endif
4539 return 0;
4540 }
4541
4542#ifdef WAVELAN_ROAMING
4543 /* Cleanup of roaming stuff... */
4544 if(do_roaming)
4545 wv_roam_cleanup(dev);
4546#endif /* WAVELAN_ROAMING */
4547
4548 link->open--;
4549
4550 /* If the card is still present */
4551 if(netif_running(dev))
4552 {
4553 netif_stop_queue(dev);
4554
4555 /* Stop receiving new messages and wait end of transmission */
4556 wv_ru_stop(dev);
4557
4558 /* Power down the module */
4559 hacr_write(base, HACR_DEFAULT & (~HACR_PWR_STAT));
4560 }
4561
4562#ifdef DEBUG_CALLBACK_TRACE
4563 printk(KERN_DEBUG "%s: <-wavelan_close()\n", dev->name);
4564#endif
4565 return 0;
4566}
4567
4568/*------------------------------------------------------------------*/
4569/*
4570 * wavelan_attach() creates an "instance" of the driver, allocating
4571 * local data structures for one device (one interface). The device
4572 * is registered with Card Services.
4573 *
4574 * The dev_link structure is initialized, but we don't actually
4575 * configure the card at this point -- we wait until we receive a
4576 * card insertion event.
4577 */
Dominik Brodowskif8cfa612005-11-14 21:25:51 +01004578static int
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02004579wavelan_probe(struct pcmcia_device *p_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004580{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004581 struct net_device * dev; /* Interface generic data */
4582 net_local * lp; /* Interface specific data */
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02004583 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004584
4585#ifdef DEBUG_CALLBACK_TRACE
4586 printk(KERN_DEBUG "-> wavelan_attach()\n");
4587#endif
4588
Linus Torvalds1da177e2005-04-16 15:20:36 -07004589 /* The io structure describes IO port mapping */
Dominik Brodowskifd238232006-03-05 10:45:09 +01004590 p_dev->io.NumPorts1 = 8;
4591 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
4592 p_dev->io.IOAddrLines = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593
4594 /* Interrupt setup */
Dominik Brodowskifd238232006-03-05 10:45:09 +01004595 p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
4596 p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
4597 p_dev->irq.Handler = wavelan_interrupt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004598
4599 /* General socket configuration */
Dominik Brodowskifd238232006-03-05 10:45:09 +01004600 p_dev->conf.Attributes = CONF_ENABLE_IRQ;
4601 p_dev->conf.IntType = INT_MEMORY_AND_IO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004602
4603 /* Allocate the generic data structure */
4604 dev = alloc_etherdev(sizeof(net_local));
Dominik Brodowskifd238232006-03-05 10:45:09 +01004605 if (!dev)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +01004606 return -ENOMEM;
Dominik Brodowskifd238232006-03-05 10:45:09 +01004607
4608 p_dev->priv = p_dev->irq.Instance = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004609
4610 lp = netdev_priv(dev);
4611
4612 /* Init specific data */
4613 lp->configured = 0;
4614 lp->reconfig_82593 = FALSE;
4615 lp->nresets = 0;
4616 /* Multicast stuff */
4617 lp->promiscuous = 0;
4618 lp->allmulticast = 0;
4619 lp->mc_count = 0;
4620
4621 /* Init spinlock */
4622 spin_lock_init(&lp->spinlock);
4623
4624 /* back links */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004625 lp->dev = dev;
4626
4627 /* wavelan NET3 callbacks */
4628 SET_MODULE_OWNER(dev);
4629 dev->open = &wavelan_open;
4630 dev->stop = &wavelan_close;
4631 dev->hard_start_xmit = &wavelan_packet_xmit;
4632 dev->get_stats = &wavelan_get_stats;
4633 dev->set_multicast_list = &wavelan_set_multicast_list;
4634#ifdef SET_MAC_ADDRESS
4635 dev->set_mac_address = &wavelan_set_mac_address;
4636#endif /* SET_MAC_ADDRESS */
4637
4638 /* Set the watchdog timer */
4639 dev->tx_timeout = &wavelan_watchdog;
4640 dev->watchdog_timeo = WATCHDOG_JIFFIES;
4641 SET_ETHTOOL_OPS(dev, &ops);
4642
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 dev->wireless_handlers = &wavelan_handler_def;
4644 lp->wireless_data.spy_data = &lp->spy_data;
4645 dev->wireless_data = &lp->wireless_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004646
4647 /* Other specific data */
4648 dev->mtu = WAVELAN_MTU;
4649
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02004650 ret = wv_pcmcia_config(p_dev);
4651 if (ret)
4652 return ret;
4653
4654 ret = wv_hw_config(dev);
4655 if (ret) {
Dominik Brodowskif8cfa612005-11-14 21:25:51 +01004656 dev->irq = 0;
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02004657 pcmcia_disable_device(p_dev);
4658 return ret;
4659 }
4660
4661 wv_init_info(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004662
4663#ifdef DEBUG_CALLBACK_TRACE
4664 printk(KERN_DEBUG "<- wavelan_attach()\n");
4665#endif
4666
Dominik Brodowskif8cfa612005-11-14 21:25:51 +01004667 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004668}
4669
4670/*------------------------------------------------------------------*/
4671/*
4672 * This deletes a driver "instance". The device is de-registered with
4673 * Card Services. If it has been released, all local data structures
4674 * are freed. Otherwise, the structures will be freed when the device
4675 * is released.
4676 */
4677static void
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004678wavelan_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004679{
4680#ifdef DEBUG_CALLBACK_TRACE
4681 printk(KERN_DEBUG "-> wavelan_detach(0x%p)\n", link);
4682#endif
4683
Dominik Brodowskie2d40962006-03-02 00:09:29 +01004684 /* Some others haven't done their job : give them another chance */
4685 wv_pcmcia_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004686
Linus Torvalds1da177e2005-04-16 15:20:36 -07004687 /* Free pieces */
4688 if(link->priv)
4689 {
4690 struct net_device * dev = (struct net_device *) link->priv;
4691
4692 /* Remove ourselves from the kernel list of ethernet devices */
4693 /* Warning : can't be called from interrupt, timer or wavelan_close() */
Dominik Brodowskifd238232006-03-05 10:45:09 +01004694 if (link->dev_node)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004695 unregister_netdev(dev);
Dominik Brodowskifd238232006-03-05 10:45:09 +01004696 link->dev_node = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004697 ((net_local *)netdev_priv(dev))->link = NULL;
4698 ((net_local *)netdev_priv(dev))->dev = NULL;
4699 free_netdev(dev);
4700 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004701
4702#ifdef DEBUG_CALLBACK_TRACE
4703 printk(KERN_DEBUG "<- wavelan_detach()\n");
4704#endif
4705}
4706
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004707static int wavelan_suspend(struct pcmcia_device *link)
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004708{
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004709 struct net_device * dev = (struct net_device *) link->priv;
4710
4711 /* NB: wavelan_close will be called, but too late, so we are
4712 * obliged to close nicely the wavelan here. David, could you
4713 * close the device before suspending them ? And, by the way,
4714 * could you, on resume, add a "route add -net ..." after the
4715 * ifconfig up ? Thanks... */
4716
4717 /* Stop receiving new messages and wait end of transmission */
4718 wv_ru_stop(dev);
4719
Dominik Brodowskie2d40962006-03-02 00:09:29 +01004720 if (link->open)
Dominik Brodowski8661bb52006-03-02 00:02:33 +01004721 netif_device_detach(dev);
4722
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004723 /* Power down the module */
4724 hacr_write(dev->base_addr, HACR_DEFAULT & (~HACR_PWR_STAT));
4725
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004726 return 0;
4727}
4728
Dominik Brodowskifba395e2006-03-31 17:21:06 +02004729static int wavelan_resume(struct pcmcia_device *link)
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004730{
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004731 struct net_device * dev = (struct net_device *) link->priv;
4732
Dominik Brodowskie2d40962006-03-02 00:09:29 +01004733 if (link->open) {
Dominik Brodowski8661bb52006-03-02 00:02:33 +01004734 wv_hw_reset(dev);
4735 netif_device_attach(dev);
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004736 }
4737
4738 return 0;
4739}
4740
4741
Dominik Brodowskib9421232005-06-27 16:28:25 -07004742static struct pcmcia_device_id wavelan_ids[] = {
4743 PCMCIA_DEVICE_PROD_ID12("AT&T","WaveLAN/PCMCIA", 0xe7c5affd, 0x1bc50975),
4744 PCMCIA_DEVICE_PROD_ID12("Digital", "RoamAbout/DS", 0x9999ab35, 0x00d05e06),
4745 PCMCIA_DEVICE_PROD_ID12("Lucent Technologies", "WaveLAN/PCMCIA", 0x23eb9949, 0x1bc50975),
4746 PCMCIA_DEVICE_PROD_ID12("NCR", "WaveLAN/PCMCIA", 0x24358cd4, 0x1bc50975),
4747 PCMCIA_DEVICE_NULL,
4748};
4749MODULE_DEVICE_TABLE(pcmcia, wavelan_ids);
4750
Linus Torvalds1da177e2005-04-16 15:20:36 -07004751static struct pcmcia_driver wavelan_driver = {
4752 .owner = THIS_MODULE,
4753 .drv = {
4754 .name = "wavelan_cs",
4755 },
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02004756 .probe = wavelan_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +01004757 .remove = wavelan_detach,
Dominik Brodowskib9421232005-06-27 16:28:25 -07004758 .id_table = wavelan_ids,
Dominik Brodowski98e4c282005-11-14 21:21:18 +01004759 .suspend = wavelan_suspend,
4760 .resume = wavelan_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004761};
4762
4763static int __init
4764init_wavelan_cs(void)
4765{
4766 return pcmcia_register_driver(&wavelan_driver);
4767}
4768
4769static void __exit
4770exit_wavelan_cs(void)
4771{
4772 pcmcia_unregister_driver(&wavelan_driver);
4773}
4774
4775module_init(init_wavelan_cs);
4776module_exit(exit_wavelan_cs);