drivers/staging/wavelan/wavelan_cs.c

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