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