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