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