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