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