b0d8b5b03152769974b382809418b47d1bd6fb08
[linux-2.6.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 >= NELS(irqvals))
32                 return 0;
33
34         return irqvals[irq];
35 }
36
37 /*------------------------------------------------------------------*/
38 /*
39  * Translate PSA irq parameter to irq number 
40  */
41 static int __init wv_psa_to_irq(u8 irqval)
42 {
43         int irq;
44
45         for (irq = 0; irq < NELS(irqvals); irq++)
46                 if (irqvals[irq] == irqval)
47                         return irq;
48
49         return -1;
50 }
51
52 #ifdef STRUCT_CHECK
53 /*------------------------------------------------------------------*/
54 /*
55  * Sanity routine to verify the sizes of the various WaveLAN interface
56  * structures.
57  */
58 static char *wv_struct_check(void)
59 {
60 #define SC(t,s,n)       if (sizeof(t) != s) return(n);
61
62         SC(psa_t, PSA_SIZE, "psa_t");
63         SC(mmw_t, MMW_SIZE, "mmw_t");
64         SC(mmr_t, MMR_SIZE, "mmr_t");
65         SC(ha_t, HA_SIZE, "ha_t");
66
67 #undef  SC
68
69         return ((char *) NULL);
70 }                               /* wv_struct_check */
71 #endif                          /* STRUCT_CHECK */
72
73 /********************* HOST ADAPTER SUBROUTINES *********************/
74 /*
75  * Useful subroutines to manage the WaveLAN ISA interface
76  *
77  * One major difference with the PCMCIA hardware (except the port mapping)
78  * is that we have to keep the state of the Host Control Register
79  * because of the interrupt enable & bus size flags.
80  */
81
82 /*------------------------------------------------------------------*/
83 /*
84  * Read from card's Host Adaptor Status Register.
85  */
86 static inline u16 hasr_read(unsigned long ioaddr)
87 {
88         return (inw(HASR(ioaddr)));
89 }                               /* hasr_read */
90
91 /*------------------------------------------------------------------*/
92 /*
93  * Write to card's Host Adapter Command Register.
94  */
95 static inline void hacr_write(unsigned long ioaddr, u16 hacr)
96 {
97         outw(hacr, HACR(ioaddr));
98 }                               /* hacr_write */
99
100 /*------------------------------------------------------------------*/
101 /*
102  * Write to card's Host Adapter Command Register. Include a delay for
103  * those times when it is needed.
104  */
105 static inline void hacr_write_slow(unsigned long ioaddr, u16 hacr)
106 {
107         hacr_write(ioaddr, hacr);
108         /* delay might only be needed sometimes */
109         mdelay(1);
110 }                               /* hacr_write_slow */
111
112 /*------------------------------------------------------------------*/
113 /*
114  * Set the channel attention bit.
115  */
116 static inline void set_chan_attn(unsigned long ioaddr, u16 hacr)
117 {
118         hacr_write(ioaddr, hacr | HACR_CA);
119 }                               /* set_chan_attn */
120
121 /*------------------------------------------------------------------*/
122 /*
123  * Reset, and then set host adaptor into default mode.
124  */
125 static inline void wv_hacr_reset(unsigned long ioaddr)
126 {
127         hacr_write_slow(ioaddr, HACR_RESET);
128         hacr_write(ioaddr, HACR_DEFAULT);
129 }                               /* wv_hacr_reset */
130
131 /*------------------------------------------------------------------*/
132 /*
133  * Set the I/O transfer over the ISA bus to 8-bit mode
134  */
135 static inline void wv_16_off(unsigned long ioaddr, u16 hacr)
136 {
137         hacr &= ~HACR_16BITS;
138         hacr_write(ioaddr, hacr);
139 }                               /* wv_16_off */
140
141 /*------------------------------------------------------------------*/
142 /*
143  * Set the I/O transfer over the ISA bus to 8-bit mode
144  */
145 static inline void wv_16_on(unsigned long ioaddr, u16 hacr)
146 {
147         hacr |= HACR_16BITS;
148         hacr_write(ioaddr, hacr);
149 }                               /* wv_16_on */
150
151 /*------------------------------------------------------------------*/
152 /*
153  * Disable interrupts on the WaveLAN hardware.
154  * (called by wv_82586_stop())
155  */
156 static inline void wv_ints_off(struct net_device * dev)
157 {
158         net_local *lp = (net_local *) dev->priv;
159         unsigned long ioaddr = dev->base_addr;
160         
161         lp->hacr &= ~HACR_INTRON;
162         hacr_write(ioaddr, lp->hacr);
163 }                               /* wv_ints_off */
164
165 /*------------------------------------------------------------------*/
166 /*
167  * Enable interrupts on the WaveLAN hardware.
168  * (called by wv_hw_reset())
169  */
170 static inline void wv_ints_on(struct net_device * dev)
171 {
172         net_local *lp = (net_local *) dev->priv;
173         unsigned long ioaddr = dev->base_addr;
174
175         lp->hacr |= HACR_INTRON;
176         hacr_write(ioaddr, lp->hacr);
177 }                               /* wv_ints_on */
178
179 /******************* MODEM MANAGEMENT SUBROUTINES *******************/
180 /*
181  * Useful subroutines to manage the modem of the WaveLAN
182  */
183
184 /*------------------------------------------------------------------*/
185 /*
186  * Read the Parameter Storage Area from the WaveLAN card's memory
187  */
188 /*
189  * Read bytes from the PSA.
190  */
191 static void psa_read(unsigned long ioaddr, u16 hacr, int o,     /* offset in PSA */
192                      u8 * b,    /* buffer to fill */
193                      int n)
194 {                               /* size to read */
195         wv_16_off(ioaddr, hacr);
196
197         while (n-- > 0) {
198                 outw(o, PIOR2(ioaddr));
199                 o++;
200                 *b++ = inb(PIOP2(ioaddr));
201         }
202
203         wv_16_on(ioaddr, hacr);
204 }                               /* psa_read */
205
206 /*------------------------------------------------------------------*/
207 /*
208  * Write the Parameter Storage Area to the WaveLAN card's memory.
209  */
210 static void psa_write(unsigned long ioaddr, u16 hacr, int o,    /* Offset in PSA */
211                       u8 * b,   /* Buffer in memory */
212                       int n)
213 {                               /* Length of buffer */
214         int count = 0;
215
216         wv_16_off(ioaddr, hacr);
217
218         while (n-- > 0) {
219                 outw(o, PIOR2(ioaddr));
220                 o++;
221
222                 outb(*b, PIOP2(ioaddr));
223                 b++;
224
225                 /* Wait for the memory to finish its write cycle */
226                 count = 0;
227                 while ((count++ < 100) &&
228                        (hasr_read(ioaddr) & HASR_PSA_BUSY)) mdelay(1);
229         }
230
231         wv_16_on(ioaddr, hacr);
232 }                               /* psa_write */
233
234 #ifdef SET_PSA_CRC
235 /*------------------------------------------------------------------*/
236 /*
237  * Calculate the PSA CRC
238  * Thanks to Valster, Nico <NVALSTER@wcnd.nl.lucent.com> for the code
239  * NOTE: By specifying a length including the CRC position the
240  * returned value should be zero. (i.e. a correct checksum in the PSA)
241  *
242  * The Windows drivers don't use the CRC, but the AP and the PtP tool
243  * depend on it.
244  */
245 static inline u16 psa_crc(u8 * psa,     /* The PSA */
246                               int size)
247 {                               /* Number of short for CRC */
248         int byte_cnt;           /* Loop on the PSA */
249         u16 crc_bytes = 0;      /* Data in the PSA */
250         int bit_cnt;            /* Loop on the bits of the short */
251
252         for (byte_cnt = 0; byte_cnt < size; byte_cnt++) {
253                 crc_bytes ^= psa[byte_cnt];     /* Its an xor */
254
255                 for (bit_cnt = 1; bit_cnt < 9; bit_cnt++) {
256                         if (crc_bytes & 0x0001)
257                                 crc_bytes = (crc_bytes >> 1) ^ 0xA001;
258                         else
259                                 crc_bytes >>= 1;
260                 }
261         }
262
263         return crc_bytes;
264 }                               /* psa_crc */
265 #endif                          /* SET_PSA_CRC */
266
267 /*------------------------------------------------------------------*/
268 /*
269  * update the checksum field in the Wavelan's PSA
270  */
271 static void update_psa_checksum(struct net_device * dev, unsigned long ioaddr, u16 hacr)
272 {
273 #ifdef SET_PSA_CRC
274         psa_t psa;
275         u16 crc;
276
277         /* read the parameter storage area */
278         psa_read(ioaddr, hacr, 0, (unsigned char *) &psa, sizeof(psa));
279
280         /* update the checksum */
281         crc = psa_crc((unsigned char *) &psa,
282                       sizeof(psa) - sizeof(psa.psa_crc[0]) -
283                       sizeof(psa.psa_crc[1])
284                       - sizeof(psa.psa_crc_status));
285
286         psa.psa_crc[0] = crc & 0xFF;
287         psa.psa_crc[1] = (crc & 0xFF00) >> 8;
288
289         /* Write it ! */
290         psa_write(ioaddr, hacr, (char *) &psa.psa_crc - (char *) &psa,
291                   (unsigned char *) &psa.psa_crc, 2);
292
293 #ifdef DEBUG_IOCTL_INFO
294         printk(KERN_DEBUG "%s: update_psa_checksum(): crc = 0x%02x%02x\n",
295                dev->name, psa.psa_crc[0], psa.psa_crc[1]);
296
297         /* Check again (luxury !) */
298         crc = psa_crc((unsigned char *) &psa,
299                       sizeof(psa) - sizeof(psa.psa_crc_status));
300
301         if (crc != 0)
302                 printk(KERN_WARNING
303                        "%s: update_psa_checksum(): CRC does not agree with PSA data (even after recalculating)\n",
304                        dev->name);
305 #endif                          /* DEBUG_IOCTL_INFO */
306 #endif                          /* SET_PSA_CRC */
307 }                               /* update_psa_checksum */
308
309 /*------------------------------------------------------------------*/
310 /*
311  * Write 1 byte to the MMC.
312  */
313 static inline void mmc_out(unsigned long ioaddr, u16 o, u8 d)
314 {
315         int count = 0;
316
317         /* Wait for MMC to go idle */
318         while ((count++ < 100) && (inw(HASR(ioaddr)) & HASR_MMC_BUSY))
319                 udelay(10);
320
321         outw((u16) (((u16) d << 8) | (o << 1) | 1), MMCR(ioaddr));
322 }
323
324 /*------------------------------------------------------------------*/
325 /*
326  * Routine to write bytes to the Modem Management Controller.
327  * We start at the end because it is the way it should be!
328  */
329 static inline void mmc_write(unsigned long ioaddr, u8 o, u8 * b, int n)
330 {
331         o += n;
332         b += n;
333
334         while (n-- > 0)
335                 mmc_out(ioaddr, --o, *(--b));
336 }                               /* mmc_write */
337
338 /*------------------------------------------------------------------*/
339 /*
340  * Read a byte from the MMC.
341  * Optimised version for 1 byte, avoid using memory.
342  */
343 static inline u8 mmc_in(unsigned long ioaddr, u16 o)
344 {
345         int count = 0;
346
347         while ((count++ < 100) && (inw(HASR(ioaddr)) & HASR_MMC_BUSY))
348                 udelay(10);
349         outw(o << 1, MMCR(ioaddr));
350
351         while ((count++ < 100) && (inw(HASR(ioaddr)) & HASR_MMC_BUSY))
352                 udelay(10);
353         return (u8) (inw(MMCR(ioaddr)) >> 8);
354 }
355
356 /*------------------------------------------------------------------*/
357 /*
358  * Routine to read bytes from the Modem Management Controller.
359  * The implementation is complicated by a lack of address lines,
360  * which prevents decoding of the low-order bit.
361  * (code has just been moved in the above function)
362  * We start at the end because it is the way it should be!
363  */
364 static inline void mmc_read(unsigned long ioaddr, u8 o, u8 * b, int n)
365 {
366         o += n;
367         b += n;
368
369         while (n-- > 0)
370                 *(--b) = mmc_in(ioaddr, --o);
371 }                               /* mmc_read */
372
373 /*------------------------------------------------------------------*/
374 /*
375  * Get the type of encryption available.
376  */
377 static inline int mmc_encr(unsigned long ioaddr)
378 {                               /* I/O port of the card */
379         int temp;
380
381         temp = mmc_in(ioaddr, mmroff(0, mmr_des_avail));
382         if ((temp != MMR_DES_AVAIL_DES) && (temp != MMR_DES_AVAIL_AES))
383                 return 0;
384         else
385                 return temp;
386 }
387
388 /*------------------------------------------------------------------*/
389 /*
390  * Wait for the frequency EEPROM to complete a command.
391  * I hope this one will be optimally inlined.
392  */
393 static inline void fee_wait(unsigned long ioaddr,       /* I/O port of the card */
394                             int delay,  /* Base delay to wait for */
395                             int number)
396 {                               /* Number of time to wait */
397         int count = 0;          /* Wait only a limited time */
398
399         while ((count++ < number) &&
400                (mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
401                 MMR_FEE_STATUS_BUSY)) udelay(delay);
402 }
403
404 /*------------------------------------------------------------------*/
405 /*
406  * Read bytes from the Frequency EEPROM (frequency select cards).
407  */
408 static void fee_read(unsigned long ioaddr,      /* I/O port of the card */
409                      u16 o,     /* destination offset */
410                      u16 * b,   /* data buffer */
411                      int n)
412 {                               /* number of registers */
413         b += n;                 /* Position at the end of the area */
414
415         /* Write the address */
416         mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1);
417
418         /* Loop on all buffer */
419         while (n-- > 0) {
420                 /* Write the read command */
421                 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
422                         MMW_FEE_CTRL_READ);
423
424                 /* Wait until EEPROM is ready (should be quick). */
425                 fee_wait(ioaddr, 10, 100);
426
427                 /* Read the value. */
428                 *--b = ((mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)) << 8) |
429                         mmc_in(ioaddr, mmroff(0, mmr_fee_data_l)));
430         }
431 }
432
433
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 inline 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 inline 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 inline 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         printk(KERN_DEBUG "##### WaveLAN PSA contents: #####\n");
884         printk(KERN_DEBUG "psa_io_base_addr_1: 0x%02X %02X %02X %02X\n",
885                p->psa_io_base_addr_1,
886                p->psa_io_base_addr_2,
887                p->psa_io_base_addr_3, p->psa_io_base_addr_4);
888         printk(KERN_DEBUG "psa_rem_boot_addr_1: 0x%02X %02X %02X\n",
889                p->psa_rem_boot_addr_1,
890                p->psa_rem_boot_addr_2, p->psa_rem_boot_addr_3);
891         printk(KERN_DEBUG "psa_holi_params: 0x%02x, ", p->psa_holi_params);
892         printk("psa_int_req_no: %d\n", p->psa_int_req_no);
893 #ifdef DEBUG_SHOW_UNUSED
894         printk(KERN_DEBUG
895                "psa_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
896                p->psa_unused0[0], p->psa_unused0[1], p->psa_unused0[2],
897                p->psa_unused0[3], p->psa_unused0[4], p->psa_unused0[5],
898                p->psa_unused0[6]);
899 #endif                          /* DEBUG_SHOW_UNUSED */
900         printk(KERN_DEBUG
901                "psa_univ_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
902                p->psa_univ_mac_addr[0], p->psa_univ_mac_addr[1],
903                p->psa_univ_mac_addr[2], p->psa_univ_mac_addr[3],
904                p->psa_univ_mac_addr[4], p->psa_univ_mac_addr[5]);
905         printk(KERN_DEBUG
906                "psa_local_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
907                p->psa_local_mac_addr[0], p->psa_local_mac_addr[1],
908                p->psa_local_mac_addr[2], p->psa_local_mac_addr[3],
909                p->psa_local_mac_addr[4], p->psa_local_mac_addr[5]);
910         printk(KERN_DEBUG "psa_univ_local_sel: %d, ",
911                p->psa_univ_local_sel);
912         printk("psa_comp_number: %d, ", p->psa_comp_number);
913         printk("psa_thr_pre_set: 0x%02x\n", p->psa_thr_pre_set);
914         printk(KERN_DEBUG "psa_feature_select/decay_prm: 0x%02x, ",
915                p->psa_feature_select);
916         printk("psa_subband/decay_update_prm: %d\n", p->psa_subband);
917         printk(KERN_DEBUG "psa_quality_thr: 0x%02x, ", p->psa_quality_thr);
918         printk("psa_mod_delay: 0x%02x\n", p->psa_mod_delay);
919         printk(KERN_DEBUG "psa_nwid: 0x%02x%02x, ", p->psa_nwid[0],
920                p->psa_nwid[1]);
921         printk("psa_nwid_select: %d\n", p->psa_nwid_select);
922         printk(KERN_DEBUG "psa_encryption_select: %d, ",
923                p->psa_encryption_select);
924         printk
925             ("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
926              p->psa_encryption_key[0], p->psa_encryption_key[1],
927              p->psa_encryption_key[2], p->psa_encryption_key[3],
928              p->psa_encryption_key[4], p->psa_encryption_key[5],
929              p->psa_encryption_key[6], p->psa_encryption_key[7]);
930         printk(KERN_DEBUG "psa_databus_width: %d\n", p->psa_databus_width);
931         printk(KERN_DEBUG "psa_call_code/auto_squelch: 0x%02x, ",
932                p->psa_call_code[0]);
933         printk
934             ("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
935              p->psa_call_code[0], p->psa_call_code[1], p->psa_call_code[2],
936              p->psa_call_code[3], p->psa_call_code[4], p->psa_call_code[5],
937              p->psa_call_code[6], p->psa_call_code[7]);
938 #ifdef DEBUG_SHOW_UNUSED
939         printk(KERN_DEBUG "psa_reserved[]: %02X:%02X:%02X:%02X\n",
940                p->psa_reserved[0],
941                p->psa_reserved[1], p->psa_reserved[2], p->psa_reserved[3]);
942 #endif                          /* DEBUG_SHOW_UNUSED */
943         printk(KERN_DEBUG "psa_conf_status: %d, ", p->psa_conf_status);
944         printk("psa_crc: 0x%02x%02x, ", p->psa_crc[0], p->psa_crc[1]);
945         printk("psa_crc_status: 0x%02x\n", p->psa_crc_status);
946 }                               /* wv_psa_show */
947 #endif                          /* DEBUG_PSA_SHOW */
948
949 #ifdef DEBUG_MMC_SHOW
950 /*------------------------------------------------------------------*/
951 /*
952  * Print the formatted status of the Modem Management Controller.
953  * This function needs to be completed.
954  */
955 static void wv_mmc_show(struct net_device * dev)
956 {
957         unsigned long ioaddr = dev->base_addr;
958         net_local *lp = (net_local *) dev->priv;
959         mmr_t m;
960
961         /* Basic check */
962         if (hasr_read(ioaddr) & HASR_NO_CLK) {
963                 printk(KERN_WARNING
964                        "%s: wv_mmc_show: modem not connected\n",
965                        dev->name);
966                 return;
967         }
968
969         /* Read the mmc */
970         mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
971         mmc_read(ioaddr, 0, (u8 *) & m, sizeof(m));
972         mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
973
974         /* Don't forget to update statistics */
975         lp->wstats.discard.nwid +=
976             (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
977
978         printk(KERN_DEBUG "##### WaveLAN modem status registers: #####\n");
979 #ifdef DEBUG_SHOW_UNUSED
980         printk(KERN_DEBUG
981                "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
982                m.mmr_unused0[0], m.mmr_unused0[1], m.mmr_unused0[2],
983                m.mmr_unused0[3], m.mmr_unused0[4], m.mmr_unused0[5],
984                m.mmr_unused0[6], m.mmr_unused0[7]);
985 #endif                          /* DEBUG_SHOW_UNUSED */
986         printk(KERN_DEBUG "Encryption algorithm: %02X - Status: %02X\n",
987                m.mmr_des_avail, m.mmr_des_status);
988 #ifdef DEBUG_SHOW_UNUSED
989         printk(KERN_DEBUG "mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n",
990                m.mmr_unused1[0],
991                m.mmr_unused1[1],
992                m.mmr_unused1[2], m.mmr_unused1[3], m.mmr_unused1[4]);
993 #endif                          /* DEBUG_SHOW_UNUSED */
994         printk(KERN_DEBUG "dce_status: 0x%x [%s%s%s%s]\n",
995                m.mmr_dce_status,
996                (m.
997                 mmr_dce_status & MMR_DCE_STATUS_RX_BUSY) ?
998                "energy detected," : "",
999                (m.
1000                 mmr_dce_status & MMR_DCE_STATUS_LOOPT_IND) ?
1001                "loop test indicated," : "",
1002                (m.
1003                 mmr_dce_status & MMR_DCE_STATUS_TX_BUSY) ?
1004                "transmitter on," : "",
1005                (m.
1006                 mmr_dce_status & MMR_DCE_STATUS_JBR_EXPIRED) ?
1007                "jabber timer expired," : "");
1008         printk(KERN_DEBUG "Dsp ID: %02X\n", m.mmr_dsp_id);
1009 #ifdef DEBUG_SHOW_UNUSED
1010         printk(KERN_DEBUG "mmc_unused2[]: %02X:%02X\n",
1011                m.mmr_unused2[0], m.mmr_unused2[1]);
1012 #endif                          /* DEBUG_SHOW_UNUSED */
1013         printk(KERN_DEBUG "# correct_nwid: %d, # wrong_nwid: %d\n",
1014                (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l,
1015                (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l);
1016         printk(KERN_DEBUG "thr_pre_set: 0x%x [current signal %s]\n",
1017                m.mmr_thr_pre_set & MMR_THR_PRE_SET,
1018                (m.
1019                 mmr_thr_pre_set & MMR_THR_PRE_SET_CUR) ? "above" :
1020                "below");
1021         printk(KERN_DEBUG "signal_lvl: %d [%s], ",
1022                m.mmr_signal_lvl & MMR_SIGNAL_LVL,
1023                (m.
1024                 mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) ? "new msg" :
1025                "no new msg");
1026         printk("silence_lvl: %d [%s], ",
1027                m.mmr_silence_lvl & MMR_SILENCE_LVL,
1028                (m.
1029                 mmr_silence_lvl & MMR_SILENCE_LVL_VALID) ? "update done" :
1030                "no new update");
1031         printk("sgnl_qual: 0x%x [%s]\n", m.mmr_sgnl_qual & MMR_SGNL_QUAL,
1032                (m.
1033                 mmr_sgnl_qual & MMR_SGNL_QUAL_ANT) ? "Antenna 1" :
1034                "Antenna 0");
1035 #ifdef DEBUG_SHOW_UNUSED
1036         printk(KERN_DEBUG "netw_id_l: %x\n", m.mmr_netw_id_l);
1037 #endif                          /* DEBUG_SHOW_UNUSED */
1038 }                               /* wv_mmc_show */
1039 #endif                          /* DEBUG_MMC_SHOW */
1040
1041 #ifdef DEBUG_I82586_SHOW
1042 /*------------------------------------------------------------------*/
1043 /*
1044  * Print the last block of the i82586 memory.
1045  */
1046 static void wv_scb_show(unsigned long ioaddr)
1047 {
1048         scb_t scb;
1049
1050         obram_read(ioaddr, OFFSET_SCB, (unsigned char *) &scb,
1051                    sizeof(scb));
1052
1053         printk(KERN_DEBUG "##### WaveLAN system control block: #####\n");
1054
1055         printk(KERN_DEBUG "status: ");
1056         printk("stat 0x%x[%s%s%s%s] ",
1057                (scb.
1058                 scb_status & (SCB_ST_CX | SCB_ST_FR | SCB_ST_CNA |
1059                               SCB_ST_RNR)) >> 12,
1060                (scb.
1061                 scb_status & SCB_ST_CX) ? "command completion interrupt," :
1062                "", (scb.scb_status & SCB_ST_FR) ? "frame received," : "",
1063                (scb.
1064                 scb_status & SCB_ST_CNA) ? "command unit not active," : "",
1065                (scb.
1066                 scb_status & SCB_ST_RNR) ? "receiving unit not ready," :
1067                "");
1068         printk("cus 0x%x[%s%s%s] ", (scb.scb_status & SCB_ST_CUS) >> 8,
1069                ((scb.scb_status & SCB_ST_CUS) ==
1070                 SCB_ST_CUS_IDLE) ? "idle" : "",
1071                ((scb.scb_status & SCB_ST_CUS) ==
1072                 SCB_ST_CUS_SUSP) ? "suspended" : "",
1073                ((scb.scb_status & SCB_ST_CUS) ==
1074                 SCB_ST_CUS_ACTV) ? "active" : "");
1075         printk("rus 0x%x[%s%s%s%s]\n", (scb.scb_status & SCB_ST_RUS) >> 4,
1076                ((scb.scb_status & SCB_ST_RUS) ==
1077                 SCB_ST_RUS_IDLE) ? "idle" : "",
1078                ((scb.scb_status & SCB_ST_RUS) ==
1079                 SCB_ST_RUS_SUSP) ? "suspended" : "",
1080                ((scb.scb_status & SCB_ST_RUS) ==
1081                 SCB_ST_RUS_NRES) ? "no resources" : "",
1082                ((scb.scb_status & SCB_ST_RUS) ==
1083                 SCB_ST_RUS_RDY) ? "ready" : "");
1084
1085         printk(KERN_DEBUG "command: ");
1086         printk("ack 0x%x[%s%s%s%s] ",
1087                (scb.
1088                 scb_command & (SCB_CMD_ACK_CX | SCB_CMD_ACK_FR |
1089                                SCB_CMD_ACK_CNA | SCB_CMD_ACK_RNR)) >> 12,
1090                (scb.
1091                 scb_command & SCB_CMD_ACK_CX) ? "ack cmd completion," : "",
1092                (scb.
1093                 scb_command & SCB_CMD_ACK_FR) ? "ack frame received," : "",
1094                (scb.
1095                 scb_command & SCB_CMD_ACK_CNA) ? "ack CU not active," : "",
1096                (scb.
1097                 scb_command & SCB_CMD_ACK_RNR) ? "ack RU not ready," : "");
1098         printk("cuc 0x%x[%s%s%s%s%s] ",
1099                (scb.scb_command & SCB_CMD_CUC) >> 8,
1100                ((scb.scb_command & SCB_CMD_CUC) ==
1101                 SCB_CMD_CUC_NOP) ? "nop" : "",
1102                ((scb.scb_command & SCB_CMD_CUC) ==
1103                 SCB_CMD_CUC_GO) ? "start cbl_offset" : "",
1104                ((scb.scb_command & SCB_CMD_CUC) ==
1105                 SCB_CMD_CUC_RES) ? "resume execution" : "",
1106                ((scb.scb_command & SCB_CMD_CUC) ==
1107                 SCB_CMD_CUC_SUS) ? "suspend execution" : "",
1108                ((scb.scb_command & SCB_CMD_CUC) ==
1109                 SCB_CMD_CUC_ABT) ? "abort execution" : "");
1110         printk("ruc 0x%x[%s%s%s%s%s]\n",
1111                (scb.scb_command & SCB_CMD_RUC) >> 4,
1112                ((scb.scb_command & SCB_CMD_RUC) ==
1113                 SCB_CMD_RUC_NOP) ? "nop" : "",
1114                ((scb.scb_command & SCB_CMD_RUC) ==
1115                 SCB_CMD_RUC_GO) ? "start rfa_offset" : "",
1116                ((scb.scb_command & SCB_CMD_RUC) ==
1117                 SCB_CMD_RUC_RES) ? "resume reception" : "",
1118                ((scb.scb_command & SCB_CMD_RUC) ==
1119                 SCB_CMD_RUC_SUS) ? "suspend reception" : "",
1120                ((scb.scb_command & SCB_CMD_RUC) ==
1121                 SCB_CMD_RUC_ABT) ? "abort reception" : "");
1122
1123         printk(KERN_DEBUG "cbl_offset 0x%x ", scb.scb_cbl_offset);
1124         printk("rfa_offset 0x%x\n", scb.scb_rfa_offset);
1125
1126         printk(KERN_DEBUG "crcerrs %d ", scb.scb_crcerrs);
1127         printk("alnerrs %d ", scb.scb_alnerrs);
1128         printk("rscerrs %d ", scb.scb_rscerrs);
1129         printk("ovrnerrs %d\n", scb.scb_ovrnerrs);
1130 }
1131
1132 /*------------------------------------------------------------------*/
1133 /*
1134  * Print the formatted status of the i82586's receive unit.
1135  */
1136 static void wv_ru_show(struct net_device * dev)
1137 {
1138         /* net_local *lp = (net_local *) dev->priv; */
1139
1140         printk(KERN_DEBUG
1141                "##### WaveLAN i82586 receiver unit status: #####\n");
1142         printk(KERN_DEBUG "ru:");
1143         /*
1144          * Not implemented yet
1145          */
1146         printk("\n");
1147 }                               /* wv_ru_show */
1148
1149 /*------------------------------------------------------------------*/
1150 /*
1151  * Display info about one control block of the i82586 memory.
1152  */
1153 static void wv_cu_show_one(struct net_device * dev, net_local * lp, int i, u16 p)
1154 {
1155         unsigned long ioaddr;
1156         ac_tx_t actx;
1157
1158         ioaddr = dev->base_addr;
1159
1160         printk("%d: 0x%x:", i, p);
1161
1162         obram_read(ioaddr, p, (unsigned char *) &actx, sizeof(actx));
1163         printk(" status=0x%x,", actx.tx_h.ac_status);
1164         printk(" command=0x%x,", actx.tx_h.ac_command);
1165
1166         /*
1167            {
1168            tbd_t      tbd;
1169
1170            obram_read(ioaddr, actx.tx_tbd_offset, (unsigned char *)&tbd, sizeof(tbd));
1171            printk(" tbd_status=0x%x,", tbd.tbd_status);
1172            }
1173          */
1174
1175         printk("|");
1176 }
1177
1178 /*------------------------------------------------------------------*/
1179 /*
1180  * Print status of the command unit of the i82586.
1181  */
1182 static void wv_cu_show(struct net_device * dev)
1183 {
1184         net_local *lp = (net_local *) dev->priv;
1185         unsigned int i;
1186         u16 p;
1187
1188         printk(KERN_DEBUG
1189                "##### WaveLAN i82586 command unit status: #####\n");
1190
1191         printk(KERN_DEBUG);
1192         for (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++) {
1193                 wv_cu_show_one(dev, lp, i, p);
1194
1195                 p += TXBLOCKZ;
1196                 if (p >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
1197                         p -= NTXBLOCKS * TXBLOCKZ;
1198         }
1199         printk("\n");
1200 }
1201 #endif                          /* DEBUG_I82586_SHOW */
1202
1203 #ifdef DEBUG_DEVICE_SHOW
1204 /*------------------------------------------------------------------*/
1205 /*
1206  * Print the formatted status of the WaveLAN PCMCIA device driver.
1207  */
1208 static void wv_dev_show(struct net_device * dev)
1209 {
1210         printk(KERN_DEBUG "dev:");
1211         printk(" state=%lX,", dev->state);
1212         printk(" trans_start=%ld,", dev->trans_start);
1213         printk(" flags=0x%x,", dev->flags);
1214         printk("\n");
1215 }                               /* wv_dev_show */
1216
1217 /*------------------------------------------------------------------*/
1218 /*
1219  * Print the formatted status of the WaveLAN PCMCIA device driver's
1220  * private information.
1221  */
1222 static void wv_local_show(struct net_device * dev)
1223 {
1224         net_local *lp;
1225
1226         lp = (net_local *) dev->priv;
1227
1228         printk(KERN_DEBUG "local:");
1229         printk(" tx_n_in_use=%d,", lp->tx_n_in_use);
1230         printk(" hacr=0x%x,", lp->hacr);
1231         printk(" rx_head=0x%x,", lp->rx_head);
1232         printk(" rx_last=0x%x,", lp->rx_last);
1233         printk(" tx_first_free=0x%x,", lp->tx_first_free);
1234         printk(" tx_first_in_use=0x%x,", lp->tx_first_in_use);
1235         printk("\n");
1236 }                               /* wv_local_show */
1237 #endif                          /* DEBUG_DEVICE_SHOW */
1238
1239 #if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO)
1240 /*------------------------------------------------------------------*/
1241 /*
1242  * Dump packet header (and content if necessary) on the screen
1243  */
1244 static inline void wv_packet_info(u8 * p,       /* Packet to dump */
1245                                   int length,   /* Length of the packet */
1246                                   char *msg1,   /* Name of the device */
1247                                   char *msg2)
1248 {                               /* Name of the function */
1249         int i;
1250         int maxi;
1251
1252         printk(KERN_DEBUG
1253                "%s: %s(): dest %02X:%02X:%02X:%02X:%02X:%02X, length %d\n",
1254                msg1, msg2, p[0], p[1], p[2], p[3], p[4], p[5], length);
1255         printk(KERN_DEBUG
1256                "%s: %s(): src %02X:%02X:%02X:%02X:%02X:%02X, type 0x%02X%02X\n",
1257                msg1, msg2, p[6], p[7], p[8], p[9], p[10], p[11], p[12],
1258                p[13]);
1259
1260 #ifdef DEBUG_PACKET_DUMP
1261
1262         printk(KERN_DEBUG "data=\"");
1263
1264         if ((maxi = length) > DEBUG_PACKET_DUMP)
1265                 maxi = DEBUG_PACKET_DUMP;
1266         for (i = 14; i < maxi; i++)
1267                 if (p[i] >= ' ' && p[i] <= '~')
1268                         printk(" %c", p[i]);
1269                 else
1270                         printk("%02X", p[i]);
1271         if (maxi < length)
1272                 printk("..");
1273         printk("\"\n");
1274         printk(KERN_DEBUG "\n");
1275 #endif                          /* DEBUG_PACKET_DUMP */
1276 }
1277 #endif                          /* defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) */
1278
1279 /*------------------------------------------------------------------*/
1280 /*
1281  * This is the information which is displayed by the driver at startup.
1282  * There are lots of flags for configuring it to your liking.
1283  */
1284 static inline void wv_init_info(struct net_device * dev)
1285 {
1286         short ioaddr = dev->base_addr;
1287         net_local *lp = (net_local *) dev->priv;
1288         psa_t psa;
1289         int i;
1290
1291         /* Read the parameter storage area */
1292         psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa));
1293
1294 #ifdef DEBUG_PSA_SHOW
1295         wv_psa_show(&psa);
1296 #endif
1297 #ifdef DEBUG_MMC_SHOW
1298         wv_mmc_show(dev);
1299 #endif
1300 #ifdef DEBUG_I82586_SHOW
1301         wv_cu_show(dev);
1302 #endif
1303
1304 #ifdef DEBUG_BASIC_SHOW
1305         /* Now, let's go for the basic stuff. */
1306         printk(KERN_NOTICE "%s: WaveLAN at %#x,", dev->name, ioaddr);
1307         for (i = 0; i < WAVELAN_ADDR_SIZE; i++)
1308                 printk("%s%02X", (i == 0) ? " " : ":", dev->dev_addr[i]);
1309         printk(", IRQ %d", dev->irq);
1310
1311         /* Print current network ID. */
1312         if (psa.psa_nwid_select)
1313                 printk(", nwid 0x%02X-%02X", psa.psa_nwid[0],
1314                        psa.psa_nwid[1]);
1315         else
1316                 printk(", nwid off");
1317
1318         /* If 2.00 card */
1319         if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
1320               (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
1321                 unsigned short freq;
1322
1323                 /* Ask the EEPROM to read the frequency from the first area. */
1324                 fee_read(ioaddr, 0x00, &freq, 1);
1325
1326                 /* Print frequency */
1327                 printk(", 2.00, %ld", (freq >> 6) + 2400L);
1328
1329                 /* Hack! */
1330                 if (freq & 0x20)
1331                         printk(".5");
1332         } else {
1333                 printk(", PC");
1334                 switch (psa.psa_comp_number) {
1335                 case PSA_COMP_PC_AT_915:
1336                 case PSA_COMP_PC_AT_2400:
1337                         printk("-AT");
1338                         break;
1339                 case PSA_COMP_PC_MC_915:
1340                 case PSA_COMP_PC_MC_2400:
1341                         printk("-MC");
1342                         break;
1343                 case PSA_COMP_PCMCIA_915:
1344                         printk("MCIA");
1345                         break;
1346                 default:
1347                         printk("?");
1348                 }
1349                 printk(", ");
1350                 switch (psa.psa_subband) {
1351                 case PSA_SUBBAND_915:
1352                         printk("915");
1353                         break;
1354                 case PSA_SUBBAND_2425:
1355                         printk("2425");
1356                         break;
1357                 case PSA_SUBBAND_2460:
1358                         printk("2460");
1359                         break;
1360                 case PSA_SUBBAND_2484:
1361                         printk("2484");
1362                         break;
1363                 case PSA_SUBBAND_2430_5:
1364                         printk("2430.5");
1365                         break;
1366                 default:
1367                         printk("?");
1368                 }
1369         }
1370
1371         printk(" MHz\n");
1372 #endif                          /* DEBUG_BASIC_SHOW */
1373
1374 #ifdef DEBUG_VERSION_SHOW
1375         /* Print version information */
1376         printk(KERN_NOTICE "%s", version);
1377 #endif
1378 }                               /* wv_init_info */
1379
1380 /********************* IOCTL, STATS & RECONFIG *********************/
1381 /*
1382  * We found here routines that are called by Linux on different
1383  * occasions after the configuration and not for transmitting data
1384  * These may be called when the user use ifconfig, /proc/net/dev
1385  * or wireless extensions
1386  */
1387
1388 /*------------------------------------------------------------------*/
1389 /*
1390  * Get the current Ethernet statistics. This may be called with the
1391  * card open or closed.
1392  * Used when the user read /proc/net/dev
1393  */
1394 static en_stats *wavelan_get_stats(struct net_device * dev)
1395 {
1396 #ifdef DEBUG_IOCTL_TRACE
1397         printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name);
1398 #endif
1399
1400         return (&((net_local *) dev->priv)->stats);
1401 }
1402
1403 /*------------------------------------------------------------------*/
1404 /*
1405  * Set or clear the multicast filter for this adaptor.
1406  * num_addrs == -1      Promiscuous mode, receive all packets
1407  * num_addrs == 0       Normal mode, clear multicast list
1408  * num_addrs > 0        Multicast mode, receive normal and MC packets,
1409  *                      and do best-effort filtering.
1410  */
1411 static void wavelan_set_multicast_list(struct net_device * dev)
1412 {
1413         net_local *lp = (net_local *) dev->priv;
1414
1415 #ifdef DEBUG_IOCTL_TRACE
1416         printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n",
1417                dev->name);
1418 #endif
1419
1420 #ifdef DEBUG_IOCTL_INFO
1421         printk(KERN_DEBUG
1422                "%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
1423                dev->name, dev->flags, dev->mc_count);
1424 #endif
1425
1426         /* Are we asking for promiscuous mode,
1427          * or all multicast addresses (we don't have that!)
1428          * or too many multicast addresses for the hardware filter? */
1429         if ((dev->flags & IFF_PROMISC) ||
1430             (dev->flags & IFF_ALLMULTI) ||
1431             (dev->mc_count > I82586_MAX_MULTICAST_ADDRESSES)) {
1432                 /*
1433                  * Enable promiscuous mode: receive all packets.
1434                  */
1435                 if (!lp->promiscuous) {
1436                         lp->promiscuous = 1;
1437                         lp->mc_count = 0;
1438
1439                         wv_82586_reconfig(dev);
1440
1441                         /* Tell the kernel that we are doing a really bad job. */
1442                         dev->flags |= IFF_PROMISC;
1443                 }
1444         } else
1445                 /* Are there multicast addresses to send? */
1446         if (dev->mc_list != (struct dev_mc_list *) NULL) {
1447                 /*
1448                  * Disable promiscuous mode, but receive all packets
1449                  * in multicast list
1450                  */
1451 #ifdef MULTICAST_AVOID
1452                 if (lp->promiscuous || (dev->mc_count != lp->mc_count))
1453 #endif
1454                 {
1455                         lp->promiscuous = 0;
1456                         lp->mc_count = dev->mc_count;
1457
1458                         wv_82586_reconfig(dev);
1459                 }
1460         } else {
1461                 /*
1462                  * Switch to normal mode: disable promiscuous mode and 
1463                  * clear the multicast list.
1464                  */
1465                 if (lp->promiscuous || lp->mc_count == 0) {
1466                         lp->promiscuous = 0;
1467                         lp->mc_count = 0;
1468
1469                         wv_82586_reconfig(dev);
1470                 }
1471         }
1472 #ifdef DEBUG_IOCTL_TRACE
1473         printk(KERN_DEBUG "%s: <-wavelan_set_multicast_list()\n",
1474                dev->name);
1475 #endif
1476 }
1477
1478 /*------------------------------------------------------------------*/
1479 /*
1480  * This function doesn't exist.
1481  * (Note : it was a nice way to test the reconfigure stuff...)
1482  */
1483 #ifdef SET_MAC_ADDRESS
1484 static int wavelan_set_mac_address(struct net_device * dev, void *addr)
1485 {
1486         struct sockaddr *mac = addr;
1487
1488         /* Copy the address. */
1489         memcpy(dev->dev_addr, mac->sa_data, WAVELAN_ADDR_SIZE);
1490
1491         /* Reconfigure the beast. */
1492         wv_82586_reconfig(dev);
1493
1494         return 0;
1495 }
1496 #endif                          /* SET_MAC_ADDRESS */
1497
1498
1499 /*------------------------------------------------------------------*/
1500 /*
1501  * Frequency setting (for hardware capable of it)
1502  * It's a bit complicated and you don't really want to look into it.
1503  * (called in wavelan_ioctl)
1504  */
1505 static inline int wv_set_frequency(unsigned long ioaddr,        /* I/O port of the card */
1506                                    iw_freq * frequency)
1507 {
1508         const int BAND_NUM = 10;        /* Number of bands */
1509         long freq = 0L;         /* offset to 2.4 GHz in .5 MHz */
1510 #ifdef DEBUG_IOCTL_INFO
1511         int i;
1512 #endif
1513
1514         /* Setting by frequency */
1515         /* Theoretically, you may set any frequency between
1516          * the two limits with a 0.5 MHz precision. In practice,
1517          * I don't want you to have trouble with local regulations.
1518          */
1519         if ((frequency->e == 1) &&
1520             (frequency->m >= (int) 2.412e8)
1521             && (frequency->m <= (int) 2.487e8)) {
1522                 freq = ((frequency->m / 10000) - 24000L) / 5;
1523         }
1524
1525         /* Setting by channel (same as wfreqsel) */
1526         /* Warning: each channel is 22 MHz wide, so some of the channels
1527          * will interfere. */
1528         if ((frequency->e == 0) && (frequency->m < BAND_NUM)) {
1529                 /* Get frequency offset. */
1530                 freq = channel_bands[frequency->m] >> 1;
1531         }
1532
1533         /* Verify that the frequency is allowed. */
1534         if (freq != 0L) {
1535                 u16 table[10];  /* Authorized frequency table */
1536
1537                 /* Read the frequency table. */
1538                 fee_read(ioaddr, 0x71, table, 10);
1539
1540 #ifdef DEBUG_IOCTL_INFO
1541                 printk(KERN_DEBUG "Frequency table: ");
1542                 for (i = 0; i < 10; i++) {
1543                         printk(" %04X", table[i]);
1544                 }
1545                 printk("\n");
1546 #endif
1547
1548                 /* Look in the table to see whether the frequency is allowed. */
1549                 if (!(table[9 - ((freq - 24) / 16)] &
1550                       (1 << ((freq - 24) % 16)))) return -EINVAL;       /* not allowed */
1551         } else
1552                 return -EINVAL;
1553
1554         /* if we get a usable frequency */
1555         if (freq != 0L) {
1556                 unsigned short area[16];
1557                 unsigned short dac[2];
1558                 unsigned short area_verify[16];
1559                 unsigned short dac_verify[2];
1560                 /* Corresponding gain (in the power adjust value table)
1561                  * See AT&T WaveLAN Data Manual, REF 407-024689/E, page 3-8
1562                  * and WCIN062D.DOC, page 6.2.9. */
1563                 unsigned short power_limit[] = { 40, 80, 120, 160, 0 };
1564                 int power_band = 0;     /* Selected band */
1565                 unsigned short power_adjust;    /* Correct value */
1566
1567                 /* Search for the gain. */
1568                 power_band = 0;
1569                 while ((freq > power_limit[power_band]) &&
1570                        (power_limit[++power_band] != 0));
1571
1572                 /* Read the first area. */
1573                 fee_read(ioaddr, 0x00, area, 16);
1574
1575                 /* Read the DAC. */
1576                 fee_read(ioaddr, 0x60, dac, 2);
1577
1578                 /* Read the new power adjust value. */
1579                 fee_read(ioaddr, 0x6B - (power_band >> 1), &power_adjust,
1580                          1);
1581                 if (power_band & 0x1)
1582                         power_adjust >>= 8;
1583                 else
1584                         power_adjust &= 0xFF;
1585
1586 #ifdef DEBUG_IOCTL_INFO
1587                 printk(KERN_DEBUG "WaveLAN EEPROM Area 1: ");
1588                 for (i = 0; i < 16; i++) {
1589                         printk(" %04X", area[i]);
1590                 }
1591                 printk("\n");
1592
1593                 printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n",
1594                        dac[0], dac[1]);
1595 #endif
1596
1597                 /* Frequency offset (for info only) */
1598                 area[0] = ((freq << 5) & 0xFFE0) | (area[0] & 0x1F);
1599
1600                 /* Receiver Principle main divider coefficient */
1601                 area[3] = (freq >> 1) + 2400L - 352L;
1602                 area[2] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1603
1604                 /* Transmitter Main divider coefficient */
1605                 area[13] = (freq >> 1) + 2400L;
1606                 area[12] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1607
1608                 /* Other parts of the area are flags, bit streams or unused. */
1609
1610                 /* Set the value in the DAC. */
1611                 dac[1] = ((power_adjust >> 1) & 0x7F) | (dac[1] & 0xFF80);
1612                 dac[0] = ((power_adjust & 0x1) << 4) | (dac[0] & 0xFFEF);
1613
1614                 /* Write the first area. */
1615                 fee_write(ioaddr, 0x00, area, 16);
1616
1617                 /* Write the DAC. */
1618                 fee_write(ioaddr, 0x60, dac, 2);
1619
1620                 /* We now should verify here that the writing of the EEPROM went OK. */
1621
1622                 /* Reread the first area. */
1623                 fee_read(ioaddr, 0x00, area_verify, 16);
1624
1625                 /* Reread the DAC. */
1626                 fee_read(ioaddr, 0x60, dac_verify, 2);
1627
1628                 /* Compare. */
1629                 if (memcmp(area, area_verify, 16 * 2) ||
1630                     memcmp(dac, dac_verify, 2 * 2)) {
1631 #ifdef DEBUG_IOCTL_ERROR
1632                         printk(KERN_INFO
1633                                "WaveLAN: wv_set_frequency: unable to write new frequency to EEPROM(?).\n");
1634 #endif
1635                         return -EOPNOTSUPP;
1636                 }
1637
1638                 /* We must download the frequency parameters to the
1639                  * synthesizers (from the EEPROM - area 1)
1640                  * Note: as the EEPROM is automatically decremented, we set the end
1641                  * if the area... */
1642                 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x0F);
1643                 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
1644                         MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1645
1646                 /* Wait until the download is finished. */
1647                 fee_wait(ioaddr, 100, 100);
1648
1649                 /* We must now download the power adjust value (gain) to
1650                  * the synthesizers (from the EEPROM - area 7 - DAC). */
1651                 mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x61);
1652                 mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
1653                         MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1654
1655                 /* Wait for the download to finish. */
1656                 fee_wait(ioaddr, 100, 100);
1657
1658 #ifdef DEBUG_IOCTL_INFO
1659                 /* Verification of what we have done */
1660
1661                 printk(KERN_DEBUG "WaveLAN EEPROM Area 1: ");
1662                 for (i = 0; i < 16; i++) {
1663                         printk(" %04X", area_verify[i]);
1664                 }
1665                 printk("\n");
1666
1667                 printk(KERN_DEBUG "WaveLAN EEPROM DAC:  %04X %04X\n",
1668                        dac_verify[0], dac_verify[1]);
1669 #endif
1670
1671                 return 0;
1672         } else
1673                 return -EINVAL; /* Bah, never get there... */
1674 }
1675
1676 /*------------------------------------------------------------------*/
1677 /*
1678  * Give the list of available frequencies.
1679  */
1680 static inline int wv_frequency_list(unsigned long ioaddr,       /* I/O port of the card */
1681                                     iw_freq * list,     /* List of frequencies to fill */
1682                                     int max)
1683 {                               /* Maximum number of frequencies */
1684         u16 table[10];  /* Authorized frequency table */
1685         long freq = 0L;         /* offset to 2.4 GHz in .5 MHz + 12 MHz */
1686         int i;                  /* index in the table */
1687         int c = 0;              /* Channel number */
1688
1689         /* Read the frequency table. */
1690         fee_read(ioaddr, 0x71 /* frequency table */ , table, 10);
1691
1692         /* Check all frequencies. */
1693         i = 0;
1694         for (freq = 0; freq < 150; freq++)
1695                 /* Look in the table if the frequency is allowed */
1696                 if (table[9 - (freq / 16)] & (1 << (freq % 16))) {
1697                         /* Compute approximate channel number */
1698                         while ((((channel_bands[c] >> 1) - 24) < freq) &&
1699                                (c < NELS(channel_bands)))
1700                                 c++;
1701                         list[i].i = c;  /* Set the list index */
1702
1703                         /* put in the list */
1704                         list[i].m = (((freq + 24) * 5) + 24000L) * 10000;
1705                         list[i++].e = 1;
1706
1707                         /* Check number. */
1708                         if (i >= max)
1709                                 return (i);
1710                 }
1711
1712         return (i);
1713 }
1714
1715 #ifdef IW_WIRELESS_SPY
1716 /*------------------------------------------------------------------*/
1717 /*
1718  * Gather wireless spy statistics:  for each packet, compare the source
1719  * address with our list, and if they match, get the statistics.
1720  * Sorry, but this function really needs the wireless extensions.
1721  */
1722 static inline void wl_spy_gather(struct net_device * dev,
1723                                  u8 *   mac,    /* MAC address */
1724                                  u8 *   stats)  /* Statistics to gather */
1725 {
1726         struct iw_quality wstats;
1727
1728         wstats.qual = stats[2] & MMR_SGNL_QUAL;
1729         wstats.level = stats[0] & MMR_SIGNAL_LVL;
1730         wstats.noise = stats[1] & MMR_SILENCE_LVL;
1731         wstats.updated = 0x7;
1732
1733         /* Update spy records */
1734         wireless_spy_update(dev, mac, &wstats);
1735 }
1736 #endif /* IW_WIRELESS_SPY */
1737
1738 #ifdef HISTOGRAM
1739 /*------------------------------------------------------------------*/
1740 /*
1741  * This function calculates a histogram of the signal level.
1742  * As the noise is quite constant, it's like doing it on the SNR.
1743  * We have defined a set of interval (lp->his_range), and each time
1744  * the level goes in that interval, we increment the count (lp->his_sum).
1745  * With this histogram you may detect if one WaveLAN is really weak,
1746  * or you may also calculate the mean and standard deviation of the level.
1747  */
1748 static inline void wl_his_gather(struct net_device * dev, u8 * stats)
1749 {                               /* Statistics to gather */
1750         net_local *lp = (net_local *) dev->priv;
1751         u8 level = stats[0] & MMR_SIGNAL_LVL;
1752         int i;
1753
1754         /* Find the correct interval. */
1755         i = 0;
1756         while ((i < (lp->his_number - 1))
1757                && (level >= lp->his_range[i++]));
1758
1759         /* Increment interval counter. */
1760         (lp->his_sum[i])++;
1761 }
1762 #endif /* HISTOGRAM */
1763
1764 /*------------------------------------------------------------------*/
1765 /*
1766  * Wireless Handler : get protocol name
1767  */
1768 static int wavelan_get_name(struct net_device *dev,
1769                             struct iw_request_info *info,
1770                             union iwreq_data *wrqu,
1771                             char *extra)
1772 {
1773         strcpy(wrqu->name, "WaveLAN");
1774         return 0;
1775 }
1776
1777 /*------------------------------------------------------------------*/
1778 /*
1779  * Wireless Handler : set NWID
1780  */
1781 static int wavelan_set_nwid(struct net_device *dev,
1782                             struct iw_request_info *info,
1783                             union iwreq_data *wrqu,
1784                             char *extra)
1785 {
1786         unsigned long ioaddr = dev->base_addr;
1787         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
1788         psa_t psa;
1789         mm_t m;
1790         unsigned long flags;
1791         int ret = 0;
1792
1793         /* Disable interrupts and save flags. */
1794         spin_lock_irqsave(&lp->spinlock, flags);
1795         
1796         /* Set NWID in WaveLAN. */
1797         if (!wrqu->nwid.disabled) {
1798                 /* Set NWID in psa */
1799                 psa.psa_nwid[0] = (wrqu->nwid.value & 0xFF00) >> 8;
1800                 psa.psa_nwid[1] = wrqu->nwid.value & 0xFF;
1801                 psa.psa_nwid_select = 0x01;
1802                 psa_write(ioaddr, lp->hacr,
1803                           (char *) psa.psa_nwid - (char *) &psa,
1804                           (unsigned char *) psa.psa_nwid, 3);
1805
1806                 /* Set NWID in mmc. */
1807                 m.w.mmw_netw_id_l = psa.psa_nwid[1];
1808                 m.w.mmw_netw_id_h = psa.psa_nwid[0];
1809                 mmc_write(ioaddr,
1810                           (char *) &m.w.mmw_netw_id_l -
1811                           (char *) &m,
1812                           (unsigned char *) &m.w.mmw_netw_id_l, 2);
1813                 mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel), 0x00);
1814         } else {
1815                 /* Disable NWID in the psa. */
1816                 psa.psa_nwid_select = 0x00;
1817                 psa_write(ioaddr, lp->hacr,
1818                           (char *) &psa.psa_nwid_select -
1819                           (char *) &psa,
1820                           (unsigned char *) &psa.psa_nwid_select,
1821                           1);
1822
1823                 /* Disable NWID in the mmc (no filtering). */
1824                 mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel),
1825                         MMW_LOOPT_SEL_DIS_NWID);
1826         }
1827         /* update the Wavelan checksum */
1828         update_psa_checksum(dev, ioaddr, lp->hacr);
1829
1830         /* Enable interrupts and restore flags. */
1831         spin_unlock_irqrestore(&lp->spinlock, flags);
1832
1833         return ret;
1834 }
1835
1836 /*------------------------------------------------------------------*/
1837 /*
1838  * Wireless Handler : get NWID 
1839  */
1840 static int wavelan_get_nwid(struct net_device *dev,
1841                             struct iw_request_info *info,
1842                             union iwreq_data *wrqu,
1843                             char *extra)
1844 {
1845         unsigned long ioaddr = dev->base_addr;
1846         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
1847         psa_t psa;
1848         unsigned long flags;
1849         int ret = 0;
1850
1851         /* Disable interrupts and save flags. */
1852         spin_lock_irqsave(&lp->spinlock, flags);
1853         
1854         /* Read the NWID. */
1855         psa_read(ioaddr, lp->hacr,
1856                  (char *) psa.psa_nwid - (char *) &psa,
1857                  (unsigned char *) psa.psa_nwid, 3);
1858         wrqu->nwid.value = (psa.psa_nwid[0] << 8) + psa.psa_nwid[1];
1859         wrqu->nwid.disabled = !(psa.psa_nwid_select);
1860         wrqu->nwid.fixed = 1;   /* Superfluous */
1861
1862         /* Enable interrupts and restore flags. */
1863         spin_unlock_irqrestore(&lp->spinlock, flags);
1864
1865         return ret;
1866 }
1867
1868 /*------------------------------------------------------------------*/
1869 /*
1870  * Wireless Handler : set frequency
1871  */
1872 static int wavelan_set_freq(struct net_device *dev,
1873                             struct iw_request_info *info,
1874                             union iwreq_data *wrqu,
1875                             char *extra)
1876 {
1877         unsigned long ioaddr = dev->base_addr;
1878         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
1879         unsigned long flags;
1880         int ret;
1881
1882         /* Disable interrupts and save flags. */
1883         spin_lock_irqsave(&lp->spinlock, flags);
1884         
1885         /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
1886         if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
1887               (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
1888                 ret = wv_set_frequency(ioaddr, &(wrqu->freq));
1889         else
1890                 ret = -EOPNOTSUPP;
1891
1892         /* Enable interrupts and restore flags. */
1893         spin_unlock_irqrestore(&lp->spinlock, flags);
1894
1895         return ret;
1896 }
1897
1898 /*------------------------------------------------------------------*/
1899 /*
1900  * Wireless Handler : get frequency
1901  */
1902 static int wavelan_get_freq(struct net_device *dev,
1903                             struct iw_request_info *info,
1904                             union iwreq_data *wrqu,
1905                             char *extra)
1906 {
1907         unsigned long ioaddr = dev->base_addr;
1908         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
1909         psa_t psa;
1910         unsigned long flags;
1911         int ret = 0;
1912
1913         /* Disable interrupts and save flags. */
1914         spin_lock_irqsave(&lp->spinlock, flags);
1915         
1916         /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable).
1917          * Does it work for everybody, especially old cards? */
1918         if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
1919               (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
1920                 unsigned short freq;
1921
1922                 /* Ask the EEPROM to read the frequency from the first area. */
1923                 fee_read(ioaddr, 0x00, &freq, 1);
1924                 wrqu->freq.m = ((freq >> 5) * 5 + 24000L) * 10000;
1925                 wrqu->freq.e = 1;
1926         } else {
1927                 psa_read(ioaddr, lp->hacr,
1928                          (char *) &psa.psa_subband - (char *) &psa,
1929                          (unsigned char *) &psa.psa_subband, 1);
1930
1931                 if (psa.psa_subband <= 4) {
1932                         wrqu->freq.m = fixed_bands[psa.psa_subband];
1933                         wrqu->freq.e = (psa.psa_subband != 0);
1934                 } else
1935                         ret = -EOPNOTSUPP;
1936         }
1937
1938         /* Enable interrupts and restore flags. */
1939         spin_unlock_irqrestore(&lp->spinlock, flags);
1940
1941         return ret;
1942 }
1943
1944 /*------------------------------------------------------------------*/
1945 /*
1946  * Wireless Handler : set level threshold
1947  */
1948 static int wavelan_set_sens(struct net_device *dev,
1949                             struct iw_request_info *info,
1950                             union iwreq_data *wrqu,
1951                             char *extra)
1952 {
1953         unsigned long ioaddr = dev->base_addr;
1954         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
1955         psa_t psa;
1956         unsigned long flags;
1957         int ret = 0;
1958
1959         /* Disable interrupts and save flags. */
1960         spin_lock_irqsave(&lp->spinlock, flags);
1961         
1962         /* Set the level threshold. */
1963         /* We should complain loudly if wrqu->sens.fixed = 0, because we
1964          * can't set auto mode... */
1965         psa.psa_thr_pre_set = wrqu->sens.value & 0x3F;
1966         psa_write(ioaddr, lp->hacr,
1967                   (char *) &psa.psa_thr_pre_set - (char *) &psa,
1968                   (unsigned char *) &psa.psa_thr_pre_set, 1);
1969         /* update the Wavelan checksum */
1970         update_psa_checksum(dev, ioaddr, lp->hacr);
1971         mmc_out(ioaddr, mmwoff(0, mmw_thr_pre_set),
1972                 psa.psa_thr_pre_set);
1973
1974         /* Enable interrupts and restore flags. */
1975         spin_unlock_irqrestore(&lp->spinlock, flags);
1976
1977         return ret;
1978 }
1979
1980 /*------------------------------------------------------------------*/
1981 /*
1982  * Wireless Handler : get level threshold
1983  */
1984 static int wavelan_get_sens(struct net_device *dev,
1985                             struct iw_request_info *info,
1986                             union iwreq_data *wrqu,
1987                             char *extra)
1988 {
1989         unsigned long ioaddr = dev->base_addr;
1990         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
1991         psa_t psa;
1992         unsigned long flags;
1993         int ret = 0;
1994
1995         /* Disable interrupts and save flags. */
1996         spin_lock_irqsave(&lp->spinlock, flags);
1997         
1998         /* Read the level threshold. */
1999         psa_read(ioaddr, lp->hacr,
2000                  (char *) &psa.psa_thr_pre_set - (char *) &psa,
2001                  (unsigned char *) &psa.psa_thr_pre_set, 1);
2002         wrqu->sens.value = psa.psa_thr_pre_set & 0x3F;
2003         wrqu->sens.fixed = 1;
2004
2005         /* Enable interrupts and restore flags. */
2006         spin_unlock_irqrestore(&lp->spinlock, flags);
2007
2008         return ret;
2009 }
2010
2011 /*------------------------------------------------------------------*/
2012 /*
2013  * Wireless Handler : set encryption key
2014  */
2015 static int wavelan_set_encode(struct net_device *dev,
2016                               struct iw_request_info *info,
2017                               union iwreq_data *wrqu,
2018                               char *extra)
2019 {
2020         unsigned long ioaddr = dev->base_addr;
2021         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2022         unsigned long flags;
2023         psa_t psa;
2024         int ret = 0;
2025
2026         /* Disable interrupts and save flags. */
2027         spin_lock_irqsave(&lp->spinlock, flags);
2028
2029         /* Check if capable of encryption */
2030         if (!mmc_encr(ioaddr)) {
2031                 ret = -EOPNOTSUPP;
2032         }
2033
2034         /* Check the size of the key */
2035         if((wrqu->encoding.length != 8) && (wrqu->encoding.length != 0)) {
2036                 ret = -EINVAL;
2037         }
2038
2039         if(!ret) {
2040                 /* Basic checking... */
2041                 if (wrqu->encoding.length == 8) {
2042                         /* Copy the key in the driver */
2043                         memcpy(psa.psa_encryption_key, extra,
2044                                wrqu->encoding.length);
2045                         psa.psa_encryption_select = 1;
2046
2047                         psa_write(ioaddr, lp->hacr,
2048                                   (char *) &psa.psa_encryption_select -
2049                                   (char *) &psa,
2050                                   (unsigned char *) &psa.
2051                                   psa_encryption_select, 8 + 1);
2052
2053                         mmc_out(ioaddr, mmwoff(0, mmw_encr_enable),
2054                                 MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE);
2055                         mmc_write(ioaddr, mmwoff(0, mmw_encr_key),
2056                                   (unsigned char *) &psa.
2057                                   psa_encryption_key, 8);
2058                 }
2059
2060                 /* disable encryption */
2061                 if (wrqu->encoding.flags & IW_ENCODE_DISABLED) {
2062                         psa.psa_encryption_select = 0;
2063                         psa_write(ioaddr, lp->hacr,
2064                                   (char *) &psa.psa_encryption_select -
2065                                   (char *) &psa,
2066                                   (unsigned char *) &psa.
2067                                   psa_encryption_select, 1);
2068
2069                         mmc_out(ioaddr, mmwoff(0, mmw_encr_enable), 0);
2070                 }
2071                 /* update the Wavelan checksum */
2072                 update_psa_checksum(dev, ioaddr, lp->hacr);
2073         }
2074
2075         /* Enable interrupts and restore flags. */
2076         spin_unlock_irqrestore(&lp->spinlock, flags);
2077
2078         return ret;
2079 }
2080
2081 /*------------------------------------------------------------------*/
2082 /*
2083  * Wireless Handler : get encryption key
2084  */
2085 static int wavelan_get_encode(struct net_device *dev,
2086                               struct iw_request_info *info,
2087                               union iwreq_data *wrqu,
2088                               char *extra)
2089 {
2090         unsigned long ioaddr = dev->base_addr;
2091         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2092         psa_t psa;
2093         unsigned long flags;
2094         int ret = 0;
2095
2096         /* Disable interrupts and save flags. */
2097         spin_lock_irqsave(&lp->spinlock, flags);
2098         
2099         /* Check if encryption is available */
2100         if (!mmc_encr(ioaddr)) {
2101                 ret = -EOPNOTSUPP;
2102         } else {
2103                 /* Read the encryption key */
2104                 psa_read(ioaddr, lp->hacr,
2105                          (char *) &psa.psa_encryption_select -
2106                          (char *) &psa,
2107                          (unsigned char *) &psa.
2108                          psa_encryption_select, 1 + 8);
2109
2110                 /* encryption is enabled ? */
2111                 if (psa.psa_encryption_select)
2112                         wrqu->encoding.flags = IW_ENCODE_ENABLED;
2113                 else
2114                         wrqu->encoding.flags = IW_ENCODE_DISABLED;
2115                 wrqu->encoding.flags |= mmc_encr(ioaddr);
2116
2117                 /* Copy the key to the user buffer */
2118                 wrqu->encoding.length = 8;
2119                 memcpy(extra, psa.psa_encryption_key, wrqu->encoding.length);
2120         }
2121
2122         /* Enable interrupts and restore flags. */
2123         spin_unlock_irqrestore(&lp->spinlock, flags);
2124
2125         return ret;
2126 }
2127
2128 /*------------------------------------------------------------------*/
2129 /*
2130  * Wireless Handler : get range info
2131  */
2132 static int wavelan_get_range(struct net_device *dev,
2133                              struct iw_request_info *info,
2134                              union iwreq_data *wrqu,
2135                              char *extra)
2136 {
2137         unsigned long ioaddr = dev->base_addr;
2138         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2139         struct iw_range *range = (struct iw_range *) extra;
2140         unsigned long flags;
2141         int ret = 0;
2142
2143         /* Set the length (very important for backward compatibility) */
2144         wrqu->data.length = sizeof(struct iw_range);
2145
2146         /* Set all the info we don't care or don't know about to zero */
2147         memset(range, 0, sizeof(struct iw_range));
2148
2149         /* Set the Wireless Extension versions */
2150         range->we_version_compiled = WIRELESS_EXT;
2151         range->we_version_source = 9;
2152
2153         /* Set information in the range struct.  */
2154         range->throughput = 1.6 * 1000 * 1000;  /* don't argue on this ! */
2155         range->min_nwid = 0x0000;
2156         range->max_nwid = 0xFFFF;
2157
2158         range->sensitivity = 0x3F;
2159         range->max_qual.qual = MMR_SGNL_QUAL;
2160         range->max_qual.level = MMR_SIGNAL_LVL;
2161         range->max_qual.noise = MMR_SILENCE_LVL;
2162         range->avg_qual.qual = MMR_SGNL_QUAL; /* Always max */
2163         /* Need to get better values for those two */
2164         range->avg_qual.level = 30;
2165         range->avg_qual.noise = 8;
2166
2167         range->num_bitrates = 1;
2168         range->bitrate[0] = 2000000;    /* 2 Mb/s */
2169
2170         /* Event capability (kernel + driver) */
2171         range->event_capa[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2172                                 IW_EVENT_CAPA_MASK(0x8B04));
2173         range->event_capa[1] = IW_EVENT_CAPA_K_1;
2174
2175         /* Disable interrupts and save flags. */
2176         spin_lock_irqsave(&lp->spinlock, flags);
2177         
2178         /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
2179         if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
2180               (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
2181                 range->num_channels = 10;
2182                 range->num_frequency = wv_frequency_list(ioaddr, range->freq,
2183                                                         IW_MAX_FREQUENCIES);
2184         } else
2185                 range->num_channels = range->num_frequency = 0;
2186
2187         /* Encryption supported ? */
2188         if (mmc_encr(ioaddr)) {
2189                 range->encoding_size[0] = 8;    /* DES = 64 bits key */
2190                 range->num_encoding_sizes = 1;
2191                 range->max_encoding_tokens = 1; /* Only one key possible */
2192         } else {
2193                 range->num_encoding_sizes = 0;
2194                 range->max_encoding_tokens = 0;
2195         }
2196
2197         /* Enable interrupts and restore flags. */
2198         spin_unlock_irqrestore(&lp->spinlock, flags);
2199
2200         return ret;
2201 }
2202
2203 /*------------------------------------------------------------------*/
2204 /*
2205  * Wireless Private Handler : set quality threshold
2206  */
2207 static int wavelan_set_qthr(struct net_device *dev,
2208                             struct iw_request_info *info,
2209                             union iwreq_data *wrqu,
2210                             char *extra)
2211 {
2212         unsigned long ioaddr = dev->base_addr;
2213         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2214         psa_t psa;
2215         unsigned long flags;
2216
2217         /* Disable interrupts and save flags. */
2218         spin_lock_irqsave(&lp->spinlock, flags);
2219         
2220         psa.psa_quality_thr = *(extra) & 0x0F;
2221         psa_write(ioaddr, lp->hacr,
2222                   (char *) &psa.psa_quality_thr - (char *) &psa,
2223                   (unsigned char *) &psa.psa_quality_thr, 1);
2224         /* update the Wavelan checksum */
2225         update_psa_checksum(dev, ioaddr, lp->hacr);
2226         mmc_out(ioaddr, mmwoff(0, mmw_quality_thr),
2227                 psa.psa_quality_thr);
2228
2229         /* Enable interrupts and restore flags. */
2230         spin_unlock_irqrestore(&lp->spinlock, flags);
2231
2232         return 0;
2233 }
2234
2235 /*------------------------------------------------------------------*/
2236 /*
2237  * Wireless Private Handler : get quality threshold
2238  */
2239 static int wavelan_get_qthr(struct net_device *dev,
2240                             struct iw_request_info *info,
2241                             union iwreq_data *wrqu,
2242                             char *extra)
2243 {
2244         unsigned long ioaddr = dev->base_addr;
2245         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2246         psa_t psa;
2247         unsigned long flags;
2248
2249         /* Disable interrupts and save flags. */
2250         spin_lock_irqsave(&lp->spinlock, flags);
2251         
2252         psa_read(ioaddr, lp->hacr,
2253                  (char *) &psa.psa_quality_thr - (char *) &psa,
2254                  (unsigned char *) &psa.psa_quality_thr, 1);
2255         *(extra) = psa.psa_quality_thr & 0x0F;
2256
2257         /* Enable interrupts and restore flags. */
2258         spin_unlock_irqrestore(&lp->spinlock, flags);
2259
2260         return 0;
2261 }
2262
2263 #ifdef HISTOGRAM
2264 /*------------------------------------------------------------------*/
2265 /*
2266  * Wireless Private Handler : set histogram
2267  */
2268 static int wavelan_set_histo(struct net_device *dev,
2269                              struct iw_request_info *info,
2270                              union iwreq_data *wrqu,
2271                              char *extra)
2272 {
2273         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2274
2275         /* Check the number of intervals. */
2276         if (wrqu->data.length > 16) {
2277                 return(-E2BIG);
2278         }
2279
2280         /* Disable histo while we copy the addresses.
2281          * As we don't disable interrupts, we need to do this */
2282         lp->his_number = 0;
2283
2284         /* Are there ranges to copy? */
2285         if (wrqu->data.length > 0) {
2286                 /* Copy interval ranges to the driver */
2287                 memcpy(lp->his_range, extra, wrqu->data.length);
2288
2289                 {
2290                   int i;
2291                   printk(KERN_DEBUG "Histo :");
2292                   for(i = 0; i < wrqu->data.length; i++)
2293                     printk(" %d", lp->his_range[i]);
2294                   printk("\n");
2295                 }
2296
2297                 /* Reset result structure. */
2298                 memset(lp->his_sum, 0x00, sizeof(long) * 16);
2299         }
2300
2301         /* Now we can set the number of ranges */
2302         lp->his_number = wrqu->data.length;
2303
2304         return(0);
2305 }
2306
2307 /*------------------------------------------------------------------*/
2308 /*
2309  * Wireless Private Handler : get histogram
2310  */
2311 static int wavelan_get_histo(struct net_device *dev,
2312                              struct iw_request_info *info,
2313                              union iwreq_data *wrqu,
2314                              char *extra)
2315 {
2316         net_local *lp = (net_local *) dev->priv;        /* lp is not unused */
2317
2318         /* Set the number of intervals. */
2319         wrqu->data.length = lp->his_number;
2320
2321         /* Give back the distribution statistics */
2322         if(lp->his_number > 0)
2323                 memcpy(extra, lp->his_sum, sizeof(long) * lp->his_number);
2324
2325         return(0);
2326 }
2327 #endif                  /* HISTOGRAM */
2328
2329 /*------------------------------------------------------------------*/
2330 /*
2331  * Structures to export the Wireless Handlers
2332  */
2333
2334 static const iw_handler         wavelan_handler[] =
2335 {
2336         NULL,                           /* SIOCSIWNAME */
2337         wavelan_get_name,               /* SIOCGIWNAME */
2338         wavelan_set_nwid,               /* SIOCSIWNWID */
2339         wavelan_get_nwid,               /* SIOCGIWNWID */
2340         wavelan_set_freq,               /* SIOCSIWFREQ */
2341         wavelan_get_freq,               /* SIOCGIWFREQ */
2342         NULL,                           /* SIOCSIWMODE */
2343         NULL,                           /* SIOCGIWMODE */
2344         wavelan_set_sens,               /* SIOCSIWSENS */
2345         wavelan_get_sens,               /* SIOCGIWSENS */
2346         NULL,                           /* SIOCSIWRANGE */
2347         wavelan_get_range,              /* SIOCGIWRANGE */
2348         NULL,                           /* SIOCSIWPRIV */
2349         NULL,                           /* SIOCGIWPRIV */
2350         NULL,                           /* SIOCSIWSTATS */
2351         NULL,                           /* SIOCGIWSTATS */
2352         iw_handler_set_spy,             /* SIOCSIWSPY */
2353         iw_handler_get_spy,             /* SIOCGIWSPY */
2354         iw_handler_set_thrspy,          /* SIOCSIWTHRSPY */
2355         iw_handler_get_thrspy,          /* SIOCGIWTHRSPY */
2356         NULL,                           /* SIOCSIWAP */
2357         NULL,                           /* SIOCGIWAP */
2358         NULL,                           /* -- hole -- */
2359         NULL,                           /* SIOCGIWAPLIST */
2360         NULL,                           /* -- hole -- */
2361         NULL,                           /* -- hole -- */
2362         NULL,                           /* SIOCSIWESSID */
2363         NULL,                           /* SIOCGIWESSID */
2364         NULL,                           /* SIOCSIWNICKN */
2365         NULL,                           /* SIOCGIWNICKN */
2366         NULL,                           /* -- hole -- */
2367         NULL,                           /* -- hole -- */
2368         NULL,                           /* SIOCSIWRATE */
2369         NULL,                           /* SIOCGIWRATE */
2370         NULL,                           /* SIOCSIWRTS */
2371         NULL,                           /* SIOCGIWRTS */
2372         NULL,                           /* SIOCSIWFRAG */
2373         NULL,                           /* SIOCGIWFRAG */
2374         NULL,                           /* SIOCSIWTXPOW */
2375         NULL,                           /* SIOCGIWTXPOW */
2376         NULL,                           /* SIOCSIWRETRY */
2377         NULL,                           /* SIOCGIWRETRY */
2378         /* Bummer ! Why those are only at the end ??? */
2379         wavelan_set_encode,             /* SIOCSIWENCODE */
2380         wavelan_get_encode,             /* SIOCGIWENCODE */
2381 };
2382
2383 static const iw_handler         wavelan_private_handler[] =
2384 {
2385         wavelan_set_qthr,               /* SIOCIWFIRSTPRIV */
2386         wavelan_get_qthr,               /* SIOCIWFIRSTPRIV + 1 */
2387 #ifdef HISTOGRAM
2388         wavelan_set_histo,              /* SIOCIWFIRSTPRIV + 2 */
2389         wavelan_get_histo,              /* SIOCIWFIRSTPRIV + 3 */
2390 #endif  /* HISTOGRAM */
2391 };
2392
2393 static const struct iw_priv_args wavelan_private_args[] = {
2394 /*{ cmd,         set_args,                            get_args, name } */
2395   { SIOCSIPQTHR, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setqualthr" },
2396   { SIOCGIPQTHR, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getqualthr" },
2397   { SIOCSIPHISTO, IW_PRIV_TYPE_BYTE | 16,                    0, "sethisto" },
2398   { SIOCGIPHISTO, 0,                     IW_PRIV_TYPE_INT | 16, "gethisto" },
2399 };
2400
2401 static const struct iw_handler_def      wavelan_handler_def =
2402 {
2403         .num_standard   = sizeof(wavelan_handler)/sizeof(iw_handler),
2404         .num_private    = sizeof(wavelan_private_handler)/sizeof(iw_handler),
2405         .num_private_args = sizeof(wavelan_private_args)/sizeof(struct iw_priv_args),
2406         .standard       = wavelan_handler,
2407         .private        = wavelan_private_handler,
2408         .private_args   = wavelan_private_args,
2409         .get_wireless_stats = wavelan_get_wireless_stats,
2410 };
2411
2412 /*------------------------------------------------------------------*/
2413 /*
2414  * Get wireless statistics.
2415  * Called by /proc/net/wireless
2416  */
2417 static iw_stats *wavelan_get_wireless_stats(struct net_device * dev)
2418 {
2419         unsigned long ioaddr = dev->base_addr;
2420         net_local *lp = (net_local *) dev->priv;
2421         mmr_t m;
2422         iw_stats *wstats;
2423         unsigned long flags;
2424
2425 #ifdef DEBUG_IOCTL_TRACE
2426         printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n",
2427                dev->name);
2428 #endif
2429
2430         /* Check */
2431         if (lp == (net_local *) NULL)
2432                 return (iw_stats *) NULL;
2433         
2434         /* Disable interrupts and save flags. */
2435         spin_lock_irqsave(&lp->spinlock, flags);
2436         
2437         wstats = &lp->wstats;
2438
2439         /* Get data from the mmc. */
2440         mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
2441
2442         mmc_read(ioaddr, mmroff(0, mmr_dce_status), &m.mmr_dce_status, 1);
2443         mmc_read(ioaddr, mmroff(0, mmr_wrong_nwid_l), &m.mmr_wrong_nwid_l,
2444                  2);
2445         mmc_read(ioaddr, mmroff(0, mmr_thr_pre_set), &m.mmr_thr_pre_set,
2446                  4);
2447
2448         mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
2449
2450         /* Copy data to wireless stuff. */
2451         wstats->status = m.mmr_dce_status & MMR_DCE_STATUS;
2452         wstats->qual.qual = m.mmr_sgnl_qual & MMR_SGNL_QUAL;
2453         wstats->qual.level = m.mmr_signal_lvl & MMR_SIGNAL_LVL;
2454         wstats->qual.noise = m.mmr_silence_lvl & MMR_SILENCE_LVL;
2455         wstats->qual.updated = (((m. mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 7) 
2456                         | ((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 6) 
2457                         | ((m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) >> 5));
2458         wstats->discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
2459         wstats->discard.code = 0L;
2460         wstats->discard.misc = 0L;
2461
2462         /* Enable interrupts and restore flags. */
2463         spin_unlock_irqrestore(&lp->spinlock, flags);
2464
2465 #ifdef DEBUG_IOCTL_TRACE
2466         printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n",
2467                dev->name);
2468 #endif
2469         return &lp->wstats;
2470 }
2471
2472 /************************* PACKET RECEPTION *************************/
2473 /*
2474  * This part deals with receiving the packets.
2475  * The interrupt handler gets an interrupt when a packet has been
2476  * successfully received and calls this part.
2477  */
2478
2479 /*------------------------------------------------------------------*/
2480 /*
2481  * This routine does the actual copying of data (including the Ethernet
2482  * header structure) from the WaveLAN card to an sk_buff chain that
2483  * will be passed up to the network interface layer. NOTE: we
2484  * currently don't handle trailer protocols (neither does the rest of
2485  * the network interface), so if that is needed, it will (at least in
2486  * part) be added here.  The contents of the receive ring buffer are
2487  * copied to a message chain that is then passed to the kernel.
2488  *
2489  * Note: if any errors occur, the packet is "dropped on the floor".
2490  * (called by wv_packet_rcv())
2491  */
2492 static inline void
2493 wv_packet_read(struct net_device * dev, u16 buf_off, int sksize)
2494 {
2495         net_local *lp = (net_local *) dev->priv;
2496         unsigned long ioaddr = dev->base_addr;
2497         struct sk_buff *skb;
2498
2499 #ifdef DEBUG_RX_TRACE
2500         printk(KERN_DEBUG "%s: ->wv_packet_read(0x%X, %d)\n",
2501                dev->name, buf_off, sksize);
2502 #endif
2503
2504         /* Allocate buffer for the data */
2505         if ((skb = dev_alloc_skb(sksize)) == (struct sk_buff *) NULL) {
2506 #ifdef DEBUG_RX_ERROR
2507                 printk(KERN_INFO
2508                        "%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC).\n",
2509                        dev->name, sksize);
2510 #endif
2511                 lp->stats.rx_dropped++;
2512                 return;
2513         }
2514
2515         skb->dev = dev;
2516
2517         /* Copy the packet to the buffer. */
2518         obram_read(ioaddr, buf_off, skb_put(skb, sksize), sksize);
2519         skb->protocol = eth_type_trans(skb, dev);
2520
2521 #ifdef DEBUG_RX_INFO
2522         wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read");
2523 #endif                          /* DEBUG_RX_INFO */
2524
2525         /* Statistics-gathering and associated stuff.
2526          * It seem a bit messy with all the define, but it's really
2527          * simple... */
2528         if (
2529 #ifdef IW_WIRELESS_SPY          /* defined in iw_handler.h */
2530                    (lp->spy_data.spy_number > 0) ||
2531 #endif /* IW_WIRELESS_SPY */
2532 #ifdef HISTOGRAM
2533                    (lp->his_number > 0) ||
2534 #endif /* HISTOGRAM */
2535                    0) {
2536                 u8 stats[3];    /* signal level, noise level, signal quality */
2537
2538                 /* Read signal level, silence level and signal quality bytes */
2539                 /* Note: in the PCMCIA hardware, these are part of the frame.
2540                  * It seems that for the ISA hardware, it's nowhere to be
2541                  * found in the frame, so I'm obliged to do this (it has a
2542                  * side effect on /proc/net/wireless).
2543                  * Any ideas?
2544                  */
2545                 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
2546                 mmc_read(ioaddr, mmroff(0, mmr_signal_lvl), stats, 3);
2547                 mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
2548
2549 #ifdef DEBUG_RX_INFO
2550                 printk(KERN_DEBUG
2551                        "%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2552                        dev->name, stats[0] & 0x3F, stats[1] & 0x3F,
2553                        stats[2] & 0x0F);
2554 #endif
2555
2556                 /* Spying stuff */
2557 #ifdef IW_WIRELESS_SPY
2558                 wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE,
2559                               stats);
2560 #endif /* IW_WIRELESS_SPY */
2561 #ifdef HISTOGRAM
2562                 wl_his_gather(dev, stats);
2563 #endif /* HISTOGRAM */
2564         }
2565
2566         /*
2567          * Hand the packet to the network module.
2568          */
2569         netif_rx(skb);
2570
2571         /* Keep statistics up to date */
2572         dev->last_rx = jiffies;
2573         lp->stats.rx_packets++;
2574         lp->stats.rx_bytes += sksize;
2575
2576 #ifdef DEBUG_RX_TRACE
2577         printk(KERN_DEBUG "%s: <-wv_packet_read()\n", dev->name);
2578 #endif
2579 }
2580
2581 /*------------------------------------------------------------------*/
2582 /*
2583  * Transfer as many packets as we can
2584  * from the device RAM.
2585  * (called in wavelan_interrupt()).
2586  * Note : the spinlock is already grabbed for us.
2587  */
2588 static inline void wv_receive(struct net_device * dev)
2589 {
2590         unsigned long ioaddr = dev->base_addr;
2591         net_local *lp = (net_local *) dev->priv;
2592         fd_t fd;
2593         rbd_t rbd;
2594         int nreaped = 0;
2595
2596 #ifdef DEBUG_RX_TRACE
2597         printk(KERN_DEBUG "%s: ->wv_receive()\n", dev->name);
2598 #endif
2599
2600         /* Loop on each received packet. */
2601         for (;;) {
2602                 obram_read(ioaddr, lp->rx_head, (unsigned char *) &fd,
2603                            sizeof(fd));
2604
2605                 /* Note about the status :
2606                  * It start up to be 0 (the value we set). Then, when the RU
2607                  * grab the buffer to prepare for reception, it sets the
2608                  * FD_STATUS_B flag. When the RU has finished receiving the
2609                  * frame, it clears FD_STATUS_B, set FD_STATUS_C to indicate
2610                  * completion and set the other flags to indicate the eventual
2611                  * errors. FD_STATUS_OK indicates that the reception was OK.
2612                  */
2613
2614                 /* If the current frame is not complete, we have reached the end. */
2615                 if ((fd.fd_status & FD_STATUS_C) != FD_STATUS_C)
2616                         break;  /* This is how we exit the loop. */
2617
2618                 nreaped++;
2619
2620                 /* Check whether frame was correctly received. */
2621                 if ((fd.fd_status & FD_STATUS_OK) == FD_STATUS_OK) {
2622                         /* Does the frame contain a pointer to the data?  Let's check. */
2623                         if (fd.fd_rbd_offset != I82586NULL) {
2624                                 /* Read the receive buffer descriptor */
2625                                 obram_read(ioaddr, fd.fd_rbd_offset,
2626                                            (unsigned char *) &rbd,
2627                                            sizeof(rbd));
2628
2629 #ifdef DEBUG_RX_ERROR
2630                                 if ((rbd.rbd_status & RBD_STATUS_EOF) !=
2631                                     RBD_STATUS_EOF) printk(KERN_INFO
2632                                                            "%s: wv_receive(): missing EOF flag.\n",
2633                                                            dev->name);
2634
2635                                 if ((rbd.rbd_status & RBD_STATUS_F) !=
2636                                     RBD_STATUS_F) printk(KERN_INFO
2637                                                          "%s: wv_receive(): missing F flag.\n",
2638                                                          dev->name);
2639 #endif                          /* DEBUG_RX_ERROR */
2640
2641                                 /* Read the packet and transmit to Linux */
2642                                 wv_packet_read(dev, rbd.rbd_bufl,
2643                                                rbd.
2644                                                rbd_status &
2645                                                RBD_STATUS_ACNT);
2646                         }
2647 #ifdef DEBUG_RX_ERROR
2648                         else    /* if frame has no data */
2649                                 printk(KERN_INFO
2650                                        "%s: wv_receive(): frame has no data.\n",
2651                                        dev->name);
2652 #endif
2653                 } else {        /* If reception was no successful */
2654
2655                         lp->stats.rx_errors++;
2656
2657 #ifdef DEBUG_RX_INFO
2658                         printk(KERN_DEBUG
2659                                "%s: wv_receive(): frame not received successfully (%X).\n",
2660                                dev->name, fd.fd_status);
2661 #endif
2662
2663 #ifdef DEBUG_RX_ERROR
2664                         if ((fd.fd_status & FD_STATUS_S6) != 0)
2665                                 printk(KERN_INFO
2666                                        "%s: wv_receive(): no EOF flag.\n",
2667                                        dev->name);
2668 #endif
2669
2670                         if ((fd.fd_status & FD_STATUS_S7) != 0) {
2671                                 lp->stats.rx_length_errors++;
2672 #ifdef DEBUG_RX_FAIL
2673                                 printk(KERN_DEBUG
2674                                        "%s: wv_receive(): frame too short.\n",
2675                                        dev->name);
2676 #endif
2677                         }
2678
2679                         if ((fd.fd_status & FD_STATUS_S8) != 0) {
2680                                 lp->stats.rx_over_errors++;
2681 #ifdef DEBUG_RX_FAIL
2682                                 printk(KERN_DEBUG
2683                                        "%s: wv_receive(): rx DMA overrun.\n",
2684                                        dev->name);
2685 #endif
2686                         }
2687
2688                         if ((fd.fd_status & FD_STATUS_S9) != 0) {
2689                                 lp->stats.rx_fifo_errors++;
2690 #ifdef DEBUG_RX_FAIL
2691                                 printk(KERN_DEBUG
2692                                        "%s: wv_receive(): ran out of resources.\n",
2693                                        dev->name);
2694 #endif
2695                         }
2696
2697                         if ((fd.fd_status & FD_STATUS_S10) != 0) {
2698                                 lp->stats.rx_frame_errors++;
2699 #ifdef DEBUG_RX_FAIL
2700                                 printk(KERN_DEBUG
2701                                        "%s: wv_receive(): alignment error.\n",
2702                                        dev->name);
2703 #endif
2704                         }
2705
2706                         if ((fd.fd_status & FD_STATUS_S11) != 0) {
2707                                 lp->stats.rx_crc_errors++;
2708 #ifdef DEBUG_RX_FAIL
2709                                 printk(KERN_DEBUG
2710                                        "%s: wv_receive(): CRC error.\n",
2711                                        dev->name);
2712 #endif
2713                         }
2714                 }
2715
2716                 fd.fd_status = 0;
2717                 obram_write(ioaddr, fdoff(lp->rx_head, fd_status),
2718                             (unsigned char *) &fd.fd_status,
2719                             sizeof(fd.fd_status));
2720
2721                 fd.fd_command = FD_COMMAND_EL;
2722                 obram_write(ioaddr, fdoff(lp->rx_head, fd_command),
2723                             (unsigned char *) &fd.fd_command,
2724                             sizeof(fd.fd_command));
2725
2726                 fd.fd_command = 0;
2727                 obram_write(ioaddr, fdoff(lp->rx_last, fd_command),
2728                             (unsigned char *) &fd.fd_command,
2729                             sizeof(fd.fd_command));
2730
2731                 lp->rx_last = lp->rx_head;
2732                 lp->rx_head = fd.fd_link_offset;
2733         }                       /* for(;;) -> loop on all frames */
2734
2735 #ifdef DEBUG_RX_INFO
2736         if (nreaped > 1)
2737                 printk(KERN_DEBUG "%s: wv_receive(): reaped %d\n",
2738                        dev->name, nreaped);
2739 #endif
2740 #ifdef DEBUG_RX_TRACE
2741         printk(KERN_DEBUG "%s: <-wv_receive()\n", dev->name);
2742 #endif
2743 }
2744
2745 /*********************** PACKET TRANSMISSION ***********************/
2746 /*
2747  * This part deals with sending packets through the WaveLAN.
2748  *
2749  */
2750
2751 /*------------------------------------------------------------------*/
2752 /*
2753  * This routine fills in the appropriate registers and memory
2754  * locations on the WaveLAN card and starts the card off on
2755  * the transmit.
2756  *
2757  * The principle:
2758  * Each block contains a transmit command, a NOP command,
2759  * a transmit block descriptor and a buffer.
2760  * The CU read the transmit block which point to the tbd,
2761  * read the tbd and the content of the buffer.
2762  * When it has finish with it, it goes to the next command
2763  * which in our case is the NOP. The NOP points on itself,
2764  * so the CU stop here.
2765  * When we add the next block, we modify the previous nop
2766  * to make it point on the new tx command.
2767  * Simple, isn't it ?
2768  *
2769  * (called in wavelan_packet_xmit())
2770  */
2771 static inline int wv_packet_write(struct net_device * dev, void *buf, short length)
2772 {
2773         net_local *lp = (net_local *) dev->priv;
2774         unsigned long ioaddr = dev->base_addr;
2775         unsigned short txblock;
2776         unsigned short txpred;
2777         unsigned short tx_addr;
2778         unsigned short nop_addr;
2779         unsigned short tbd_addr;
2780         unsigned short buf_addr;
2781         ac_tx_t tx;
2782         ac_nop_t nop;
2783         tbd_t tbd;
2784         int clen = length;
2785         unsigned long flags;
2786
2787 #ifdef DEBUG_TX_TRACE
2788         printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name,
2789                length);
2790 #endif
2791
2792         spin_lock_irqsave(&lp->spinlock, flags);
2793
2794         /* Check nothing bad has happened */
2795         if (lp->tx_n_in_use == (NTXBLOCKS - 1)) {
2796 #ifdef DEBUG_TX_ERROR
2797                 printk(KERN_INFO "%s: wv_packet_write(): Tx queue full.\n",
2798                        dev->name);
2799 #endif
2800                 spin_unlock_irqrestore(&lp->spinlock, flags);
2801                 return 1;
2802         }
2803
2804         /* Calculate addresses of next block and previous block. */
2805         txblock = lp->tx_first_free;
2806         txpred = txblock - TXBLOCKZ;
2807         if (txpred < OFFSET_CU)
2808                 txpred += NTXBLOCKS * TXBLOCKZ;
2809         lp->tx_first_free += TXBLOCKZ;
2810         if (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
2811                 lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
2812
2813         lp->tx_n_in_use++;
2814
2815         /* Calculate addresses of the different parts of the block. */
2816         tx_addr = txblock;
2817         nop_addr = tx_addr + sizeof(tx);
2818         tbd_addr = nop_addr + sizeof(nop);
2819         buf_addr = tbd_addr + sizeof(tbd);
2820
2821         /*
2822          * Transmit command
2823          */
2824         tx.tx_h.ac_status = 0;
2825         obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status),
2826                     (unsigned char *) &tx.tx_h.ac_status,
2827                     sizeof(tx.tx_h.ac_status));
2828
2829         /*
2830          * NOP command
2831          */
2832         nop.nop_h.ac_status = 0;
2833         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
2834                     (unsigned char *) &nop.nop_h.ac_status,
2835                     sizeof(nop.nop_h.ac_status));
2836         nop.nop_h.ac_link = nop_addr;
2837         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
2838                     (unsigned char *) &nop.nop_h.ac_link,
2839                     sizeof(nop.nop_h.ac_link));
2840
2841         /*
2842          * Transmit buffer descriptor
2843          */
2844         tbd.tbd_status = TBD_STATUS_EOF | (TBD_STATUS_ACNT & clen);
2845         tbd.tbd_next_bd_offset = I82586NULL;
2846         tbd.tbd_bufl = buf_addr;
2847         tbd.tbd_bufh = 0;
2848         obram_write(ioaddr, tbd_addr, (unsigned char *) &tbd, sizeof(tbd));
2849
2850         /*
2851          * Data
2852          */
2853         obram_write(ioaddr, buf_addr, buf, length);
2854
2855         /*
2856          * Overwrite the predecessor NOP link
2857          * so that it points to this txblock.
2858          */
2859         nop_addr = txpred + sizeof(tx);
2860         nop.nop_h.ac_status = 0;
2861         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
2862                     (unsigned char *) &nop.nop_h.ac_status,
2863                     sizeof(nop.nop_h.ac_status));
2864         nop.nop_h.ac_link = txblock;
2865         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
2866                     (unsigned char *) &nop.nop_h.ac_link,
2867                     sizeof(nop.nop_h.ac_link));
2868
2869         /* Make sure the watchdog will keep quiet for a while */
2870         dev->trans_start = jiffies;
2871
2872         /* Keep stats up to date. */
2873         lp->stats.tx_bytes += length;
2874
2875         if (lp->tx_first_in_use == I82586NULL)
2876                 lp->tx_first_in_use = txblock;
2877
2878         if (lp->tx_n_in_use < NTXBLOCKS - 1)
2879                 netif_wake_queue(dev);
2880
2881         spin_unlock_irqrestore(&lp->spinlock, flags);
2882         
2883 #ifdef DEBUG_TX_INFO
2884         wv_packet_info((u8 *) buf, length, dev->name,
2885                        "wv_packet_write");
2886 #endif                          /* DEBUG_TX_INFO */
2887
2888 #ifdef DEBUG_TX_TRACE
2889         printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name);
2890 #endif
2891
2892         return 0;
2893 }
2894
2895 /*------------------------------------------------------------------*/
2896 /*
2897  * This routine is called when we want to send a packet (NET3 callback)
2898  * In this routine, we check if the harware is ready to accept
2899  * the packet.  We also prevent reentrance.  Then we call the function
2900  * to send the packet.
2901  */
2902 static int wavelan_packet_xmit(struct sk_buff *skb, struct net_device * dev)
2903 {
2904         net_local *lp = (net_local *) dev->priv;
2905         unsigned long flags;
2906
2907 #ifdef DEBUG_TX_TRACE
2908         printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
2909                (unsigned) skb);
2910 #endif
2911
2912         /*
2913          * Block a timer-based transmit from overlapping.
2914          * In other words, prevent reentering this routine.
2915          */
2916         netif_stop_queue(dev);
2917
2918         /* If somebody has asked to reconfigure the controller, 
2919          * we can do it now.
2920          */
2921         if (lp->reconfig_82586) {
2922                 spin_lock_irqsave(&lp->spinlock, flags);
2923                 wv_82586_config(dev);
2924                 spin_unlock_irqrestore(&lp->spinlock, flags);
2925                 /* Check that we can continue */
2926                 if (lp->tx_n_in_use == (NTXBLOCKS - 1))
2927                         return 1;
2928         }
2929 #ifdef DEBUG_TX_ERROR
2930         if (skb->next)
2931                 printk(KERN_INFO "skb has next\n");
2932 #endif
2933
2934         /* Do we need some padding? */
2935         /* Note : on wireless the propagation time is in the order of 1us,
2936          * and we don't have the Ethernet specific requirement of beeing
2937          * able to detect collisions, therefore in theory we don't really
2938          * need to pad. Jean II */
2939         if (skb->len < ETH_ZLEN) {
2940                 skb = skb_padto(skb, ETH_ZLEN);
2941                 if (skb == NULL)
2942                         return 0;
2943         }
2944
2945         /* Write packet on the card */
2946         if(wv_packet_write(dev, skb->data, skb->len))
2947                 return 1;       /* We failed */
2948
2949         dev_kfree_skb(skb);
2950
2951 #ifdef DEBUG_TX_TRACE
2952         printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
2953 #endif
2954         return 0;
2955 }
2956
2957 /*********************** HARDWARE CONFIGURATION ***********************/
2958 /*
2959  * This part does the real job of starting and configuring the hardware.
2960  */
2961
2962 /*--------------------------------------------------------------------*/
2963 /*
2964  * Routine to initialize the Modem Management Controller.
2965  * (called by wv_hw_reset())
2966  */
2967 static inline int wv_mmc_init(struct net_device * dev)
2968 {
2969         unsigned long ioaddr = dev->base_addr;
2970         net_local *lp = (net_local *) dev->priv;
2971         psa_t psa;
2972         mmw_t m;
2973         int configured;
2974
2975 #ifdef DEBUG_CONFIG_TRACE
2976         printk(KERN_DEBUG "%s: ->wv_mmc_init()\n", dev->name);
2977 #endif
2978
2979         /* Read the parameter storage area. */
2980         psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa));
2981
2982 #ifdef USE_PSA_CONFIG
2983         configured = psa.psa_conf_status & 1;
2984 #else
2985         configured = 0;
2986 #endif
2987
2988         /* Is the PSA is not configured */
2989         if (!configured) {
2990                 /* User will be able to configure NWID later (with iwconfig). */
2991                 psa.psa_nwid[0] = 0;
2992                 psa.psa_nwid[1] = 0;
2993
2994                 /* no NWID checking since NWID is not set */
2995                 psa.psa_nwid_select = 0;
2996
2997                 /* Disable encryption */
2998                 psa.psa_encryption_select = 0;
2999
3000                 /* Set to standard values:
3001                  * 0x04 for AT,
3002                  * 0x01 for MCA,
3003                  * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
3004                  */
3005                 if (psa.psa_comp_number & 1)
3006                         psa.psa_thr_pre_set = 0x01;
3007                 else
3008                         psa.psa_thr_pre_set = 0x04;
3009                 psa.psa_quality_thr = 0x03;
3010
3011                 /* It is configured */
3012                 psa.psa_conf_status |= 1;
3013
3014 #ifdef USE_PSA_CONFIG
3015                 /* Write the psa. */
3016                 psa_write(ioaddr, lp->hacr,
3017                           (char *) psa.psa_nwid - (char *) &psa,
3018                           (unsigned char *) psa.psa_nwid, 4);
3019                 psa_write(ioaddr, lp->hacr,
3020                           (char *) &psa.psa_thr_pre_set - (char *) &psa,
3021                           (unsigned char *) &psa.psa_thr_pre_set, 1);
3022                 psa_write(ioaddr, lp->hacr,
3023                           (char *) &psa.psa_quality_thr - (char *) &psa,
3024                           (unsigned char *) &psa.psa_quality_thr, 1);
3025                 psa_write(ioaddr, lp->hacr,
3026                           (char *) &psa.psa_conf_status - (char *) &psa,
3027                           (unsigned char *) &psa.psa_conf_status, 1);
3028                 /* update the Wavelan checksum */
3029                 update_psa_checksum(dev, ioaddr, lp->hacr);
3030 #endif
3031         }
3032
3033         /* Zero the mmc structure. */
3034         memset(&m, 0x00, sizeof(m));
3035
3036         /* Copy PSA info to the mmc. */
3037         m.mmw_netw_id_l = psa.psa_nwid[1];
3038         m.mmw_netw_id_h = psa.psa_nwid[0];
3039
3040         if (psa.psa_nwid_select & 1)
3041                 m.mmw_loopt_sel = 0x00;
3042         else
3043                 m.mmw_loopt_sel = MMW_LOOPT_SEL_DIS_NWID;
3044
3045         memcpy(&m.mmw_encr_key, &psa.psa_encryption_key,
3046                sizeof(m.mmw_encr_key));
3047
3048         if (psa.psa_encryption_select)
3049                 m.mmw_encr_enable =
3050                     MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE;
3051         else
3052                 m.mmw_encr_enable = 0;
3053
3054         m.mmw_thr_pre_set = psa.psa_thr_pre_set & 0x3F;
3055         m.mmw_quality_thr = psa.psa_quality_thr & 0x0F;
3056
3057         /*
3058          * Set default modem control parameters.
3059          * See NCR document 407-0024326 Rev. A.
3060          */
3061         m.mmw_jabber_enable = 0x01;
3062         m.mmw_freeze = 0;
3063         m.mmw_anten_sel = MMW_ANTEN_SEL_ALG_EN;
3064         m.mmw_ifs = 0x20;
3065         m.mmw_mod_delay = 0x04;
3066         m.mmw_jam_time = 0x38;
3067
3068         m.mmw_des_io_invert = 0;
3069         m.mmw_decay_prm = 0;
3070         m.mmw_decay_updat_prm = 0;
3071
3072         /* Write all info to MMC. */
3073         mmc_write(ioaddr, 0, (u8 *) & m, sizeof(m));
3074
3075         /* The following code starts the modem of the 2.00 frequency
3076          * selectable cards at power on.  It's not strictly needed for the
3077          * following boots.
3078          * The original patch was by Joe Finney for the PCMCIA driver, but
3079          * I've cleaned it up a bit and added documentation.
3080          * Thanks to Loeke Brederveld from Lucent for the info.
3081          */
3082
3083         /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
3084          * Does it work for everybody, especially old cards? */
3085         /* Note: WFREQSEL verifies that it is able to read a sensible
3086          * frequency from EEPROM (address 0x00) and that MMR_FEE_STATUS_ID
3087          * is 0xA (Xilinx version) or 0xB (Ariadne version).
3088          * My test is more crude but does work. */
3089         if (!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
3090               (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
3091                 /* We must download the frequency parameters to the
3092                  * synthesizers (from the EEPROM - area 1)
3093                  * Note: as the EEPROM is automatically decremented, we set the end
3094                  * if the area... */
3095                 m.mmw_fee_addr = 0x0F;
3096                 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3097                 mmc_write(ioaddr, (char *) &m.mmw_fee_ctrl - (char *) &m,
3098                           (unsigned char *) &m.mmw_fee_ctrl, 2);
3099
3100                 /* Wait until the download is finished. */
3101                 fee_wait(ioaddr, 100, 100);
3102
3103 #ifdef DEBUG_CONFIG_INFO
3104                 /* The frequency was in the last word downloaded. */
3105                 mmc_read(ioaddr, (char *) &m.mmw_fee_data_l - (char *) &m,
3106                          (unsigned char *) &m.mmw_fee_data_l, 2);
3107
3108                 /* Print some info for the user. */
3109                 printk(KERN_DEBUG
3110                        "%s: WaveLAN 2.00 recognised (frequency select).  Current frequency = %ld\n",
3111                        dev->name,
3112                        ((m.
3113                          mmw_fee_data_h << 4) | (m.mmw_fee_data_l >> 4)) *
3114                        5 / 2 + 24000L);
3115 #endif
3116
3117                 /* We must now download the power adjust value (gain) to
3118                  * the synthesizers (from the EEPROM - area 7 - DAC). */
3119                 m.mmw_fee_addr = 0x61;
3120                 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3121                 mmc_write(ioaddr, (char *) &m.mmw_fee_ctrl - (char *) &m,
3122                           (unsigned char *) &m.mmw_fee_ctrl, 2);
3123
3124                 /* Wait until the download is finished. */
3125         }
3126         /* if 2.00 card */
3127 #ifdef DEBUG_CONFIG_TRACE
3128         printk(KERN_DEBUG "%s: <-wv_mmc_init()\n", dev->name);
3129 #endif
3130         return 0;
3131 }
3132
3133 /*------------------------------------------------------------------*/
3134 /*
3135  * Construct the fd and rbd structures.
3136  * Start the receive unit.
3137  * (called by wv_hw_reset())
3138  */
3139 static inline int wv_ru_start(struct net_device * dev)
3140 {
3141         net_local *lp = (net_local *) dev->priv;
3142         unsigned long ioaddr = dev->base_addr;
3143         u16 scb_cs;
3144         fd_t fd;
3145         rbd_t rbd;
3146         u16 rx;
3147         u16 rx_next;
3148         int i;
3149
3150 #ifdef DEBUG_CONFIG_TRACE
3151         printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name);
3152 #endif
3153
3154         obram_read(ioaddr, scboff(OFFSET_SCB, scb_status),
3155                    (unsigned char *) &scb_cs, sizeof(scb_cs));
3156         if ((scb_cs & SCB_ST_RUS) == SCB_ST_RUS_RDY)
3157                 return 0;
3158
3159         lp->rx_head = OFFSET_RU;
3160
3161         for (i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next) {
3162                 rx_next =
3163                     (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
3164
3165                 fd.fd_status = 0;
3166                 fd.fd_command = (i == NRXBLOCKS - 1) ? FD_COMMAND_EL : 0;
3167                 fd.fd_link_offset = rx_next;
3168                 fd.fd_rbd_offset = rx + sizeof(fd);
3169                 obram_write(ioaddr, rx, (unsigned char *) &fd, sizeof(fd));
3170
3171                 rbd.rbd_status = 0;
3172                 rbd.rbd_next_rbd_offset = I82586NULL;
3173                 rbd.rbd_bufl = rx + sizeof(fd) + sizeof(rbd);
3174                 rbd.rbd_bufh = 0;
3175                 rbd.rbd_el_size = RBD_EL | (RBD_SIZE & MAXDATAZ);
3176                 obram_write(ioaddr, rx + sizeof(fd),
3177                             (unsigned char *) &rbd, sizeof(rbd));
3178
3179                 lp->rx_last = rx;
3180         }
3181
3182         obram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset),
3183                     (unsigned char *) &lp->rx_head, sizeof(lp->rx_head));
3184
3185         scb_cs = SCB_CMD_RUC_GO;
3186         obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3187                     (unsigned char *) &scb_cs, sizeof(scb_cs));
3188
3189         set_chan_attn(ioaddr, lp->hacr);
3190
3191         for (i = 1000; i > 0; i--) {
3192                 obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
3193                            (unsigned char *) &scb_cs, sizeof(scb_cs));
3194                 if (scb_cs == 0)
3195                         break;
3196
3197                 udelay(10);
3198         }
3199
3200         if (i <= 0) {
3201 #ifdef DEBUG_CONFIG_ERROR
3202                 printk(KERN_INFO
3203                        "%s: wavelan_ru_start(): board not accepting command.\n",
3204                        dev->name);
3205 #endif
3206                 return -1;
3207         }
3208 #ifdef DEBUG_CONFIG_TRACE
3209         printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name);
3210 #endif
3211         return 0;
3212 }
3213
3214 /*------------------------------------------------------------------*/
3215 /*
3216  * Initialise the transmit blocks.
3217  * Start the command unit executing the NOP
3218  * self-loop of the first transmit block.
3219  *
3220  * Here we create the list of send buffers used to transmit packets
3221  * between the PC and the command unit. For each buffer, we create a
3222  * buffer descriptor (pointing on the buffer), a transmit command
3223  * (pointing to the buffer descriptor) and a NOP command.
3224  * The transmit command is linked to the NOP, and the NOP to itself.
3225  * When we will have finished executing the transmit command, we will
3226  * then loop on the NOP. By releasing the NOP link to a new command,
3227  * we may send another buffer.
3228  *
3229  * (called by wv_hw_reset())
3230  */
3231 static inline int wv_cu_start(struct net_device * dev)
3232 {
3233         net_local *lp = (net_local *) dev->priv;
3234         unsigned long ioaddr = dev->base_addr;
3235         int i;
3236         u16 txblock;
3237         u16 first_nop;
3238         u16 scb_cs;
3239
3240 #ifdef DEBUG_CONFIG_TRACE
3241         printk(KERN_DEBUG "%s: ->wv_cu_start()\n", dev->name);
3242 #endif
3243
3244         lp->tx_first_free = OFFSET_CU;
3245         lp->tx_first_in_use = I82586NULL;
3246
3247         for (i = 0, txblock = OFFSET_CU;
3248              i < NTXBLOCKS; i++, txblock += TXBLOCKZ) {
3249                 ac_tx_t tx;
3250                 ac_nop_t nop;
3251                 tbd_t tbd;
3252                 unsigned short tx_addr;
3253                 unsigned short nop_addr;
3254                 unsigned short tbd_addr;
3255                 unsigned short buf_addr;
3256
3257                 tx_addr = txblock;
3258                 nop_addr = tx_addr + sizeof(tx);
3259                 tbd_addr = nop_addr + sizeof(nop);
3260                 buf_addr = tbd_addr + sizeof(tbd);
3261
3262                 tx.tx_h.ac_status = 0;
3263                 tx.tx_h.ac_command = acmd_transmit | AC_CFLD_I;
3264                 tx.tx_h.ac_link = nop_addr;
3265                 tx.tx_tbd_offset = tbd_addr;
3266                 obram_write(ioaddr, tx_addr, (unsigned char *) &tx,
3267                             sizeof(tx));
3268
3269                 nop.nop_h.ac_status = 0;
3270                 nop.nop_h.ac_command = acmd_nop;
3271                 nop.nop_h.ac_link = nop_addr;
3272                 obram_write(ioaddr, nop_addr, (unsigned char *) &nop,
3273                             sizeof(nop));
3274
3275                 tbd.tbd_status = TBD_STATUS_EOF;
3276                 tbd.tbd_next_bd_offset = I82586NULL;
3277                 tbd.tbd_bufl = buf_addr;
3278                 tbd.tbd_bufh = 0;
3279                 obram_write(ioaddr, tbd_addr, (unsigned char *) &tbd,
3280                             sizeof(tbd));
3281         }
3282
3283         first_nop =
3284             OFFSET_CU + (NTXBLOCKS - 1) * TXBLOCKZ + sizeof(ac_tx_t);
3285         obram_write(ioaddr, scboff(OFFSET_SCB, scb_cbl_offset),
3286                     (unsigned char *) &first_nop, sizeof(first_nop));
3287
3288         scb_cs = SCB_CMD_CUC_GO;
3289         obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3290                     (unsigned char *) &scb_cs, sizeof(scb_cs));
3291
3292         set_chan_attn(ioaddr, lp->hacr);
3293
3294         for (i = 1000; i > 0; i--) {
3295                 obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
3296                            (unsigned char *) &scb_cs, sizeof(scb_cs));
3297                 if (scb_cs == 0)
3298                         break;
3299
3300                 udelay(10);
3301         }
3302
3303         if (i <= 0) {
3304 #ifdef DEBUG_CONFIG_ERROR
3305                 printk(KERN_INFO
3306                        "%s: wavelan_cu_start(): board not accepting command.\n",
3307                        dev->name);
3308 #endif
3309                 return -1;
3310         }
3311
3312         lp->tx_n_in_use = 0;
3313         netif_start_queue(dev);
3314 #ifdef DEBUG_CONFIG_TRACE
3315         printk(KERN_DEBUG "%s: <-wv_cu_start()\n", dev->name);
3316 #endif
3317         return 0;
3318 }
3319
3320 /*------------------------------------------------------------------*/
3321 /*
3322  * This routine does a standard configuration of the WaveLAN 
3323  * controller (i82586).
3324  *
3325  * It initialises the scp, iscp and scb structure
3326  * The first two are just pointers to the next.
3327  * The last one is used for basic configuration and for basic
3328  * communication (interrupt status).
3329  *
3330  * (called by wv_hw_reset())
3331  */
3332 static inline int wv_82586_start(struct net_device * dev)
3333 {
3334         net_local *lp = (net_local *) dev->priv;
3335         unsigned long ioaddr = dev->base_addr;
3336         scp_t scp;              /* system configuration pointer */
3337         iscp_t iscp;            /* intermediate scp */
3338         scb_t scb;              /* system control block */
3339         ach_t cb;               /* Action command header */
3340         u8 zeroes[512];
3341         int i;
3342
3343 #ifdef DEBUG_CONFIG_TRACE
3344         printk(KERN_DEBUG "%s: ->wv_82586_start()\n", dev->name);
3345 #endif
3346
3347         /*
3348          * Clear the onboard RAM.
3349          */
3350         memset(&zeroes[0], 0x00, sizeof(zeroes));
3351         for (i = 0; i < I82586_MEMZ; i += sizeof(zeroes))
3352                 obram_write(ioaddr, i, &zeroes[0], sizeof(zeroes));
3353
3354         /*
3355          * Construct the command unit structures:
3356          * scp, iscp, scb, cb.
3357          */
3358         memset(&scp, 0x00, sizeof(scp));
3359         scp.scp_sysbus = SCP_SY_16BBUS;
3360         scp.scp_iscpl = OFFSET_ISCP;
3361         obram_write(ioaddr, OFFSET_SCP, (unsigned char *) &scp,
3362                     sizeof(scp));
3363
3364         memset(&iscp, 0x00, sizeof(iscp));
3365         iscp.iscp_busy = 1;
3366         iscp.iscp_offset = OFFSET_SCB;
3367         obram_write(ioaddr, OFFSET_ISCP, (unsigned char *) &iscp,
3368                     sizeof(iscp));
3369
3370         /* Our first command is to reset the i82586. */
3371         memset(&scb, 0x00, sizeof(scb));
3372         scb.scb_command = SCB_CMD_RESET;
3373         scb.scb_cbl_offset = OFFSET_CU;
3374         scb.scb_rfa_offset = OFFSET_RU;
3375         obram_write(ioaddr, OFFSET_SCB, (unsigned char *) &scb,
3376                     sizeof(scb));
3377
3378         set_chan_attn(ioaddr, lp->hacr);
3379
3380         /* Wait for command to finish. */
3381         for (i = 1000; i > 0; i--) {
3382                 obram_read(ioaddr, OFFSET_ISCP, (unsigned char *) &iscp,
3383                            sizeof(iscp));
3384
3385                 if (iscp.iscp_busy == (unsigned short) 0)
3386                         break;
3387
3388                 udelay(10);
3389         }
3390
3391         if (i <= 0) {
3392 #ifdef DEBUG_CONFIG_ERROR
3393                 printk(KERN_INFO
3394                        "%s: wv_82586_start(): iscp_busy timeout.\n",
3395                        dev->name);
3396 #endif
3397                 return -1;
3398         }
3399
3400         /* Check command completion. */
3401         for (i = 15; i > 0; i--) {
3402                 obram_read(ioaddr, OFFSET_SCB, (unsigned char *) &scb,
3403                            sizeof(scb));
3404
3405                 if (scb.scb_status == (SCB_ST_CX | SCB_ST_CNA))
3406                         break;
3407
3408                 udelay(10);
3409         }
3410
3411         if (i <= 0) {
3412 #ifdef DEBUG_CONFIG_ERROR
3413                 printk(KERN_INFO
3414                        "%s: wv_82586_start(): status: expected 0x%02x, got 0x%02x.\n",
3415                        dev->name, SCB_ST_CX | SCB_ST_CNA, scb.scb_status);
3416 #endif
3417                 return -1;
3418         }
3419
3420         wv_ack(dev);
3421
3422         /* Set the action command header. */
3423         memset(&cb, 0x00, sizeof(cb));
3424         cb.ac_command = AC_CFLD_EL | (AC_CFLD_CMD & acmd_diagnose);
3425         cb.ac_link = OFFSET_CU;
3426         obram_write(ioaddr, OFFSET_CU, (unsigned char *) &cb, sizeof(cb));
3427
3428         if (wv_synchronous_cmd(dev, "diag()") == -1)
3429                 return -1;
3430
3431         obram_read(ioaddr, OFFSET_CU, (unsigned char *) &cb, sizeof(cb));
3432         if (cb.ac_status & AC_SFLD_FAIL) {
3433 #ifdef DEBUG_CONFIG_ERROR
3434                 printk(KERN_INFO
3435                        "%s: wv_82586_start(): i82586 Self Test failed.\n",
3436                        dev->name);
3437 #endif
3438                 return -1;
3439         }
3440 #ifdef DEBUG_I82586_SHOW
3441         wv_scb_show(ioaddr);
3442 #endif
3443
3444 #ifdef DEBUG_CONFIG_TRACE
3445         printk(KERN_DEBUG "%s: <-wv_82586_start()\n", dev->name);
3446 #endif
3447         return 0;
3448 }
3449
3450 /*------------------------------------------------------------------*/
3451 /*
3452  * This routine does a standard configuration of the WaveLAN
3453  * controller (i82586).
3454  *
3455  * This routine is a violent hack. We use the first free transmit block
3456  * to make our configuration. In the buffer area, we create the three
3457  * configuration commands (linked). We make the previous NOP point to
3458  * the beginning of the buffer instead of the tx command. After, we go
3459  * as usual to the NOP command.
3460  * Note that only the last command (mc_set) will generate an interrupt.
3461  *
3462  * (called by wv_hw_reset(), wv_82586_reconfig(), wavelan_packet_xmit())
3463  */
3464 static void wv_82586_config(struct net_device * dev)
3465 {
3466         net_local *lp = (net_local *) dev->priv;
3467         unsigned long ioaddr = dev->base_addr;
3468         unsigned short txblock;
3469         unsigned short txpred;
3470         unsigned short tx_addr;
3471         unsigned short nop_addr;
3472         unsigned short tbd_addr;
3473         unsigned short cfg_addr;
3474         unsigned short ias_addr;
3475         unsigned short mcs_addr;
3476         ac_tx_t tx;
3477         ac_nop_t nop;
3478         ac_cfg_t cfg;           /* Configure action */
3479         ac_ias_t ias;           /* IA-setup action */
3480         ac_mcs_t mcs;           /* Multicast setup */
3481         struct dev_mc_list *dmi;
3482
3483 #ifdef DEBUG_CONFIG_TRACE
3484         printk(KERN_DEBUG "%s: ->wv_82586_config()\n", dev->name);
3485 #endif
3486
3487         /* Check nothing bad has happened */
3488         if (lp->tx_n_in_use == (NTXBLOCKS - 1)) {
3489 #ifdef DEBUG_CONFIG_ERROR
3490                 printk(KERN_INFO "%s: wv_82586_config(): Tx queue full.\n",
3491                        dev->name);
3492 #endif
3493                 return;
3494         }
3495
3496         /* Calculate addresses of next block and previous block. */
3497         txblock = lp->tx_first_free;
3498         txpred = txblock - TXBLOCKZ;
3499         if (txpred < OFFSET_CU)
3500                 txpred += NTXBLOCKS * TXBLOCKZ;
3501         lp->tx_first_free += TXBLOCKZ;
3502         if (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
3503                 lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
3504
3505         lp->tx_n_in_use++;
3506
3507         /* Calculate addresses of the different parts of the block. */
3508         tx_addr = txblock;
3509         nop_addr = tx_addr + sizeof(tx);
3510         tbd_addr = nop_addr + sizeof(nop);
3511         cfg_addr = tbd_addr + sizeof(tbd_t);    /* beginning of the buffer */
3512         ias_addr = cfg_addr + sizeof(cfg);
3513         mcs_addr = ias_addr + sizeof(ias);
3514
3515         /*
3516          * Transmit command
3517          */
3518         tx.tx_h.ac_status = 0xFFFF;     /* Fake completion value */
3519         obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status),
3520                     (unsigned char *) &tx.tx_h.ac_status,
3521                     sizeof(tx.tx_h.ac_status));
3522
3523         /*
3524          * NOP command
3525          */
3526         nop.nop_h.ac_status = 0;
3527         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
3528                     (unsigned char *) &nop.nop_h.ac_status,
3529                     sizeof(nop.nop_h.ac_status));
3530         nop.nop_h.ac_link = nop_addr;
3531         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
3532                     (unsigned char *) &nop.nop_h.ac_link,
3533                     sizeof(nop.nop_h.ac_link));
3534
3535         /* Create a configure action. */
3536         memset(&cfg, 0x00, sizeof(cfg));
3537
3538         /*
3539          * For Linux we invert AC_CFG_ALOC() so as to conform
3540          * to the way that net packets reach us from above.
3541          * (See also ac_tx_t.)
3542          *
3543          * Updated from Wavelan Manual WCIN085B
3544          */
3545         cfg.cfg_byte_cnt =
3546             AC_CFG_BYTE_CNT(sizeof(ac_cfg_t) - sizeof(ach_t));
3547         cfg.cfg_fifolim = AC_CFG_FIFOLIM(4);
3548         cfg.cfg_byte8 = AC_CFG_SAV_BF(1) | AC_CFG_SRDY(0);
3549         cfg.cfg_byte9 = AC_CFG_ELPBCK(0) |
3550             AC_CFG_ILPBCK(0) |
3551             AC_CFG_PRELEN(AC_CFG_PLEN_2) |
3552             AC_CFG_ALOC(1) | AC_CFG_ADDRLEN(WAVELAN_ADDR_SIZE);
3553         cfg.cfg_byte10 = AC_CFG_BOFMET(1) |
3554             AC_CFG_ACR(6) | AC_CFG_LINPRIO(0);
3555         cfg.cfg_ifs = 0x20;
3556         cfg.cfg_slotl = 0x0C;
3557         cfg.cfg_byte13 = AC_CFG_RETRYNUM(15) | AC_CFG_SLTTMHI(0);
3558         cfg.cfg_byte14 = AC_CFG_FLGPAD(0) |
3559             AC_CFG_BTSTF(0) |
3560             AC_CFG_CRC16(0) |
3561             AC_CFG_NCRC(0) |
3562             AC_CFG_TNCRS(1) |
3563             AC_CFG_MANCH(0) |
3564             AC_CFG_BCDIS(0) | AC_CFG_PRM(lp->promiscuous);
3565         cfg.cfg_byte15 = AC_CFG_ICDS(0) |
3566             AC_CFG_CDTF(0) | AC_CFG_ICSS(0) | AC_CFG_CSTF(0);
3567 /*
3568   cfg.cfg_min_frm_len = AC_CFG_MNFRM(64);
3569 */
3570         cfg.cfg_min_frm_len = AC_CFG_MNFRM(8);
3571
3572         cfg.cfg_h.ac_command = (AC_CFLD_CMD & acmd_configure);
3573         cfg.cfg_h.ac_link = ias_addr;
3574         obram_write(ioaddr, cfg_addr, (unsigned char *) &cfg, sizeof(cfg));
3575
3576         /* Set up the MAC address */
3577         memset(&ias, 0x00, sizeof(ias));
3578         ias.ias_h.ac_command = (AC_CFLD_CMD & acmd_ia_setup);
3579         ias.ias_h.ac_link = mcs_addr;
3580         memcpy(&ias.ias_addr[0], (unsigned char *) &dev->dev_addr[0],
3581                sizeof(ias.ias_addr));
3582         obram_write(ioaddr, ias_addr, (unsigned char *) &ias, sizeof(ias));
3583
3584         /* Initialize adapter's Ethernet multicast addresses */
3585         memset(&mcs, 0x00, sizeof(mcs));
3586         mcs.mcs_h.ac_command = AC_CFLD_I | (AC_CFLD_CMD & acmd_mc_setup);
3587         mcs.mcs_h.ac_link = nop_addr;
3588         mcs.mcs_cnt = WAVELAN_ADDR_SIZE * lp->mc_count;
3589         obram_write(ioaddr, mcs_addr, (unsigned char *) &mcs, sizeof(mcs));
3590
3591         /* Any address to set? */
3592         if (lp->mc_count) {
3593                 for (dmi = dev->mc_list; dmi; dmi = dmi->next)
3594                         outsw(PIOP1(ioaddr), (u16 *) dmi->dmi_addr,
3595                               WAVELAN_ADDR_SIZE >> 1);
3596
3597 #ifdef DEBUG_CONFIG_INFO
3598                 printk(KERN_DEBUG
3599                        "%s: wv_82586_config(): set %d multicast addresses:\n",
3600                        dev->name, lp->mc_count);
3601                 for (dmi = dev->mc_list; dmi; dmi = dmi->next)
3602                         printk(KERN_DEBUG
3603                                " %02x:%02x:%02x:%02x:%02x:%02x\n",
3604                                dmi->dmi_addr[0], dmi->dmi_addr[1],
3605                                dmi->dmi_addr[2], dmi->dmi_addr[3],
3606                                dmi->dmi_addr[4], dmi->dmi_addr[5]);
3607 #endif
3608         }
3609
3610         /*
3611          * Overwrite the predecessor NOP link
3612          * so that it points to the configure action.
3613          */
3614         nop_addr = txpred + sizeof(tx);
3615         nop.nop_h.ac_status = 0;
3616         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
3617                     (unsigned char *) &nop.nop_h.ac_status,
3618                     sizeof(nop.nop_h.ac_status));
3619         nop.nop_h.ac_link = cfg_addr;
3620         obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
3621                     (unsigned char *) &nop.nop_h.ac_link,
3622                     sizeof(nop.nop_h.ac_link));
3623
3624         /* Job done, clear the flag */
3625         lp->reconfig_82586 = 0;
3626
3627         if (lp->tx_first_in_use == I82586NULL)
3628                 lp->tx_first_in_use = txblock;
3629
3630         if (lp->tx_n_in_use == (NTXBLOCKS - 1))
3631                 netif_stop_queue(dev);
3632
3633 #ifdef DEBUG_CONFIG_TRACE
3634         printk(KERN_DEBUG "%s: <-wv_82586_config()\n", dev->name);
3635 #endif
3636 }
3637
3638 /*------------------------------------------------------------------*/
3639 /*
3640  * This routine, called by wavelan_close(), gracefully stops the 
3641  * WaveLAN controller (i82586).
3642  * (called by wavelan_close())
3643  */
3644 static inline void wv_82586_stop(struct net_device * dev)
3645 {
3646         net_local *lp = (net_local *) dev->priv;
3647         unsigned long ioaddr = dev->base_addr;
3648         u16 scb_cmd;
3649
3650 #ifdef DEBUG_CONFIG_TRACE
3651         printk(KERN_DEBUG "%s: ->wv_82586_stop()\n", dev->name);
3652 #endif
3653
3654         /* Suspend both command unit and receive unit. */
3655         scb_cmd =
3656             (SCB_CMD_CUC & SCB_CMD_CUC_SUS) | (SCB_CMD_RUC &
3657                                                SCB_CMD_RUC_SUS);
3658         obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
3659                     (unsigned char *) &scb_cmd, sizeof(scb_cmd));
3660         set_chan_attn(ioaddr, lp->hacr);
3661
3662         /* No more interrupts */
3663         wv_ints_off(dev);
3664
3665 #ifdef DEBUG_CONFIG_TRACE
3666         printk(KERN_DEBUG "%s: <-wv_82586_stop()\n", dev->name);
3667 #endif
3668 }
3669
3670 /*------------------------------------------------------------------*/
3671 /*
3672  * Totally reset the WaveLAN and restart it.
3673  * Performs the following actions:
3674  *      1. A power reset (reset DMA)
3675  *      2. Initialize the radio modem (using wv_mmc_init)
3676  *      3. Reset & Configure LAN controller (using wv_82586_start)
3677  *      4. Start the LAN controller's command unit
3678  *      5. Start the LAN controller's receive unit
3679  * (called by wavelan_interrupt(), wavelan_watchdog() & wavelan_open())
3680  */
3681 static int wv_hw_reset(struct net_device * dev)
3682 {
3683         net_local *lp = (net_local *) dev->priv;
3684         unsigned long ioaddr = dev->base_addr;
3685
3686 #ifdef DEBUG_CONFIG_TRACE
3687         printk(KERN_DEBUG "%s: ->wv_hw_reset(dev=0x%x)\n", dev->name,
3688                (unsigned int) dev);
3689 #endif
3690
3691         /* Increase the number of resets done. */
3692         lp->nresets++;
3693
3694         wv_hacr_reset(ioaddr);
3695         lp->hacr = HACR_DEFAULT;
3696
3697         if ((wv_mmc_init(dev) < 0) || (wv_82586_start(dev) < 0))
3698                 return -1;
3699
3700         /* Enable the card to send interrupts. */
3701         wv_ints_on(dev);
3702
3703         /* Start card functions */
3704         if (wv_cu_start(dev) < 0)
3705                 return -1;
3706
3707         /* Setup the controller and parameters */
3708         wv_82586_config(dev);
3709
3710         /* Finish configuration with the receive unit */
3711         if (wv_ru_start(dev) < 0)
3712                 return -1;
3713
3714 #ifdef DEBUG_CONFIG_TRACE
3715         printk(KERN_DEBUG "%s: <-wv_hw_reset()\n", dev->name);
3716 #endif
3717         return 0;
3718 }
3719
3720 /*------------------------------------------------------------------*/
3721 /*