git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/wavelan.c

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