?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Avoid console spam with ext3 aborted journal.
[linux-2.6/verdex.git] / drivers / net / wireless / wavelan.c
blob7a5e20a17890c81316c8bac8dcefd0963c29288e
1 /*
2 * WaveLAN ISA driver
3 *
4 * Jean II - HPLB '96
5 *
6 * Reorganisation and extension of the driver.
7 * Original copyright follows (also see the end of this file).
8 * See wavelan.p.h for details.
9 *
10 *
11 *
12 * AT&T GIS (nee NCR) WaveLAN card:
13 * An Ethernet-like radio transceiver
14 * controlled by an Intel 82586 coprocessor.
15 */
16
17 #include "wavelan.p.h" /* Private header */
18
19 /************************* MISC SUBROUTINES **************************/
20 /*
21 * Subroutines which won't fit in one of the following category
22 * (WaveLAN modem or i82586)
23 */
24
25 /*------------------------------------------------------------------*/
26 /*
27 * Translate irq number to PSA irq parameter
28 */
29 static u8 wv_irq_to_psa(int irq)
30 {
31 if (irq < 0 || irq >= NELS(irqvals))
32 return 0;
33
34 return irqvals[irq];
35 }
36
37 /*------------------------------------------------------------------*/
38 /*
39 * Translate PSA irq parameter to irq number
40 */
41 static int __init wv_psa_to_irq(u8 irqval)
42 {
43 int irq;
44
45 for (irq = 0; irq < NELS(irqvals); irq++)
46 if (irqvals[irq] == irqval)
47 return irq;
48
49 return -1;
50 }
51
52 #ifdef STRUCT_CHECK
53 /*------------------------------------------------------------------*/
54 /*
55 * Sanity routine to verify the sizes of the various WaveLAN interface
56 * structures.
57 */
58 static char *wv_struct_check(void)
59 {
60 #define SC(t,s,n) if (sizeof(t) != s) return(n);
61
62 SC(psa_t, PSA_SIZE, "psa_t");
63 SC(mmw_t, MMW_SIZE, "mmw_t");
64 SC(mmr_t, MMR_SIZE, "mmr_t");
65 SC(ha_t, HA_SIZE, "ha_t");
66
67 #undef SC
68
69 return ((char *) NULL);
70 } /* wv_struct_check */
71 #endif /* STRUCT_CHECK */
72
73 /********************* HOST ADAPTER SUBROUTINES *********************/
74 /*
75 * Useful subroutines to manage the WaveLAN ISA interface
76 *
77 * One major difference with the PCMCIA hardware (except the port mapping)
78 * is that we have to keep the state of the Host Control Register
79 * because of the interrupt enable & bus size flags.
80 */
81
82 /*------------------------------------------------------------------*/
83 /*
84 * Read from card's Host Adaptor Status Register.
85 */
86 static inline u16 hasr_read(unsigned long ioaddr)
87 {
88 return (inw(HASR(ioaddr)));
89 } /* hasr_read */
90
91 /*------------------------------------------------------------------*/
92 /*
93 * Write to card's Host Adapter Command Register.
94 */
95 static inline void hacr_write(unsigned long ioaddr, u16 hacr)
96 {
97 outw(hacr, HACR(ioaddr));
98 } /* hacr_write */
99
100 /*------------------------------------------------------------------*/
101 /*
102 * Write to card's Host Adapter Command Register. Include a delay for
103 * those times when it is needed.
104 */
105 static inline void hacr_write_slow(unsigned long ioaddr, u16 hacr)
106 {
107 hacr_write(ioaddr, hacr);
108 /* delay might only be needed sometimes */
109 mdelay(1);
110 } /* hacr_write_slow */
111
112 /*------------------------------------------------------------------*/
113 /*
114 * Set the channel attention bit.
115 */
116 static inline void set_chan_attn(unsigned long ioaddr, u16 hacr)
117 {
118 hacr_write(ioaddr, hacr | HACR_CA);
119 } /* set_chan_attn */
120
121 /*------------------------------------------------------------------*/
122 /*
123 * Reset, and then set host adaptor into default mode.
124 */
125 static inline void wv_hacr_reset(unsigned long ioaddr)
126 {
127 hacr_write_slow(ioaddr, HACR_RESET);
128 hacr_write(ioaddr, HACR_DEFAULT);
129 } /* wv_hacr_reset */
130
131 /*------------------------------------------------------------------*/
132 /*
133 * Set the I/O transfer over the ISA bus to 8-bit mode
134 */
135 static inline void wv_16_off(unsigned long ioaddr, u16 hacr)
136 {
137 hacr &= ~HACR_16BITS;
138 hacr_write(ioaddr, hacr);
139 } /* wv_16_off */
140
141 /*------------------------------------------------------------------*/
142 /*
143 * Set the I/O transfer over the ISA bus to 8-bit mode
144 */
145 static inline void wv_16_on(unsigned long ioaddr, u16 hacr)
146 {
147 hacr |= HACR_16BITS;
148 hacr_write(ioaddr, hacr);
149 } /* wv_16_on */
150
151 /*------------------------------------------------------------------*/
152 /*
153 * Disable interrupts on the WaveLAN hardware.
154 * (called by wv_82586_stop())
155 */
156 static inline void wv_ints_off(struct net_device * dev)
157 {
158 net_local *lp = (net_local *) dev->priv;
159 unsigned long ioaddr = dev->base_addr;
160
161 lp->hacr &= ~HACR_INTRON;
162 hacr_write(ioaddr, lp->hacr);
163 } /* wv_ints_off */
164
165 /*------------------------------------------------------------------*/
166 /*
167 * Enable interrupts on the WaveLAN hardware.
168 * (called by wv_hw_reset())
169 */
170 static inline void wv_ints_on(struct net_device * dev)
171 {
172 net_local *lp = (net_local *) dev->priv;
173 unsigned long ioaddr = dev->base_addr;
174
175 lp->hacr |= HACR_INTRON;
176 hacr_write(ioaddr, lp->hacr);
177 } /* wv_ints_on */
178
179 /******************* MODEM MANAGEMENT SUBROUTINES *******************/
180 /*
181 * Useful subroutines to manage the modem of the WaveLAN
182 */
183
184 /*------------------------------------------------------------------*/
185 /*
186 * Read the Parameter Storage Area from the WaveLAN card's memory
187 */
188 /*
189 * Read bytes from the PSA.
190 */
191 static void psa_read(unsigned long ioaddr, u16 hacr, int o, /* offset in PSA */
192 u8 * b, /* buffer to fill */
193 int n)
194 { /* size to read */
195 wv_16_off(ioaddr, hacr);
196
197 while (n-- > 0) {
198 outw(o, PIOR2(ioaddr));
199 o++;
200 *b++ = inb(PIOP2(ioaddr));
201 }
202
203 wv_16_on(ioaddr, hacr);
204 } /* psa_read */
205
206 /*------------------------------------------------------------------*/
207 /*
208 * Write the Parameter Storage Area to the WaveLAN card's memory.
209 */
210 static void psa_write(unsigned long ioaddr, u16 hacr, int o, /* Offset in PSA */
211 u8 * b, /* Buffer in memory */
212 int n)
213 { /* Length of buffer */
214 int count = 0;
215
216 wv_16_off(ioaddr, hacr);
217
218 while (n-- > 0) {
219 outw(o, PIOR2(ioaddr));
220 o++;
221
222 outb(*b, PIOP2(ioaddr));
223 b++;
224
225 /* Wait for the memory to finish its write cycle */
226 count = 0;
227 while ((count++ < 100) &&
228 (hasr_read(ioaddr) & HASR_PSA_BUSY)) mdelay(1);
229 }
230
231 wv_16_on(ioaddr, hacr);
232 } /* psa_write */
233
234 #ifdef SET_PSA_CRC
235 /*------------------------------------------------------------------*/
236 /*
237 * Calculate the PSA CRC
238 * Thanks to Valster, Nico <NVALSTER@wcnd.nl.lucent.com> for the code
239 * NOTE: By specifying a length including the CRC position the
240 * returned value should be zero. (i.e. a correct checksum in the PSA)
241 *
242 * The Windows drivers don't use the CRC, but the AP and the PtP tool
243 * depend on it.
244 */
245 static inline u16 psa_crc(u8 * psa, /* The PSA */
246 int size)
247 { /* Number of short for CRC */
248 int byte_cnt; /* Loop on the PSA */
249 u16 crc_bytes = 0; /* Data in the PSA */
250 int bit_cnt; /* Loop on the bits of the short */
251
252 for (byte_cnt = 0; byte_cnt < size; byte_cnt++) {
253 crc_bytes ^= psa[byte_cnt]; /* Its an xor */
254
255 for (bit_cnt = 1; bit_cnt < 9; bit_cnt++) {
256 if (crc_bytes & 0x0001)
257 crc_bytes = (crc_bytes >> 1) ^ 0xA001;
258 else
259 crc_bytes >>= 1;
260 }
261 }
262
263 return crc_bytes;
264 } /* psa_crc */
265 #endif /* SET_PSA_CRC */
266
267 /*------------------------------------------------------------------*/
268 /*
269 * update the checksum field in the Wavelan's PSA
270 */
271 static void update_psa_checksum(struct net_device * dev, unsigned long ioaddr, u16 hacr)
272 {
273 #ifdef SET_PSA_CRC
274 psa_t psa;
275 u16 crc;
276
277 /* read the parameter storage area */
278 psa_read(ioaddr, hacr, 0, (unsigned char *) &psa, sizeof(psa));
279
280 /* update the checksum */
281 crc = psa_crc((unsigned char *) &psa,
282 sizeof(psa) - sizeof(psa.psa_crc[0]) -
283 sizeof(psa.psa_crc[1])
284 - sizeof(psa.psa_crc_status));
285
286 psa.psa_crc[0] = crc & 0xFF;
287 psa.psa_crc[1] = (crc & 0xFF00) >> 8;
288
289 /* Write it ! */
290 psa_write(ioaddr, hacr, (char *) &psa.psa_crc - (char *) &psa,
291 (unsigned char *) &psa.psa_crc, 2);
292
293 #ifdef DEBUG_IOCTL_INFO
294 printk(KERN_DEBUG "%s: update_psa_checksum(): crc = 0x%02x%02x\n",
295 dev->name, psa.psa_crc[0], psa.psa_crc[1]);
296
297 /* Check again (luxury !) */
298 crc = psa_crc((unsigned char *) &psa,
299 sizeof(psa) - sizeof(psa.psa_crc_status));
300
301 if (crc != 0)
302 printk(KERN_WARNING
303 "%s: update_psa_checksum(): CRC does not agree with PSA data (even after recalculating)\n",
304 dev->name);
305 #endif /* DEBUG_IOCTL_INFO */
306 #endif /* SET_PSA_CRC */
307 } /* update_psa_checksum */
308
309 /*------------------------------------------------------------------*/
310 /*
311 * Write 1 byte to the MMC.
312 */
313 static inline void mmc_out(unsigned long ioaddr, u16 o, u8 d)
314 {
315 int count = 0;
316
317 /* Wait for MMC to go idle */
318 while ((count++ < 100) && (inw(HASR(ioaddr)) & HASR_MMC_BUSY))
319 udelay(10);
320
321 outw((u16) (((u16) d << 8) | (o << 1) | 1), MMCR(ioaddr));
322 }
323
324 /*------------------------------------------------------------------*/
325 /*
326 * Routine to write bytes to the Modem Management Controller.
327 * We start at the end because it is the way it should be!
328 */
329 static inline void mmc_write(unsigned long ioaddr, u8 o, u8 * b, int n)
330 {
331 o += n;
332 b += n;
333
334 while (n-- > 0)
335 mmc_out(ioaddr, --o, *(--b));
336 } /* mmc_write */
337
338 /*------------------------------------------------------------------*/
339 /*
340 * Read a byte from the MMC.
341 * Optimised version for 1 byte, avoid using memory.
342 */
343 static inline u8 mmc_in(unsigned long ioaddr, u16 o)
344 {
345 int count = 0;
346
347 while ((count++ < 100) && (inw(HASR(ioaddr)) & HASR_MMC_BUSY))
348 udelay(10);
349 outw(o << 1, MMCR(ioaddr));
350
351 while ((count++ < 100) && (inw(HASR(ioaddr)) & HASR_MMC_BUSY))
352 udelay(10);
353 return (u8) (inw(MMCR(ioaddr)) >> 8);
354 }
355
356 /*------------------------------------------------------------------*/
357 /*
358 * Routine to read bytes from the Modem Management Controller.
359 * The implementation is complicated by a lack of address lines,
360 * which prevents decoding of the low-order bit.
361 * (code has just been moved in the above function)
362 * We start at the end because it is the way it should be!
363 */
364 static inline void mmc_read(unsigned long ioaddr, u8 o, u8 * b, int n)
365 {
366 o += n;
367 b += n;
368
369 while (n-- > 0)
370 *(--b) = mmc_in(ioaddr, --o);
371 } /* mmc_read */
372
373 /*------------------------------------------------------------------*/
374 /*
375 * Get the type of encryption available.
376 */
377 static inline int mmc_encr(unsigned long ioaddr)
378 { /* I/O port of the card */
379 int temp;
380
381 temp = mmc_in(ioaddr, mmroff(0, mmr_des_avail));
382 if ((temp != MMR_DES_AVAIL_DES) && (temp != MMR_DES_AVAIL_AES))
383 return 0;
384 else
385 return temp;
386 }
387
388 /*------------------------------------------------------------------*/
389 /*
390 * Wait for the frequency EEPROM to complete a command.
391 * I hope this one will be optimally inlined.
392 */
393 static inline void fee_wait(unsigned long ioaddr, /* I/O port of the card */
394 int delay, /* Base delay to wait for */
395 int number)
396 { /* Number of time to wait */
397 int count = 0; /* Wait only a limited time */
398
399 while ((count++ < number) &&
400 (mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
401 MMR_FEE_STATUS_BUSY)) udelay(delay);
402 }
403
404 /*------------------------------------------------------------------*/
405 /*
406 * Read bytes from the Frequency EEPROM (frequency select cards).
407 */
408 static void fee_read(unsigned long ioaddr, /* I/O port of the card */
409 u16 o, /* destination offset */
410 u16 * b, /* data buffer */
411 int n)
412 { /* number of registers */
413 b += n; /* Position at the end of the area */
414
415 /* Write the address */
416 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1);
417
418 /* Loop on all buffer */
419 while (n-- > 0) {
420 /* Write the read command */
421 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
422 MMW_FEE_CTRL_READ);
423
424 /* Wait until EEPROM is ready (should be quick). */
425 fee_wait(ioaddr, 10, 100);
426
427 /* Read the value. */
428 *--b = ((mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)) << 8) |
429 mmc_in(ioaddr, mmroff(0, mmr_fee_data_l)));
430 }
431 }
432
433 #ifdef WIRELESS_EXT /* if the wireless extension exists in the kernel */
434
435 /*------------------------------------------------------------------*/
436 /*
437 * Write bytes from the Frequency EEPROM (frequency select cards).
438 * This is a bit complicated, because the frequency EEPROM has to
439 * be unprotected and the write enabled.
440 * Jean II
441 */
442 static void fee_write(unsigned long ioaddr, /* I/O port of the card */
443 u16 o, /* destination offset */
444 u16 * b, /* data buffer */
445 int n)
446 { /* number of registers */
447 b += n; /* Position at the end of the area. */
448
449 #ifdef EEPROM_IS_PROTECTED /* disabled */
450 #ifdef DOESNT_SEEM_TO_WORK /* disabled */
451 /* Ask to read the protected register */
452 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRREAD);
453
454 fee_wait(ioaddr, 10, 100);
455
456 /* Read the protected register. */
457 printk("Protected 2: %02X-%02X\n",
458 mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)),
459 mmc_in(ioaddr, mmroff(0, mmr_fee_data_l)));
460 #endif /* DOESNT_SEEM_TO_WORK */
461
462 /* Enable protected register. */
463 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN);
464 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PREN);
465
466 fee_wait(ioaddr, 10, 100);
467
468 /* Unprotect area. */
469 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n);
470 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
471 #ifdef DOESNT_SEEM_TO_WORK /* disabled */
472 /* or use: */
473 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRCLEAR);
474 #endif /* DOESNT_SEEM_TO_WORK */
475
476 fee_wait(ioaddr, 10, 100);
477 #endif /* EEPROM_IS_PROTECTED */
478
479 /* Write enable. */
480 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN);
481 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WREN);
482
483 fee_wait(ioaddr, 10, 100);
484
485 /* Write the EEPROM address. */
486 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1);
487
488 /* Loop on all buffer */
489 while (n-- > 0) {
490 /* Write the value. */
491 mmc_out(ioaddr, mmwoff(0, mmw_fee_data_h), (*--b) >> 8);
492 mmc_out(ioaddr, mmwoff(0, mmw_fee_data_l), *b & 0xFF);
493
494 /* Write the write command. */
495 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
496 MMW_FEE_CTRL_WRITE);
497
498 /* WaveLAN documentation says to wait at least 10 ms for EEBUSY = 0 */
499 mdelay(10);
500 fee_wait(ioaddr, 10, 100);
501 }
502
503 /* Write disable. */
504 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_DS);
505 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WDS);
506
507 fee_wait(ioaddr, 10, 100);
508
509 #ifdef EEPROM_IS_PROTECTED /* disabled */
510 /* Reprotect EEPROM. */
511 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x00);
512 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
513
514 fee_wait(ioaddr, 10, 100);
515 #endif /* EEPROM_IS_PROTECTED */
516 }
517 #endif /* WIRELESS_EXT */
518
519 /************************ I82586 SUBROUTINES *************************/
520 /*
521 * Useful subroutines to manage the Ethernet controller
522 */
523
524 /*------------------------------------------------------------------*/
525 /*
526 * Read bytes from the on-board RAM.
527 * Why does inlining this function make it fail?
528 */
529 static /*inline */ void obram_read(unsigned long ioaddr,
530 u16 o, u8 * b, int n)
531 {
532 outw(o, PIOR1(ioaddr));
533 insw(PIOP1(ioaddr), (unsigned short *) b, (n + 1) >> 1);
534 }
535
536 /*------------------------------------------------------------------*/
537 /*
538 * Write bytes to the on-board RAM.
539 */
540 static inline void obram_write(unsigned long ioaddr, u16 o, u8 * b, int n)
541 {
542 outw(o, PIOR1(ioaddr));
543 outsw(PIOP1(ioaddr), (unsigned short *) b, (n + 1) >> 1);
544 }
545
546 /*------------------------------------------------------------------*/
547 /*
548 * Acknowledge the reading of the status issued by the i82586.
549 */
550 static void wv_ack(struct net_device * dev)
551 {
552 net_local *lp = (net_local *) dev->priv;
553 unsigned long ioaddr = dev->base_addr;
554 u16 scb_cs;
555 int i;
556
557 obram_read(ioaddr, scboff(OFFSET_SCB, scb_status),
558 (unsigned char *) &scb_cs, sizeof(scb_cs));
559 scb_cs &= SCB_ST_INT;
560
561 if (scb_cs == 0)
562 return;
563
564 obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
565 (unsigned char *) &scb_cs, sizeof(scb_cs));
566
567 set_chan_attn(ioaddr, lp->hacr);
568
569 for (i = 1000; i > 0; i--) {
570 obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
571 (unsigned char *) &scb_cs, sizeof(scb_cs));
572 if (scb_cs == 0)
573 break;
574
575 udelay(10);
576 }
577 udelay(100);
578
579 #ifdef DEBUG_CONFIG_ERROR
580 if (i <= 0)
581 printk(KERN_INFO
582 "%s: wv_ack(): board not accepting command.\n",
583 dev->name);
584 #endif
585 }
586
587 /*------------------------------------------------------------------*/
588 /*
589 * Set channel attention bit and busy wait until command has
590 * completed, then acknowledge completion of the command.
591 */
592 static inline int wv_synchronous_cmd(struct net_device * dev, const char *str)
593 {
594 net_local *lp = (net_local *) dev->priv;
595 unsigned long ioaddr = dev->base_addr;
596 u16 scb_cmd;
597 ach_t cb;
598 int i;
599
600 scb_cmd = SCB_CMD_CUC & SCB_CMD_CUC_GO;
601 obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
602 (unsigned char *) &scb_cmd, sizeof(scb_cmd));
603
604 set_chan_attn(ioaddr, lp->hacr);
605
606 for (i = 1000; i > 0; i--) {
607 obram_read(ioaddr, OFFSET_CU, (unsigned char *) &cb,
608 sizeof(cb));
609 if (cb.ac_status & AC_SFLD_C)
610 break;
611
612 udelay(10);
613 }
614 udelay(100);
615
616 if (i <= 0 || !(cb.ac_status & AC_SFLD_OK)) {
617 #ifdef DEBUG_CONFIG_ERROR
618 printk(KERN_INFO "%s: %s failed; status = 0x%x\n",
619 dev->name, str, cb.ac_status);
620 #endif
621 #ifdef DEBUG_I82586_SHOW
622 wv_scb_show(ioaddr);
623 #endif
624 return -1;
625 }
626
627 /* Ack the status */
628 wv_ack(dev);
629
630 return 0;
631 }
632
633 /*------------------------------------------------------------------*/
634 /*
635 * Configuration commands completion interrupt.
636 * Check if done, and if OK.
637 */
638 static inline int
639 wv_config_complete(struct net_device * dev, unsigned long ioaddr, net_local * lp)
640 {
641 unsigned short mcs_addr;
642 unsigned short status;
643 int ret;
644
645 #ifdef DEBUG_INTERRUPT_TRACE
646 printk(KERN_DEBUG "%s: ->wv_config_complete()\n", dev->name);
647 #endif
648
649 mcs_addr = lp->tx_first_in_use + sizeof(ac_tx_t) + sizeof(ac_nop_t)
650 + sizeof(tbd_t) + sizeof(ac_cfg_t) + sizeof(ac_ias_t);
651
652 /* Read the status of the last command (set mc list). */
653 obram_read(ioaddr, acoff(mcs_addr, ac_status),
654 (unsigned char *) &status, sizeof(status));
655
656 /* If not completed -> exit */
657 if ((status & AC_SFLD_C) == 0)
658 ret = 0; /* Not ready to be scrapped */
659 else {
660 #ifdef DEBUG_CONFIG_ERROR
661 unsigned short cfg_addr;
662 unsigned short ias_addr;
663
664 /* Check mc_config command */
665 if ((status & AC_SFLD_OK) != AC_SFLD_OK)
666 printk(KERN_INFO
667 "%s: wv_config_complete(): set_multicast_address failed; status = 0x%x\n",
668 dev->name, status);
669
670 /* check ia-config command */
671 ias_addr = mcs_addr - sizeof(ac_ias_t);
672 obram_read(ioaddr, acoff(ias_addr, ac_status),
673 (unsigned char *) &status, sizeof(status));
674 if ((status & AC_SFLD_OK) != AC_SFLD_OK)
675 printk(KERN_INFO
676 "%s: wv_config_complete(): set_MAC_address failed; status = 0x%x\n",
677 dev->name, status);
678
679 /* Check config command. */
680 cfg_addr = ias_addr - sizeof(ac_cfg_t);
681 obram_read(ioaddr, acoff(cfg_addr, ac_status),
682 (unsigned char *) &status, sizeof(status));
683 if ((status & AC_SFLD_OK) != AC_SFLD_OK)
684 printk(KERN_INFO
685 "%s: wv_config_complete(): configure failed; status = 0x%x\n",
686 dev->name, status);
687 #endif /* DEBUG_CONFIG_ERROR */
688
689 ret = 1; /* Ready to be scrapped */
690 }
691
692 #ifdef DEBUG_INTERRUPT_TRACE
693 printk(KERN_DEBUG "%s: <-wv_config_complete() - %d\n", dev->name,
694 ret);
695 #endif
696 return ret;
697 }
698
699 /*------------------------------------------------------------------*/
700 /*
701 * Command completion interrupt.
702 * Reclaim as many freed tx buffers as we can.
703 * (called in wavelan_interrupt()).
704 * Note : the spinlock is already grabbed for us.
705 */
706 static int wv_complete(struct net_device * dev, unsigned long ioaddr, net_local * lp)
707 {
708 int nreaped = 0;
709
710 #ifdef DEBUG_INTERRUPT_TRACE
711 printk(KERN_DEBUG "%s: ->wv_complete()\n", dev->name);
712 #endif
713
714 /* Loop on all the transmit buffers */
715 while (lp->tx_first_in_use != I82586NULL) {
716 unsigned short tx_status;
717
718 /* Read the first transmit buffer */
719 obram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status),
720 (unsigned char *) &tx_status,
721 sizeof(tx_status));
722
723 /* If not completed -> exit */
724 if ((tx_status & AC_SFLD_C) == 0)
725 break;
726
727 /* Hack for reconfiguration */
728 if (tx_status == 0xFFFF)
729 if (!wv_config_complete(dev, ioaddr, lp))
730 break; /* Not completed */
731
732 /* We now remove this buffer */
733 nreaped++;
734 --lp->tx_n_in_use;
735
736 /*
737 if (lp->tx_n_in_use > 0)
738 printk("%c", "0123456789abcdefghijk"[lp->tx_n_in_use]);
739 */
740
741 /* Was it the last one? */
742 if (lp->tx_n_in_use <= 0)
743 lp->tx_first_in_use = I82586NULL;
744 else {
745 /* Next one in the chain */
746 lp->tx_first_in_use += TXBLOCKZ;
747 if (lp->tx_first_in_use >=
748 OFFSET_CU +
749 NTXBLOCKS * TXBLOCKZ) lp->tx_first_in_use -=
750 NTXBLOCKS * TXBLOCKZ;
751 }
752
753 /* Hack for reconfiguration */
754 if (tx_status == 0xFFFF)
755 continue;
756
757 /* Now, check status of the finished command */
758 if (tx_status & AC_SFLD_OK) {
759 int ncollisions;
760
761 lp->stats.tx_packets++;
762 ncollisions = tx_status & AC_SFLD_MAXCOL;
763 lp->stats.collisions += ncollisions;
764 #ifdef DEBUG_TX_INFO
765 if (ncollisions > 0)
766 printk(KERN_DEBUG
767 "%s: wv_complete(): tx completed after %d collisions.\n",
768 dev->name, ncollisions);
769 #endif
770 } else {
771 lp->stats.tx_errors++;
772 if (tx_status & AC_SFLD_S10) {
773 lp->stats.tx_carrier_errors++;
774 #ifdef DEBUG_TX_FAIL
775 printk(KERN_DEBUG
776 "%s: wv_complete(): tx error: no CS.\n",
777 dev->name);
778 #endif
779 }
780 if (tx_status & AC_SFLD_S9) {
781 lp->stats.tx_carrier_errors++;
782 #ifdef DEBUG_TX_FAIL
783 printk(KERN_DEBUG
784 "%s: wv_complete(): tx error: lost CTS.\n",
785 dev->name);
786 #endif
787 }
788 if (tx_status & AC_SFLD_S8) {
789 lp->stats.tx_fifo_errors++;
790 #ifdef DEBUG_TX_FAIL
791 printk(KERN_DEBUG
792 "%s: wv_complete(): tx error: slow DMA.\n",
793 dev->name);
794 #endif
795 }
796 if (tx_status & AC_SFLD_S6) {
797 lp->stats.tx_heartbeat_errors++;
798 #ifdef DEBUG_TX_FAIL
799 printk(KERN_DEBUG
800 "%s: wv_complete(): tx error: heart beat.\n",
801 dev->name);
802 #endif
803 }
804 if (tx_status & AC_SFLD_S5) {
805 lp->stats.tx_aborted_errors++;
806 #ifdef DEBUG_TX_FAIL
807 printk(KERN_DEBUG
808 "%s: wv_complete(): tx error: too many collisions.\n",
809 dev->name);
810 #endif
811 }
812 }
813
814 #ifdef DEBUG_TX_INFO
815 printk(KERN_DEBUG
816 "%s: wv_complete(): tx completed, tx_status 0x%04x\n",
817 dev->name, tx_status);
818 #endif
819 }
820
821 #ifdef DEBUG_INTERRUPT_INFO
822 if (nreaped > 1)
823 printk(KERN_DEBUG "%s: wv_complete(): reaped %d\n",
824 dev->name, nreaped);
825 #endif
826
827 /*
828 * Inform upper layers.
829 */
830 if (lp->tx_n_in_use < NTXBLOCKS - 1) {
831 netif_wake_queue(dev);
832 }
833 #ifdef DEBUG_INTERRUPT_TRACE
834 printk(KERN_DEBUG "%s: <-wv_complete()\n", dev->name);
835 #endif
836 return nreaped;
837 }
838
839 /*------------------------------------------------------------------*/
840 /*
841 * Reconfigure the i82586, or at least ask for it.
842 * Because wv_82586_config uses a transmission buffer, we must do it
843 * when we are sure that there is one left, so we do it now
844 * or in wavelan_packet_xmit() (I can't find any better place,
845 * wavelan_interrupt is not an option), so you may experience
846 * delays sometimes.
847 */
848 static inline void wv_82586_reconfig(struct net_device * dev)
849 {
850 net_local *lp = (net_local *) dev->priv;
851 unsigned long flags;
852
853 /* Arm the flag, will be cleard in wv_82586_config() */
854 lp->reconfig_82586 = 1;
855
856 /* Check if we can do it now ! */
857 if((netif_running(dev)) && !(netif_queue_stopped(dev))) {
858 spin_lock_irqsave(&lp->spinlock, flags);
859 /* May fail */
860 wv_82586_config(dev);
861 spin_unlock_irqrestore(&lp->spinlock, flags);
862 }
863 else {
864 #ifdef DEBUG_CONFIG_INFO
865 printk(KERN_DEBUG
866 "%s: wv_82586_reconfig(): delayed (state = %lX)\n",
867 dev->name, dev->state);
868 #endif
869 }
870 }
871
872 /********************* DEBUG & INFO SUBROUTINES *********************/
873 /*
874 * This routine is used in the code to show information for debugging.
875 * Most of the time, it dumps the contents of hardware structures.
876 */
877
878 #ifdef DEBUG_PSA_SHOW
879 /*------------------------------------------------------------------*/
880 /*
881 * Print the formatted contents of the Parameter Storage Area.
882 */
883 static void wv_psa_show(psa_t * p)
884 {
885 printk(KERN_DEBUG "##### WaveLAN PSA contents: #####\n");
886 printk(KERN_DEBUG "psa_io_base_addr_1: 0x%02X %02X %02X %02X\n",
887 p->psa_io_base_addr_1,
888 p->psa_io_base_addr_2,
889 p->psa_io_base_addr_3, p->psa_io_base_addr_4);
890 printk(KERN_DEBUG "psa_rem_boot_addr_1: 0x%02X %02X %02X\n",
891 p->psa_rem_boot_addr_1,
892 p->psa_rem_boot_addr_2, p->psa_rem_boot_addr_3);
893 printk(KERN_DEBUG "psa_holi_params: 0x%02x, ", p->psa_holi_params);
894 printk("psa_int_req_no: %d\n", p->psa_int_req_no);
895 #ifdef DEBUG_SHOW_UNUSED
896 printk(KERN_DEBUG
897 "psa_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
898 p->psa_unused0[0], p->psa_unused0[1], p->psa_unused0[2],
899 p->psa_unused0[3], p->psa_unused0[4], p->psa_unused0[5],
900 p->psa_unused0[6]);
901 #endif /* DEBUG_SHOW_UNUSED */
902 printk(KERN_DEBUG
903 "psa_univ_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
904 p->psa_univ_mac_addr[0], p->psa_univ_mac_addr[1],
905 p->psa_univ_mac_addr[2], p->psa_univ_mac_addr[3],
906 p->psa_univ_mac_addr[4], p->psa_univ_mac_addr[5]);
907 printk(KERN_DEBUG
908 "psa_local_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
909 p->psa_local_mac_addr[0], p->psa_local_mac_addr[1],
910 p->psa_local_mac_addr[2], p->psa_local_mac_addr[3],
911 p->psa_local_mac_addr[4], p->psa_local_mac_addr[5]);
912 printk(KERN_DEBUG "psa_univ_local_sel: %d, ",
913 p->psa_univ_local_sel);
914 printk("psa_comp_number: %d, ", p->psa_comp_number);
915 printk("psa_thr_pre_set: 0x%02x\n", p->psa_thr_pre_set);
916 printk(KERN_DEBUG "psa_feature_select/decay_prm: 0x%02x, ",
917 p->psa_feature_select);
918 printk("psa_subband/decay_update_prm: %d\n", p->psa_subband);
919 printk(KERN_DEBUG "psa_quality_thr: 0x%02x, ", p->psa_quality_thr);
920 printk("psa_mod_delay: 0x%02x\n", p->psa_mod_delay);
921 printk(KERN_DEBUG "psa_nwid: 0x%02x%02x, ", p->psa_nwid[0],
922 p->psa_nwid[1]);
923 printk("psa_nwid_select: %d\n", p->psa_nwid_select);
924 printk(KERN_DEBUG "psa_encryption_select: %d, ",
925 p->psa_encryption_select);
926 printk
927 ("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
928 p->psa_encryption_key[0], p->psa_encryption_key[1],
929 p->psa_encryption_key[2], p->psa_encryption_key[3],
930 p->psa_encryption_key[4], p->psa_encryption_key[5],
931 p->psa_encryption_key[6], p->psa_encryption_key[7]);
932 printk(KERN_DEBUG "psa_databus_width: %d\n", p->psa_databus_width);
933 printk(KERN_DEBUG "psa_call_code/auto_squelch: 0x%02x, ",
934 p->psa_call_code[0]);
935 printk
936 ("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
937 p->psa_call_code[0], p->psa_call_code[1], p->psa_call_code[2],
938 p->psa_call_code[3], p->psa_call_code[4], p->psa_call_code[5],
939 p->psa_call_code[6], p->psa_call_code[7]);
940 #ifdef DEBUG_SHOW_UNUSED
941 printk(KERN_DEBUG "psa_reserved[]: %02X:%02X:%02X:%02X\n",
942 p->psa_reserved[0],
943 p->psa_reserved[1], p->psa_reserved[2], p->psa_reserved[3]);
944 #endif /* DEBUG_SHOW_UNUSED */
945 printk(KERN_DEBUG "psa_conf_status: %d, ", p->psa_conf_status);
946 printk("psa_crc: 0x%02x%02x, ", p->psa_crc[0], p->psa_crc[1]);
947 printk("psa_crc_status: 0x%02x\n", p->psa_crc_status);
948 } /* wv_psa_show */
949 #endif /* DEBUG_PSA_SHOW */
950
951 #ifdef DEBUG_MMC_SHOW
952 /*------------------------------------------------------------------*/
953 /*
954 * Print the formatted status of the Modem Management Controller.
955 * This function needs to be completed.
956 */
957 static void wv_mmc_show(struct net_device * dev)
958 {
959 unsigned long ioaddr = dev->base_addr;
960 net_local *lp = (net_local *) dev->priv;
961 mmr_t m;
962
963 /* Basic check */
964 if (hasr_read(ioaddr) & HASR_NO_CLK) {
965 printk(KERN_WARNING
966 "%s: wv_mmc_show: modem not connected\n",
967 dev->name);
968 return;
969 }
970
971 /* Read the mmc */
972 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
973 mmc_read(ioaddr, 0, (u8 *) & m, sizeof(m));
974 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
975
976 #ifdef WIRELESS_EXT /* if wireless extension exists in the kernel */
977 /* Don't forget to update statistics */
978 lp->wstats.discard.nwid +=
979 (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
980 #endif /* WIRELESS_EXT */
981
982 printk(KERN_DEBUG "##### WaveLAN modem status registers: #####\n");
983 #ifdef DEBUG_SHOW_UNUSED
984 printk(KERN_DEBUG
985 "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
986 m.mmr_unused0[0], m.mmr_unused0[1], m.mmr_unused0[2],
987 m.mmr_unused0[3], m.mmr_unused0[4], m.mmr_unused0[5],
988 m.mmr_unused0[6], m.mmr_unused0[7]);
989 #endif /* DEBUG_SHOW_UNUSED */
990 printk(KERN_DEBUG "Encryption algorithm: %02X - Status: %02X\n",
991 m.mmr_des_avail, m.mmr_des_status);
992 #ifdef DEBUG_SHOW_UNUSED
993 printk(KERN_DEBUG "mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n",
994 m.mmr_unused1[0],
995 m.mmr_unused1[1],
996 m.mmr_unused1[2], m.mmr_unused1[3], m.mmr_unused1[4]);
997 #endif /* DEBUG_SHOW_UNUSED */
998 printk(KERN_DEBUG "dce_status: 0x%x [%s%s%s%s]\n",
999 m.mmr_dce_status,
1000 (m.
1001 mmr_dce_status & MMR_DCE_STATUS_RX_BUSY) ?
1002 "energy detected," : "",
1003 (m.
1004 mmr_dce_status & MMR_DCE_STATUS_LOOPT_IND) ?
1005 "loop test indicated," : "",
1006 (m.
1007 mmr_dce_status & MMR_DCE_STATUS_TX_BUSY) ?
1008 "transmitter on," : "",
1009 (m.
1010 mmr_dce_status & MMR_DCE_STATUS_JBR_EXPIRED) ?
1011 "jabber timer expired," : "");
1012 printk(KERN_DEBUG "Dsp ID: %02X\n", m.mmr_dsp_id);
1013 #ifdef DEBUG_SHOW_UNUSED
1014 printk(KERN_DEBUG "mmc_unused2[]: %02X:%02X\n",
1015 m.mmr_unused2[0], m.mmr_unused2[1]);
1016 #endif /* DEBUG_SHOW_UNUSED */
1017 printk(KERN_DEBUG "# correct_nwid: %d, # wrong_nwid: %d\n",
1018 (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l,
1019 (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l);
1020 printk(KERN_DEBUG "thr_pre_set: 0x%x [current signal %s]\n",
1021 m.mmr_thr_pre_set & MMR_THR_PRE_SET,
1022 (m.
1023 mmr_thr_pre_set & MMR_THR_PRE_SET_CUR) ? "above" :
1024 "below");
1025 printk(KERN_DEBUG "signal_lvl: %d [%s], ",
1026 m.mmr_signal_lvl & MMR_SIGNAL_LVL,
1027 (m.
1028 mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) ? "new msg" :
1029 "no new msg");
1030 printk("silence_lvl: %d [%s], ",
1031 m.mmr_silence_lvl & MMR_SILENCE_LVL,
1032 (m.
1033 mmr_silence_lvl & MMR_SILENCE_LVL_VALID) ? "update done" :
1034 "no new update");
1035 printk("sgnl_qual: 0x%x [%s]\n", m.mmr_sgnl_qual & MMR_SGNL_QUAL,
1036 (m.
1037 mmr_sgnl_qual & MMR_SGNL_QUAL_ANT) ? "Antenna 1" :
1038 "Antenna 0");
1039 #ifdef DEBUG_SHOW_UNUSED
1040 printk(KERN_DEBUG "netw_id_l: %x\n", m.mmr_netw_id_l);
1041 #endif /* DEBUG_SHOW_UNUSED */
1042 } /* wv_mmc_show */
1043 #endif /* DEBUG_MMC_SHOW */
1044
1045 #ifdef DEBUG_I82586_SHOW
1046 /*------------------------------------------------------------------*/
1047 /*
1048 * Print the last block of the i82586 memory.
1049 */
1050 static void wv_scb_show(unsigned long ioaddr)
1051 {
1052 scb_t scb;
1053
1054 obram_read(ioaddr, OFFSET_SCB, (unsigned char *) &scb,
1055 sizeof(scb));
1056
1057 printk(KERN_DEBUG "##### WaveLAN system control block: #####\n");
1058
1059 printk(KERN_DEBUG "status: ");
1060 printk("stat 0x%x[%s%s%s%s] ",
1061 (scb.
1062 scb_status & (SCB_ST_CX | SCB_ST_FR | SCB_ST_CNA |
1063 SCB_ST_RNR)) >> 12,
1064 (scb.
1065 scb_status & SCB_ST_CX) ? "command completion interrupt," :
1066 "", (scb.scb_status & SCB_ST_FR) ? "frame received," : "",
1067 (scb.
1068 scb_status & SCB_ST_CNA) ? "command unit not active," : "",
1069 (scb.
1070 scb_status & SCB_ST_RNR) ? "receiving unit not ready," :
1071 "");
1072 printk("cus 0x%x[%s%s%s] ", (scb.scb_status & SCB_ST_CUS) >> 8,
1073 ((scb.scb_status & SCB_ST_CUS) ==
1074 SCB_ST_CUS_IDLE) ? "idle" : "",
1075 ((scb.scb_status & SCB_ST_CUS) ==
1076 SCB_ST_CUS_SUSP) ? "suspended" : "",
1077 ((scb.scb_status & SCB_ST_CUS) ==
1078 SCB_ST_CUS_ACTV) ? "active" : "");
1079 printk("rus 0x%x[%s%s%s%s]\n", (scb.scb_status & SCB_ST_RUS) >> 4,
1080 ((scb.scb_status & SCB_ST_RUS) ==
1081 SCB_ST_RUS_IDLE) ? "idle" : "",
1082 ((scb.scb_status & SCB_ST_RUS) ==
1083 SCB_ST_RUS_SUSP) ? "suspended" : "",
1084 ((scb.scb_status & SCB_ST_RUS) ==
1085 SCB_ST_RUS_NRES) ? "no resources" : "",
1086 ((scb.scb_status & SCB_ST_RUS) ==
1087 SCB_ST_RUS_RDY) ? "ready" : "");
1088
1089 printk(KERN_DEBUG "command: ");
1090 printk("ack 0x%x[%s%s%s%s] ",
1091 (scb.
1092 scb_command & (SCB_CMD_ACK_CX | SCB_CMD_ACK_FR |
1093 SCB_CMD_ACK_CNA | SCB_CMD_ACK_RNR)) >> 12,
1094 (scb.
1095 scb_command & SCB_CMD_ACK_CX) ? "ack cmd completion," : "",
1096 (scb.
1097 scb_command & SCB_CMD_ACK_FR) ? "ack frame received," : "",
1098 (scb.
1099 scb_command & SCB_CMD_ACK_CNA) ? "ack CU not active," : "",
1100 (scb.
1101 scb_command & SCB_CMD_ACK_RNR) ? "ack RU not ready," : "");
1102 printk("cuc 0x%x[%s%s%s%s%s] ",
1103 (scb.scb_command & SCB_CMD_CUC) >> 8,
1104 ((scb.scb_command & SCB_CMD_CUC) ==
1105 SCB_CMD_CUC_NOP) ? "nop" : "",
1106 ((scb.scb_command & SCB_CMD_CUC) ==
1107 SCB_CMD_CUC_GO) ? "start cbl_offset" : "",
1108 ((scb.scb_command & SCB_CMD_CUC) ==
1109 SCB_CMD_CUC_RES) ? "resume execution" : "",
1110 ((scb.scb_command & SCB_CMD_CUC) ==
1111 SCB_CMD_CUC_SUS) ? "suspend execution" : "",
1112 ((scb.scb_command & SCB_CMD_CUC) ==
1113 SCB_CMD_CUC_ABT) ? "abort execution" : "");
1114 printk("ruc 0x%x[%s%s%s%s%s]\n",
1115 (scb.scb_command & SCB_CMD_RUC) >> 4,
1116 ((scb.scb_command & SCB_CMD_RUC) ==
1117 SCB_CMD_RUC_NOP) ? "nop" : "",
1118 ((scb.scb_command & SCB_CMD_RUC) ==
1119 SCB_CMD_RUC_GO) ? "start rfa_offset" : "",
1120 ((scb.scb_command & SCB_CMD_RUC) ==
1121 SCB_CMD_RUC_RES) ? "resume reception" : "",
1122 ((scb.scb_command & SCB_CMD_RUC) ==
1123 SCB_CMD_RUC_SUS) ? "suspend reception" : "",
1124 ((scb.scb_command & SCB_CMD_RUC) ==
1125 SCB_CMD_RUC_ABT) ? "abort reception" : "");
1126
1127 printk(KERN_DEBUG "cbl_offset 0x%x ", scb.scb_cbl_offset);
1128 printk("rfa_offset 0x%x\n", scb.scb_rfa_offset);
1129
1130 printk(KERN_DEBUG "crcerrs %d ", scb.scb_crcerrs);
1131 printk("alnerrs %d ", scb.scb_alnerrs);
1132 printk("rscerrs %d ", scb.scb_rscerrs);
1133 printk("ovrnerrs %d\n", scb.scb_ovrnerrs);
1134 }
1135
1136 /*------------------------------------------------------------------*/
1137 /*
1138 * Print the formatted status of the i82586's receive unit.
1139 */
1140 static void wv_ru_show(struct net_device * dev)
1141 {
1142 /* net_local *lp = (net_local *) dev->priv; */
1143
1144 printk(KERN_DEBUG
1145 "##### WaveLAN i82586 receiver unit status: #####\n");
1146 printk(KERN_DEBUG "ru:");
1147 /*
1148 * Not implemented yet
1149 */
1150 printk("\n");
1151 } /* wv_ru_show */
1152
1153 /*------------------------------------------------------------------*/
1154 /*
1155 * Display info about one control block of the i82586 memory.
1156 */
1157 static void wv_cu_show_one(struct net_device * dev, net_local * lp, int i, u16 p)
1158 {
1159 unsigned long ioaddr;
1160 ac_tx_t actx;
1161
1162 ioaddr = dev->base_addr;
1163
1164 printk("%d: 0x%x:", i, p);
1165
1166 obram_read(ioaddr, p, (unsigned char *) &actx, sizeof(actx));
1167 printk(" status=0x%x,", actx.tx_h.ac_status);
1168 printk(" command=0x%x,", actx.tx_h.ac_command);
1169
1170 /*
1171 {
1172 tbd_t tbd;
1173
1174 obram_read(ioaddr, actx.tx_tbd_offset, (unsigned char *)&tbd, sizeof(tbd));
1175 printk(" tbd_status=0x%x,", tbd.tbd_status);
1176 }
1177 */
1178
1179 printk("|");
1180 }
1181
1182 /*------------------------------------------------------------------*/
1183 /*
1184 * Print status of the command unit of the i82586.
1185 */
1186 static void wv_cu_show(struct net_device * dev)
1187 {
1188 net_local *lp = (net_local *) dev->priv;
1189 unsigned int i;
1190 u16 p;
1191
1192 printk(KERN_DEBUG
1193 "##### WaveLAN i82586 command unit status: #####\n");
1194
1195 printk(KERN_DEBUG);
1196 for (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++) {
1197 wv_cu_show_one(dev, lp, i, p);
1198
1199 p += TXBLOCKZ;
1200 if (p >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
1201 p -= NTXBLOCKS * TXBLOCKZ;
1202 }
1203 printk("\n");
1204 }
1205 #endif /* DEBUG_I82586_SHOW */
1206
1207 #ifdef DEBUG_DEVICE_SHOW
1208 /*------------------------------------------------------------------*/
1209 /*
1210 * Print the formatted status of the WaveLAN PCMCIA device driver.
1211 */
1212 static void wv_dev_show(struct net_device * dev)
1213 {
1214 printk(KERN_DEBUG "dev:");
1215 printk(" state=%lX,", dev->state);
1216 printk(" trans_start=%ld,", dev->trans_start);
1217 printk(" flags=0x%x,", dev->flags);
1218 printk("\n");
1219 } /* wv_dev_show */
1220
1221 /*------------------------------------------------------------------*/
1222 /*
1223 * Print the formatted status of the WaveLAN PCMCIA device driver's
1224 * private information.
1225 */
1226 static void wv_local_show(struct net_device * dev)
1227 {
1228 net_local *lp;
1229
1230 lp = (net_local *) dev->priv;
1231
1232 printk(KERN_DEBUG "local:");
1233 printk(" tx_n_in_use=%d,", lp->tx_n_in_use);
1234 printk(" hacr=0x%x,", lp->hacr);
1235 printk(" rx_head=0x%x,", lp->rx_head);
1236 printk(" rx_last=0x%x,", lp->rx_last);
1237 printk(" tx_first_free=0x%x,", lp->tx_first_free);
1238 printk(" tx_first_in_use=0x%x,", lp->tx_first_in_use);
1239 printk("\n");
1240 } /* wv_local_show */
1241 #endif /* DEBUG_DEVICE_SHOW */
1242
1243 #if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO)
1244 /*------------------------------------------------------------------*/
1245 /*
1246 * Dump packet header (and content if necessary) on the screen
1247 */
1248 static inline void wv_packet_info(u8 * p, /* Packet to dump */
1249 int length, /* Length of the packet */
1250 char *msg1, /* Name of the device */
1251 char *msg2)
1252 { /* Name of the function */
1253 int i;
1254 int maxi;
1255
1256 printk(KERN_DEBUG
1257 "%s: %s(): dest %02X:%02X:%02X:%02X:%02X:%02X, length %d\n",
1258 msg1, msg2, p[0], p[1], p[2], p[3], p[4], p[5], length);
1259 printk(KERN_DEBUG
1260 "%s: %s(): src %02X:%02X:%02X:%02X:%02X:%02X, type 0x%02X%02X\n",
1261 msg1, msg2, p[6], p[7], p[8], p[9], p[10], p[11], p[12],
1262 p[13]);
1263
1264 #ifdef DEBUG_PACKET_DUMP
1265
1266 printk(KERN_DEBUG "data=\"");
1267
1268 if ((maxi = length) > DEBUG_PACKET_DUMP)
1269 maxi = DEBUG_PACKET_DUMP;
1270 for (i = 14; i < maxi; i++)
1271 if (p[i] >= ' ' && p[i] <= '~')
1272 printk(" %c", p[i]);
1273 else
1274 printk("%02X", p[i]);
1275 if (maxi < length)
1276 printk("..");
1277 printk("\"\n");
1278 printk(KERN_DEBUG "\n");
1279 #endif /* DEBUG_PACKET_DUMP */
1280 }
1281 #endif /* defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) */
1282
1283 /*------------------------------------------------------------------*/
1284 /*
1285 * This is the information which is displayed by the driver at startup.
1286 * There are lots of flags for configuring it to your liking.
1287 */
1288 static inline void wv_init_info(struct net_device * dev)
1289 {
1290 short ioaddr = dev->base_addr;
1291 net_local *lp = (net_local *) dev->priv;
1292 psa_t psa;
1293 int i;
1294
1295 /* Read the parameter storage area */
1296 psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa));
1297
1298 #ifdef DEBUG_PSA_SHOW
1299 wv_psa_show(&psa);
1300 #endif
1301 #ifdef DEBUG_MMC_SHOW
1302 wv_mmc_show(dev);
1303 #endif
1304 #ifdef DEBUG_I82586_SHOW
1305 wv_cu_show(dev);
1306 #endif
1307
1308 #ifdef DEBUG_BASIC_SHOW
1309 /* Now, let's go for the basic stuff. */
1310 printk(KERN_NOTICE "%s: WaveLAN at %#x,", dev->name, ioaddr);
1311 for (i = 0; i < WAVELAN_ADDR_SIZE; i++)
1312 printk("%s%02X", (i == 0) ? " " : ":", dev->dev_addr[i]);
1313 printk(", IRQ %d", dev->irq);
1314
1315 /* Print current network ID. */
1316 if (psa.psa_nwid_select)
1317 printk(", nwid 0x%02X-%02X", psa.psa_nwid[0],
1318 psa.psa_nwid[1]);
1319 else
1320 printk(", nwid off");
1321
1322 /* If 2.00 card */
1323 if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
1324 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
1325 unsigned short freq;
1326
1327 /* Ask the EEPROM to read the frequency from the first area. */
1328 fee_read(ioaddr, 0x00, &freq, 1);
1329
1330 /* Print frequency */
1331 printk(", 2.00, %ld", (freq >> 6) + 2400L);
1332
1333 /* Hack! */
1334 if (freq & 0x20)
1335 printk(".5");
1336 } else {
1337 printk(", PC");
1338 switch (psa.psa_comp_number) {
1339 case PSA_COMP_PC_AT_915:
1340 case PSA_COMP_PC_AT_2400:
1341 printk("-AT");
1342 break;
1343 case PSA_COMP_PC_MC_915:
1344 case PSA_COMP_PC_MC_2400:
1345 printk("-MC");
1346 break;
1347 case PSA_COMP_PCMCIA_915:
1348 printk("MCIA");
1349 break;
1350 default:
1351 printk("?");
1352 }
1353 printk(", ");
1354 switch (psa.psa_subband) {
1355 case PSA_SUBBAND_915:
1356 printk("915");
1357 break;
1358 case PSA_SUBBAND_2425:
1359 printk("2425");
1360 break;
1361 case PSA_SUBBAND_2460:
1362 printk("2460");
1363 break;
1364 case PSA_SUBBAND_2484:
1365 printk("2484");
1366 break;
1367 case PSA_SUBBAND_2430_5:
1368 printk("2430.5");
1369 break;
1370 default:
1371 printk("?");
1372 }
1373 }
1374
1375 printk(" MHz\n");
1376 #endif /* DEBUG_BASIC_SHOW */
1377
1378 #ifdef DEBUG_VERSION_SHOW
1379 /* Print version information */
1380 printk(KERN_NOTICE "%s", version);
1381 #endif
1382 } /* wv_init_info */
1383
1384 /********************* IOCTL, STATS & RECONFIG *********************/
1385 /*
1386 * We found here routines that are called by Linux on different
1387 * occasions after the configuration and not for transmitting data
1388 * These may be called when the user use ifconfig, /proc/net/dev
1389 * or wireless extensions
1390 */
1391
1392 /*------------------------------------------------------------------*/
1393 /*
1394 * Get the current Ethernet statistics. This may be called with the
1395 * card open or closed.
1396 * Used when the user read /proc/net/dev
1397 */
1398 static en_stats *wavelan_get_stats(struct net_device * dev)
1399 {
1400 #ifdef DEBUG_IOCTL_TRACE
1401 printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name);
1402 #endif
1403
1404 return (&((net_local *) dev->priv)->stats);
1405 }
1406
1407 /*------------------------------------------------------------------*/
1408 /*
1409 * Set or clear the multicast filter for this adaptor.
1410 * num_addrs == -1 Promiscuous mode, receive all packets
1411 * num_addrs == 0 Normal mode, clear multicast list
1412 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1413 * and do best-effort filtering.
1414 */
1415 static void wavelan_set_multicast_list(struct net_device * dev)
1416 {
1417 net_local *lp = (net_local *) dev->priv;
1418
1419 #ifdef DEBUG_IOCTL_TRACE
1420 printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n",
1421 dev->name);
1422 #endif
1423
1424 #ifdef DEBUG_IOCTL_INFO
1425 printk(KERN_DEBUG
1426 "%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
1427 dev->name, dev->flags, dev->mc_count);
1428 #endif
1429
1430 /* Are we asking for promiscuous mode,
1431 * or all multicast addresses (we don't have that!)
1432 * or too many multicast addresses for the hardware filter? */
1433 if ((dev->flags & IFF_PROMISC) ||
1434 (dev->flags & IFF_ALLMULTI) ||
1435 (dev->mc_count > I82586_MAX_MULTICAST_ADDRESSES)) {
1436 /*
1437 * Enable promiscuous mode: receive all packets.
1438 */
1439 if (!lp->promiscuous) {
1440 lp->promiscuous = 1;
1441 lp->mc_count = 0;
1442
1443 wv_82586_reconfig(dev);
1444
1445 /* Tell the kernel that we are doing a really bad job. */
1446 dev->flags |= IFF_PROMISC;
1447 }
1448 } else
1449 /* Are there multicast addresses to send? */
1450 if (dev->mc_list != (struct dev_mc_list *) NULL) {
1451 /*
1452 * Disable promiscuous mode, but receive all packets
1453 * in multicast list
1454 */
1455 #ifdef MULTICAST_AVOID
1456 if (lp->promiscuous || (dev->mc_count != lp->mc_count))
1457 #endif
1458 {
1459 lp->promiscuous = 0;
1460 lp->mc_count = dev->mc_count;
1461
1462 wv_82586_reconfig(dev);
1463 }
1464 } else {
1465 /*
1466 * Switch to normal mode: disable promiscuous mode and
1467 * clear the multicast list.
1468 */
1469 if (lp->promiscuous || lp->mc_count == 0) {
1470 lp->promiscuous = 0;
1471 lp->mc_count = 0;
1472
1473 wv_82586_reconfig(dev);
1474 }
1475 }
1476 #ifdef DEBUG_IOCTL_TRACE
1477 printk(KERN_DEBUG "%s: <-wavelan_set_multicast_list()\n",
1478 dev->name);
1479 #endif
1480 }
1481
1482 /*------------------------------------------------------------------*/
1483 /*
1484 * This function doesn't exist.
1485 * (Note : it was a nice way to test the reconfigure stuff...)
1486 */
1487 #ifdef SET_MAC_ADDRESS
1488 static int wavelan_set_mac_address(struct net_device * dev, void *addr)
1489 {
1490 struct sockaddr *mac = addr;
1491
1492 /* Copy the address. */
1493 memcpy(dev->dev_addr, mac->sa_data, WAVELAN_ADDR_SIZE);
1494
1495 /* Reconfigure the beast. */
1496 wv_82586_reconfig(dev);
1497
1498 return 0;
1499 }
1500 #endif /* SET_MAC_ADDRESS */
1501
1502 #ifdef WIRELESS_EXT /* if wireless extensions exist in the kernel */
1503
1504 /*------------------------------------------------------------------*/
1505 /*
1506 * Frequency setting (for hardware capable of it)
1507 * It's a bit complicated and you don't really want to look into it.
1508 * (called in wavelan_ioctl)
1509 */
1510 static inline int wv_set_frequency(unsigned long ioaddr, /* I/O port of the card */
1511 iw_freq * frequency)
1512 {
1513 const int BAND_NUM = 10; /* Number of bands */
1514 long freq = 0L; /* offset to 2.4 GHz in .5 MHz */
1515 #ifdef DEBUG_IOCTL_INFO
1516 int i;
1517 #endif
1518
1519 /* Setting by frequency */
1520 /* Theoretically, you may set any frequency between
1521 * the two limits with a 0.5 MHz precision. In practice,
1522 * I don't want you to have trouble with local regulations.
1523 */
1524 if ((frequency->e == 1) &&
1525 (frequency->m >= (int) 2.412e8)
1526 && (frequency->m <= (int) 2.487e8)) {
1527 freq = ((frequency->m / 10000) - 24000L) / 5;
1528 }
1529
1530 /* Setting by channel (same as wfreqsel) */
1531 /* Warning: each channel is 22 MHz wide, so some of the channels
1532 * will interfere. */
1533 if ((frequency->e == 0) && (frequency->m < BAND_NUM)) {
1534 /* Get frequency offset. */
1535 freq = channel_bands[frequency->m] >> 1;
1536 }
1537
1538 /* Verify that the frequency is allowed. */
1539 if (freq != 0L) {
1540 u16 table[10]; /* Authorized frequency table */
1541
1542 /* Read the frequency table. */
1543 fee_read(ioaddr, 0x71, table, 10);
1544
1545 #ifdef DEBUG_IOCTL_INFO
1546 printk(KERN_DEBUG "Frequency table: ");
1547 for (i = 0; i < 10; i++) {
1548 printk(" %04X", table[i]);
1549 }
1550 printk("\n");
1551 #endif
1552
1553 /* Look in the table to see whether the frequency is allowed. */
1554 if (!(table[9 - ((freq - 24) / 16)] &
1555 (1 << ((freq - 24) % 16)))) return -EINVAL; /* not allowed */
1556 } else
1557 return -EINVAL;
1558
1559 /* if we get a usable frequency */
1560 if (freq != 0L) {
1561 unsigned short area[16];
1562 unsigned short dac[2];
1563 unsigned short area_verify[16];
1564 unsigned short dac_verify[2];
1565 /* Corresponding gain (in the power adjust value table)
1566 * See AT&T WaveLAN Data Manual, REF 407-024689/E, page 3-8
1567 * and WCIN062D.DOC, page 6.2.9. */
1568 unsigned short power_limit[] = { 40, 80, 120, 160, 0 };
1569 int power_band = 0; /* Selected band */
1570 unsigned short power_adjust; /* Correct value */
1571
1572 /* Search for the gain. */
1573 power_band = 0;
1574 while ((freq > power_limit[power_band]) &&
1575 (power_limit[++power_band] != 0));
1576
1577 /* Read the first area. */
1578 fee_read(ioaddr, 0x00, area, 16);
1579
1580 /* Read the DAC. */
1581 fee_read(ioaddr, 0x60, dac, 2);
1582
1583 /* Read the new power adjust value. */
1584 fee_read(ioaddr, 0x6B - (power_band >> 1), &power_adjust,
1585 1);
1586 if (power_band & 0x1)
1587 power_adjust >>= 8;
1588 else
1589 power_adjust &= 0xFF;
1590
1591 #ifdef DEBUG_IOCTL_INFO
1592 printk(KERN_DEBUG "WaveLAN EEPROM Area 1: ");
1593 for (i = 0; i < 16; i++) {
1594 printk(" %04X", area[i]);
1595 }
1596 printk("\n");
1597
1598 printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n",
1599 dac[0], dac[1]);
1600 #endif
1601
1602 /* Frequency offset (for info only) */
1603 area[0] = ((freq << 5) & 0xFFE0) | (area[0] & 0x1F);
1604
1605 /* Receiver Principle main divider coefficient */
1606 area[3] = (freq >> 1) + 2400L - 352L;
1607 area[2] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1608
1609 /* Transmitter Main divider coefficient */
1610 area[13] = (freq >> 1) + 2400L;
1611 area[12] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1612
1613 /* Other parts of the area are flags, bit streams or unused. */
1614
1615 /* Set the value in the DAC. */
1616 dac[1] = ((power_adjust >> 1) & 0x7F) | (dac[1] & 0xFF80);
1617 dac[0] = ((power_adjust & 0x1) << 4) | (dac[0] & 0xFFEF);
1618
1619 /* Write the first area. */
1620 fee_write(ioaddr, 0x00, area, 16);
1621
1622 /* Write the DAC. */
1623 fee_write(ioaddr, 0x60, dac, 2);
1624
1625 /* We now should verify here that the writing of the EEPROM went OK. */
1626
1627 /* Reread the first area. */
1628 fee_read(ioaddr, 0x00, area_verify, 16);
1629
1630 /* Reread the DAC. */
1631 fee_read(ioaddr, 0x60, dac_verify, 2);
1632
1633 /* Compare. */
1634 if (memcmp(area, area_verify, 16 * 2) ||
1635 memcmp(dac, dac_verify, 2 * 2)) {
1636 #ifdef DEBUG_IOCTL_ERROR
1637 printk(KERN_INFO
1638 "WaveLAN: wv_set_frequency: unable to write new frequency to EEPROM(?).\n");
1639 #endif
1640 return -EOPNOTSUPP;
1641 }
1642
1643 /* We must download the frequency parameters to the
1644 * synthesizers (from the EEPROM - area 1)
1645 * Note: as the EEPROM is automatically decremented, we set the end
1646 * if the area... */
1647 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x0F);
1648 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
1649 MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1650
1651 /* Wait until the download is finished. */
1652 fee_wait(ioaddr, 100, 100);
1653
1654 /* We must now download the power adjust value (gain) to
1655 * the synthesizers (from the EEPROM - area 7 - DAC). */
1656 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x61);
1657 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
1658 MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1659
1660 /* Wait for the download to finish. */
1661 fee_wait(ioaddr, 100, 100);
1662
1663 #ifdef DEBUG_IOCTL_INFO
1664 /* Verification of what we have done */
1665
1666 printk(KERN_DEBUG "WaveLAN EEPROM Area 1: ");
1667 for (i = 0; i < 16; i++) {
1668 printk(" %04X", area_verify[i]);
1669 }
1670 printk("\n");
1671
1672 printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n",
1673 dac_verify[0], dac_verify[1]);
1674 #endif
1675
1676 return 0;
1677 } else
1678 return -EINVAL; /* Bah, never get there... */
1679 }
1680
1681 /*------------------------------------------------------------------*/
1682 /*
1683 * Give the list of available frequencies.
1684 */
1685 static inline int wv_frequency_list(unsigned long ioaddr, /* I/O port of the card */
1686 iw_freq * list, /* List of frequencies to fill */
1687 int max)
1688 { /* Maximum number of frequencies */
1689 u16 table[10]; /* Authorized frequency table */
1690 long freq = 0L; /* offset to 2.4 GHz in .5 MHz + 12 MHz */
1691 int i; /* index in the table */
1692 int c = 0; /* Channel number */
1693
1694 /* Read the frequency table. */
1695 fee_read(ioaddr, 0x71 /* frequency table */ , table, 10);
1696
1697 /* Check all frequencies. */
1698 i = 0;
1699 for (freq = 0; freq < 150; freq++)
1700 /* Look in the table if the frequency is allowed */
1701 if (table[9 - (freq / 16)] & (1 << (freq % 16))) {
1702 /* Compute approximate channel number */
1703 while ((((channel_bands[c] >> 1) - 24) < freq) &&
1704 (c < NELS(channel_bands)))
1705 c++;
1706 list[i].i = c; /* Set the list index */
1707
1708 /* put in the list */
1709 list[i].m = (((freq + 24) * 5) + 24000L) * 10000;
1710 list[i++].e = 1;
1711
1712 /* Check number. */
1713 if (i >= max)
1714 return (i);
1715 }
1716
1717 return (i);
1718 }
1719
1720 #ifdef IW_WIRELESS_SPY
1721 /*------------------------------------------------------------------*/
1722 /*
1723 * Gather wireless spy statistics: for each packet, compare the source
1724 * address with our list, and if they match, get the statistics.
1725 * Sorry, but this function really needs the wireless extensions.
1726 */
1727 static inline void wl_spy_gather(struct net_device * dev,
1728 u8 * mac, /* MAC address */
1729 u8 * stats) /* Statistics to gather */
1730 {
1731 struct iw_quality wstats;
1732
1733 wstats.qual = stats[2] & MMR_SGNL_QUAL;
1734 wstats.level = stats[0] & MMR_SIGNAL_LVL;
1735 wstats.noise = stats[1] & MMR_SILENCE_LVL;
1736 wstats.updated = 0x7;
1737
1738 /* Update spy records */
1739 wireless_spy_update(dev, mac, &wstats);
1740 }
1741 #endif /* IW_WIRELESS_SPY */
1742
1743 #ifdef HISTOGRAM
1744 /*------------------------------------------------------------------*/
1745 /*
1746 * This function calculates a histogram of the signal level.
1747 * As the noise is quite constant, it's like doing it on the SNR.
1748 * We have defined a set of interval (lp->his_range), and each time
1749 * the level goes in that interval, we increment the count (lp->his_sum).
1750 * With this histogram you may detect if one WaveLAN is really weak,
1751 * or you may also calculate the mean and standard deviation of the level.
1752 */
1753 static inline void wl_his_gather(struct net_device * dev, u8 * stats)
1754 { /* Statistics to gather */
1755 net_local *lp = (net_local *) dev->priv;
1756 u8 level = stats[0] & MMR_SIGNAL_LVL;
1757 int i;
1758
1759 /* Find the correct interval. */
1760 i = 0;
1761 while ((i < (lp->his_number - 1))
1762 && (level >= lp->his_range[i++]));
1763
1764 /* Increment interval counter. */
1765 (lp->his_sum[i])++;
1766 }
1767 #endif /* HISTOGRAM */
1768
1769 /*------------------------------------------------------------------*/
1770 /*
1771 * Wireless Handler : get protocol name
1772 */
1773 static int wavelan_get_name(struct net_device *dev,
1774 struct iw_request_info *info,
1775 union iwreq_data *wrqu,
1776 char *extra)
1777 {
1778 strcpy(wrqu->name, "WaveLAN");
1779 return 0;
1780 }
1781
1782 /*------------------------------------------------------------------*/
1783 /*
1784 * Wireless Handler : set NWID
1785 */
1786 static int wavelan_set_nwid(struct net_device *dev,
1787 struct iw_request_info *info,
1788 union iwreq_data *wrqu,
1789 char *extra)
1790 {
1791 unsigned long ioaddr = dev->base_addr;
1792 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
1793 psa_t psa;
1794 mm_t m;
1795 unsigned long flags;
1796 int ret = 0;
1797
1798 /* Disable interrupts and save flags. */
1799 spin_lock_irqsave(&lp->spinlock, flags);
1800
1801 /* Set NWID in WaveLAN. */
1802 if (!wrqu->nwid.disabled) {
1803 /* Set NWID in psa */
1804 psa.psa_nwid[0] = (wrqu->nwid.value & 0xFF00) >> 8;
1805 psa.psa_nwid[1] = wrqu->nwid.value & 0xFF;
1806 psa.psa_nwid_select = 0x01;
1807 psa_write(ioaddr, lp->hacr,
1808 (char *) psa.psa_nwid - (char *) &psa,
1809 (unsigned char *) psa.psa_nwid, 3);
1810
1811 /* Set NWID in mmc. */
1812 m.w.mmw_netw_id_l = psa.psa_nwid[1];
1813 m.w.mmw_netw_id_h = psa.psa_nwid[0];
1814 mmc_write(ioaddr,
1815 (char *) &m.w.mmw_netw_id_l -
1816 (char *) &m,
1817 (unsigned char *) &m.w.mmw_netw_id_l, 2);
1818 mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel), 0x00);
1819 } else {
1820 /* Disable NWID in the psa. */
1821 psa.psa_nwid_select = 0x00;
1822 psa_write(ioaddr, lp->hacr,
1823 (char *) &psa.psa_nwid_select -
1824 (char *) &psa,
1825 (unsigned char *) &psa.psa_nwid_select,
1826 1);
1827
1828 /* Disable NWID in the mmc (no filtering). */
1829 mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel),
1830 MMW_LOOPT_SEL_DIS_NWID);
1831 }
1832 /* update the Wavelan checksum */
1833 update_psa_checksum(dev, ioaddr, lp->hacr);
1834
1835 /* Enable interrupts and restore flags. */
1836 spin_unlock_irqrestore(&lp->spinlock, flags);
1837
1838 return ret;
1839 }
1840
1841 /*------------------------------------------------------------------*/
1842 /*
1843 * Wireless Handler : get NWID
1844 */
1845 static int wavelan_get_nwid(struct net_device *dev,
1846 struct iw_request_info *info,
1847 union iwreq_data *wrqu,
1848 char *extra)
1849 {
1850 unsigned long ioaddr = dev->base_addr;
1851 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
1852 psa_t psa;
1853 unsigned long flags;
1854 int ret = 0;
1855
1856 /* Disable interrupts and save flags. */
1857 spin_lock_irqsave(&lp->spinlock, flags);
1858
1859 /* Read the NWID. */
1860 psa_read(ioaddr, lp->hacr,
1861 (char *) psa.psa_nwid - (char *) &psa,
1862 (unsigned char *) psa.psa_nwid, 3);
1863 wrqu->nwid.value = (psa.psa_nwid[0] << 8) + psa.psa_nwid[1];
1864 wrqu->nwid.disabled = !(psa.psa_nwid_select);
1865 wrqu->nwid.fixed = 1; /* Superfluous */
1866
1867 /* Enable interrupts and restore flags. */
1868 spin_unlock_irqrestore(&lp->spinlock, flags);
1869
1870 return ret;
1871 }
1872
1873 /*------------------------------------------------------------------*/
1874 /*
1875 * Wireless Handler : set frequency
1876 */
1877 static int wavelan_set_freq(struct net_device *dev,
1878 struct iw_request_info *info,
1879 union iwreq_data *wrqu,
1880 char *extra)
1881 {
1882 unsigned long ioaddr = dev->base_addr;
1883 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
1884 unsigned long flags;
1885 int ret;
1886
1887 /* Disable interrupts and save flags. */
1888 spin_lock_irqsave(&lp->spinlock, flags);
1889
1890 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
1891 if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
1892 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
1893 ret = wv_set_frequency(ioaddr, &(wrqu->freq));
1894 else
1895 ret = -EOPNOTSUPP;
1896
1897 /* Enable interrupts and restore flags. */
1898 spin_unlock_irqrestore(&lp->spinlock, flags);
1899
1900 return ret;
1901 }
1902
1903 /*------------------------------------------------------------------*/
1904 /*
1905 * Wireless Handler : get frequency
1906 */
1907 static int wavelan_get_freq(struct net_device *dev,
1908 struct iw_request_info *info,
1909 union iwreq_data *wrqu,
1910 char *extra)
1911 {
1912 unsigned long ioaddr = dev->base_addr;
1913 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
1914 psa_t psa;
1915 unsigned long flags;
1916 int ret = 0;
1917
1918 /* Disable interrupts and save flags. */
1919 spin_lock_irqsave(&lp->spinlock, flags);
1920
1921 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable).
1922 * Does it work for everybody, especially old cards? */
1923 if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
1924 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
1925 unsigned short freq;
1926
1927 /* Ask the EEPROM to read the frequency from the first area. */
1928 fee_read(ioaddr, 0x00, &freq, 1);
1929 wrqu->freq.m = ((freq >> 5) * 5 + 24000L) * 10000;
1930 wrqu->freq.e = 1;
1931 } else {
1932 psa_read(ioaddr, lp->hacr,
1933 (char *) &psa.psa_subband - (char *) &psa,
1934 (unsigned char *) &psa.psa_subband, 1);
1935
1936 if (psa.psa_subband <= 4) {
1937 wrqu->freq.m = fixed_bands[psa.psa_subband];
1938 wrqu->freq.e = (psa.psa_subband != 0);
1939 } else
1940 ret = -EOPNOTSUPP;
1941 }
1942
1943 /* Enable interrupts and restore flags. */
1944 spin_unlock_irqrestore(&lp->spinlock, flags);
1945
1946 return ret;
1947 }
1948
1949 /*------------------------------------------------------------------*/
1950 /*
1951 * Wireless Handler : set level threshold
1952 */
1953 static int wavelan_set_sens(struct net_device *dev,
1954 struct iw_request_info *info,
1955 union iwreq_data *wrqu,
1956 char *extra)
1957 {
1958 unsigned long ioaddr = dev->base_addr;
1959 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
1960 psa_t psa;
1961 unsigned long flags;
1962 int ret = 0;
1963
1964 /* Disable interrupts and save flags. */
1965 spin_lock_irqsave(&lp->spinlock, flags);
1966
1967 /* Set the level threshold. */
1968 /* We should complain loudly if wrqu->sens.fixed = 0, because we
1969 * can't set auto mode... */
1970 psa.psa_thr_pre_set = wrqu->sens.value & 0x3F;
1971 psa_write(ioaddr, lp->hacr,
1972 (char *) &psa.psa_thr_pre_set - (char *) &psa,
1973 (unsigned char *) &psa.psa_thr_pre_set, 1);
1974 /* update the Wavelan checksum */
1975 update_psa_checksum(dev, ioaddr, lp->hacr);
1976 mmc_out(ioaddr, mmwoff(0, mmw_thr_pre_set),
1977 psa.psa_thr_pre_set);
1978
1979 /* Enable interrupts and restore flags. */
1980 spin_unlock_irqrestore(&lp->spinlock, flags);
1981
1982 return ret;
1983 }
1984
1985 /*------------------------------------------------------------------*/
1986 /*
1987 * Wireless Handler : get level threshold
1988 */
1989 static int wavelan_get_sens(struct net_device *dev,
1990 struct iw_request_info *info,
1991 union iwreq_data *wrqu,
1992 char *extra)
1993 {
1994 unsigned long ioaddr = dev->base_addr;
1995 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
1996 psa_t psa;
1997 unsigned long flags;
1998 int ret = 0;
1999
2000 /* Disable interrupts and save flags. */
2001 spin_lock_irqsave(&lp->spinlock, flags);
2002
2003 /* Read the level threshold. */
2004 psa_read(ioaddr, lp->hacr,
2005 (char *) &psa.psa_thr_pre_set - (char *) &psa,
2006 (unsigned char *) &psa.psa_thr_pre_set, 1);
2007 wrqu->sens.value = psa.psa_thr_pre_set & 0x3F;
2008 wrqu->sens.fixed = 1;
2009
2010 /* Enable interrupts and restore flags. */
2011 spin_unlock_irqrestore(&lp->spinlock, flags);
2012
2013 return ret;
2014 }
2015
2016 /*------------------------------------------------------------------*/
2017 /*
2018 * Wireless Handler : set encryption key
2019 */
2020 static int wavelan_set_encode(struct net_device *dev,
2021 struct iw_request_info *info,
2022 union iwreq_data *wrqu,
2023 char *extra)
2024 {
2025 unsigned long ioaddr = dev->base_addr;
2026 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2027 unsigned long flags;
2028 psa_t psa;
2029 int ret = 0;
2030
2031 /* Disable interrupts and save flags. */
2032 spin_lock_irqsave(&lp->spinlock, flags);
2033
2034 /* Check if capable of encryption */
2035 if (!mmc_encr(ioaddr)) {
2036 ret = -EOPNOTSUPP;
2037 }
2038
2039 /* Check the size of the key */
2040 if((wrqu->encoding.length != 8) && (wrqu->encoding.length != 0)) {
2041 ret = -EINVAL;
2042 }
2043
2044 if(!ret) {
2045 /* Basic checking... */
2046 if (wrqu->encoding.length == 8) {
2047 /* Copy the key in the driver */
2048 memcpy(psa.psa_encryption_key, extra,
2049 wrqu->encoding.length);
2050 psa.psa_encryption_select = 1;
2051
2052 psa_write(ioaddr, lp->hacr,
2053 (char *) &psa.psa_encryption_select -
2054 (char *) &psa,
2055 (unsigned char *) &psa.
2056 psa_encryption_select, 8 + 1);
2057
2058 mmc_out(ioaddr, mmwoff(0, mmw_encr_enable),
2059 MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE);
2060 mmc_write(ioaddr, mmwoff(0, mmw_encr_key),
2061 (unsigned char *) &psa.
2062 psa_encryption_key, 8);
2063 }
2064
2065 /* disable encryption */
2066 if (wrqu->encoding.flags & IW_ENCODE_DISABLED) {
2067 psa.psa_encryption_select = 0;
2068 psa_write(ioaddr, lp->hacr,
2069 (char *) &psa.psa_encryption_select -
2070 (char *) &psa,
2071 (unsigned char *) &psa.
2072 psa_encryption_select, 1);
2073
2074 mmc_out(ioaddr, mmwoff(0, mmw_encr_enable), 0);
2075 }
2076 /* update the Wavelan checksum */
2077 update_psa_checksum(dev, ioaddr, lp->hacr);
2078 }
2079
2080 /* Enable interrupts and restore flags. */
2081 spin_unlock_irqrestore(&lp->spinlock, flags);
2082
2083 return ret;
2084 }
2085
2086 /*------------------------------------------------------------------*/
2087 /*
2088 * Wireless Handler : get encryption key
2089 */
2090 static int wavelan_get_encode(struct net_device *dev,
2091 struct iw_request_info *info,
2092 union iwreq_data *wrqu,
2093 char *extra)
2094 {
2095 unsigned long ioaddr = dev->base_addr;
2096 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2097 psa_t psa;
2098 unsigned long flags;
2099 int ret = 0;
2100
2101 /* Disable interrupts and save flags. */
2102 spin_lock_irqsave(&lp->spinlock, flags);
2103
2104 /* Check if encryption is available */
2105 if (!mmc_encr(ioaddr)) {
2106 ret = -EOPNOTSUPP;
2107 } else {
2108 /* Read the encryption key */
2109 psa_read(ioaddr, lp->hacr,
2110 (char *) &psa.psa_encryption_select -
2111 (char *) &psa,
2112 (unsigned char *) &psa.
2113 psa_encryption_select, 1 + 8);
2114
2115 /* encryption is enabled ? */
2116 if (psa.psa_encryption_select)
2117 wrqu->encoding.flags = IW_ENCODE_ENABLED;
2118 else
2119 wrqu->encoding.flags = IW_ENCODE_DISABLED;
2120 wrqu->encoding.flags |= mmc_encr(ioaddr);
2121
2122 /* Copy the key to the user buffer */
2123 wrqu->encoding.length = 8;
2124 memcpy(extra, psa.psa_encryption_key, wrqu->encoding.length);
2125 }
2126
2127 /* Enable interrupts and restore flags. */
2128 spin_unlock_irqrestore(&lp->spinlock, flags);
2129
2130 return ret;
2131 }
2132
2133 /*------------------------------------------------------------------*/
2134 /*
2135 * Wireless Handler : get range info
2136 */
2137 static int wavelan_get_range(struct net_device *dev,
2138 struct iw_request_info *info,
2139 union iwreq_data *wrqu,
2140 char *extra)
2141 {
2142 unsigned long ioaddr = dev->base_addr;
2143 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2144 struct iw_range *range = (struct iw_range *) extra;
2145 unsigned long flags;
2146 int ret = 0;
2147
2148 /* Set the length (very important for backward compatibility) */
2149 wrqu->data.length = sizeof(struct iw_range);
2150
2151 /* Set all the info we don't care or don't know about to zero */
2152 memset(range, 0, sizeof(struct iw_range));
2153
2154 /* Set the Wireless Extension versions */
2155 range->we_version_compiled = WIRELESS_EXT;
2156 range->we_version_source = 9;
2157
2158 /* Set information in the range struct. */
2159 range->throughput = 1.6 * 1000 * 1000; /* don't argue on this ! */
2160 range->min_nwid = 0x0000;
2161 range->max_nwid = 0xFFFF;
2162
2163 range->sensitivity = 0x3F;
2164 range->max_qual.qual = MMR_SGNL_QUAL;
2165 range->max_qual.level = MMR_SIGNAL_LVL;
2166 range->max_qual.noise = MMR_SILENCE_LVL;
2167 range->avg_qual.qual = MMR_SGNL_QUAL; /* Always max */
2168 /* Need to get better values for those two */
2169 range->avg_qual.level = 30;
2170 range->avg_qual.noise = 8;
2171
2172 range->num_bitrates = 1;
2173 range->bitrate[0] = 2000000; /* 2 Mb/s */
2174
2175 /* Event capability (kernel + driver) */
2176 range->event_capa[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2177 IW_EVENT_CAPA_MASK(0x8B04));
2178 range->event_capa[1] = IW_EVENT_CAPA_K_1;
2179
2180 /* Disable interrupts and save flags. */
2181 spin_lock_irqsave(&lp->spinlock, flags);
2182
2183 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
2184 if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
2185 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
2186 range->num_channels = 10;
2187 range->num_frequency = wv_frequency_list(ioaddr, range->freq,
2188 IW_MAX_FREQUENCIES);
2189 } else
2190 range->num_channels = range->num_frequency = 0;
2191
2192 /* Encryption supported ? */
2193 if (mmc_encr(ioaddr)) {
2194 range->encoding_size[0] = 8; /* DES = 64 bits key */
2195 range->num_encoding_sizes = 1;
2196 range->max_encoding_tokens = 1; /* Only one key possible */
2197 } else {
2198 range->num_encoding_sizes = 0;
2199 range->max_encoding_tokens = 0;
2200 }
2201
2202 /* Enable interrupts and restore flags. */
2203 spin_unlock_irqrestore(&lp->spinlock, flags);
2204
2205 return ret;
2206 }
2207
2208 /*------------------------------------------------------------------*/
2209 /*
2210 * Wireless Private Handler : set quality threshold
2211 */
2212 static int wavelan_set_qthr(struct net_device *dev,
2213 struct iw_request_info *info,
2214 union iwreq_data *wrqu,
2215 char *extra)
2216 {
2217 unsigned long ioaddr = dev->base_addr;
2218 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2219 psa_t psa;
2220 unsigned long flags;
2221
2222 /* Disable interrupts and save flags. */
2223 spin_lock_irqsave(&lp->spinlock, flags);
2224
2225 psa.psa_quality_thr = *(extra) & 0x0F;
2226 psa_write(ioaddr, lp->hacr,
2227 (char *) &psa.psa_quality_thr - (char *) &psa,
2228 (unsigned char *) &psa.psa_quality_thr, 1);
2229 /* update the Wavelan checksum */
2230 update_psa_checksum(dev, ioaddr, lp->hacr);
2231 mmc_out(ioaddr, mmwoff(0, mmw_quality_thr),
2232 psa.psa_quality_thr);
2233
2234 /* Enable interrupts and restore flags. */
2235 spin_unlock_irqrestore(&lp->spinlock, flags);
2236
2237 return 0;
2238 }
2239
2240 /*------------------------------------------------------------------*/
2241 /*
2242 * Wireless Private Handler : get quality threshold
2243 */
2244 static int wavelan_get_qthr(struct net_device *dev,
2245 struct iw_request_info *info,
2246 union iwreq_data *wrqu,
2247 char *extra)
2248 {
2249 unsigned long ioaddr = dev->base_addr;
2250 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2251 psa_t psa;
2252 unsigned long flags;
2253
2254 /* Disable interrupts and save flags. */
2255 spin_lock_irqsave(&lp->spinlock, flags);
2256
2257 psa_read(ioaddr, lp->hacr,
2258 (char *) &psa.psa_quality_thr - (char *) &psa,
2259 (unsigned char *) &psa.psa_quality_thr, 1);
2260 *(extra) = psa.psa_quality_thr & 0x0F;
2261
2262 /* Enable interrupts and restore flags. */
2263 spin_unlock_irqrestore(&lp->spinlock, flags);
2264
2265 return 0;
2266 }
2267
2268 #ifdef HISTOGRAM
2269 /*------------------------------------------------------------------*/
2270 /*
2271 * Wireless Private Handler : set histogram
2272 */
2273 static int wavelan_set_histo(struct net_device *dev,
2274 struct iw_request_info *info,
2275 union iwreq_data *wrqu,
2276 char *extra)
2277 {
2278 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2279
2280 /* Check the number of intervals. */
2281 if (wrqu->data.length > 16) {
2282 return(-E2BIG);
2283 }
2284
2285 /* Disable histo while we copy the addresses.
2286 * As we don't disable interrupts, we need to do this */
2287 lp->his_number = 0;
2288
2289 /* Are there ranges to copy? */
2290 if (wrqu->data.length > 0) {
2291 /* Copy interval ranges to the driver */
2292 memcpy(lp->his_range, extra, wrqu->data.length);
2293
2294 {
2295 int i;
2296 printk(KERN_DEBUG "Histo :");
2297 for(i = 0; i < wrqu->data.length; i++)
2298 printk(" %d", lp->his_range[i]);
2299 printk("\n");
2300 }
2301
2302 /* Reset result structure. */
2303 memset(lp->his_sum, 0x00, sizeof(long) * 16);
2304 }
2305
2306 /* Now we can set the number of ranges */
2307 lp->his_number = wrqu->data.length;
2308
2309 return(0);
2310 }
2311
2312 /*------------------------------------------------------------------*/
2313 /*
2314 * Wireless Private Handler : get histogram
2315 */
2316 static int wavelan_get_histo(struct net_device *dev,
2317 struct iw_request_info *info,
2318 union iwreq_data *wrqu,
2319 char *extra)
2320 {
2321 net_local *lp = (net_local *) dev->priv; /* lp is not unused */
2322
2323 /* Set the number of intervals. */
2324 wrqu->data.length = lp->his_number;
2325
2326 /* Give back the distribution statistics */
2327 if(lp->his_number > 0)
2328 memcpy(extra, lp->his_sum, sizeof(long) * lp->his_number);
2329
2330 return(0);
2331 }
2332 #endif /* HISTOGRAM */
2333
2334 /*------------------------------------------------------------------*/
2335 /*
2336 * Structures to export the Wireless Handlers
2337 */
2338
2339 static const iw_handler wavelan_handler[] =
2340 {
2341 NULL, /* SIOCSIWNAME */
2342 wavelan_get_name, /* SIOCGIWNAME */
2343 wavelan_set_nwid, /* SIOCSIWNWID */
2344 wavelan_get_nwid, /* SIOCGIWNWID */
2345 wavelan_set_freq, /* SIOCSIWFREQ */
2346 wavelan_get_freq, /* SIOCGIWFREQ */
2347 NULL, /* SIOCSIWMODE */
2348 NULL, /* SIOCGIWMODE */
2349 wavelan_set_sens, /* SIOCSIWSENS */
2350 wavelan_get_sens, /* SIOCGIWSENS */
2351 NULL, /* SIOCSIWRANGE */
2352 wavelan_get_range, /* SIOCGIWRANGE */
2353 NULL, /* SIOCSIWPRIV */
2354 NULL, /* SIOCGIWPRIV */
2355 NULL, /* SIOCSIWSTATS */
2356 NULL, /* SIOCGIWSTATS */
2357 iw_handler_set_spy, /* SIOCSIWSPY */
2358 iw_handler_get_spy, /* SIOCGIWSPY */
2359 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
2360 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
2361 NULL, /* SIOCSIWAP */
2362 NULL, /* SIOCGIWAP */
2363 NULL, /* -- hole -- */
2364 NULL, /* SIOCGIWAPLIST */
2365 NULL, /* -- hole -- */
2366 NULL, /* -- hole -- */
2367 NULL, /* SIOCSIWESSID */
2368 NULL, /* SIOCGIWESSID */
2369 NULL, /* SIOCSIWNICKN */
2370 NULL, /* SIOCGIWNICKN */
2371 NULL, /* -- hole -- */
2372 NULL, /* -- hole -- */
2373 NULL, /* SIOCSIWRATE */
2374 NULL, /* SIOCGIWRATE */
2375 NULL, /* SIOCSIWRTS */
2376 NULL, /* SIOCGIWRTS */
2377 NULL, /* SIOCSIWFRAG */
2378 NULL, /* SIOCGIWFRAG */
2379 NULL, /* SIOCSIWTXPOW */
2380 NULL, /* SIOCGIWTXPOW */
2381 NULL, /* SIOCSIWRETRY */
2382 NULL, /* SIOCGIWRETRY */
2383 /* Bummer ! Why those are only at the end ??? */
2384 wavelan_set_encode, /* SIOCSIWENCODE */
2385 wavelan_get_encode, /* SIOCGIWENCODE */
2386 };
2387
2388 static const iw_handler wavelan_private_handler[] =
2389 {
2390 wavelan_set_qthr, /* SIOCIWFIRSTPRIV */
2391 wavelan_get_qthr, /* SIOCIWFIRSTPRIV + 1 */
2392 #ifdef HISTOGRAM
2393 wavelan_set_histo, /* SIOCIWFIRSTPRIV + 2 */
2394 wavelan_get_histo, /* SIOCIWFIRSTPRIV + 3 */
2395 #endif /* HISTOGRAM */
2396 };
2397
2398 static const struct iw_priv_args wavelan_private_args[] = {
2399 /*{ cmd, set_args, get_args, name } */
2400 { SIOCSIPQTHR, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setqualthr" },
2401 { SIOCGIPQTHR, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getqualthr" },
2402 { SIOCSIPHISTO, IW_PRIV_TYPE_BYTE | 16, 0, "sethisto" },
2403 { SIOCGIPHISTO, 0, IW_PRIV_TYPE_INT | 16, "gethisto" },
2404 };
2405
2406 static const struct iw_handler_def wavelan_handler_def =
2407 {
2408 .num_standard = sizeof(wavelan_handler)/sizeof(iw_handler),
2409 .num_private = sizeof(wavelan_private_handler)/sizeof(iw_handler),
2410 .num_private_args = sizeof(wavelan_private_args)/sizeof(struct iw_priv_args),
2411 .standard = wavelan_handler,
2412 .private = wavelan_private_handler,
2413 .private_args = wavelan_private_args,
2414 .get_wireless_stats = wavelan_get_wireless_stats,
2415 };
2416
2417 /*------------------------------------------------------------------*/
2418 /*
2419 * Get wireless statistics.
2420 * Called by /proc/net/wireless
2421 */
2422 static iw_stats *wavelan_get_wireless_stats(struct net_device * dev)
2423 {
2424 unsigned long ioaddr = dev->base_addr;
2425 net_local *lp = (net_local *) dev->priv;
2426 mmr_t m;
2427 iw_stats *wstats;
2428 unsigned long flags;
2429
2430 #ifdef DEBUG_IOCTL_TRACE
2431 printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n",
2432 dev->name);
2433 #endif
2434
2435 /* Check */
2436 if (lp == (net_local *) NULL)
2437 return (iw_stats *) NULL;
2438
2439 /* Disable interrupts and save flags. */
2440 spin_lock_irqsave(&lp->spinlock, flags);
2441
2442 wstats = &lp->wstats;
2443
2444 /* Get data from the mmc. */
2445 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
2446
2447 mmc_read(ioaddr, mmroff(0, mmr_dce_status), &m.mmr_dce_status, 1);
2448 mmc_read(ioaddr, mmroff(0, mmr_wrong_nwid_l), &m.mmr_wrong_nwid_l,
2449 2);
2450 mmc_read(ioaddr, mmroff(0, mmr_thr_pre_set), &m.mmr_thr_pre_set,
2451 4);
2452
2453 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
2454
2455 /* Copy data to wireless stuff. */
2456 wstats->status = m.mmr_dce_status & MMR_DCE_STATUS;
2457 wstats->qual.qual = m.mmr_sgnl_qual & MMR_SGNL_QUAL;
2458 wstats->qual.level = m.mmr_signal_lvl & MMR_SIGNAL_LVL;
2459 wstats->qual.noise = m.mmr_silence_lvl & MMR_SILENCE_LVL;
2460 wstats->qual.updated = (((m. mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 7)
2461 | ((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 6)
2462 | ((m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) >> 5));
2463 wstats->discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
2464 wstats->discard.code = 0L;
2465 wstats->discard.misc = 0L;
2466
2467 /* Enable interrupts and restore flags. */
2468 spin_unlock_irqrestore(&lp->spinlock, flags);
2469
2470 #ifdef DEBUG_IOCTL_TRACE
2471 printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n",
2472 dev->name);
2473 #endif
2474 return &lp->wstats;
2475 }
2476 #endif /* WIRELESS_EXT */
2477
2478 /************************* PACKET RECEPTION *************************/
2479 /*
2480 * This part deals with receiving the packets.
2481 * The interrupt handler gets an interrupt when a packet has been
2482 * successfully received and calls this part.
2483 */
2484
2485 /*------------------------------------------------------------------*/
2486 /*
2487 * This routine does the actual copying of data (including the Ethernet
2488 * header structure) from the WaveLAN card to an sk_buff chain that
2489 * will be passed up to the network interface layer. NOTE: we
2490 * currently don't handle trailer protocols (neither does the rest of
2491 * the network interface), so if that is needed, it will (at least in
2492 * part) be added here. The contents of the receive ring buffer are
2493 * copied to a message chain that is then passed to the kernel.
2494 *
2495 * Note: if any errors occur, the packet is "dropped on the floor".
2496 * (called by wv_packet_rcv())
2497 */
2498 static inline void
2499 wv_packet_read(struct net_device * dev, u16 buf_off, int sksize)
2500 {
2501 net_local *lp = (net_local *) dev->priv;
2502 unsigned long ioaddr = dev->base_addr;
2503 struct sk_buff *skb;
2504
2505 #ifdef DEBUG_RX_TRACE
2506 printk(KERN_DEBUG "%s: ->wv_packet_read(0x%X, %d)\n",
2507 dev->name, buf_off, sksize);
2508 #endif
2509
2510 /* Allocate buffer for the data */
2511 if ((skb = dev_alloc_skb(sksize)) == (struct sk_buff *) NULL) {
2512 #ifdef DEBUG_RX_ERROR
2513 printk(KERN_INFO
2514 "%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC).\n",
2515 dev->name, sksize);
2516 #endif
2517 lp->stats.rx_dropped++;
2518 return;
2519 }
2520
2521 skb->dev = dev;
2522
2523 /* Copy the packet to the buffer. */
2524 obram_read(ioaddr, buf_off, skb_put(skb, sksize), sksize);
2525 skb->protocol = eth_type_trans(skb, dev);
2526
2527 #ifdef DEBUG_RX_INFO
2528 wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read");
2529 #endif /* DEBUG_RX_INFO */
2530
2531 /* Statistics-gathering and associated stuff.
2532 * It seem a bit messy with all the define, but it's really
2533 * simple... */
2534 if (
2535 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
2536 (lp->spy_data.spy_number > 0) ||
2537 #endif /* IW_WIRELESS_SPY */
2538 #ifdef HISTOGRAM
2539 (lp->his_number > 0) ||
2540 #endif /* HISTOGRAM */
2541 0) {
2542 u8 stats[3]; /* signal level, noise level, signal quality */
2543
2544 /* Read signal level, silence level and signal quality bytes */
2545 /* Note: in the PCMCIA hardware, these are part of the frame.
2546 * It seems that for the ISA hardware, it's nowhere to be
2547 * found in the frame, so I'm obliged to do this (it has a
2548 * side effect on /proc/net/wireless).
2549 * Any ideas?
2550 */
2551 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
2552 mmc_read(ioaddr, mmroff(0, mmr_signal_lvl), stats, 3);
2553 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
2554
2555 #ifdef DEBUG_RX_INFO
2556 printk(KERN_DEBUG
2557 "%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2558 dev->name, stats[0] & 0x3F, stats[1] & 0x3F,
2559 stats[2] & 0x0F);
2560 #endif
2561
2562 /* Spying stuff */
2563 #ifdef IW_WIRELESS_SPY
2564 wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE,
2565 stats);
2566 #endif /* IW_WIRELESS_SPY */
2567 #ifdef HISTOGRAM
2568 wl_his_gather(dev, stats);
2569 #endif /* HISTOGRAM */
2570 }
2571
2572 /*
2573 * Hand the packet to the network module.
2574 */
2575 netif_rx(skb);
2576
2577 /* Keep statistics up to date */
2578 dev->last_rx = jiffies;
2579 lp->stats.rx_packets++;
2580 lp->stats.rx_bytes += sksize;
2581
2582 #ifdef DEBUG_RX_TRACE
2583 printk(KERN_DEBUG "%s: <-wv_packet_read()\n", dev->name);
2584 #endif
2585 }
2586
2587 /*------------------------------------------------------------------*/
2588 /*
2589 * Transfer as many packets as we can
2590 * from the device RAM.
2591 * (called in wavelan_interrupt()).
2592 * Note : the spinlock is already grabbed for us.
2593 */
2594 static inline void wv_receive(struct net_device * dev)
2595 {
2596 unsigned long ioaddr = dev->base_addr;
2597 net_local *lp = (net_local *) dev->priv;
2598 fd_t fd;
2599 rbd_t rbd;
2600 int nreaped = 0;
2601
2602 #ifdef DEBUG_RX_TRACE
2603 printk(KERN_DEBUG "%s: ->wv_receive()\n", dev->name);
2604 #endif
2605
2606 /* Loop on each received packet. */
2607 for (;;) {
2608 obram_read(ioaddr, lp->rx_head, (unsigned char *) &fd,
2609 sizeof(fd));
2610
2611 /* Note about the status :
2612 * It start up to be 0 (the value we set). Then, when the RU
2613 * grab the buffer to prepare for reception, it sets the
2614 * FD_STATUS_B flag. When the RU has finished receiving the
2615 * frame, it clears FD_STATUS_B, set FD_STATUS_C to indicate
2616 * completion and set the other flags to indicate the eventual
2617 * errors. FD_STATUS_OK indicates that the reception was OK.
2618 */
2619
2620 /* If the current frame is not complete, we have reached the end. */
2621 if ((fd.fd_status & FD_STATUS_C) != FD_STATUS_C)
2622 break; /* This is how we exit the loop. */
2623
2624 nreaped++;
2625
2626 /* Check whether frame was correctly received. */
2627 if ((fd.fd_status & FD_STATUS_OK) == FD_STATUS_OK) {
2628 /* Does the frame contain a pointer to the data? Let's check. */
2629 if (fd.fd_rbd_offset != I82586NULL) {
2630 /* Read the receive buffer descriptor */
2631 obram_read(ioaddr, fd.fd_rbd_offset,
2632 (unsigned char *) &rbd,
2633 sizeof(rbd));
2634
2635 #ifdef DEBUG_RX_ERROR
2636 if ((rbd.rbd_status & RBD_STATUS_EOF) !=
2637 RBD_STATUS_EOF) printk(KERN_INFO
2638 "%s: wv_receive(): missing EOF flag.\n",
2639 dev->name);
2640
2641 if ((rbd.rbd_status & RBD_STATUS_F) !=
2642 RBD_STATUS_F) printk(KERN_INFO
2643 "%s: wv_receive(): missing F flag.\n",
2644 dev->name);
2645 #endif /* DEBUG_RX_ERROR */
2646
2647 /* Read the packet and transmit to Linux */
2648 wv_packet_read(dev, rbd.rbd_bufl,
2649 rbd.
2650 rbd_status &
2651 RBD_STATUS_ACNT);
2652 }
2653 #ifdef DEBUG_RX_ERROR
2654 else /* if frame has no data */
2655 printk(KERN_INFO
2656 "%s: wv_receive(): frame has no data.\n",
2657 dev->name);
2658 #endif
2659 } else { /* If reception was no successful */
2660
2661 lp->stats.rx_errors++;
2662
2663 #ifdef DEBUG_RX_INFO
2664 printk(KERN_DEBUG
2665 "%s: wv_receive(): frame not received successfully (%X).\n",
2666 dev->name, fd.fd_status);
2667 #endif
2668
2669 #ifdef DEBUG_RX_ERROR
2670 if ((fd.fd_status & FD_STATUS_S6) != 0)
2671 printk(KERN_INFO
2672 "%s: wv_receive(): no EOF flag.\n",
2673 dev->name);
2674 #endif
2675
2676 if ((fd.fd_status & FD_STATUS_S7) != 0) {
2677 lp->stats.rx_length_errors++;
2678 #ifdef DEBUG_RX_FAIL
2679 printk(KERN_DEBUG
2680 "%s: wv_receive(): frame too short.\n",
2681 dev->name);
2682 #endif
2683 }
2684
2685 if ((fd.fd_status & FD_STATUS_S8) != 0) {
2686 lp->stats.rx_over_errors++;
2687 #ifdef DEBUG_RX_FAIL
2688 printk(KERN_DEBUG
2689 "%s: wv_receive(): rx DMA overrun.\n",
2690 dev->name);
2691 #endif
2692 }
2693
2694 if ((fd.fd_status & FD_STATUS_S9) != 0) {
2695 lp->stats.rx_fifo_errors++;
2696 #ifdef DEBUG_RX_FAIL
2697 printk(KERN_DEBUG
2698 "%s: wv_receive(): ran out of resources.\n",
2699 dev->name);
2700 #endif
2701 }
2702
2703 if ((fd.fd_status & FD_STATUS_S10) != 0) {
2704 lp->stats.rx_frame_errors++;
2705 #ifdef DEBUG_RX_FAIL
2706 printk(KERN_DEBUG
2707 "%s: wv_receive(): alignment error.\n",
2708 dev->name);
2709 #endif
2710 }
2711
2712 if ((fd.fd_status & FD_STATUS_S11) != 0) {
2713 lp->stats.rx_crc_errors++;
2714 #ifdef DEBUG_RX_FAIL
2715 printk(KERN_DEBUG
2716 "%s: wv_receive(): CRC error.\n",
2717 dev->name);
2718 #endif
2719 }
2720 }
2721
2722 fd.fd_status = 0;
2723 obram_write(ioaddr, fdoff(lp->rx_head, fd_status),
2724 (unsigned char *) &fd.fd_status,
2725 sizeof(fd.fd_status));
2726
2727 fd.fd_command = FD_COMMAND_EL;
2728 obram_write(ioaddr, fdoff(lp->rx_head, fd_command),
2729 (unsigned char *) &fd.fd_command,
2730 sizeof(fd.fd_command));
2731
2732 fd.fd_command = 0;
2733 obram_write(ioaddr, fdoff(lp->rx_last, fd_command),
2734 (unsigned char *) &fd.fd_command,
2735 sizeof(fd.fd_command));
2736
2737 lp->rx_last = lp->rx_head;
2738 lp->rx_head = fd.fd_link_offset;
2739 } /* for(;;) -> loop on all frames */
2740
2741 #ifdef DEBUG_RX_INFO
2742 if (nreaped > 1)
2743 printk(KERN_DEBUG "%s: wv_receive(): reaped %d\n",
2744 dev->name, nreaped);
2745 #endif
2746 #ifdef DEBUG_RX_TRACE
2747 printk(KERN_DEBUG "%s: <-wv_receive()\n", dev->name);
2748 #endif
2749 }
2750
2751 /*********************** PACKET TRANSMISSION ***********************/
2752 /*
2753 * This part deals with sending packets through the WaveLAN.
2754 *
2755 */
2756
2757 /*------------------------------------------------------------------*/
2758 /*
2759 * This routine fills in the appropriate registers and memory
2760 * locations on the WaveLAN card and starts the card off on
2761 * the transmit.
2762 *
2763 * The principle:
2764 * Each block contains a transmit command, a NOP command,
2765 * a transmit block descriptor and a buffer.
2766 * The CU read the transmit block which point to the tbd,
2767 * read the tbd and the content of the buffer.
2768 * When it has finish with it, it goes to the next command
2769 * which in our case is the NOP. The NOP points on itself,
2770 * so the CU stop here.
2771 * When we add the next block, we modify the previous nop
2772 * to make it point on the new tx command.
2773 * Simple, isn't it ?
2774 *
2775 * (called in wavelan_packet_xmit())
2776 */
2777 static inline int wv_packet_write(struct net_device * dev, void *buf, short length)
2778 {
2779 net_local *lp = (net_local *) dev->priv;
2780 unsigned long ioaddr = dev->base_addr;
2781 unsigned short txblock;
2782 unsigned short txpred;
2783 unsigned short tx_addr;
2784 unsigned short nop_addr;
2785 unsigned short tbd_addr;
2786 unsigned short buf_addr;
2787 ac_tx_t tx;
2788 ac_nop_t nop;
2789 tbd_t tbd;
2790 int clen = length;
2791 unsigned long flags;
2792
2793 #ifdef DEBUG_TX_TRACE
2794 printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name,
2795 length);
2796 #endif
2797
2798 spin_lock_irqsave(&lp->spinlock, flags);
2799
2800 /* Check nothing bad has happened */
2801 if (lp->tx_n_in_use == (NTXBLOCKS - 1)) {
2802 #ifdef DEBUG_TX_ERROR
2803 printk(KERN_INFO "%s: wv_packet_write(): Tx queue full.\n",
2804 dev->name);
2805 #endif
2806 spin_unlock_irqrestore(&lp->spinlock, flags);
2807 return 1;
2808 }
2809
2810 /* Calculate addresses of next block and previous block. */
2811 txblock = lp->tx_first_free;
2812 txpred = txblock - TXBLOCKZ;
2813 if (txpred < OFFSET_CU)
2814 txpred += NTXBLOCKS * TXBLOCKZ;
2815 lp->tx_first_free += TXBLOCKZ;
2816 if (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
2817 lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
2818
2819 lp->tx_n_in_use++;
2820
2821 /* Calculate addresses of the different parts of the block. */
2822 tx_addr = txblock;
2823 nop_addr = tx_addr + sizeof(tx);
2824 tbd_addr = nop_addr + sizeof(nop);
2825 buf_addr = tbd_addr + sizeof(tbd);
2826
2827 /*
2828 * Transmit command
2829 */
2830 tx.tx_h.ac_status = 0;
2831 obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status),
2832 (unsigned char *) &tx.tx_h.ac_status,
2833 sizeof(tx.tx_h.ac_status));
2834
2835 /*
2836 * NOP command
2837 */
2838 nop.nop_h.ac_status = 0;
2839 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
2840 (unsigned char *) &nop.nop_h.ac_status,
2841 sizeof(nop.nop_h.ac_status));
2842 nop.nop_h.ac_link = nop_addr;
2843 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
2844 (unsigned char *) &nop.nop_h.ac_link,
2845 sizeof(nop.nop_h.ac_link));
2846
2847 /*
2848 * Transmit buffer descriptor
2849 */
2850 tbd.tbd_status = TBD_STATUS_EOF | (TBD_STATUS_ACNT & clen);
2851 tbd.tbd_next_bd_offset = I82586NULL;
2852 tbd.tbd_bufl = buf_addr;
2853 tbd.tbd_bufh = 0;
2854 obram_write(ioaddr, tbd_addr, (unsigned char *) &tbd, sizeof(tbd));
2855
2856 /*
2857 * Data
2858 */
2859 obram_write(ioaddr, buf_addr, buf, length);
2860
2861 /*
2862 * Overwrite the predecessor NOP link
2863 * so that it points to this txblock.
2864 */
2865 nop_addr = txpred + sizeof(tx);
2866 nop.nop_h.ac_status = 0;
2867 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
2868 (unsigned char *) &nop.nop_h.ac_status,
2869 sizeof(nop.nop_h.ac_status));
2870 nop.nop_h.ac_link = txblock;
2871 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
2872 (unsigned char *) &nop.nop_h.ac_link,
2873 sizeof(nop.nop_h.ac_link));
2874
2875 /* Make sure the watchdog will keep quiet for a while */
2876 dev->trans_start = jiffies;
2877
2878 /* Keep stats up to date. */
2879 lp->stats.tx_bytes += length;
2880
2881 if (lp->tx_first_in_use == I82586NULL)
2882 lp->tx_first_in_use = txblock;
2883
2884 if (lp->tx_n_in_use < NTXBLOCKS - 1)
2885 netif_wake_queue(dev);
2886
2887 spin_unlock_irqrestore(&lp->spinlock, flags);
2888
2889 #ifdef DEBUG_TX_INFO
2890 wv_packet_info((u8 *) buf, length, dev->name,
2891 "wv_packet_write");
2892 #endif /* DEBUG_TX_INFO */
2893
2894 #ifdef DEBUG_TX_TRACE
2895 printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name);
2896 #endif
2897
2898 return 0;
2899 }
2900
2901 /*------------------------------------------------------------------*/
2902 /*
2903 * This routine is called when we want to send a packet (NET3 callback)
2904 * In this routine, we check if the harware is ready to accept
2905 * the packet. We also prevent reentrance. Then we call the function
2906 * to send the packet.
2907 */
2908 static int wavelan_packet_xmit(struct sk_buff *skb, struct net_device * dev)
2909 {
2910 net_local *lp = (net_local *) dev->priv;
2911 unsigned long flags;
2912
2913 #ifdef DEBUG_TX_TRACE
2914 printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
2915 (unsigned) skb);
2916 #endif
2917
2918 /*
2919 * Block a timer-based transmit from overlapping.
2920 * In other words, prevent reentering this routine.
2921 */
2922 netif_stop_queue(dev);
2923
2924 /* If somebody has asked to reconfigure the controller,
2925 * we can do it now.
2926 */
2927 if (lp->reconfig_82586) {
2928 spin_lock_irqsave(&lp->spinlock, flags);
2929 wv_82586_config(dev);
2930 spin_unlock_irqrestore(&lp->spinlock, flags);
2931 /* Check that we can continue */
2932 if (lp->tx_n_in_use == (NTXBLOCKS - 1))
2933 return 1;
2934 }
2935 #ifdef DEBUG_TX_ERROR
2936 if (skb->next)
2937 printk(KERN_INFO "skb has next\n");
2938 #endif
2939
2940 /* Do we need some padding? */
2941 /* Note : on wireless the propagation time is in the order of 1us,
2942 * and we don't have the Ethernet specific requirement of beeing
2943 * able to detect collisions, therefore in theory we don't really
2944 * need to pad. Jean II */
2945 if (skb->len < ETH_ZLEN) {
2946 skb = skb_padto(skb, ETH_ZLEN);
2947 if (skb == NULL)
2948 return 0;
2949 }
2950
2951 /* Write packet on the card */
2952 if(wv_packet_write(dev, skb->data, skb->len))
2953 return 1; /* We failed */
2954
2955 dev_kfree_skb(skb);
2956
2957 #ifdef DEBUG_TX_TRACE
2958 printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
2959 #endif
2960 return 0;
2961 }
2962
2963 /*********************** HARDWARE CONFIGURATION ***********************/
2964 /*
2965 * This part does the real job of starting and configuring the hardware.
2966 */
2967
2968 /*--------------------------------------------------------------------*/
2969 /*
2970 * Routine to initialize the Modem Management Controller.
2971 * (called by wv_hw_reset())
2972 */
2973 static inline int wv_mmc_init(struct net_device * dev)
2974 {
2975 unsigned long ioaddr = dev->base_addr;
2976 net_local *lp = (net_local *) dev->priv;
2977 psa_t psa;
2978 mmw_t m;
2979 int configured;
2980
2981 #ifdef DEBUG_CONFIG_TRACE
2982 printk(KERN_DEBUG "%s: ->wv_mmc_init()\n", dev->name);
2983 #endif
2984
2985 /* Read the parameter storage area. */
2986 psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa));
2987
2988 #ifdef USE_PSA_CONFIG
2989 configured = psa.psa_conf_status & 1;
2990 #else
2991 configured = 0;
2992 #endif
2993
2994 /* Is the PSA is not configured */
2995 if (!configured) {
2996 /* User will be able to configure NWID later (with iwconfig). */
2997 psa.psa_nwid[0] = 0;
2998 psa.psa_nwid[1] = 0;
2999
3000 /* no NWID checking since NWID is not set */
3001 psa.psa_nwid_select = 0;
3002
3003 /* Disable encryption */
3004 psa.psa_encryption_select = 0;
3005
3006 /* Set to standard values:
3007 * 0x04 for AT,
3008 * 0x01 for MCA,
3009 * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
3010 */
3011 if (psa.psa_comp_number & 1)
3012 psa.psa_thr_pre_set = 0x01;
3013 else
3014 psa.psa_thr_pre_set = 0x04;
3015 psa.psa_quality_thr = 0x03;
3016
3017 /* It is configured */
3018 psa.psa_conf_status |= 1;
3019
3020 #ifdef USE_PSA_CONFIG
3021 /* Write the psa. */
3022 psa_write(ioaddr, lp->hacr,
3023 (char *) psa.psa_nwid - (char *) &psa,
3024 (unsigned char *) psa.psa_nwid, 4);
3025 psa_write(ioaddr, lp->hacr,
3026 (char *) &psa.psa_thr_pre_set - (char *) &psa,
3027 (unsigned char *) &psa.psa_thr_pre_set, 1);
3028 psa_write(ioaddr, lp->hacr,
3029 (char *) &psa.psa_quality_thr - (char *) &psa,
3030 (unsigned char *) &psa.psa_quality_thr, 1);
3031 psa_write(ioaddr, lp->hacr,
3032 (char *) &psa.psa_conf_status - (char *) &psa,
3033 (unsigned char *) &psa.psa_conf_status, 1);
3034 /* update the Wavelan checksum */
3035 update_psa_checksum(dev, ioaddr, lp->hacr);
3036 #endif
3037 }
3038
3039 /* Zero the mmc structure. */
3040 memset(&m, 0x00, sizeof(m));
3041
3042 /* Copy PSA info to the mmc. */
3043 m.mmw_netw_id_l = psa.psa_nwid[1];
3044 m.mmw_netw_id_h = psa.psa_nwid[0];
3045
3046 if (psa.psa_nwid_select & 1)
3047 m.mmw_loopt_sel = 0x00;
3048 else
3049 m.mmw_loopt_sel = MMW_LOOPT_SEL_DIS_NWID;
3050
3051 memcpy(&m.mmw_encr_key, &psa.psa_encryption_key,
3052 sizeof(m.mmw_encr_key));
3053
3054 if (psa.psa_encryption_select)
3055 m.mmw_encr_enable =
3056 MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE;
3057 else
3058 m.mmw_encr_enable = 0;
3059
3060 m.mmw_thr_pre_set = psa.psa_thr_pre_set & 0x3F;
3061 m.mmw_quality_thr = psa.psa_quality_thr & 0x0F;
3062
3063 /*
3064 * Set default modem control parameters.
3065 * See NCR document 407-0024326 Rev. A.
3066 */
3067 m.mmw_jabber_enable = 0x01;
3068 m.mmw_freeze = 0;
3069 m.mmw_anten_sel = MMW_ANTEN_SEL_ALG_EN;
3070 m.mmw_ifs = 0x20;
3071 m.mmw_mod_delay = 0x04;
3072 m.mmw_jam_time = 0x38;
3073
3074 m.mmw_des_io_invert = 0;
3075 m.mmw_decay_prm = 0;
3076 m.mmw_decay_updat_prm = 0;
3077
3078 /* Write all info to MMC. */
3079 mmc_write(ioaddr, 0, (u8 *) & m, sizeof(m));
3080
3081 /* The following code starts the modem of the 2.00 frequency
3082 * selectable cards at power on. It's not strictly needed for the
3083 * following boots.
3084 * The original patch was by Joe Finney for the PCMCIA driver, but
3085 * I've cleaned it up a bit and added documentation.
3086 * Thanks to Loeke Brederveld from Lucent for the info.
3087 */
3088
3089 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
3090 * Does it work for everybody, especially old cards? */
3091 /* Note: WFREQSEL verifies that it is able to read a sensible
3092 * frequency from EEPROM (address 0x00) and that MMR_FEE_STATUS_ID
3093 * is 0xA (Xilinx version) or 0xB (Ariadne version).
3094 * My test is more crude but does work. */
3095 if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
3096 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
3097 /* We must download the frequency parameters to the
3098 * synthesizers (from the EEPROM - area 1)
3099 * Note: as the EEPROM is automatically decremented, we set the end
3100 * if the area... */
3101 m.mmw_fee_addr = 0x0F;
3102 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3103 mmc_write(ioaddr, (char *) &m.mmw_fee_ctrl - (char *) &m,
3104 (unsigned char *) &m.mmw_fee_ctrl, 2);
3105
3106 /* Wait until the download is finished. */
3107 fee_wait(ioaddr, 100, 100);
3108
3109 #ifdef DEBUG_CONFIG_INFO
3110 /* The frequency was in the last word downloaded. */
3111 mmc_read(ioaddr, (char *) &m.mmw_fee_data_l - (char *) &m,
3112 (unsigned char *) &m.mmw_fee_data_l, 2);
3113
3114 /* Print some info for the user. */
3115 printk(KERN_DEBUG
3116 "%s: WaveLAN 2.00 recognised (frequency select). Current frequency = %ld\n",
3117 dev->name,
3118 ((m.
3119 mmw_fee_data_h << 4) | (m.mmw_fee_data_l >> 4)) *
3120 5 / 2 + 24000L);
3121 #endif
3122
3123 /* We must now download the power adjust value (gain) to
3124 * the synthesizers (from the EEPROM - area 7 - DAC). */
3125 m.mmw_fee_addr = 0x61;
3126 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3127 mmc_write(ioaddr, (char *) &m.mmw_fee_ctrl - (char *) &m,
3128 (unsigned char *) &m.mmw_fee_ctrl, 2);
3129
3130 /* Wait until the download is finished. */
3131 }
3132 /* if 2.00 card */
3133 #ifdef DEBUG_CONFIG_TRACE
3134 printk(KERN_DEBUG "%s: <-wv_mmc_init()\n", dev->name);
3135 #endif
3136 return 0;
3137 }
3138
3139 /*------------------------------------------------------------------*/
3140 /*
3141 * Construct the fd and rbd structures.
3142 * Start the receive unit.
3143 * (called by wv_hw_reset())
3144 */
3145 static inline int wv_ru_start(struct net_device * dev)
3146 {
3147 net_local *lp = (net_local *) dev->priv;
3148 unsigned long ioaddr = dev->base_addr;
3149 u16 scb_cs;
3150 fd_t fd;
3151 rbd_t rbd;
3152 u16 rx;
3153 u16 rx_next;
3154 int i;
3155
3156 #ifdef DEBUG_CONFIG_TRACE
3157 printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name);
3158 #endif
3159
3160 obram_read(ioaddr, scboff(OFFSET_SCB, scb_status),
3161 (unsigned char *) &scb_cs, sizeof(scb_cs));
3162 if ((scb_cs & SCB_ST_RUS) == SCB_ST_RUS_RDY)
3163 return 0;
3164
3165 lp->rx_head = OFFSET_RU;
3166
3167 for (i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next) {
3168 rx_next =
3169 (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
3170
3171 fd.fd_status = 0;
3172 fd.fd_command = (i == NRXBLOCKS - 1) ? FD_COMMAND_EL : 0;
3173 fd.fd_link_offset = rx_next;
3174 fd.fd_rbd_offset = rx + sizeof(fd);
3175 obram_write(ioaddr, rx, (unsigned char *) &fd, sizeof(fd));
3176
3177 rbd.rbd_status = 0;
3178 rbd.rbd_next_rbd_offset = I82586NULL;
3179 rbd.rbd_bufl = rx + sizeof(fd) + sizeof(rbd);
3180 rbd.rbd_bufh = 0;
3181 rbd.rbd_el_size = RBD_EL | (RBD_SIZE & MAXDATAZ);
3182 obram_write(ioaddr, rx + sizeof(fd),
3183 (unsigned char *) &rbd, sizeof(rbd));
3184
3185 lp->rx_last = rx;
3186 }
3187
3188 obram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset),
3189 (unsigned char *) &lp->rx_head, sizeof(lp->rx_head));
3190
3191 scb_cs = SCB_CMD_RUC_GO;
3192 obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3193 (unsigned char *) &scb_cs, sizeof(scb_cs));
3194
3195 set_chan_attn(ioaddr, lp->hacr);
3196
3197 for (i = 1000; i > 0; i--) {
3198 obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
3199 (unsigned char *) &scb_cs, sizeof(scb_cs));
3200 if (scb_cs == 0)
3201 break;
3202
3203 udelay(10);
3204 }
3205
3206 if (i <= 0) {
3207 #ifdef DEBUG_CONFIG_ERROR
3208 printk(KERN_INFO
3209 "%s: wavelan_ru_start(): board not accepting command.\n",
3210 dev->name);
3211 #endif
3212 return -1;
3213 }
3214 #ifdef DEBUG_CONFIG_TRACE
3215 printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name);
3216 #endif
3217 return 0;
3218 }
3219
3220 /*------------------------------------------------------------------*/
3221 /*
3222 * Initialise the transmit blocks.
3223 * Start the command unit executing the NOP
3224 * self-loop of the first transmit block.
3225 *
3226 * Here we create the list of send buffers used to transmit packets
3227 * between the PC and the command unit. For each buffer, we create a
3228 * buffer descriptor (pointing on the buffer), a transmit command
3229 * (pointing to the buffer descriptor) and a NOP command.
3230 * The transmit command is linked to the NOP, and the NOP to itself.
3231 * When we will have finished executing the transmit command, we will
3232 * then loop on the NOP. By releasing the NOP link to a new command,
3233 * we may send another buffer.
3234 *
3235 * (called by wv_hw_reset())
3236 */
3237 static inline int wv_cu_start(struct net_device * dev)
3238 {
3239 net_local *lp = (net_local *) dev->priv;
3240 unsigned long ioaddr = dev->base_addr;
3241 int i;
3242 u16 txblock;
3243 u16 first_nop;
3244 u16 scb_cs;
3245
3246 #ifdef DEBUG_CONFIG_TRACE
3247 printk(KERN_DEBUG "%s: ->wv_cu_start()\n", dev->name);
3248 #endif
3249
3250 lp->tx_first_free = OFFSET_CU;
3251 lp->tx_first_in_use = I82586NULL;
3252
3253 for (i = 0, txblock = OFFSET_CU;
3254 i < NTXBLOCKS; i++, txblock += TXBLOCKZ) {
3255 ac_tx_t tx;
3256 ac_nop_t nop;
3257 tbd_t tbd;
3258 unsigned short tx_addr;
3259 unsigned short nop_addr;
3260 unsigned short tbd_addr;
3261 unsigned short buf_addr;
3262
3263 tx_addr = txblock;
3264 nop_addr = tx_addr + sizeof(tx);
3265 tbd_addr = nop_addr + sizeof(nop);
3266 buf_addr = tbd_addr + sizeof(tbd);
3267
3268 tx.tx_h.ac_status = 0;
3269 tx.tx_h.ac_command = acmd_transmit | AC_CFLD_I;
3270 tx.tx_h.ac_link = nop_addr;
3271 tx.tx_tbd_offset = tbd_addr;
3272 obram_write(ioaddr, tx_addr, (unsigned char *) &tx,
3273 sizeof(tx));
3274
3275 nop.nop_h.ac_status = 0;
3276 nop.nop_h.ac_command = acmd_nop;
3277 nop.nop_h.ac_link = nop_addr;
3278 obram_write(ioaddr, nop_addr, (unsigned char *) &nop,
3279 sizeof(nop));
3280
3281 tbd.tbd_status = TBD_STATUS_EOF;
3282 tbd.tbd_next_bd_offset = I82586NULL;
3283 tbd.tbd_bufl = buf_addr;
3284 tbd.tbd_bufh = 0;
3285 obram_write(ioaddr, tbd_addr, (unsigned char *) &tbd,
3286 sizeof(tbd));
3287 }
3288
3289 first_nop =
3290 OFFSET_CU + (NTXBLOCKS - 1) * TXBLOCKZ + sizeof(ac_tx_t);
3291 obram_write(ioaddr, scboff(OFFSET_SCB, scb_cbl_offset),
3292 (unsigned char *) &first_nop, sizeof(first_nop));
3293
3294 scb_cs = SCB_CMD_CUC_GO;
3295 obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3296 (unsigned char *) &scb_cs, sizeof(scb_cs));
3297
3298 set_chan_attn(ioaddr, lp->hacr);
3299
3300 for (i = 1000; i > 0; i--) {
3301 obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
3302 (unsigned char *) &scb_cs, sizeof(scb_cs));
3303 if (scb_cs == 0)
3304 break;
3305
3306 udelay(10);
3307 }
3308
3309 if (i <= 0) {
3310 #ifdef DEBUG_CONFIG_ERROR
3311 printk(KERN_INFO
3312 "%s: wavelan_cu_start(): board not accepting command.\n",
3313 dev->name);
3314 #endif
3315 return -1;
3316 }
3317
3318 lp->tx_n_in_use = 0;
3319 netif_start_queue(dev);
3320 #ifdef DEBUG_CONFIG_TRACE
3321 printk(KERN_DEBUG "%s: <-wv_cu_start()\n", dev->name);
3322 #endif
3323 return 0;
3324 }
3325
3326 /*------------------------------------------------------------------*/
3327 /*
3328 * This routine does a standard configuration of the WaveLAN
3329 * controller (i82586).
3330 *
3331 * It initialises the scp, iscp and scb structure
3332 * The first two are just pointers to the next.
3333 * The last one is used for basic configuration and for basic
3334 * communication (interrupt status).
3335 *
3336 * (called by wv_hw_reset())
3337 */
3338 static inline int wv_82586_start(struct net_device * dev)
3339 {
3340 net_local *lp = (net_local *) dev->priv;
3341 unsigned long ioaddr = dev->base_addr;
3342 scp_t scp; /* system configuration pointer */
3343 iscp_t iscp; /* intermediate scp */
3344 scb_t scb; /* system control block */
3345 ach_t cb; /* Action command header */
3346 u8 zeroes[512];
3347 int i;
3348
3349 #ifdef DEBUG_CONFIG_TRACE
3350 printk(KERN_DEBUG "%s: ->wv_82586_start()\n", dev->name);
3351 #endif
3352
3353 /*
3354 * Clear the onboard RAM.
3355 */
3356 memset(&zeroes[0], 0x00, sizeof(zeroes));
3357 for (i = 0; i < I82586_MEMZ; i += sizeof(zeroes))
3358 obram_write(ioaddr, i, &zeroes[0], sizeof(zeroes));
3359
3360 /*
3361 * Construct the command unit structures:
3362 * scp, iscp, scb, cb.
3363 */
3364 memset(&scp, 0x00, sizeof(scp));
3365 scp.scp_sysbus = SCP_SY_16BBUS;
3366 scp.scp_iscpl = OFFSET_ISCP;
3367 obram_write(ioaddr, OFFSET_SCP, (unsigned char *) &scp,
3368 sizeof(scp));
3369
3370 memset(&iscp, 0x00, sizeof(iscp));
3371 iscp.iscp_busy = 1;
3372 iscp.iscp_offset = OFFSET_SCB;
3373 obram_write(ioaddr, OFFSET_ISCP, (unsigned char *) &iscp,
3374 sizeof(iscp));
3375
3376 /* Our first command is to reset the i82586. */
3377 memset(&scb, 0x00, sizeof(scb));
3378 scb.scb_command = SCB_CMD_RESET;
3379 scb.scb_cbl_offset = OFFSET_CU;
3380 scb.scb_rfa_offset = OFFSET_RU;
3381 obram_write(ioaddr, OFFSET_SCB, (unsigned char *) &scb,
3382 sizeof(scb));
3383
3384 set_chan_attn(ioaddr, lp->hacr);
3385
3386 /* Wait for command to finish. */
3387 for (i = 1000; i > 0; i--) {
3388 obram_read(ioaddr, OFFSET_ISCP, (unsigned char *) &iscp,
3389 sizeof(iscp));
3390
3391 if (iscp.iscp_busy == (unsigned short) 0)
3392 break;
3393
3394 udelay(10);
3395 }
3396
3397 if (i <= 0) {
3398 #ifdef DEBUG_CONFIG_ERROR
3399 printk(KERN_INFO
3400 "%s: wv_82586_start(): iscp_busy timeout.\n",
3401 dev->name);
3402 #endif
3403 return -1;
3404 }
3405
3406 /* Check command completion. */
3407 for (i = 15; i > 0; i--) {
3408 obram_read(ioaddr, OFFSET_SCB, (unsigned char *) &scb,
3409 sizeof(scb));
3410
3411 if (scb.scb_status == (SCB_ST_CX | SCB_ST_CNA))
3412 break;
3413
3414 udelay(10);
3415 }
3416
3417 if (i <= 0) {
3418 #ifdef DEBUG_CONFIG_ERROR
3419 printk(KERN_INFO
3420 "%s: wv_82586_start(): status: expected 0x%02x, got 0x%02x.\n",
3421 dev->name, SCB_ST_CX | SCB_ST_CNA, scb.scb_status);
3422 #endif
3423 return -1;
3424 }
3425
3426 wv_ack(dev);
3427
3428 /* Set the action command header. */
3429 memset(&cb, 0x00, sizeof(cb));
3430 cb.ac_command = AC_CFLD_EL | (AC_CFLD_CMD & acmd_diagnose);
3431 cb.ac_link = OFFSET_CU;
3432 obram_write(ioaddr, OFFSET_CU, (unsigned char *) &cb, sizeof(cb));
3433
3434 if (wv_synchronous_cmd(dev, "diag()") == -1)
3435 return -1;
3436
3437 obram_read(ioaddr, OFFSET_CU, (unsigned char *) &cb, sizeof(cb));
3438 if (cb.ac_status & AC_SFLD_FAIL) {
3439 #ifdef DEBUG_CONFIG_ERROR
3440 printk(KERN_INFO
3441 "%s: wv_82586_start(): i82586 Self Test failed.\n",
3442 dev->name);
3443 #endif
3444 return -1;
3445 }
3446 #ifdef DEBUG_I82586_SHOW
3447 wv_scb_show(ioaddr);
3448 #endif
3449
3450 #ifdef DEBUG_CONFIG_TRACE
3451 printk(KERN_DEBUG "%s: <-wv_82586_start()\n", dev->name);
3452 #endif
3453 return 0;
3454 }
3455
3456 /*------------------------------------------------------------------*/
3457 /*
3458 * This routine does a standard configuration of the WaveLAN
3459 * controller (i82586).
3460 *
3461 * This routine is a violent hack. We use the first free transmit block
3462 * to make our configuration. In the buffer area, we create the three
3463 * configuration commands (linked). We make the previous NOP point to
3464 * the beginning of the buffer instead of the tx command. After, we go
3465 * as usual to the NOP command.
3466 * Note that only the last command (mc_set) will generate an interrupt.
3467 *
3468 * (called by wv_hw_reset(), wv_82586_reconfig(), wavelan_packet_xmit())
3469 */
3470 static void wv_82586_config(struct net_device * dev)
3471 {
3472 net_local *lp = (net_local *) dev->priv;
3473 unsigned long ioaddr = dev->base_addr;
3474 unsigned short txblock;
3475 unsigned short txpred;
3476 unsigned short tx_addr;
3477 unsigned short nop_addr;
3478 unsigned short tbd_addr;
3479 unsigned short cfg_addr;
3480 unsigned short ias_addr;
3481 unsigned short mcs_addr;
3482 ac_tx_t tx;
3483 ac_nop_t nop;
3484 ac_cfg_t cfg; /* Configure action */
3485 ac_ias_t ias; /* IA-setup action */
3486 ac_mcs_t mcs; /* Multicast setup */
3487 struct dev_mc_list *dmi;
3488
3489 #ifdef DEBUG_CONFIG_TRACE
3490 printk(KERN_DEBUG "%s: ->wv_82586_config()\n", dev->name);
3491 #endif
3492
3493 /* Check nothing bad has happened */
3494 if (lp->tx_n_in_use == (NTXBLOCKS - 1)) {
3495 #ifdef DEBUG_CONFIG_ERROR
3496 printk(KERN_INFO "%s: wv_82586_config(): Tx queue full.\n",
3497 dev->name);
3498 #endif
3499 return;
3500 }
3501
3502 /* Calculate addresses of next block and previous block. */
3503 txblock = lp->tx_first_free;
3504 txpred = txblock - TXBLOCKZ;
3505 if (txpred < OFFSET_CU)
3506 txpred += NTXBLOCKS * TXBLOCKZ;
3507 lp->tx_first_free += TXBLOCKZ;
3508 if (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
3509 lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
3510
3511 lp->tx_n_in_use++;
3512
3513 /* Calculate addresses of the different parts of the block. */
3514 tx_addr = txblock;
3515 nop_addr = tx_addr + sizeof(tx);
3516 tbd_addr = nop_addr + sizeof(nop);
3517 cfg_addr = tbd_addr + sizeof(tbd_t); /* beginning of the buffer */
3518 ias_addr = cfg_addr + sizeof(cfg);
3519 mcs_addr = ias_addr + sizeof(ias);
3520
3521 /*
3522 * Transmit command
3523 */
3524 tx.tx_h.ac_status = 0xFFFF; /* Fake completion value */
3525 obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status),
3526 (unsigned char *) &tx.tx_h.ac_status,
3527 sizeof(tx.tx_h.ac_status));
3528
3529 /*
3530 * NOP command
3531 */
3532 nop.nop_h.ac_status = 0;
3533 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
3534 (unsigned char *) &nop.nop_h.ac_status,
3535 sizeof(nop.nop_h.ac_status));
3536 nop.nop_h.ac_link = nop_addr;
3537 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
3538 (unsigned char *) &nop.nop_h.ac_link,
3539 sizeof(nop.nop_h.ac_link));
3540
3541 /* Create a configure action. */
3542 memset(&cfg, 0x00, sizeof(cfg));
3543
3544 /*
3545 * For Linux we invert AC_CFG_ALOC() so as to conform
3546 * to the way that net packets reach us from above.
3547 * (See also ac_tx_t.)
3548 *
3549 * Updated from Wavelan Manual WCIN085B
3550 */
3551 cfg.cfg_byte_cnt =
3552 AC_CFG_BYTE_CNT(sizeof(ac_cfg_t) - sizeof(ach_t));
3553 cfg.cfg_fifolim = AC_CFG_FIFOLIM(4);
3554 cfg.cfg_byte8 = AC_CFG_SAV_BF(1) | AC_CFG_SRDY(0);
3555 cfg.cfg_byte9 = AC_CFG_ELPBCK(0) |
3556 AC_CFG_ILPBCK(0) |
3557 AC_CFG_PRELEN(AC_CFG_PLEN_2) |
3558 AC_CFG_ALOC(1) | AC_CFG_ADDRLEN(WAVELAN_ADDR_SIZE);
3559 cfg.cfg_byte10 = AC_CFG_BOFMET(1) |
3560 AC_CFG_ACR(6) | AC_CFG_LINPRIO(0);
3561 cfg.cfg_ifs = 0x20;
3562 cfg.cfg_slotl = 0x0C;
3563 cfg.cfg_byte13 = AC_CFG_RETRYNUM(15) | AC_CFG_SLTTMHI(0);
3564 cfg.cfg_byte14 = AC_CFG_FLGPAD(0) |
3565 AC_CFG_BTSTF(0) |
3566 AC_CFG_CRC16(0) |
3567 AC_CFG_NCRC(0) |
3568 AC_CFG_TNCRS(1) |
3569 AC_CFG_MANCH(0) |
3570 AC_CFG_BCDIS(0) | AC_CFG_PRM(lp->promiscuous);
3571 cfg.cfg_byte15 = AC_CFG_ICDS(0) |
3572 AC_CFG_CDTF(0) | AC_CFG_ICSS(0) | AC_CFG_CSTF(0);
3573 /*
3574 cfg.cfg_min_frm_len = AC_CFG_MNFRM(64);
3575 */
3576 cfg.cfg_min_frm_len = AC_CFG_MNFRM(8);
3577
3578 cfg.cfg_h.ac_command = (AC_CFLD_CMD & acmd_configure);
3579 cfg.cfg_h.ac_link = ias_addr;
3580 obram_write(ioaddr, cfg_addr, (unsigned char *) &cfg, sizeof(cfg));
3581
3582 /* Set up the MAC address */
3583 memset(&ias, 0x00, sizeof(ias));
3584 ias.ias_h.ac_command = (AC_CFLD_CMD & acmd_ia_setup);
3585 ias.ias_h.ac_link = mcs_addr;
3586 memcpy(&ias.ias_addr[0], (unsigned char *) &dev->dev_addr[0],
3587 sizeof(ias.ias_addr));
3588 obram_write(ioaddr, ias_addr, (unsigned char *) &ias, sizeof(ias));
3589
3590 /* Initialize adapter's Ethernet multicast addresses */
3591 memset(&mcs, 0x00, sizeof(mcs));
3592 mcs.mcs_h.ac_command = AC_CFLD_I | (AC_CFLD_CMD & acmd_mc_setup);
3593 mcs.mcs_h.ac_link = nop_addr;
3594 mcs.mcs_cnt = WAVELAN_ADDR_SIZE * lp->mc_count;
3595 obram_write(ioaddr, mcs_addr, (unsigned char *) &mcs, sizeof(mcs));
3596
3597 /* Any address to set? */
3598 if (lp->mc_count) {
3599 for (dmi = dev->mc_list; dmi; dmi = dmi->next)
3600 outsw(PIOP1(ioaddr), (u16 *) dmi->dmi_addr,
3601 WAVELAN_ADDR_SIZE >> 1);
3602
3603 #ifdef DEBUG_CONFIG_INFO
3604 printk(KERN_DEBUG
3605 "%s: wv_82586_config(): set %d multicast addresses:\n",
3606 dev->name, lp->mc_count);
3607 for (dmi = dev->mc_list; dmi; dmi = dmi->next)
3608 printk(KERN_DEBUG
3609 " %02x:%02x:%02x:%02x:%02x:%02x\n",
3610 dmi->dmi_addr[0], dmi->dmi_addr[1],
3611 dmi->dmi_addr[2], dmi->dmi_addr[3],
3612 dmi->dmi_addr[4], dmi->dmi_addr[5]);
3613 #endif
3614 }
3615
3616 /*
3617 * Overwrite the predecessor NOP link
3618 * so that it points to the configure action.
3619 */
3620 nop_addr = txpred + sizeof(tx);
3621 nop.nop_h.ac_status = 0;
3622 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
3623 (unsigned char *) &nop.nop_h.ac_status,
3624 sizeof(nop.nop_h.ac_status));
3625 nop.nop_h.ac_link = cfg_addr;
3626 obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
3627 (unsigned char *) &nop.nop_h.ac_link,
3628 sizeof(nop.nop_h.ac_link));
3629
3630 /* Job done, clear the flag */
3631 lp->reconfig_82586 = 0;
3632
3633 if (lp->tx_first_in_use == I82586NULL)
3634 lp->tx_first_in_use = txblock;
3635
3636 if (lp->tx_n_in_use == (NTXBLOCKS - 1))
3637 netif_stop_queue(dev);
3638
3639 #ifdef DEBUG_CONFIG_TRACE
3640 printk(KERN_DEBUG "%s: <-wv_82586_config()\n", dev->name);
3641 #endif
3642 }
3643
3644 /*------------------------------------------------------------------*/
3645 /*
3646 * This routine, called by wavelan_close(), gracefully stops the
3647 * WaveLAN controller (i82586).
3648 * (called by wavelan_close())
3649 */
3650 static inline void wv_82586_stop(struct net_device * dev)
3651 {
3652 net_local *lp = (net_local *) dev->priv;
3653 unsigned long ioaddr = dev->base_addr;
3654 u16 scb_cmd;
3655
3656 #ifdef DEBUG_CONFIG_TRACE
3657 printk(KERN_DEBUG "%s: ->wv_82586_stop()\n", dev->name);
3658 #endif
3659
3660 /* Suspend both command unit and receive unit. */
3661 scb_cmd =
3662 (SCB_CMD_CUC & SCB_CMD_CUC_SUS) | (SCB_CMD_RUC &
3663 SCB_CMD_RUC_SUS);
3664 obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3665 (unsigned char *) &scb_cmd, sizeof(scb_cmd));
3666 set_chan_attn(ioaddr, lp->hacr);
3667
3668 /* No more interrupts */
3669 wv_ints_off(dev);
3670
3671 #ifdef DEBUG_CONFIG_TRACE
3672 printk(KERN_DEBUG "%s: <-wv_82586_stop()\n", dev->name);
3673 #endif
3674 }
3675
3676 /*------------------------------------------------------------------*/
3677 /*
3678 * Totally reset the WaveLAN and restart it.
3679 * Performs the following actions:
3680 * 1. A power reset (reset DMA)
3681 * 2. Initialize the radio modem (using wv_mmc_init)
3682 * 3. Reset & Configure LAN controller (using wv_82586_start)
3683 * 4. Start the LAN controller's command unit
3684 * 5. Start the LAN controller's receive unit
3685 * (called by wavelan_interrupt(), wavelan_watchdog() & wavelan_open())
3686 */
3687 static int wv_hw_reset(struct net_device * dev)
3688 {
3689 net_local *lp = (net_local *) dev->priv;
3690 unsigned long ioaddr = dev->base_addr;
3691
3692 #ifdef DEBUG_CONFIG_TRACE
3693 printk(KERN_DEBUG "%s: ->wv_hw_reset(dev=0x%x)\n", dev->name,
3694 (unsigned int) dev);
3695 #endif
3696
3697 /* Increase the number of resets done. */
3698 lp->nresets++;
3699
3700 wv_hacr_reset(ioaddr);
3701 lp->hacr = HACR_DEFAULT;
3702
3703 if ((wv_mmc_init(dev) < 0) || (wv_82586_start(dev) < 0))
3704 return -1;
3705
3706 /* Enable the card to send interrupts. */
3707 wv_ints_on(dev);
3708
3709 /* Start card functions */
3710 if (wv_cu_start(dev) < 0)
3711 return -1;
3712
3713 /* Setup the controller and parameters */
3714 wv_82586_config(dev);
3715
3716 /* Finish configuration with the receive unit */
3717 if (wv_ru_start(dev) < 0)
3718 return -1;
3719
3720 #ifdef DEBUG_CONFIG_TRACE
3721 printk(KERN_DEBUG "%s: <-wv_hw_reset()\n", dev->name);
3722 #endif
3723 return 0;
3724 }
3725
3726 /*------------------------------------------------------------------*/
3727 /*
3728 * Check if there is a WaveLAN at the specific base address.
3729 * As a side effect, this reads the MAC address.
3730 * (called in wavelan_probe() and init_module())
3731 */
3732 static int wv_check_ioaddr(unsigned long ioaddr, u8 * mac)
3733 {
3734 int i; /* Loop counter */
3735
3736 /* Check if the base address if available. */
3737 if (!request_region(ioaddr, sizeof(ha_t), "wavelan probe"))
3738 return -EBUSY; /* ioaddr already used */
3739
3740 /* Reset host interface */
3741 wv_hacr_reset(ioaddr);
3742
3743 /* Read the MAC address from the parameter storage area. */
3744 psa_read(ioaddr, HACR_DEFAULT, psaoff(0, psa_univ_mac_addr),
3745 mac, 6);
3746
3747 release_region(ioaddr, sizeof(ha_t));
3748
3749 /*
3750 * Check the first three octets of the address for the manufacturer's code.
3751 * Note: if this can't find your WaveLAN card, you've got a
3752 * non-NCR/AT&T/Lucent ISA card. See wavelan.p.h for detail on
3753 * how to configure your card.
3754 */
3755 for (i = 0; i < (sizeof(MAC_ADDRESSES) / sizeof(char) / 3); i++)
3756 if ((mac[0] == MAC_ADDRESSES[i][0]) &&
3757 (mac[1] == MAC_ADDRESSES[i][1]) &&
3758 (mac[2] == MAC_ADDRESSES[i][2]))
3759 return 0;
3760
3761 #ifdef DEBUG_CONFIG_INFO
3762 printk(KERN_WARNING
3763 "WaveLAN (0x%3X): your MAC address might be %02X:%02X:%02X.\n",
3764 ioaddr, mac[0], mac[1], mac[2]);
3765 #endif
3766 return -ENODEV;
3767 }
3768
3769 /************************ INTERRUPT HANDLING ************************/
3770
3771 /*
3772 * This function is the interrupt handler for the WaveLAN card. This
3773 * routine will be called whenever:
3774 */
3775 static irqreturn_t wavelan_interrupt(int irq, void *dev_id, struct pt_regs *regs)
3776 {
3777 struct net_device *dev;
3778 unsigned long ioaddr;
3779 net_local *lp;
3780 u16 hasr;
3781 u16 status;
3782 u16 ack_cmd;
3783
3784 dev = dev_id;
3785
3786 #ifdef DEBUG_INTERRUPT_TRACE
3787 printk(KERN_DEBUG "%s: ->wavelan_interrupt()\n", dev->name);
3788 #endif
3789
3790 lp = (net_local *) dev->priv;
3791 ioaddr = dev->base_addr;
3792
3793 #ifdef DEBUG_INTERRUPT_INFO
3794 /* Check state of our spinlock */
3795 if(spin_is_locked(&lp->spinlock))
3796 printk(KERN_DEBUG
3797 "%s: wavelan_interrupt(): spinlock is already locked !!!\n",
3798 dev->name);
3799 #endif
3800
3801 /* Prevent reentrancy. We need to do that because we may have
3802 * multiple interrupt handler running concurrently.
3803 * It is safe because interrupts are disabled before acquiring
3804 * the spinlock. */
3805 spin_lock(&lp->spinlock);
3806
3807 /* We always had spurious interrupts at startup, but lately I
3808 * saw them comming *between* the request_irq() and the
3809 * spin_lock_irqsave() in wavelan_open(), so the spinlock
3810 * protection is no enough.
3811 * So, we also check lp->hacr that will tell us is we enabled
3812 * irqs or not (see wv_ints_on()).
3813 * We can't use netif_running(dev) because we depend on the
3814 * proper processing of the irq generated during the config. */
3815
3816 /* Which interrupt it is ? */
3817 hasr = hasr_read(ioaddr);
3818
3819 #ifdef DEBUG_INTERRUPT_INFO
3820 printk(KERN_INFO
3821 "%s: wavelan_interrupt(): hasr 0x%04x; hacr 0x%04x.\n",
3822 dev->name, hasr, lp->hacr);
3823 #endif
3824
3825 /* Check modem interrupt */
3826 if ((hasr & HASR_MMC_INTR) && (lp->hacr & HACR_MMC_INT_ENABLE)) {
3827 u8 dce_status;
3828
3829 /*
3830 * Interrupt from the modem management controller.
3831 * This will clear it -- ignored for now.
3832 */
3833 mmc_read(ioaddr, mmroff(0, mmr_dce_status), &dce_status,
3834 sizeof(dce_status));
3835
3836 #ifdef DEBUG_INTERRUPT_ERROR
3837 printk(KERN_INFO
3838 "%s: wavelan_interrupt(): unexpected mmc interrupt: status 0x%04x.\n",
3839 dev->name, dce_status);
3840 #endif
3841 }
3842
3843 /* Check if not controller interrupt */
3844 if (((hasr & HASR_82586_INTR) == 0) ||
3845 ((lp->hacr & HACR_82586_INT_ENABLE) == 0)) {
3846 #ifdef DEBUG_INTERRUPT_ERROR
3847 printk(KERN_INFO
3848 "%s: wavelan_interrupt(): interrupt not coming from i82586 - hasr 0x%04x.\n",
3849 dev->name, hasr);
3850 #endif
3851 spin_unlock (&lp->spinlock);
3852 return IRQ_NONE;
3853 }
3854
3855 /* Read interrupt data. */
3856 obram_read(ioaddr, scboff(OFFSET_SCB, scb_status),
3857 (unsigned char *) &status, sizeof(status));
3858
3859 /*
3860 * Acknowledge the interrupt(s).
3861 */
3862 ack_cmd = status & SCB_ST_INT;
3863 obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3864 (unsigned char *) &ack_cmd, sizeof(ack_cmd));
3865 set_chan_attn(ioaddr, lp->hacr);
3866
3867 #ifdef DEBUG_INTERRUPT_INFO
3868 printk(KERN_DEBUG "%s: wavelan_interrupt(): status 0x%04x.\n",
3869 dev->name, status);
3870 #endif
3871
3872 /* Command completed. */
3873 if ((status & SCB_ST_CX) == SCB_ST_CX) {
3874 #ifdef DEBUG_INTERRUPT_INFO
3875 printk(KERN_DEBUG
3876 "%s: wavelan_interrupt(): command completed.\n",
3877 dev->name);
3878 #endif
3879 wv_complete(dev, ioaddr, lp);
3880 }
3881
3882 /* Frame received. */
3883 if ((status & SCB_ST_FR) == SCB_ST_FR) {
3884 #ifdef DEBUG_INTERRUPT_INFO
3885 printk(KERN_DEBUG
3886 "%s: wavelan_interrupt(): received packet.\n",
3887 dev->name);
3888 #endif
3889 wv_receive(dev);
3890 }
3891
3892 /* Check the state of the command unit. */
3893 if (((status & SCB_ST_CNA) == SCB_ST_CNA) ||
3894 (((status & SCB_ST_CUS) != SCB_ST_CUS_ACTV) &&
3895 (netif_running(dev)))) {
3896 #ifdef DEBUG_INTERRUPT_ERROR
3897 printk(KERN_INFO
3898 "%s: wavelan_interrupt(): CU inactive -- restarting\n",
3899 dev->name);
3900 #endif
3901 wv_hw_reset(dev);
3902 }
3903
3904 /* Check the state of the command unit. */
3905 if (((status & SCB_ST_RNR) == SCB_ST_RNR) ||
3906 (((status & SCB_ST_RUS) != SCB_ST_RUS_RDY) &&
3907 (netif_running(dev)))) {
3908 #ifdef DEBUG_INTERRUPT_ERROR
3909 printk(KERN_INFO
3910 "%s: wavelan_interrupt(): RU not ready -- restarting\n",
3911 dev->name);
3912 #endif
3913 wv_hw_reset(dev);
3914 }
3915
3916 /* Release spinlock */
3917 spin_unlock (&lp->spinlock);
3918
3919 #ifdef DEBUG_INTERRUPT_TRACE
3920 printk(KERN_DEBUG "%s: <-wavelan_interrupt()\n", dev->name);
3921 #endif
3922 return IRQ_HANDLED;
3923 }
3924
3925 /*------------------------------------------------------------------*/
3926 /*
3927 * Watchdog: when we start a transmission, a timer is set for us in the
3928 * kernel. If the transmission completes, this timer is disabled. If
3929 * the timer expires, we are called and we try to unlock the hardware.
3930 */
3931 static void wavelan_watchdog(struct net_device * dev)
3932 {
3933 net_local * lp = (net_local *)dev->priv;
3934 u_long ioaddr = dev->base_addr;
3935 unsigned long flags;
3936 unsigned int nreaped;
3937
3938 #ifdef DEBUG_INTERRUPT_TRACE
3939 printk(KERN_DEBUG "%s: ->wavelan_watchdog()\n", dev->name);
3940 #endif
3941
3942 #ifdef DEBUG_INTERRUPT_ERROR
3943 printk(KERN_INFO "%s: wavelan_watchdog: watchdog timer expired\n",
3944 dev->name);
3945 #endif
3946
3947 /* Check that we came here for something */
3948 if (lp->tx_n_in_use <= 0) {
3949 return;
3950 }
3951
3952 spin_lock_irqsave(&lp->spinlock, flags);
3953
3954 /* Try to see if some buffers are not free (in case we missed
3955 * an interrupt */
3956 nreaped = wv_complete(dev, ioaddr, lp);
3957
3958 #ifdef DEBUG_INTERRUPT_INFO
3959 printk(KERN_DEBUG
3960 "%s: wavelan_watchdog(): %d reaped, %d remain.\n",
3961 dev->name, nreaped, lp->tx_n_in_use);
3962 #endif
3963
3964 #ifdef DEBUG_PSA_SHOW
3965 {
3966 psa_t psa;
3967 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
3968 wv_psa_show(&psa);
3969 }
3970 #endif
3971 #ifdef DEBUG_MMC_SHOW
3972 wv_mmc_show(dev);
3973 #endif
3974 #ifdef DEBUG_I82586_SHOW
3975 wv_cu_show(dev);
3976 #endif
3977
3978 /* If no buffer has been freed */
3979 if (nreaped == 0) {
3980 #ifdef DEBUG_INTERRUPT_ERROR
3981 printk(KERN_INFO
3982 "%s: wavelan_watchdog(): cleanup failed, trying reset\n",
3983 dev->name);
3984 #endif
3985 wv_hw_reset(dev);
3986 }
3987
3988 /* At this point, we should have some free Tx buffer ;-) */
3989 if (lp->tx_n_in_use < NTXBLOCKS - 1)
3990 netif_wake_queue(dev);
3991
3992 spin_unlock_irqrestore(&lp->spinlock, flags);
3993
3994 #ifdef DEBUG_INTERRUPT_TRACE
3995 printk(KERN_DEBUG "%s: <-wavelan_watchdog()\n", dev->name);
3996 #endif
3997 }
3998
3999 /********************* CONFIGURATION CALLBACKS *********************/
4000 /*
4001 * Here are the functions called by the Linux networking code (NET3)
4002 * for initialization, configuration and deinstallations of the
4003 * WaveLAN ISA hardware.
4004 */
4005
4006 /*------------------------------------------------------------------*/
4007 /*
4008 * Configure and start up the WaveLAN PCMCIA adaptor.
4009 * Called by NET3 when it "opens" the device.
4010 */
4011 static int wavelan_open(struct net_device * dev)
4012 {
4013 net_local * lp = (net_local *)dev->priv;
4014 unsigned long flags;
4015
4016 #ifdef DEBUG_CALLBACK_TRACE
4017 printk(KERN_DEBUG "%s: ->wavelan_open(dev=0x%x)\n", dev->name,
4018 (unsigned int) dev);
4019 #endif
4020
4021 /* Check irq */
4022 if (dev->irq == 0) {
4023 #ifdef DEBUG_CONFIG_ERROR
4024 printk(KERN_WARNING "%s: wavelan_open(): no IRQ\n",
4025 dev->name);
4026 #endif
4027 return -ENXIO;
4028 }
4029
4030 if (request_irq(dev->irq, &wavelan_interrupt, 0, "WaveLAN", dev) != 0)
4031 {
4032 #ifdef DEBUG_CONFIG_ERROR
4033 printk(KERN_WARNING "%s: wavelan_open(): invalid IRQ\n",
4034 dev->name);
4035 #endif
4036 return -EAGAIN;
4037 }
4038
4039 spin_lock_irqsave(&lp->spinlock, flags);
4040
4041 if (wv_hw_reset(dev) != -1) {
4042 netif_start_queue(dev);
4043 } else {
4044 free_irq(dev->irq, dev);
4045 #ifdef DEBUG_CONFIG_ERROR
4046 printk(KERN_INFO
4047 "%s: wavelan_open(): impossible to start the card\n",
4048 dev->name);
4049 #endif
4050 spin_unlock_irqrestore(&lp->spinlock, flags);
4051 return -EAGAIN;
4052 }
4053 spin_unlock_irqrestore(&lp->spinlock, flags);
4054
4055 #ifdef DEBUG_CALLBACK_TRACE
4056 printk(KERN_DEBUG "%s: <-wavelan_open()\n", dev->name);
4057 #endif
4058 return 0;
4059 }
4060
4061 /*------------------------------------------------------------------*/
4062 /*
4063 * Shut down the WaveLAN ISA card.
4064 * Called by NET3 when it "closes" the device.
4065 */
4066 static int wavelan_close(struct net_device * dev)
4067 {
4068 net_local *lp = (net_local *) dev->priv;
4069 unsigned long flags;
4070
4071 #ifdef DEBUG_CALLBACK_TRACE
4072 printk(KERN_DEBUG "%s: ->wavelan_close(dev=0x%x)\n", dev->name,
4073 (unsigned int) dev);
4074 #endif
4075
4076 netif_stop_queue(dev);
4077
4078 /*
4079 * Flush the Tx and disable Rx.
4080 */
4081 spin_lock_irqsave(&lp->spinlock, flags);
4082 wv_82586_stop(dev);
4083 spin_unlock_irqrestore(&lp->spinlock, flags);
4084
4085 free_irq(dev->irq, dev);
4086
4087 #ifdef DEBUG_CALLBACK_TRACE
4088 printk(KERN_DEBUG "%s: <-wavelan_close()\n", dev->name);
4089 #endif
4090 return 0;
4091 }
4092
4093 /*------------------------------------------------------------------*/
4094 /*
4095 * Probe an I/O address, and if the WaveLAN is there configure the
4096 * device structure
4097 * (called by wavelan_probe() and via init_module()).
4098 */
4099 static int __init wavelan_config(struct net_device *dev, unsigned short ioaddr)
4100 {
4101 u8 irq_mask;
4102 int irq;
4103 net_local *lp;
4104 mac_addr mac;
4105 int err;
4106
4107 if (!request_region(ioaddr, sizeof(ha_t), "wavelan"))
4108 return -EADDRINUSE;
4109
4110 err = wv_check_ioaddr(ioaddr, mac);
4111 if (err)
4112 goto out;
4113
4114 memcpy(dev->dev_addr, mac, 6);
4115
4116 dev->base_addr = ioaddr;
4117
4118 #ifdef DEBUG_CALLBACK_TRACE
4119 printk(KERN_DEBUG "%s: ->wavelan_config(dev=0x%x, ioaddr=0x%lx)\n",
4120 dev->name, (unsigned int) dev, ioaddr);
4121 #endif
4122
4123 /* Check IRQ argument on command line. */
4124 if (dev->irq != 0) {
4125 irq_mask = wv_irq_to_psa(dev->irq);
4126
4127 if (irq_mask == 0) {
4128 #ifdef DEBUG_CONFIG_ERROR
4129 printk(KERN_WARNING
4130 "%s: wavelan_config(): invalid IRQ %d ignored.\n",
4131 dev->name, dev->irq);
4132 #endif
4133 dev->irq = 0;
4134 } else {
4135 #ifdef DEBUG_CONFIG_INFO
4136 printk(KERN_DEBUG
4137 "%s: wavelan_config(): changing IRQ to %d\n",
4138 dev->name, dev->irq);
4139 #endif
4140 psa_write(ioaddr, HACR_DEFAULT,
4141 psaoff(0, psa_int_req_no), &irq_mask, 1);
4142 /* update the Wavelan checksum */
4143 update_psa_checksum(dev, ioaddr, HACR_DEFAULT);
4144 wv_hacr_reset(ioaddr);
4145 }
4146 }
4147
4148 psa_read(ioaddr, HACR_DEFAULT, psaoff(0, psa_int_req_no),
4149 &irq_mask, 1);
4150 if ((irq = wv_psa_to_irq(irq_mask)) == -1) {
4151 #ifdef DEBUG_CONFIG_ERROR
4152 printk(KERN_INFO
4153 "%s: wavelan_config(): could not wavelan_map_irq(%d).\n",
4154 dev->name, irq_mask);
4155 #endif
4156 err = -EAGAIN;
4157 goto out;
4158 }
4159
4160 dev->irq = irq;
4161
4162 dev->mem_start = 0x0000;
4163 dev->mem_end = 0x0000;
4164 dev->if_port = 0;
4165
4166 /* Initialize device structures */
4167 memset(dev->priv, 0, sizeof(net_local));
4168 lp = (net_local *) dev->priv;
4169
4170 /* Back link to the device structure. */
4171 lp->dev = dev;
4172 /* Add the device at the beginning of the linked list. */
4173 lp->next = wavelan_list;
4174 wavelan_list = lp;
4175
4176 lp->hacr = HACR_DEFAULT;
4177
4178 /* Multicast stuff */
4179 lp->promiscuous = 0;
4180 lp->mc_count = 0;
4181
4182 /* Init spinlock */
4183 spin_lock_init(&lp->spinlock);
4184
4185 SET_MODULE_OWNER(dev);
4186 dev->open = wavelan_open;
4187 dev->stop = wavelan_close;
4188 dev->hard_start_xmit = wavelan_packet_xmit;
4189 dev->get_stats = wavelan_get_stats;
4190 dev->set_multicast_list = &wavelan_set_multicast_list;
4191 dev->tx_timeout = &wavelan_watchdog;
4192 dev->watchdog_timeo = WATCHDOG_JIFFIES;
4193 #ifdef SET_MAC_ADDRESS
4194 dev->set_mac_address = &wavelan_set_mac_address;
4195 #endif /* SET_MAC_ADDRESS */
4196
4197 #ifdef WIRELESS_EXT /* if wireless extension exists in the kernel */
4198 dev->wireless_handlers = &wavelan_handler_def;
4199 lp->wireless_data.spy_data = &lp->spy_data;
4200 dev->wireless_data = &lp->wireless_data;
4201 #endif
4202
4203 dev->mtu = WAVELAN_MTU;
4204
4205 /* Display nice information. */
4206 wv_init_info(dev);
4207
4208 #ifdef DEBUG_CALLBACK_TRACE
4209 printk(KERN_DEBUG "%s: <-wavelan_config()\n", dev->name);
4210 #endif
4211 return 0;
4212 out:
4213 release_region(ioaddr, sizeof(ha_t));
4214 return err;
4215 }
4216
4217 /*------------------------------------------------------------------*/
4218 /*
4219 * Check for a network adaptor of this type. Return '0' iff one
4220 * exists. There seem to be different interpretations of
4221 * the initial value of dev->base_addr.
4222 * We follow the example in drivers/net/ne.c.
4223 * (called in "Space.c")
4224 */
4225 struct net_device * __init wavelan_probe(int unit)
4226 {
4227 struct net_device *dev;
4228 short base_addr;
4229 int def_irq;
4230 int i;
4231 int r = 0;
4232
4233 #ifdef STRUCT_CHECK
4234 if (wv_struct_check() != (char *) NULL) {
4235 printk(KERN_WARNING
4236 "%s: wavelan_probe(): structure/compiler botch: \"%s\"\n",
4237 dev->name, wv_struct_check());
4238 return -ENODEV;
4239 }
4240 #endif /* STRUCT_CHECK */
4241
4242 dev = alloc_etherdev(sizeof(net_local));
4243 if (!dev)
4244 return ERR_PTR(-ENOMEM);
4245
4246 sprintf(dev->name, "eth%d", unit);
4247 netdev_boot_setup_check(dev);
4248 base_addr = dev->base_addr;
4249 def_irq = dev->irq;
4250
4251 #ifdef DEBUG_CALLBACK_TRACE
4252 printk(KERN_DEBUG
4253 "%s: ->wavelan_probe(dev=%p (base_addr=0x%x))\n",
4254 dev->name, dev, (unsigned int) dev->base_addr);
4255 #endif
4256
4257 /* Don't probe at all. */
4258 if (base_addr < 0) {
4259 #ifdef DEBUG_CONFIG_ERROR
4260 printk(KERN_WARNING
4261 "%s: wavelan_probe(): invalid base address\n",
4262 dev->name);
4263 #endif
4264 r = -ENXIO;
4265 } else if (base_addr > 0x100) { /* Check a single specified location. */
4266 r = wavelan_config(dev, base_addr);
4267 #ifdef DEBUG_CONFIG_INFO
4268 if (r != 0)
4269 printk(KERN_DEBUG
4270 "%s: wavelan_probe(): no device at specified base address (0x%X) or address already in use\n",
4271 dev->name, base_addr);
4272 #endif
4273
4274 #ifdef DEBUG_CALLBACK_TRACE
4275 printk(KERN_DEBUG "%s: <-wavelan_probe()\n", dev->name);
4276 #endif
4277 } else { /* Scan all possible addresses of the WaveLAN hardware. */
4278 for (i = 0; i < NELS(iobase); i++) {
4279 dev->irq = def_irq;
4280 if (wavelan_config(dev, iobase[i]) == 0) {
4281 #ifdef DEBUG_CALLBACK_TRACE
4282 printk(KERN_DEBUG
4283 "%s: <-wavelan_probe()\n",
4284 dev->name);
4285 #endif
4286 break;
4287 }
4288 }
4289 if (i == NELS(iobase))
4290 r = -ENODEV;
4291 }
4292 if (r)
4293 goto out;
4294 r = register_netdev(dev);
4295 if (r)
4296 goto out1;
4297 return dev;
4298 out1:
4299 release_region(dev->base_addr, sizeof(ha_t));
4300 wavelan_list = wavelan_list->next;
4301 out:
4302 free_netdev(dev);
4303 return ERR_PTR(r);
4304 }
4305
4306 /****************************** MODULE ******************************/
4307 /*
4308 * Module entry point: insertion and removal
4309 */
4310
4311 #ifdef MODULE
4312 /*------------------------------------------------------------------*/
4313 /*
4314 * Insertion of the module
4315 * I'm now quite proud of the multi-device support.
4316 */
4317 int init_module(void)
4318 {
4319 int ret = -EIO; /* Return error if no cards found */
4320 int i;
4321
4322 #ifdef DEBUG_MODULE_TRACE
4323 printk(KERN_DEBUG "-> init_module()\n");
4324 #endif
4325
4326 /* If probing is asked */
4327 if (io[0] == 0) {
4328 #ifdef DEBUG_CONFIG_ERROR
4329 printk(KERN_WARNING
4330 "WaveLAN init_module(): doing device probing (bad !)\n");
4331 printk(KERN_WARNING
4332 "Specify base addresses while loading module to correct the problem\n");
4333 #endif
4334
4335 /* Copy the basic set of address to be probed. */
4336 for (i = 0; i < NELS(iobase); i++)
4337 io[i] = iobase[i];
4338 }
4339
4340
4341 /* Loop on all possible base addresses. */
4342 i = -1;
4343 while ((io[++i] != 0) && (i < NELS(io))) {
4344 struct net_device *dev = alloc_etherdev(sizeof(net_local));
4345 if (!dev)
4346 break;
4347 if (name[i])
4348 strcpy(dev->name, name[i]); /* Copy name */
4349 dev->base_addr = io[i];
4350 dev->irq = irq[i];
4351
4352 /* Check if there is something at this base address. */
4353 if (wavelan_config(dev, io[i]) == 0) {
4354 if (register_netdev(dev) != 0) {
4355 release_region(dev->base_addr, sizeof(ha_t));
4356 wavelan_list = wavelan_list->next;
4357 } else {
4358 ret = 0;
4359 continue;
4360 }
4361 }
4362 free_netdev(dev);
4363 }
4364
4365 #ifdef DEBUG_CONFIG_ERROR
4366 if (!wavelan_list)
4367 printk(KERN_WARNING
4368 "WaveLAN init_module(): no device found\n");
4369 #endif
4370
4371 #ifdef DEBUG_MODULE_TRACE
4372 printk(KERN_DEBUG "<- init_module()\n");
4373 #endif
4374 return ret;
4375 }
4376
4377 /*------------------------------------------------------------------*/
4378 /*
4379 * Removal of the module
4380 */
4381 void cleanup_module(void)
4382 {
4383 #ifdef DEBUG_MODULE_TRACE
4384 printk(KERN_DEBUG "-> cleanup_module()\n");
4385 #endif
4386
4387 /* Loop on all devices and release them. */
4388 while (wavelan_list) {
4389 struct net_device *dev = wavelan_list->dev;
4390
4391 #ifdef DEBUG_CONFIG_INFO
4392 printk(KERN_DEBUG
4393 "%s: cleanup_module(): removing device at 0x%x\n",
4394 dev->name, (unsigned int) dev);
4395 #endif
4396 unregister_netdev(dev);
4397
4398 release_region(dev->base_addr, sizeof(ha_t));
4399 wavelan_list = wavelan_list->next;
4400
4401 free_netdev(dev);
4402 }
4403
4404 #ifdef DEBUG_MODULE_TRACE
4405 printk(KERN_DEBUG "<- cleanup_module()\n");
4406 #endif
4407 }
4408 #endif /* MODULE */
4409 MODULE_LICENSE("GPL");
4410
4411 /*
4412 * This software may only be used and distributed
4413 * according to the terms of the GNU General Public License.
4414 *
4415 * This software was developed as a component of the
4416 * Linux operating system.
4417 * It is based on other device drivers and information
4418 * either written or supplied by:
4419 * Ajay Bakre (bakre@paul.rutgers.edu),
4420 * Donald Becker (becker@scyld.com),
4421 * Loeke Brederveld (Loeke.Brederveld@Utrecht.NCR.com),
4422 * Anders Klemets (klemets@it.kth.se),
4423 * Vladimir V. Kolpakov (w@stier.koenig.ru),
4424 * Marc Meertens (Marc.Meertens@Utrecht.NCR.com),
4425 * Pauline Middelink (middelin@polyware.iaf.nl),
4426 * Robert Morris (rtm@das.harvard.edu),
4427 * Jean Tourrilhes (jt@hplb.hpl.hp.com),
4428 * Girish Welling (welling@paul.rutgers.edu),
4429 *
4430 * Thanks go also to:
4431 * James Ashton (jaa101@syseng.anu.edu.au),
4432 * Alan Cox (alan@redhat.com),
4433 * Allan Creighton (allanc@cs.usyd.edu.au),
4434 * Matthew Geier (matthew@cs.usyd.edu.au),
4435 * Remo di Giovanni (remo@cs.usyd.edu.au),
4436 * Eckhard Grah (grah@wrcs1.urz.uni-wuppertal.de),
4437 * Vipul Gupta (vgupta@cs.binghamton.edu),
4438 * Mark Hagan (mhagan@wtcpost.daytonoh.NCR.COM),
4439 * Tim Nicholson (tim@cs.usyd.edu.au),
4440 * Ian Parkin (ian@cs.usyd.edu.au),
4441 * John Rosenberg (johnr@cs.usyd.edu.au),
4442 * George Rossi (george@phm.gov.au),
4443 * Arthur Scott (arthur@cs.usyd.edu.au),
4444 * Peter Storey,
4445 * for their assistance and advice.
4446 *
4447 * Please send bug reports, updates, comments to:
4448 *
4449 * Bruce Janson Email: bruce@cs.usyd.edu.au
4450 * Basser Department of Computer Science Phone: +61-2-9351-3423
4451 * University of Sydney, N.S.W., 2006, AUSTRALIA Fax: +61-2-9351-3838
4452 */
Verdex Pro support