URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [net/] [wavelan.c] - Blame information for rev 1777

Go to most recent revision | Details | Compare with Previous | View Log

/*
 *      WaveLAN ISA driver
 *
 *              Jean II - HPLB '96
 *
 * Reorganisation and extension of the driver.
 * Original copyright follows (also see the end of this file).
 * See wavelan.p.h for details.
 */
 
/*
 * AT&T GIS (nee NCR) WaveLAN card:
 *      An Ethernet-like radio transceiver
 *      controlled by an Intel 82586 coprocessor.
 */
 
#include "wavelan.p.h"          /* Private header */
 
/************************* MISC SUBROUTINES **************************/
/*
 * Subroutines which won't fit in one of the following category
 * (WaveLAN modem or i82586)
 */
 
/*------------------------------------------------------------------*/
/*
 * Wrapper for disabling interrupts.
 */
static inline unsigned long
wv_splhi(void)
{
  unsigned long flags;
 
  save_flags(flags);
  cli();
 
  return(flags);
}
 
/*------------------------------------------------------------------*/
/*
 * Wrapper for re-enabling interrupts.
 */
static inline void
wv_splx(unsigned long   flags)
{
  restore_flags(flags);
}
 
/*------------------------------------------------------------------*/
/*
 * Translate irq number to PSA irq parameter
 */
static u_char
wv_irq_to_psa(int       irq)
{
  if(irq < 0 || irq >= NELS(irqvals))
    return 0;
 
  return irqvals[irq];
}
 
/*------------------------------------------------------------------*/
/*
 * Translate PSA irq parameter to irq number
 */
static int
wv_psa_to_irq(u_char    irqval)
{
  int   irq;
 
  for(irq = 0; irq < NELS(irqvals); irq++)
    if(irqvals[irq] == irqval)
      return irq;
 
  return -1;
}
 
#ifdef STRUCT_CHECK
/*------------------------------------------------------------------*/
/*
 * Sanity routine to verify the sizes of the various WaveLAN interface
 * structures.
 */
static char *
wv_struct_check(void)
{
#define SC(t,s,n)       if (sizeof(t) != s) return(n);
 
  SC(psa_t, PSA_SIZE, "psa_t");
  SC(mmw_t, MMW_SIZE, "mmw_t");
  SC(mmr_t, MMR_SIZE, "mmr_t");
  SC(ha_t, HA_SIZE, "ha_t");
 
#undef  SC
 
  return((char *) NULL);
} /* wv_struct_check */
#endif  /* STRUCT_CHECK */
 
/********************* HOST ADAPTER SUBROUTINES *********************/
/*
 * Useful subroutines to manage the WaveLAN ISA interface
 *
 * One major difference with the PCMCIA hardware (except the port mapping)
 * is that we have to keep the state of the Host Control Register
 * because of the interrupt enable & bus size flags.
 */
 
/*------------------------------------------------------------------*/
/*
 * Read from card's Host Adaptor Status Register.
 */
static inline u_short
hasr_read(u_long        ioaddr)
{
  return(inw(HASR(ioaddr)));
} /* hasr_read */
 
/*------------------------------------------------------------------*/
/*
 * Write to card's Host Adapter Command Register.
 */
static inline void
hacr_write(u_long       ioaddr,
           u_short      hacr)
{
  outw(hacr, HACR(ioaddr));
} /* hacr_write */
 
/*------------------------------------------------------------------*/
/*
 * Write to card's Host Adapter Command Register. Include a delay for
 * those times when it is needed.
 */
static inline void
hacr_write_slow(u_long  ioaddr,
                u_short hacr)
{
  hacr_write(ioaddr, hacr);
  /* delay might only be needed sometimes */
  udelay(1000L);
} /* hacr_write_slow */
 
/*------------------------------------------------------------------*/
/*
 * Set the channel attention bit.
 */
static inline void
set_chan_attn(u_long    ioaddr,
              u_short   hacr)
{
  hacr_write(ioaddr, hacr | HACR_CA);
} /* set_chan_attn */
 
/*------------------------------------------------------------------*/
/*
 * Reset, and then set host adaptor into default mode.
 */
static inline void
wv_hacr_reset(u_long    ioaddr)
{
  hacr_write_slow(ioaddr, HACR_RESET);
  hacr_write(ioaddr, HACR_DEFAULT);
} /* wv_hacr_reset */
 
/*------------------------------------------------------------------*/
/*
 * Set the i/o transfer over the ISA bus to 8 bits mode
 */
static inline void
wv_16_off(u_long        ioaddr,
          u_short       hacr)
{
  hacr &= ~HACR_16BITS;
  hacr_write(ioaddr, hacr);
} /* wv_16_off */
 
/*------------------------------------------------------------------*/
/*
 * Set the i/o transfer over the ISA bus to 8 bits mode
 */
static inline void
wv_16_on(u_long         ioaddr,
         u_short        hacr)
{
  hacr |= HACR_16BITS;
  hacr_write(ioaddr, hacr);
} /* wv_16_on */
 
/*------------------------------------------------------------------*/
/*
 * Disable interrupts on the WaveLAN hardware
 */
static inline void
wv_ints_off(device *    dev)
{
  net_local *   lp = (net_local *)dev->priv;
  u_long        ioaddr = dev->base_addr;
  u_long        x;
 
  x = wv_splhi();
 
  lp->hacr &= ~HACR_INTRON;
  hacr_write(ioaddr, lp->hacr);
 
  wv_splx(x);
} /* wv_ints_off */
 
/*------------------------------------------------------------------*/
/*
 * Enable interrupts on the WaveLAN hardware
 */
static inline void
wv_ints_on(device *     dev)
{
  net_local *   lp = (net_local *)dev->priv;
  u_long        ioaddr = dev->base_addr;
  u_long        x;
 
  x = wv_splhi();
 
  lp->hacr |= HACR_INTRON;
  hacr_write(ioaddr, lp->hacr);
 
  wv_splx(x);
} /* wv_ints_on */
 
/******************* MODEM MANAGEMENT SUBROUTINES *******************/
/*
 * Useful subroutines to manage the modem of the WaveLAN
 */
 
/*------------------------------------------------------------------*/
/*
 * Read the Parameter Storage Area from the WaveLAN card's memory
 */
/*
 * Read bytes from the PSA.
 */
static void
psa_read(u_long         ioaddr,
         u_short        hacr,
         int            o,      /* offset in PSA */
         u_char *       b,      /* buffer to fill */
         int            n)      /* size to read */
{
  wv_16_off(ioaddr, hacr);
 
  while(n-- > 0)
    {
      outw(o, PIOR2(ioaddr));
      o++;
      *b++ = inb(PIOP2(ioaddr));
    }
 
  wv_16_on(ioaddr, hacr);
} /* psa_read */
 
/*------------------------------------------------------------------*/
/*
 * Write the Paramter Storage Area to the WaveLAN card's memory
 */
static void
psa_write(u_long        ioaddr,
          u_short       hacr,
          int           o,      /* Offset in psa */
          u_char *      b,      /* Buffer in memory */
          int           n)      /* Length of buffer */
{
  int   count = 0;
 
  wv_16_off(ioaddr, hacr);
 
  while(n-- > 0)
    {
      outw(o, PIOR2(ioaddr));
      o++;
 
      outb(*b, PIOP2(ioaddr));
      b++;
 
      /* Wait for the memory to finish its write cycle */
      count = 0;
      while((count++ < 100) &&
            (hasr_read(ioaddr) & HASR_PSA_BUSY))
        udelay(1000);
    }
 
  wv_16_on(ioaddr, hacr);
} /* psa_write */
 
#ifdef SET_PSA_CRC
/*------------------------------------------------------------------*/
/*
 * Calculate the PSA CRC
 * Thanks to Valster, Nico <NVALSTER@wcnd.nl.lucent.com> for the code
 * NOTE: By specifying a length including the CRC position the
 * returned value should be zero. (i.e. a correct checksum in the PSA)
 *
 * The Windows drivers don't use the CRC, but the AP and the PtP tool
 * depend on it.
 */
static inline u_short
psa_crc(u_char *        psa,    /* The PSA */
        int             size)   /* Number of short for CRC */
{
  int           byte_cnt;       /* Loop on the PSA */
  u_short       crc_bytes = 0;   /* Data in the PSA */
  int           bit_cnt;        /* Loop on the bits of the short */
 
  for(byte_cnt = 0; byte_cnt < size; byte_cnt++ )
    {
      crc_bytes ^= psa[byte_cnt];       /* Its an xor */
 
      for(bit_cnt = 1; bit_cnt < 9; bit_cnt++ )
        {
          if(crc_bytes & 0x0001)
            crc_bytes = (crc_bytes >> 1) ^ 0xA001;
          else
            crc_bytes >>= 1 ;
        }
    }
 
  return crc_bytes;
} /* psa_crc */
 
/*------------------------------------------------------------------*/
/*
 * update the checksum field in the Wavelan's PSA
 */
static void
update_psa_checksum(device *    dev,
                    u_long      ioaddr,
                    u_short     hacr)
{
  psa_t         psa;
  u_short       crc;
 
  /* read the parameter storage area */
  psa_read(ioaddr, hacr, 0, (unsigned char *) &psa, sizeof(psa));
 
  /* update the checksum */
  crc = psa_crc((unsigned char *) &psa,
                sizeof(psa) - sizeof(psa.psa_crc[0]) - sizeof(psa.psa_crc[1])
                - sizeof(psa.psa_crc_status));
 
  psa.psa_crc[0] = crc & 0xFF;
  psa.psa_crc[1] = (crc & 0xFF00) >> 8;
 
  /* Write it ! */
  psa_write(ioaddr, hacr, (char *)&psa.psa_crc - (char *)&psa,
            (unsigned char *)&psa.psa_crc, 2);
 
#ifdef DEBUG_IOCTL_INFO
  printk (KERN_DEBUG "%s: update_psa_checksum(): crc = 0x%02x%02x\n",
          dev->name, psa.psa_crc[0], psa.psa_crc[1]);
 
  /* Check again (luxury !) */
  crc = psa_crc ((unsigned char *) &psa,
                 sizeof(psa) - sizeof(psa.psa_crc_status));
 
  if(crc != 0)
    printk(KERN_WARNING "%s: update_psa_checksum(): CRC does not agree with PSA data (even after recalculating)\n", dev->name);
#endif /* DEBUG_IOCTL_INFO */
} /* update_psa_checksum */
#endif  /* SET_PSA_CRC */
 
/*------------------------------------------------------------------*/
/*
 * Write 1 byte to the MMC.
 */
static inline void
mmc_out(u_long          ioaddr,
        u_short         o,
        u_char          d)
{
  /* Wait for MMC to go idle */
  while(inw(HASR(ioaddr)) & HASR_MMC_BUSY)
    ;
 
  outw((u_short) (((u_short) d << 8) | (o << 1) | 1),
       MMCR(ioaddr));
}
 
/*------------------------------------------------------------------*/
/*
 * Routine to write bytes to the Modem Management Controller.
 * We start by the end because it is the way it should be !
 */
static inline void
mmc_write(u_long        ioaddr,
          u_char        o,
          u_char *      b,
          int           n)
{
  o += n;
  b += n;
 
  while(n-- > 0 )
    mmc_out(ioaddr, --o, *(--b));
} /* mmc_write */
 
/*------------------------------------------------------------------*/
/*
 * Read 1 byte from the MMC.
 * Optimised version for 1 byte, avoid using memory...
 */
static inline u_char
mmc_in(u_long   ioaddr,
       u_short  o)
{
  while(inw(HASR(ioaddr)) & HASR_MMC_BUSY)
    ;
  outw(o << 1, MMCR(ioaddr));
 
  while(inw(HASR(ioaddr)) & HASR_MMC_BUSY)
    ;
  return (u_char) (inw(MMCR(ioaddr)) >> 8);
}
 
/*------------------------------------------------------------------*/
/*
 * Routine to read bytes from the Modem Management Controller.
 * The implementation is complicated by a lack of address lines,
 * which prevents decoding of the low-order bit.
 * (code has just been moved in the above function)
 * We start by the end because it is the way it should be !
 */
static inline void
mmc_read(u_long         ioaddr,
         u_char         o,
         u_char *       b,
         int            n)
{
  o += n;
  b += n;
 
  while(n-- > 0)
    *(--b) = mmc_in(ioaddr, --o);
} /* mmc_read */
 
/*------------------------------------------------------------------*/
/*
 * Get the type of encryption available...
 */
static inline int
mmc_encr(u_long         ioaddr) /* i/o port of the card */
{
  int   temp;
 
  temp = mmc_in(ioaddr, mmroff(0, mmr_des_avail));
  if((temp != MMR_DES_AVAIL_DES) && (temp != MMR_DES_AVAIL_AES))
    return 0;
  else
    return temp;
}
 
/*------------------------------------------------------------------*/
/*
 * Wait for the frequency EEPROM to complete a command...
 * I hope this one will be optimally inlined...
 */
static inline void
fee_wait(u_long         ioaddr, /* i/o port of the card */
         int            delay,  /* Base delay to wait for */
         int            number) /* Number of time to wait */
{
  int           count = 0;       /* Wait only a limited time */
 
  while((count++ < number) &&
        (mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & MMR_FEE_STATUS_BUSY))
    udelay(delay);
}
 
/*------------------------------------------------------------------*/
/*
 * Read bytes from the frequency EEPROM (frequency select cards).
 */
static void
fee_read(u_long         ioaddr, /* i/o port of the card */
         u_short        o,      /* destination offset */
         u_short *      b,      /* data buffer */
         int            n)      /* number of registers */
{
  b += n;               /* Position at the end of the area */
 
  /* Write the address */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1);
 
  /* Loop on all buffer */
  while(n-- > 0)
    {
      /* Write the read command */
      mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_READ);
 
      /* Wait until EEPROM is ready (should be quick!) */
      fee_wait(ioaddr, 10, 100);
 
      /* Read the value */
      *--b = ((mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)) << 8) |
              mmc_in(ioaddr, mmroff(0, mmr_fee_data_l)));
    }
}
 
#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
 
/*------------------------------------------------------------------*/
/*
 * Write bytes from the Frequency EEPROM (frequency select cards).
 * This is a bit complicated, because the frequency EEPROM has to
 * be unprotected and the write enabled.
 * Jean II
 */
static void
fee_write(u_long        ioaddr, /* i/o port of the card */
          u_short       o,      /* destination offset */
          u_short *     b,      /* data buffer */
          int           n)      /* number of registers */
{
  b += n;               /* Position at the end of the area */
 
#ifdef EEPROM_IS_PROTECTED      /* disabled */
#ifdef DOESNT_SEEM_TO_WORK      /* disabled */
  /* Ask to read the protected register */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRREAD);
 
  fee_wait(ioaddr, 10, 100);
 
  /* Read the protected register */
  printk("Protected 2 : %02X-%02X\n",
         mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)),
         mmc_in(ioaddr, mmroff(0, mmr_fee_data_l)));
#endif  /* DOESNT_SEEM_TO_WORK */
 
  /* Enable protected register */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN);
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PREN);
 
  fee_wait(ioaddr, 10, 100);
 
  /* Unprotect area */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n);
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
#ifdef DOESNT_SEEM_TO_WORK      /* disabled */
  /* Or use : */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRCLEAR);
#endif  /* DOESNT_SEEM_TO_WORK */
 
  fee_wait(ioaddr, 10, 100);
#endif  /* EEPROM_IS_PROTECTED */
 
  /* Write enable */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN);
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WREN);
 
  fee_wait(ioaddr, 10, 100);
 
  /* Write the EEPROM address */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1);
 
  /* Loop on all buffer */
  while(n-- > 0)
    {
      /* Write the value */
      mmc_out(ioaddr, mmwoff(0, mmw_fee_data_h), (*--b) >> 8);
      mmc_out(ioaddr, mmwoff(0, mmw_fee_data_l), *b & 0xFF);
 
      /* Write the write command */
      mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WRITE);
 
      /* Wavelan doc says : wait at least 10 ms for EEBUSY = 0 */
      udelay(10000);
      fee_wait(ioaddr, 10, 100);
    }
 
  /* Write disable */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_DS);
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WDS);
 
  fee_wait(ioaddr, 10, 100);
 
#ifdef EEPROM_IS_PROTECTED      /* disabled */
  /* Reprotect EEPROM */
  mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x00);
  mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
 
  fee_wait(ioaddr, 10, 100);
#endif  /* EEPROM_IS_PROTECTED */
}
#endif  /* WIRELESS_EXT */
 
/************************ I82586 SUBROUTINES *************************/
/*
 * Usefull subroutines to manage the Ethernet controler
 */
 
/*------------------------------------------------------------------*/
/*
 * Read bytes from the on-board RAM.
 * Why inlining this function make it fail ???
 */
static /*inline*/ void
obram_read(u_long       ioaddr,
           u_short      o,
           u_char *     b,
           int          n)
{
  outw(o, PIOR1(ioaddr));
  insw(PIOP1(ioaddr), (unsigned short *) b, (n + 1) >> 1);
}
 
/*------------------------------------------------------------------*/
/*
 * Write bytes to the on-board RAM.
 */
static inline void
obram_write(u_long      ioaddr,
            u_short     o,
            u_char *    b,
            int         n)
{
  outw(o, PIOR1(ioaddr));
  outsw(PIOP1(ioaddr), (unsigned short *) b, (n + 1) >> 1);
}
 
/*------------------------------------------------------------------*/
/*
 * Acknowledge the reading of the status issued by the i82586
 */
static void
wv_ack(device *         dev)
{
  net_local *   lp = (net_local *)dev->priv;
  u_long        ioaddr = dev->base_addr;
  u_short       scb_cs;
  int           i;
 
  obram_read(ioaddr, scboff(OFFSET_SCB, scb_status),
             (unsigned char *) &scb_cs, sizeof(scb_cs));
  scb_cs &= SCB_ST_INT;
 
  if(scb_cs == 0)
    return;
 
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
              (unsigned char *) &scb_cs, sizeof(scb_cs));
 
  set_chan_attn(ioaddr, lp->hacr);
 
  for(i = 1000; i > 0; i--)
    {
      obram_read(ioaddr, scboff(OFFSET_SCB, scb_command), (unsigned char *)&scb_cs, sizeof(scb_cs));
      if(scb_cs == 0)
        break;
 
      udelay(10);
    }
  udelay(100);
 
#ifdef DEBUG_CONFIG_ERROR
  if(i <= 0)
    printk(KERN_INFO "%s: wv_ack(): board not accepting command.\n",
           dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * Set channel attention bit and busy wait until command has
 * completed, then acknowledge the command completion.
 */
static inline int
wv_synchronous_cmd(device *     dev,
                   const char * str)
{
  net_local *   lp = (net_local *)dev->priv;
  u_long        ioaddr = dev->base_addr;
  u_short       scb_cmd;
  ach_t         cb;
  int           i;
 
  scb_cmd = SCB_CMD_CUC & SCB_CMD_CUC_GO;
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
              (unsigned char *) &scb_cmd, sizeof(scb_cmd));
 
  set_chan_attn(ioaddr, lp->hacr);
 
  for (i = 1000; i > 0; i--)
    {
      obram_read(ioaddr, OFFSET_CU, (unsigned char *)&cb, sizeof(cb));
      if (cb.ac_status & AC_SFLD_C)
        break;
 
      udelay(10);
    }
  udelay(100);
 
  if(i <= 0 || !(cb.ac_status & AC_SFLD_OK))
    {
#ifdef DEBUG_CONFIG_ERROR
      printk(KERN_INFO "%s: %s failed; status = 0x%x\n",
             dev->name, str, cb.ac_status);
#endif
#ifdef DEBUG_I82586_SHOW
      wv_scb_show(ioaddr);
#endif
      return -1;
    }
 
  /* Ack the status */
  wv_ack(dev);
 
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Configuration commands completion interrupt.
 * Check if done, and if ok...
 */
static inline int
wv_config_complete(device *     dev,
                   u_long       ioaddr,
                   net_local *  lp)
{
  unsigned short        mcs_addr;
  unsigned short        status;
  int                   ret;
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: ->wv_config_complete()\n", dev->name);
#endif
 
  mcs_addr = lp->tx_first_in_use + sizeof(ac_tx_t) + sizeof(ac_nop_t)
    + sizeof(tbd_t) + sizeof(ac_cfg_t) + sizeof(ac_ias_t);
 
  /* Read the status of the last command (set mc list) */
  obram_read(ioaddr, acoff(mcs_addr, ac_status), (unsigned char *)&status, sizeof(status));
 
  /* If not completed -> exit */
  if((status & AC_SFLD_C) == 0)
    ret = 0;             /* Not ready to be scrapped */
  else
    {
#ifdef DEBUG_CONFIG_ERROR
      unsigned short    cfg_addr;
      unsigned short    ias_addr;
 
      /* Check mc_config command */
      if((status & AC_SFLD_OK) != 0)
        printk(KERN_INFO "wv_config_complete(): set_multicast_address failed; status = 0x%x\n",
               dev->name, str, status);
 
      /* check ia-config command */
      ias_addr = mcs_addr - sizeof(ac_ias_t);
      obram_read(ioaddr, acoff(ias_addr, ac_status), (unsigned char *)&status, sizeof(status));
      if((status & AC_SFLD_OK) != 0)
        printk(KERN_INFO "wv_config_complete(): set_MAC_address; status = 0x%x\n",
               dev->name, str, status);
 
      /* Check config command */
      cfg_addr = ias_addr - sizeof(ac_cfg_t);
      obram_read(ioaddr, acoff(cfg_addr, ac_status), (unsigned char *)&status, sizeof(status));
      if((status & AC_SFLD_OK) != 0)
        printk(KERN_INFO "wv_config_complete(): configure; status = 0x%x\n",
               dev->name, str, status);
#endif  /* DEBUG_CONFIG_ERROR */
 
      ret = 1;          /* Ready to be scrapped */
    }
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: <-wv_config_complete() - %d\n", dev->name, ret);
#endif
  return ret;
}
 
/*------------------------------------------------------------------*/
/*
 * Command completion interrupt.
 * Reclaim as many freed tx buffers as we can.
 */
static int
wv_complete(device *    dev,
            u_long      ioaddr,
            net_local * lp)
{
  int   nreaped = 0;
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: ->wv_complete()\n", dev->name);
#endif
 
  /* Loop on all the transmit buffers */
  while(lp->tx_first_in_use != I82586NULL)
    {
      unsigned short    tx_status;
 
      /* Read the first transmit buffer */
      obram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status), (unsigned char *)&tx_status, sizeof(tx_status));
 
      /* Hack for reconfiguration... */
      if(tx_status == 0xFFFF)
        if(!wv_config_complete(dev, ioaddr, lp))
          break;        /* Not completed */
 
      /* If not completed -> exit */
      if((tx_status & AC_SFLD_C) == 0)
        break;
 
      /* We now remove this buffer */
      nreaped++;
      --lp->tx_n_in_use;
 
/*
if (lp->tx_n_in_use > 0)
        printk("%c", "0123456789abcdefghijk"[lp->tx_n_in_use]);
*/
 
      /* Was it the last one ? */
      if(lp->tx_n_in_use <= 0)
        lp->tx_first_in_use = I82586NULL;
      else
        {
          /* Next one in the chain */
          lp->tx_first_in_use += TXBLOCKZ;
          if(lp->tx_first_in_use >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
            lp->tx_first_in_use -= NTXBLOCKS * TXBLOCKZ;
        }
 
      /* Hack for reconfiguration... */
      if(tx_status == 0xFFFF)
        continue;
 
      /* Now, check status of the finished command */
      if(tx_status & AC_SFLD_OK)
        {
          int   ncollisions;
 
          lp->stats.tx_packets++;
          ncollisions = tx_status & AC_SFLD_MAXCOL;
          lp->stats.collisions += ncollisions;
#ifdef DEBUG_INTERRUPT_INFO
          if(ncollisions > 0)
            printk(KERN_DEBUG "%s: wv_complete(): tx completed after %d collisions.\n",
                   dev->name, ncollisions);
#endif
        }
      else
        {
          lp->stats.tx_errors++;
#ifndef IGNORE_NORMAL_XMIT_ERRS
          if(tx_status & AC_SFLD_S10)
            {
              lp->stats.tx_carrier_errors++;
#ifdef DEBUG_INTERRUPT_ERROR
              printk(KERN_INFO "%s: wv_complete(): tx error: no CS.\n",
                     dev->name);
#endif
            }
#endif  /* IGNORE_NORMAL_XMIT_ERRS */
          if(tx_status & AC_SFLD_S9)
            {
              lp->stats.tx_carrier_errors++;
#ifdef DEBUG_INTERRUPT_ERROR
              printk(KERN_INFO "%s: wv_complete(): tx error: lost CTS.\n",
                     dev->name);
#endif
            }
          if(tx_status & AC_SFLD_S8)
            {
              lp->stats.tx_fifo_errors++;
#ifdef DEBUG_INTERRUPT_ERROR
              printk(KERN_INFO "%s: wv_complete(): tx error: slow DMA.\n",
                     dev->name);
#endif
            }
#ifndef IGNORE_NORMAL_XMIT_ERRS
          if(tx_status & AC_SFLD_S6)
            {
              lp->stats.tx_heartbeat_errors++;
#ifdef DEBUG_INTERRUPT_ERROR
              printk(KERN_INFO "%s: wv_complete(): tx error: heart beat.\n",
                     dev->name);
#endif
            }
          if(tx_status & AC_SFLD_S5)
            {
              lp->stats.tx_aborted_errors++;
#ifdef DEBUG_INTERRUPT_ERROR
              printk(KERN_INFO "%s: wv_complete(): tx error: too many collisions.\n",
                     dev->name);
#endif
            }
#endif  /* IGNORE_NORMAL_XMIT_ERRS */
        }
 
#ifdef DEBUG_INTERRUPT_INFO
      printk(KERN_DEBUG "%s: wv_complete(): tx completed, tx_status 0x%04x\n",
             dev->name, tx_status);
#endif
    }
 
#ifdef DEBUG_INTERRUPT_INFO
  if(nreaped > 1)
    printk(KERN_DEBUG "%s: wv_complete(): reaped %d\n", dev->name, nreaped);
#endif
 
  /*
   * Inform upper layers.
   */
  if(lp->tx_n_in_use < NTXBLOCKS - 1)
    {
      dev->tbusy = 0;
      mark_bh(NET_BH);
    }
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: <-wv_complete()\n", dev->name);
#endif
  return nreaped;
}
 
/*------------------------------------------------------------------*/
/*
 * Reconfigure the i82586, or at least ask for it...
 * Because wv_82586_config use a transmission buffer, we must do it
 * when we are sure that there is one left, so we do it now
 * or in wavelan_packet_xmit() (I can't find any better place,
 * wavelan_interrupt is not an option...), so you may experience
 * some delay sometime...
 */
static inline void
wv_82586_reconfig(device *      dev)
{
  net_local *   lp = (net_local *)dev->priv;
 
  /* Check if we can do it now ! */
  if(!(dev->start) || (set_bit(0, (void *)&dev->tbusy) != 0))
    {
      lp->reconfig_82586 = 1;
#ifdef DEBUG_CONFIG_INFO
      printk(KERN_DEBUG "%s: wv_82586_reconfig(): delayed (busy = %ld, start = %d)\n",
             dev->name, dev->tbusy, dev->start);
#endif
    }
  else
    wv_82586_config(dev);
}
 
/********************* DEBUG & INFO SUBROUTINES *********************/
/*
 * This routines are used in the code to show debug informations.
 * Most of the time, it dump the content of hardware structures...
 */
 
#ifdef DEBUG_PSA_SHOW
/*------------------------------------------------------------------*/
/*
 * Print the formatted contents of the Parameter Storage Area.
 */
static void
wv_psa_show(psa_t *     p)
{
  printk(KERN_DEBUG "##### WaveLAN psa contents: #####\n");
  printk(KERN_DEBUG "psa_io_base_addr_1: 0x%02X %02X %02X %02X\n",
         p->psa_io_base_addr_1,
         p->psa_io_base_addr_2,
         p->psa_io_base_addr_3,
         p->psa_io_base_addr_4);
  printk(KERN_DEBUG "psa_rem_boot_addr_1: 0x%02X %02X %02X\n",
         p->psa_rem_boot_addr_1,
         p->psa_rem_boot_addr_2,
         p->psa_rem_boot_addr_3);
  printk(KERN_DEBUG "psa_holi_params: 0x%02x, ", p->psa_holi_params);
  printk("psa_int_req_no: %d\n", p->psa_int_req_no);
#ifdef DEBUG_SHOW_UNUSED
  printk(KERN_DEBUG "psa_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
         p->psa_unused0[0],
         p->psa_unused0[1],
         p->psa_unused0[2],
         p->psa_unused0[3],
         p->psa_unused0[4],
         p->psa_unused0[5],
         p->psa_unused0[6]);
#endif  /* DEBUG_SHOW_UNUSED */
  printk(KERN_DEBUG "psa_univ_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
         p->psa_univ_mac_addr[0],
         p->psa_univ_mac_addr[1],
         p->psa_univ_mac_addr[2],
         p->psa_univ_mac_addr[3],
         p->psa_univ_mac_addr[4],
         p->psa_univ_mac_addr[5]);
  printk(KERN_DEBUG "psa_local_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n",
         p->psa_local_mac_addr[0],
         p->psa_local_mac_addr[1],
         p->psa_local_mac_addr[2],
         p->psa_local_mac_addr[3],
         p->psa_local_mac_addr[4],
         p->psa_local_mac_addr[5]);
  printk(KERN_DEBUG "psa_univ_local_sel: %d, ", p->psa_univ_local_sel);
  printk("psa_comp_number: %d, ", p->psa_comp_number);
  printk("psa_thr_pre_set: 0x%02x\n", p->psa_thr_pre_set);
  printk(KERN_DEBUG "psa_feature_select/decay_prm: 0x%02x, ",
         p->psa_feature_select);
  printk("psa_subband/decay_update_prm: %d\n", p->psa_subband);
  printk(KERN_DEBUG "psa_quality_thr: 0x%02x, ", p->psa_quality_thr);
  printk("psa_mod_delay: 0x%02x\n", p->psa_mod_delay);
  printk(KERN_DEBUG "psa_nwid: 0x%02x%02x, ", p->psa_nwid[0], p->psa_nwid[1]);
  printk("psa_nwid_select: %d\n", p->psa_nwid_select);
  printk(KERN_DEBUG "psa_encryption_select: %d, ", p->psa_encryption_select);
  printk("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
         p->psa_encryption_key[0],
         p->psa_encryption_key[1],
         p->psa_encryption_key[2],
         p->psa_encryption_key[3],
         p->psa_encryption_key[4],
         p->psa_encryption_key[5],
         p->psa_encryption_key[6],
         p->psa_encryption_key[7]);
  printk(KERN_DEBUG "psa_databus_width: %d\n", p->psa_databus_width);
  printk(KERN_DEBUG "psa_call_code/auto_squelch: 0x%02x, ",
         p->psa_call_code[0]);
  printk("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
         p->psa_call_code[0],
         p->psa_call_code[1],
         p->psa_call_code[2],
         p->psa_call_code[3],
         p->psa_call_code[4],
         p->psa_call_code[5],
         p->psa_call_code[6],
         p->psa_call_code[7]);
#ifdef DEBUG_SHOW_UNUSED
  printk(KERN_DEBUG "psa_reserved[]: %02X:%02X:%02X:%02X\n",
         p->psa_reserved[0],
         p->psa_reserved[1],
         p->psa_reserved[2],
         p->psa_reserved[3]);
#endif  /* DEBUG_SHOW_UNUSED */
  printk(KERN_DEBUG "psa_conf_status: %d, ", p->psa_conf_status);
  printk("psa_crc: 0x%02x%02x, ", p->psa_crc[0], p->psa_crc[1]);
  printk("psa_crc_status: 0x%02x\n", p->psa_crc_status);
} /* wv_psa_show */
#endif  /* DEBUG_PSA_SHOW */
 
#ifdef DEBUG_MMC_SHOW
/*------------------------------------------------------------------*/
/*
 * Print the formatted status of the Modem Management Controller.
 * This function need to be completed...
 */
static void
wv_mmc_show(device *    dev)
{
  u_long        ioaddr = dev->base_addr;
  net_local *   lp = (net_local *)dev->priv;
  mmr_t         m;
 
  /* Basic check */
  if(hasr_read(ioaddr) & HASR_NO_CLK)
    {
      printk(KERN_WARNING "%s: wv_mmc_show: modem not connected\n",
             dev->name);
      return;
    }
 
  /* Read the mmc */
  mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
  mmc_read(ioaddr, 0, (u_char *)&m, sizeof(m));
  mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
 
#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
  /* Don't forget to update statistics */
  lp->wstats.discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
#endif  /* WIRELESS_EXT */
 
  printk(KERN_DEBUG "##### WaveLAN modem status registers: #####\n");
#ifdef DEBUG_SHOW_UNUSED
  printk(KERN_DEBUG "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
         m.mmr_unused0[0],
         m.mmr_unused0[1],
         m.mmr_unused0[2],
         m.mmr_unused0[3],
         m.mmr_unused0[4],
         m.mmr_unused0[5],
         m.mmr_unused0[6],
         m.mmr_unused0[7]);
#endif  /* DEBUG_SHOW_UNUSED */
  printk(KERN_DEBUG "Encryption algorythm: %02X - Status: %02X\n",
         m.mmr_des_avail, m.mmr_des_status);
#ifdef DEBUG_SHOW_UNUSED
  printk(KERN_DEBUG "mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n",
         m.mmr_unused1[0],
         m.mmr_unused1[1],
         m.mmr_unused1[2],
         m.mmr_unused1[3],
         m.mmr_unused1[4]);
#endif  /* DEBUG_SHOW_UNUSED */
  printk(KERN_DEBUG "dce_status: 0x%x [%s%s%s%s]\n",
         m.mmr_dce_status,
         (m.mmr_dce_status & MMR_DCE_STATUS_RX_BUSY) ? "energy detected,":"",
         (m.mmr_dce_status & MMR_DCE_STATUS_LOOPT_IND) ?
         "loop test indicated," : "",
         (m.mmr_dce_status & MMR_DCE_STATUS_TX_BUSY) ? "transmitter on," : "",
         (m.mmr_dce_status & MMR_DCE_STATUS_JBR_EXPIRED) ?
         "jabber timer expired," : "");
  printk(KERN_DEBUG "Dsp ID: %02X\n",
         m.mmr_dsp_id);
#ifdef DEBUG_SHOW_UNUSED
  printk(KERN_DEBUG "mmc_unused2[]: %02X:%02X\n",
         m.mmr_unused2[0],
         m.mmr_unused2[1]);
#endif  /* DEBUG_SHOW_UNUSED */
  printk(KERN_DEBUG "# correct_nwid: %d, # wrong_nwid: %d\n",
         (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l,
         (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l);
  printk(KERN_DEBUG "thr_pre_set: 0x%x [current signal %s]\n",
         m.mmr_thr_pre_set & MMR_THR_PRE_SET,
         (m.mmr_thr_pre_set & MMR_THR_PRE_SET_CUR) ? "above" : "below");
  printk(KERN_DEBUG "signal_lvl: %d [%s], ",
         m.mmr_signal_lvl & MMR_SIGNAL_LVL,
         (m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) ? "new msg" : "no new msg");
  printk("silence_lvl: %d [%s], ", m.mmr_silence_lvl & MMR_SILENCE_LVL,
         (m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) ? "update done" : "no new update");
  printk("sgnl_qual: 0x%x [%s]\n",
         m.mmr_sgnl_qual & MMR_SGNL_QUAL,
         (m.mmr_sgnl_qual & MMR_SGNL_QUAL_ANT) ? "Antenna 1" : "Antenna 0");
#ifdef DEBUG_SHOW_UNUSED
  printk(KERN_DEBUG "netw_id_l: %x\n", m.mmr_netw_id_l);
#endif  /* DEBUG_SHOW_UNUSED */
} /* wv_mmc_show */
#endif  /* DEBUG_MMC_SHOW */
 
#ifdef DEBUG_I82586_SHOW
/*------------------------------------------------------------------*/
/*
 * Print the last block of the i82586 memory
 */
static void
wv_scb_show(u_long      ioaddr)
{
  scb_t         scb;
 
  obram_read(ioaddr, OFFSET_SCB, (unsigned char *)&scb, sizeof(scb));
 
  printk(KERN_DEBUG "##### WaveLAN system control block: #####\n");
 
  printk(KERN_DEBUG "status: ");
  printk("stat 0x%x[%s%s%s%s] ",
         (scb.scb_status & (SCB_ST_CX | SCB_ST_FR | SCB_ST_CNA | SCB_ST_RNR)) >> 12,
         (scb.scb_status & SCB_ST_CX) ? "cmd completion interrupt," : "",
         (scb.scb_status & SCB_ST_FR) ? "frame received," : "",
         (scb.scb_status & SCB_ST_CNA) ? "cmd unit not active," : "",
         (scb.scb_status & SCB_ST_RNR) ? "rcv unit not ready," : "");
  printk("cus 0x%x[%s%s%s] ",
         (scb.scb_status & SCB_ST_CUS) >> 8,
         ((scb.scb_status & SCB_ST_CUS) == SCB_ST_CUS_IDLE) ? "idle" : "",
         ((scb.scb_status & SCB_ST_CUS) == SCB_ST_CUS_SUSP) ? "suspended" : "",
         ((scb.scb_status & SCB_ST_CUS) == SCB_ST_CUS_ACTV) ? "active" : "");
  printk("rus 0x%x[%s%s%s%s]\n",
         (scb.scb_status & SCB_ST_RUS) >> 4,
         ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_IDLE) ? "idle" : "",
         ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_SUSP) ? "suspended" : "",
         ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_NRES) ? "no resources" : "",
         ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_RDY) ? "ready" : "");
 
  printk(KERN_DEBUG "command: ");
  printk("ack 0x%x[%s%s%s%s] ",
         (scb.scb_command & (SCB_CMD_ACK_CX | SCB_CMD_ACK_FR | SCB_CMD_ACK_CNA | SCB_CMD_ACK_RNR)) >> 12,
         (scb.scb_command & SCB_CMD_ACK_CX) ? "ack cmd completion," : "",
         (scb.scb_command & SCB_CMD_ACK_FR) ? "ack frame received," : "",
         (scb.scb_command & SCB_CMD_ACK_CNA) ? "ack CU not active," : "",
         (scb.scb_command & SCB_CMD_ACK_RNR) ? "ack RU not ready," : "");
  printk("cuc 0x%x[%s%s%s%s%s] ",
         (scb.scb_command & SCB_CMD_CUC) >> 8,
         ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_NOP) ? "nop" : "",
         ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_GO) ? "start cbl_offset" : "",
         ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_RES) ? "resume execution" : "",
         ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_SUS) ? "suspend execution" : "",
         ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_ABT) ? "abort execution" : "");
  printk("ruc 0x%x[%s%s%s%s%s]\n",
         (scb.scb_command & SCB_CMD_RUC) >> 4,
         ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_NOP) ? "nop" : "",
         ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_GO) ? "start rfa_offset" : "",
         ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_RES) ? "resume reception" : "",
         ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_SUS) ? "suspend reception" : "",
         ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_ABT) ? "abort reception" : "");
 
  printk(KERN_DEBUG "cbl_offset 0x%x ", scb.scb_cbl_offset);
  printk("rfa_offset 0x%x\n", scb.scb_rfa_offset);
 
  printk(KERN_DEBUG "crcerrs %d ", scb.scb_crcerrs);
  printk("alnerrs %d ", scb.scb_alnerrs);
  printk("rscerrs %d ", scb.scb_rscerrs);
  printk("ovrnerrs %d\n", scb.scb_ovrnerrs);
}
 
/*------------------------------------------------------------------*/
/*
 * Print the formatted status of the i82586's receive unit.
 */
static void
wv_ru_show(device *     dev)
{
  /* net_local *lp = (net_local *) dev->priv; */
 
  printk(KERN_DEBUG "##### WaveLAN i82586 receiver unit status: #####\n");
  printk(KERN_DEBUG "ru:");
  /*
   * Not implemented yet...
   */
  printk("\n");
} /* wv_ru_show */
 
/*------------------------------------------------------------------*/
/*
 * Display info about one control block of the i82586 memory
 */
static void
wv_cu_show_one(device *         dev,
               net_local *      lp,
               int              i,
               u_short          p)
{
  u_long                ioaddr;
  ac_tx_t               actx;
 
  ioaddr = dev->base_addr;
 
  printk("%d: 0x%x:", i, p);
 
  obram_read(ioaddr, p, (unsigned char *)&actx, sizeof(actx));
  printk(" status=0x%x,", actx.tx_h.ac_status);
  printk(" command=0x%x,", actx.tx_h.ac_command);
 
  /*
  {
    tbd_t       tbd;
 
    obram_read(ioaddr, actx.tx_tbd_offset, (unsigned char *)&tbd, sizeof(tbd));
    printk(" tbd_status=0x%x,", tbd.tbd_status);
  }
  */
 
  printk("|");
}
 
/*------------------------------------------------------------------*/
/*
 * Print status of the command unit of the i82586
 */
static void
wv_cu_show(device *     dev)
{
  net_local *   lp = (net_local *)dev->priv;
  unsigned int  i;
  u_short       p;
 
  printk(KERN_DEBUG "##### WaveLAN i82586 command unit status: #####\n");
 
  printk(KERN_DEBUG);
  for(i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++)
    {
      wv_cu_show_one(dev, lp, i, p);
 
      p += TXBLOCKZ;
      if(p >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
        p -= NTXBLOCKS * TXBLOCKZ;
    }
  printk("\n");
}
#endif  /* DEBUG_I82586_SHOW */
 
#ifdef DEBUG_DEVICE_SHOW
/*------------------------------------------------------------------*/
/*
 * Print the formatted status of the WaveLAN PCMCIA device driver.
 */
static void
wv_dev_show(device *    dev)
{
  printk(KERN_DEBUG "dev:");
  printk(" start=%d,", dev->start);
  printk(" tbusy=%ld,", dev->tbusy);
  printk(" interrupt=%d,", dev->interrupt);
  printk(" trans_start=%ld,", dev->trans_start);
  printk(" flags=0x%x,", dev->flags);
  printk("\n");
} /* wv_dev_show */
 
/*------------------------------------------------------------------*/
/*
 * Print the formatted status of the WaveLAN PCMCIA device driver's
 * private information.
 */
static void
wv_local_show(device *  dev)
{
  net_local *lp;
 
  lp = (net_local *)dev->priv;
 
  printk(KERN_DEBUG "local:");
  printk(" tx_n_in_use=%d,", lp->tx_n_in_use);
  printk(" hacr=0x%x,", lp->hacr);
  printk(" rx_head=0x%x,", lp->rx_head);
  printk(" rx_last=0x%x,", lp->rx_last);
  printk(" tx_first_free=0x%x,", lp->tx_first_free);
  printk(" tx_first_in_use=0x%x,", lp->tx_first_in_use);
  printk("\n");
} /* wv_local_show */
#endif  /* DEBUG_DEVICE_SHOW */
 
#if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO)
/*------------------------------------------------------------------*/
/*
 * Dump packet header (and content if necessary) on the screen
 */
static inline void
wv_packet_info(u_char *         p,              /* Packet to dump */
               int              length,         /* Length of the packet */
               char *           msg1,           /* Name of the device */
               char *           msg2)           /* Name of the function */
{
#ifndef DEBUG_PACKET_DUMP
  printk(KERN_DEBUG "%s: %s(): dest %02X:%02X:%02X:%02X:%02X:%02X, length %d\n",
         msg1, msg2, p[0], p[1], p[2], p[3], p[4], p[5], length);
  printk(KERN_DEBUG "%s: %s(): src %02X:%02X:%02X:%02X:%02X:%02X, type 0x%02X%02X\n",
         msg1, msg2, p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13]);
 
#else   /* DEBUG_PACKET_DUMP */
  int           i;
  int           maxi;
 
  printk(KERN_DEBUG "%s: %s(): len=%d, data=\"", msg1, msg2, length);
 
  if((maxi = length) > DEBUG_PACKET_DUMP)
    maxi = DEBUG_PACKET_DUMP;
  for(i = 0; i < maxi; i++)
    if(p[i] >= ' ' && p[i] <= '~')
      printk(" %c", p[i]);
    else
      printk("%02X", p[i]);
  if(maxi < length)
    printk("..");
  printk("\"\n");
  printk(KERN_DEBUG "\n");
#endif  /* DEBUG_PACKET_DUMP */
}
#endif  /* defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) */
 
/*------------------------------------------------------------------*/
/*
 * This is the information which is displayed by the driver at startup
 * There  is a lot of flag to configure it at your will...
 */
static inline void
wv_init_info(device *   dev)
{
  short         ioaddr = dev->base_addr;
  net_local *   lp = (net_local *)dev->priv;
  psa_t         psa;
  int           i;
 
  /* Read the parameter storage area */
  psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa));
 
#ifdef DEBUG_PSA_SHOW
  wv_psa_show(&psa);
#endif
#ifdef DEBUG_MMC_SHOW
  wv_mmc_show(dev);
#endif
#ifdef DEBUG_I82586_SHOW
  wv_cu_show(dev);
#endif
 
#ifdef DEBUG_BASIC_SHOW
  /* Now, let's go for the basic stuff */
  printk(KERN_NOTICE "%s: WaveLAN at %#x,", dev->name, ioaddr);
  for(i = 0; i < WAVELAN_ADDR_SIZE; i++)
    printk("%s%02X", (i == 0) ? " " : ":", dev->dev_addr[i]);
  printk(", IRQ %d", dev->irq);
 
  /* Print current network id */
  if(psa.psa_nwid_select)
    printk(", nwid 0x%02X-%02X", psa.psa_nwid[0], psa.psa_nwid[1]);
  else
    printk(", nwid off");
 
  /* If 2.00 card */
  if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
       (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
    {
      unsigned short    freq;
 
      /* Ask the EEPROM to read the frequency from the first area */
      fee_read(ioaddr, 0x00 /* 1st area - frequency... */,
               &freq, 1);
 
      /* Print frequency */
      printk(", 2.00, %ld", (freq >> 6) + 2400L);
 
      /* Hack !!! */
      if(freq & 0x20)
        printk(".5");
    }
  else
    {
      printk(", PC");
      switch(psa.psa_comp_number)
        {
        case PSA_COMP_PC_AT_915:
        case PSA_COMP_PC_AT_2400:
          printk("-AT");
          break;
        case PSA_COMP_PC_MC_915:
        case PSA_COMP_PC_MC_2400:
          printk("-MC");
          break;
        case PSA_COMP_PCMCIA_915:
          printk("MCIA");
          break;
        default:
          printk("???");
        }
      printk(", ");
      switch (psa.psa_subband)
        {
        case PSA_SUBBAND_915:
          printk("915");
          break;
        case PSA_SUBBAND_2425:
          printk("2425");
          break;
        case PSA_SUBBAND_2460:
          printk("2460");
          break;
        case PSA_SUBBAND_2484:
          printk("2484");
          break;
        case PSA_SUBBAND_2430_5:
          printk("2430.5");
          break;
        default:
          printk("???");
        }
    }
 
  printk(" MHz\n");
#endif  /* DEBUG_BASIC_SHOW */
 
#ifdef DEBUG_VERSION_SHOW
  /* Print version information */
  printk(KERN_NOTICE "%s", version);
#endif
} /* wv_init_info */
 
/********************* IOCTL, STATS & RECONFIG *********************/
/*
 * We found here routines that are called by Linux on differents
 * occasions after the configuration and not for transmitting data
 * These may be called when the user use ifconfig, /proc/net/dev
 * or wireless extensions
 */
 
/*------------------------------------------------------------------*/
/*
 * Get the current ethernet statistics. This may be called with the
 * card open or closed.
 * Used when the user read /proc/net/dev
 */
static en_stats *
wavelan_get_stats(device *      dev)
{
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name);
#endif
 
  return(&((net_local *) dev->priv)->stats);
}
 
/*------------------------------------------------------------------*/
/*
 * Set or clear the multicast filter for this adaptor.
 * num_addrs == -1      Promiscuous mode, receive all packets
 * num_addrs == 0       Normal mode, clear multicast list
 * num_addrs > 0        Multicast mode, receive normal and MC packets,
 *                      and do best-effort filtering.
 */
static void
wavelan_set_multicast_list(device *     dev)
{
  net_local *   lp = (net_local *) dev->priv;
 
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n", dev->name);
#endif
 
#ifdef DEBUG_IOCTL_INFO
  printk(KERN_DEBUG "%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
         dev->name, dev->flags, dev->mc_count);
#endif
 
  /* If we ask for promiscuous mode,
   * or all multicast addresses (we don't have that !)
   * or too much multicast addresses for the hardware filter */
  if((dev->flags & IFF_PROMISC) ||
     (dev->flags & IFF_ALLMULTI) ||
     (dev->mc_count > I82586_MAX_MULTICAST_ADDRESSES))
    {
      /*
       * Enable promiscuous mode: receive all packets.
       */
      if(!lp->promiscuous)
        {
          lp->promiscuous = 1;
          lp->mc_count = 0;
 
          wv_82586_reconfig(dev);
 
          /* Tell the kernel that we are doing a really bad job... */
          dev->flags |= IFF_PROMISC;
        }
    }
  else
    /* If there is some multicast addresses to send */
    if(dev->mc_list != (struct dev_mc_list *) NULL)
      {
        /*
         * Disable promiscuous mode, but receive all packets
         * in multicast list
         */
#ifdef MULTICAST_AVOID
        if(lp->promiscuous ||
           (dev->mc_count != lp->mc_count))
#endif
          {
            lp->promiscuous = 0;
            lp->mc_count = dev->mc_count;
 
            wv_82586_reconfig(dev);
          }
      }
    else
      {
        /*
         * Switch to normal mode: disable promiscuous mode and
         * clear the multicast list.
         */
        if(lp->promiscuous || lp->mc_count == 0)
          {
            lp->promiscuous = 0;
            lp->mc_count = 0;
 
            wv_82586_reconfig(dev);
          }
      }
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_set_multicast_list()\n", dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * This function doesn't exist...
 */
static int
wavelan_set_mac_address(device *        dev,
                        void *          addr)
{
  struct sockaddr *     mac = addr;
 
  /* Copy the address */
  memcpy(dev->dev_addr, mac->sa_data, WAVELAN_ADDR_SIZE);
 
  /* Reconfig the beast */
  wv_82586_reconfig(dev);
 
  return 0;
}
 
#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
 
/*------------------------------------------------------------------*/
/*
 * Frequency setting (for hardware able of it)
 * It's a bit complicated and you don't really want to look into it...
 * (called in wavelan_ioctl)
 */
static inline int
wv_set_frequency(u_long         ioaddr, /* i/o port of the card */
                 iw_freq *      frequency)
{
  const int     BAND_NUM = 10;  /* Number of bands */
  long          freq = 0L;      /* offset to 2.4 GHz in .5 MHz */
#ifdef DEBUG_IOCTL_INFO
  int           i;
#endif
 
  /* Setting by frequency */
  /* Theoretically, you may set any frequency between
   * the two limits with a 0.5 MHz precision. In practice,
   * I don't want you to have trouble with local
   * regulations... */
  if((frequency->e == 1) &&
     (frequency->m >= (int) 2.412e8) && (frequency->m <= (int) 2.487e8))
    {
      freq = ((frequency->m / 10000) - 24000L) / 5;
    }
 
  /* Setting by channel (same as wfreqsel) */
  /* Warning : each channel is 22MHz wide, so some of the channels
   * will interfere... */
  if((frequency->e == 0) &&
     (frequency->m >= 0) && (frequency->m < BAND_NUM))
    {
      /* frequency in 1/4 of MHz (as read in the offset register) */
      short     bands[] = { 0x30, 0x58, 0x64, 0x7A, 0x80, 0xA8, 0xD0, 0xF0, 0xF8, 0x150 };
 
      /* Get frequency offset */
      freq = bands[frequency->m] >> 1;
    }
 
  /* Verify if the frequency is allowed */
  if(freq != 0L)
    {
      u_short   table[10];      /* Authorized frequency table */
 
      /* Read the frequency table */
      fee_read(ioaddr, 0x71 /* frequency table */,
               table, 10);
 
#ifdef DEBUG_IOCTL_INFO
      printk(KERN_DEBUG "Frequency table :");
      for(i = 0; i < 10; i++)
        {
          printk(" %04X",
                 table[i]);
        }
      printk("\n");
#endif
 
      /* Look in the table if the frequency is allowed */
      if(!(table[9 - ((freq - 24) / 16)] &
           (1 << ((freq - 24) % 16))))
        return -EINVAL;         /* not allowed */
    }
  else
    return -EINVAL;
 
  /* If we get a usable frequency */
  if(freq != 0L)
    {
      unsigned short    area[16];
      unsigned short    dac[2];
      unsigned short    area_verify[16];
      unsigned short    dac_verify[2];
      /* Corresponding gain (in the power adjust value table)
       * see AT&T WaveLAN Data Manual, REF 407-024689/E, page 3-8
       * & WCIN062D.DOC, page 6.2.9 */
      unsigned short    power_limit[] = { 40, 80, 120, 160, 0 };
      int               power_band = 0;          /* Selected band */
      unsigned short    power_adjust;           /* Correct value */
 
      /* Search for the gain */
      power_band = 0;
      while((freq > power_limit[power_band]) &&
            (power_limit[++power_band] != 0))
        ;
 
      /* Read the first area */
      fee_read(ioaddr, 0x00,
               area, 16);
 
      /* Read the DAC */
      fee_read(ioaddr, 0x60,
               dac, 2);
 
      /* Read the new power adjust value */
      fee_read(ioaddr, 0x6B - (power_band >> 1),
               &power_adjust, 1);
      if(power_band & 0x1)
        power_adjust >>= 8;
      else
        power_adjust &= 0xFF;
 
#ifdef DEBUG_IOCTL_INFO
      printk(KERN_DEBUG "WaveLAN EEPROM Area 1:");
      for(i = 0; i < 16; i++)
        {
          printk(" %04X",
                 area[i]);
        }
      printk("\n");
 
      printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n",
             dac[0], dac[1]);
#endif
 
      /* Frequency offset (for info only) */
      area[0] = ((freq << 5) & 0xFFE0) | (area[0] & 0x1F);
 
      /* Receiver Principle main divider coefficient */
      area[3] = (freq >> 1) + 2400L - 352L;
      area[2] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
 
      /* Transmitter Main divider coefficient */
      area[13] = (freq >> 1) + 2400L;
      area[12] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
 
      /* Others part of the area are flags, bit streams or unused... */
 
      /* Set the value in the DAC. */
      dac[1] = ((power_adjust >> 1) & 0x7F) | (dac[1] & 0xFF80);
      dac[0] = ((power_adjust & 0x1) << 4) | (dac[0] & 0xFFEF);
 
      /* Write the first area. */
      fee_write(ioaddr, 0x00,
                area, 16);
 
      /* Write the DAC. */
      fee_write(ioaddr, 0x60,
                dac, 2);
 
      /* We now should verify here that the EEPROM writing was OK. */
 
      /* Reread the first area. */
      fee_read(ioaddr, 0x00,
               area_verify, 16);
 
      /* ReRead the DAC */
      fee_read(ioaddr, 0x60,
               dac_verify, 2);
 
      /* Compare */
      if(memcmp(area, area_verify, 16 * 2) ||
         memcmp(dac, dac_verify, 2 * 2))
        {
#ifdef DEBUG_IOCTL_ERROR
          printk(KERN_INFO "WaveLAN: wv_set_frequency: unable to write new frequency to EEPROM(?).\n");
#endif
          return -EOPNOTSUPP;
        }
 
      /* We must download the frequency parameters to the
       * synthesizers (from the EEPROM - area 1)
       * Note: as the EEPROM is automatically decremented, we set the end
       * if the area... */
      mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x0F);
      mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
              MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
 
      /* Wait until the download is finished */
      fee_wait(ioaddr, 100, 100);
 
      /* We must now download the power adjust value (gain) to
       * the synthesizers (from the EEPROM - area 7 - DAC) */
      mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x61);
      mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl),
              MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
 
      /* Wait until the download is finished */
      fee_wait(ioaddr, 100, 100);
 
#ifdef DEBUG_IOCTL_INFO
      /* Verification of what we have done... */
 
      printk(KERN_DEBUG "WaveLAN EEPROM Area 1:");
      for(i = 0; i < 16; i++)
        {
          printk(" %04X",
                 area_verify[i]);
        }
      printk("\n");
 
      printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n",
             dac_verify[0], dac_verify[1]);
#endif
 
      return 0;
    }
  else
    return -EINVAL;             /* Bah, never get there... */
}
 
/*------------------------------------------------------------------*/
/*
 * Give the list of available frequencies
 */
static inline int
wv_frequency_list(u_long        ioaddr, /* i/o port of the card */
                  iw_freq *     list,   /* List of frequency to fill */
                  int           max)    /* Maximum number of frequencies */
{
  u_short       table[10];      /* Authorized frequency table */
  long          freq = 0L;      /* offset to 2.4 GHz in .5 MHz + 12 MHz */
  int           i;              /* index in the table */
 
  /* Read the frequency table */
  fee_read(ioaddr, 0x71 /* frequency table */,
           table, 10);
 
  /* Look all frequencies */
  i = 0;
  for(freq = 0; freq < 150; freq++)
    /* Look in the table if the frequency is allowed */
    if(table[9 - (freq / 16)] & (1 << (freq % 16)))
      {
        /* put in the list */
        list[i].m = (((freq + 24) * 5) + 24000L) * 10000;
        list[i++].e = 1;
 
        /* Check number */
        if(i >= max)
          return(i);
      }
 
  return(i);
}
 
#ifdef WIRELESS_SPY
/*------------------------------------------------------------------*/
/*
 * Gather wireless spy statistics : for each packet, compare the source
 * address with out list, and if match, get the stats...
 * Sorry, but this function really need wireless extensions...
 */
static inline void
wl_spy_gather(device *  dev,
              u_char *  mac,            /* MAC address */
              u_char *  stats)          /* Statistics to gather */
{
  net_local *   lp = (net_local *) dev->priv;
  int           i;
 
  /* Look all addresses */
  for(i = 0; i < lp->spy_number; i++)
    /* If match */
    if(!memcmp(mac, lp->spy_address[i], WAVELAN_ADDR_SIZE))
      {
        /* Update statistics */
        lp->spy_stat[i].qual = stats[2] & MMR_SGNL_QUAL;
        lp->spy_stat[i].level = stats[0] & MMR_SIGNAL_LVL;
        lp->spy_stat[i].noise = stats[1] & MMR_SILENCE_LVL;
        lp->spy_stat[i].updated = 0x7;
      }
}
#endif  /* WIRELESS_SPY */
 
#ifdef HISTOGRAM
/*------------------------------------------------------------------*/
/*
 * This function calculates an histogram on the signal level.
 * As the noise is quite constant, it's like doing it on the SNR.
 * We have defined a set of interval (lp->his_range), and each time
 * the level goes in that interval, we increment the count (lp->his_sum).
 * With this histogram you may detect if one WaveLAN is really weak,
 * or you may also calculate the mean and standard deviation of the level.
 */
static inline void
wl_his_gather(device *  dev,
              u_char *  stats)          /* Statistics to gather */
{
  net_local *   lp = (net_local *) dev->priv;
  u_char        level = stats[0] & MMR_SIGNAL_LVL;
  int           i;
 
  /* Find the correct interval */
  i = 0;
  while((i < (lp->his_number - 1)) && (level >= lp->his_range[i++]))
    ;
 
  /* Increment interval counter */
  (lp->his_sum[i])++;
}
#endif  /* HISTOGRAM */
 
/*------------------------------------------------------------------*/
/*
 * Perform ioctl : config & info stuff
 * This is here that are treated the wireless extensions (iwconfig)
 */
static int
wavelan_ioctl(struct device *   dev,    /* device on which the ioctl is applied */
              struct ifreq *    rq,     /* data passed */
              int               cmd)    /* ioctl number */
{
  u_long                ioaddr = dev->base_addr;
  net_local *           lp = (net_local *)dev->priv;    /* lp is not unused */
  struct iwreq *        wrq = (struct iwreq *) rq;
  psa_t                 psa;
  mm_t                  m;
  unsigned long         x;
  int                   ret = 0;
 
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_ioctl(cmd=0x%X)\n", dev->name, cmd);
#endif
 
  /* Disable interrupts & save flags */
  x = wv_splhi();
 
  /* Look what is the request */
  switch(cmd)
    {
      /* --------------- WIRELESS EXTENSIONS --------------- */
 
    case SIOCGIWNAME:
      strcpy(wrq->u.name, "Wavelan");
      break;
 
    case SIOCSIWNWID:
      /* Set NWID in WaveLAN */
      if(wrq->u.nwid.on)
        {
          /* Set NWID in psa */
          psa.psa_nwid[0] = (wrq->u.nwid.nwid & 0xFF00) >> 8;
          psa.psa_nwid[1] = wrq->u.nwid.nwid & 0xFF;
          psa.psa_nwid_select = 0x01;
          psa_write(ioaddr, lp->hacr, (char *)psa.psa_nwid - (char *)&psa,
                    (unsigned char *)psa.psa_nwid, 3);
 
          /* Set NWID in mmc */
          m.w.mmw_netw_id_l = wrq->u.nwid.nwid & 0xFF;
          m.w.mmw_netw_id_h = (wrq->u.nwid.nwid & 0xFF00) >> 8;
          mmc_write(ioaddr, (char *)&m.w.mmw_netw_id_l - (char *)&m,
                    (unsigned char *)&m.w.mmw_netw_id_l, 2);
          mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel), 0x00);
        }
      else
        {
          /* Disable nwid in the psa */
          psa.psa_nwid_select = 0x00;
          psa_write(ioaddr, lp->hacr,
                    (char *)&psa.psa_nwid_select - (char *)&psa,
                    (unsigned char *)&psa.psa_nwid_select, 1);
 
          /* Disable nwid in the mmc (no filtering) */
          mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel), MMW_LOOPT_SEL_DIS_NWID);
        }
#ifdef SET_PSA_CRC
      /* update the Wavelan checksum */
      update_psa_checksum(dev, ioaddr, lp->hacr);
#endif
      break;
 
    case SIOCGIWNWID:
      /* Read the NWID */
      psa_read(ioaddr, lp->hacr, (char *)psa.psa_nwid - (char *)&psa,
               (unsigned char *)psa.psa_nwid, 3);
      wrq->u.nwid.nwid = (psa.psa_nwid[0] << 8) + psa.psa_nwid[1];
      wrq->u.nwid.on = psa.psa_nwid_select;
      break;
 
    case SIOCSIWFREQ:
      /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable) */
      if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
           (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
        ret = wv_set_frequency(ioaddr, &(wrq->u.freq));
      else
        ret = -EOPNOTSUPP;
      break;
 
    case SIOCGIWFREQ:
      /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
       * (does it work for everybody ??? - especially old cards...) */
      if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
           (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
        {
          unsigned short        freq;
 
          /* Ask the EEPROM to read the frequency from the first area */
          fee_read(ioaddr, 0x00 /* 1st area - frequency... */,
                   &freq, 1);
          wrq->u.freq.m = ((freq >> 5) * 5 + 24000L) * 10000;
          wrq->u.freq.e = 1;
        }
      else
        {
          int   bands[] = { 915e6, 2.425e8, 2.46e8, 2.484e8, 2.4305e8 };
 
          psa_read(ioaddr, lp->hacr, (char *)&psa.psa_subband - (char *)&psa,
                   (unsigned char *)&psa.psa_subband, 1);
 
          if(psa.psa_subband <= 4)
            {
              wrq->u.freq.m = bands[psa.psa_subband];
              wrq->u.freq.e = (psa.psa_subband != 0);
            }
          else
            ret = -EOPNOTSUPP;
        }
      break;
 
    case SIOCSIWSENS:
      /* Set the level threshold */
      if(!suser())
        return -EPERM;
      psa.psa_thr_pre_set = wrq->u.sensitivity & 0x3F;
      psa_write(ioaddr, lp->hacr, (char *)&psa.psa_thr_pre_set - (char *)&psa,
               (unsigned char *) &psa.psa_thr_pre_set, 1);
#ifdef SET_PSA_CRC
      /* update the Wavelan checksum */
      update_psa_checksum(dev, ioaddr, lp->hacr);
#endif
      mmc_out(ioaddr, mmwoff(0, mmw_thr_pre_set), psa.psa_thr_pre_set);
      break;
 
    case SIOCGIWSENS:
      /* Read the level threshold */
      psa_read(ioaddr, lp->hacr, (char *)&psa.psa_thr_pre_set - (char *)&psa,
               (unsigned char *) &psa.psa_thr_pre_set, 1);
      wrq->u.sensitivity = psa.psa_thr_pre_set & 0x3F;
      break;
 
     case SIOCSIWENCODE:
       /* Set encryption key */
       if(!mmc_encr(ioaddr))
         {
           ret = -EOPNOTSUPP;
           break;
         }
 
       if(wrq->u.encoding.method)
         {      /* enable encryption */
           int          i;
           long long    key = wrq->u.encoding.code;
 
           for(i = 7; i >= 0; i--)
             {
               psa.psa_encryption_key[i] = key & 0xFF;
               key >>= 8;
             }
           psa.psa_encryption_select = 1;
           psa_write(ioaddr, lp->hacr,
                     (char *) &psa.psa_encryption_select - (char *) &psa,
                     (unsigned char *) &psa.psa_encryption_select, 8+1);
 
           mmc_out(ioaddr, mmwoff(0, mmw_encr_enable),
                   MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE);
           mmc_write(ioaddr, mmwoff(0, mmw_encr_key),
                     (unsigned char *) &psa.psa_encryption_key, 8);
         }
       else
         {      /* disable encryption */
           psa.psa_encryption_select = 0;
           psa_write(ioaddr, lp->hacr,
                     (char *) &psa.psa_encryption_select - (char *) &psa,
                     (unsigned char *) &psa.psa_encryption_select, 1);
 
           mmc_out(ioaddr, mmwoff(0, mmw_encr_enable), 0);
         }
#ifdef SET_PSA_CRC
       /* update the Wavelan checksum */
       update_psa_checksum(dev, ioaddr, lp->hacr);
#endif
       break;
 
     case SIOCGIWENCODE:
       /* Read the encryption key */
       if(!mmc_encr(ioaddr))
         {
           ret = -EOPNOTSUPP;
           break;
         }
 
       /* only super-user can see encryption key */
       if(!suser())
         {
           ret = -EPERM;
           break;
         }
       else
         {
           int          i;
           long long    key = 0;
 
           psa_read(ioaddr, lp->hacr,
                    (char *) &psa.psa_encryption_select - (char *) &psa,
                    (unsigned char *) &psa.psa_encryption_select, 1+8);
           for(i = 0; i < 8; i++)
             {
               key <<= 8;
               key += psa.psa_encryption_key[i];
             }
           wrq->u.encoding.code = key;
 
           /* encryption is enabled */
           if(psa.psa_encryption_select)
             wrq->u.encoding.method = mmc_encr(ioaddr);
           else
             wrq->u.encoding.method = 0;
         }
       break;
 
    case SIOCGIWRANGE:
      /* basic checking */
      if(wrq->u.data.pointer != (caddr_t) 0)
        {
          struct iw_range       range;
 
          /* Verify the user buffer */
          ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer,
                            sizeof(struct iw_range));
          if(ret)
            break;
 
          /* Set the length (useless : its constant...) */
          wrq->u.data.length = sizeof(struct iw_range);
 
          /* Set information in the range struct */
          range.throughput = 1.6 * 1024 * 1024; /* don't argue on this ! */
          range.min_nwid = 0x0000;
          range.max_nwid = 0xFFFF;
 
          /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
          if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
               (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
            {
              range.num_channels = 10;
              range.num_frequency = wv_frequency_list(ioaddr, range.freq,
                                                      IW_MAX_FREQUENCIES);
            }
          else
            range.num_channels = range.num_frequency = 0;
 
          range.sensitivity = 0x3F;
          range.max_qual.qual = MMR_SGNL_QUAL;
          range.max_qual.level = MMR_SIGNAL_LVL;
          range.max_qual.noise = MMR_SILENCE_LVL;
 
          /* Copy structure to the user buffer */
          copy_to_user(wrq->u.data.pointer, &range,
                       sizeof(struct iw_range));
        }
      break;
 
    case SIOCGIWPRIV:
      /* Basic checking... */
      if(wrq->u.data.pointer != (caddr_t) 0)
        {
          struct iw_priv_args   priv[] =
          {     /* cmd,         set_args,       get_args,       name */
            { SIOCSIPQTHR, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setqualthr" },
            { SIOCGIPQTHR, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getqualthr" },
 
            { SIOCSIPHISTO, IW_PRIV_TYPE_BYTE | 16,     0, "sethisto" },
            { SIOCGIPHISTO, 0,       IW_PRIV_TYPE_INT | 16, "gethisto" },
          };
 
          /* Verify the user buffer */
          ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer,
                            sizeof(priv));
          if(ret)
            break;
 
          /* Set the number of ioctl available */
          wrq->u.data.length = 4;
 
          /* Copy structure to the user buffer */
          copy_to_user(wrq->u.data.pointer, (u_char *) priv,
                       sizeof(priv));
        }
      break;
 
#ifdef WIRELESS_SPY
    case SIOCSIWSPY:
      /* Set the spy list */
 
      /* Check the number of addresses */
      if(wrq->u.data.length > IW_MAX_SPY)
        {
          ret = -E2BIG;
          break;
        }
      lp->spy_number = wrq->u.data.length;
 
      /* If there is some addresses to copy */
      if(lp->spy_number > 0)
        {
          struct sockaddr       address[IW_MAX_SPY];
          int                   i;
 
          /* Verify where the user has set his addresses */
          ret = verify_area(VERIFY_READ, wrq->u.data.pointer,
                            sizeof(struct sockaddr) * lp->spy_number);
          if(ret)
            break;
          /* Copy addresses to the driver */
          copy_from_user(address, wrq->u.data.pointer,
                         sizeof(struct sockaddr) * lp->spy_number);
 
          /* Copy addresses to the lp structure */
          for(i = 0; i < lp->spy_number; i++)
            {
              memcpy(lp->spy_address[i], address[i].sa_data,
                     WAVELAN_ADDR_SIZE);
            }
 
          /* Reset structure... */
          memset(lp->spy_stat, 0x00, sizeof(iw_qual) * IW_MAX_SPY);
 
#ifdef DEBUG_IOCTL_INFO
          printk(KERN_DEBUG "SetSpy - Set of new addresses is :\n");
          for(i = 0; i < wrq->u.data.length; i++)
            printk(KERN_DEBUG "%02X:%02X:%02X:%02X:%02X:%02X \n",
                   lp->spy_address[i][0],
                   lp->spy_address[i][1],
                   lp->spy_address[i][2],
                   lp->spy_address[i][3],
                   lp->spy_address[i][4],
                   lp->spy_address[i][5]);
#endif  /* DEBUG_IOCTL_INFO */
        }
 
      break;
 
    case SIOCGIWSPY:
      /* Get the spy list and spy stats */
 
      /* Set the number of addresses */
      wrq->u.data.length = lp->spy_number;
 
      /* If the user want to have the addresses back... */
      if((lp->spy_number > 0) && (wrq->u.data.pointer != (caddr_t) 0))
        {
          struct sockaddr       address[IW_MAX_SPY];
          int                   i;
 
          /* Verify the user buffer */
          ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer,
                            (sizeof(iw_qual) + sizeof(struct sockaddr))
                            * IW_MAX_SPY);
          if(ret)
            break;
 
          /* Copy addresses from the lp structure */
          for(i = 0; i < lp->spy_number; i++)
            {
              memcpy(address[i].sa_data, lp->spy_address[i],
                     WAVELAN_ADDR_SIZE);
              address[i].sa_family = AF_UNIX;
            }
 
          /* Copy addresses to the user buffer */
          copy_to_user(wrq->u.data.pointer, address,
                       sizeof(struct sockaddr) * lp->spy_number);
 
          /* Copy stats to the user buffer (just after) */
          copy_to_user(wrq->u.data.pointer +
                       (sizeof(struct sockaddr) * lp->spy_number),
                       lp->spy_stat, sizeof(iw_qual) * lp->spy_number);
 
          /* Reset updated flags */
          for(i = 0; i < lp->spy_number; i++)
            lp->spy_stat[i].updated = 0x0;
        }       /* if(pointer != NULL) */
 
      break;
#endif  /* WIRELESS_SPY */
 
      /* ------------------ PRIVATE IOCTL ------------------ */
 
    case SIOCSIPQTHR:
      if(!suser())
        return -EPERM;
      psa.psa_quality_thr = *(wrq->u.name) & 0x0F;
      psa_write(ioaddr, lp->hacr, (char *)&psa.psa_quality_thr - (char *)&psa,
               (unsigned char *)&psa.psa_quality_thr, 1);
#ifdef SET_PSA_CRC
      /* update the Wavelan checksum */
      update_psa_checksum(dev, ioaddr, lp->hacr);
#endif
      mmc_out(ioaddr, mmwoff(0, mmw_quality_thr), psa.psa_quality_thr);
      break;
 
    case SIOCGIPQTHR:
      psa_read(ioaddr, lp->hacr, (char *)&psa.psa_quality_thr - (char *)&psa,
               (unsigned char *)&psa.psa_quality_thr, 1);
      *(wrq->u.name) = psa.psa_quality_thr & 0x0F;
      break;
 
#ifdef HISTOGRAM
    case SIOCSIPHISTO:
      /* Verif if the user is root */
      if(!suser())
        return -EPERM;
 
      /* Check the number of intervals */
      if(wrq->u.data.length > 16)
        {
          ret = -E2BIG;
          break;
        }
      lp->his_number = wrq->u.data.length;
 
      /* If there is some addresses to copy */
      if(lp->his_number > 0)
        {
          /* Verify where the user has set his addresses */
          ret = verify_area(VERIFY_READ, wrq->u.data.pointer,
                            sizeof(char) * lp->his_number);
          if(ret)
            break;
          /* Copy interval ranges to the driver */
          copy_from_user(lp->his_range, wrq->u.data.pointer,
                         sizeof(char) * lp->his_number);
 
          /* Reset structure... */
          memset(lp->his_sum, 0x00, sizeof(long) * 16);
        }
      break;
 
    case SIOCGIPHISTO:
      /* Set the number of intervals */
      wrq->u.data.length = lp->his_number;
 
      /* Give back the distribution statistics */
      if((lp->his_number > 0) && (wrq->u.data.pointer != (caddr_t) 0))
        {
          /* Verify the user buffer */
          ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer,
                            sizeof(long) * 16);
          if(ret)
            break;
 
          /* Copy data to the user buffer */
          copy_to_user(wrq->u.data.pointer, lp->his_sum,
                       sizeof(long) * lp->his_number);
        }       /* if(pointer != NULL) */
      break;
#endif  /* HISTOGRAM */
 
      /* ------------------- OTHER IOCTL ------------------- */
 
    default:
      ret = -EOPNOTSUPP;
    }
 
  /* Enable interrupts, restore flags */
  wv_splx(x);
 
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_ioctl()\n", dev->name);
#endif
  return ret;
}
 
/*------------------------------------------------------------------*/
/*
 * Get wireless statistics
 * Called by /proc/net/wireless
 */
static iw_stats *
wavelan_get_wireless_stats(device *     dev)
{
  u_long                ioaddr = dev->base_addr;
  net_local *           lp = (net_local *) dev->priv;
  mmr_t                 m;
  iw_stats *            wstats;
  unsigned long         x;
 
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n", dev->name);
#endif
 
  /* Disable interrupts & save flags */
  x = wv_splhi();
 
  if(lp == (net_local *) NULL)
    return (iw_stats *) NULL;
  wstats = &lp->wstats;
 
  /* Get data from the mmc */
  mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
 
  mmc_read(ioaddr, mmroff(0, mmr_dce_status), &m.mmr_dce_status, 1);
  mmc_read(ioaddr, mmroff(0, mmr_wrong_nwid_l), &m.mmr_wrong_nwid_l, 2);
  mmc_read(ioaddr, mmroff(0, mmr_thr_pre_set), &m.mmr_thr_pre_set, 4);
 
  mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
 
  /* Copy data to wireless stuff */
  wstats->status = m.mmr_dce_status & MMR_DCE_STATUS;
  wstats->qual.qual = m.mmr_sgnl_qual & MMR_SGNL_QUAL;
  wstats->qual.level = m.mmr_signal_lvl & MMR_SIGNAL_LVL;
  wstats->qual.noise = m.mmr_silence_lvl & MMR_SILENCE_LVL;
  wstats->qual.updated = (((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 7) |
                          ((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 6) |
                          ((m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) >> 5));
  wstats->discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
  wstats->discard.code = 0L;
  wstats->discard.misc = 0L;
 
  /* Enable interrupts & restore flags */
  wv_splx(x);
 
#ifdef DEBUG_IOCTL_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n", dev->name);
#endif
  return &lp->wstats;
}
#endif  /* WIRELESS_EXT */
 
/************************* PACKET RECEPTION *************************/
/*
 * This part deals with receiving the packets.
 * The interrupt handler gets an interrupt when a packet has been
 * successfully received and calls this part.
 */
 
/*------------------------------------------------------------------*/
/*
 * This routine does the actual copying of data (including the Ethernet
 * header structure) from the WaveLAN card to an sk_buff chain that
 * will be passed up to the network interface layer. NOTE: we
 * currently don't handle trailer protocols (neither does the rest of
 * the network interface), so if that is needed, it will (at least in
 * part) be added here.  The contents of the receive ring buffer are
 * copied to a message chain that is then passed to the kernel.
 *
 * Note: if any errors occur, the packet is "dropped on the floor"
 * (called by wv_packet_rcv())
 */
static inline void
wv_packet_read(device *         dev,
               u_short          buf_off,
               int              sksize)
{
  net_local *           lp = (net_local *) dev->priv;
  u_long                ioaddr = dev->base_addr;
  struct sk_buff *      skb;
 
#ifdef DEBUG_RX_TRACE
  printk(KERN_DEBUG "%s: ->wv_packet_read(0x%X, %d)\n",
         dev->name, fd_p, sksize);
#endif
 
  /* Allocate buffer for the data */
  if((skb = dev_alloc_skb(sksize)) == (struct sk_buff *) NULL)
    {
#ifdef DEBUG_RX_ERROR
      printk(KERN_INFO "%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC).\n",
             dev->name, sksize);
#endif
      lp->stats.rx_dropped++;
      return;
    }
 
  skb->dev = dev;
 
  /* Copy the packet to the buffer */
  obram_read(ioaddr, buf_off, skb_put(skb, sksize), sksize);
  skb->protocol=eth_type_trans(skb, dev);
 
#ifdef DEBUG_RX_INFO
  wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read");
#endif  /* DEBUG_RX_INFO */
 
  /* Statistics gathering & stuff associated.
   * It seem a bit messy with all the define, but it's really simple... */
#if defined(WIRELESS_SPY) || defined(HISTOGRAM)
  if(
#ifdef WIRELESS_SPY
     (lp->spy_number > 0) ||
#endif  /* WIRELESS_SPY */
#ifdef HISTOGRAM
     (lp->his_number > 0) ||
#endif  /* HISTOGRAM */
     0)
    {
      u_char    stats[3];       /* signal level, noise level, signal quality */
 
      /* read signal level, silence level and signal quality bytes */
      /* Note: in the PCMCIA hardware, these are part of the frame. It seems
       * that for the ISA hardware, it's nowhere to be found in the frame,
       * so I'm obliged to do this (it has a side effect on /proc/net/wireless).
       * Any ideas? */
      mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1);
      mmc_read(ioaddr, mmroff(0, mmr_signal_lvl), stats, 3);
      mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
 
#ifdef DEBUG_RX_INFO
      printk(KERN_DEBUG "%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
             dev->name, stats[0] & 0x3F, stats[1] & 0x3F, stats[2] & 0x0F);
#endif
 
      /* Spying stuff */
#ifdef WIRELESS_SPY
      wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE, stats);
#endif  /* WIRELESS_SPY */
#ifdef HISTOGRAM
      wl_his_gather(dev, stats);
#endif  /* HISTOGRAM */
    }
#endif  /* defined(WIRELESS_SPY) || defined(HISTOGRAM) */
 
  /*
   * Hand the packet to the Network Module
   */
  netif_rx(skb);
 
  lp->stats.rx_packets++;
 
#ifdef DEBUG_RX_TRACE
  printk(KERN_DEBUG "%s: <-wv_packet_read()\n", dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * Transfer as many packets as we can
 * from the device RAM.
 * Called by the interrupt handler.
 */
static inline void
wv_receive(device *     dev)
{
  u_long        ioaddr = dev->base_addr;
  net_local *   lp = (net_local *)dev->priv;
  int           nreaped = 0;
 
#ifdef DEBUG_RX_TRACE
  printk(KERN_DEBUG "%s: ->wv_receive()\n", dev->name);
#endif
 
  /* Loop on each received packet */
  for(;;)
    {
      fd_t              fd;
      rbd_t             rbd;
      ushort            pkt_len;
 
      obram_read(ioaddr, lp->rx_head, (unsigned char *) &fd, sizeof(fd));
 
      /* If the current frame is not complete, we have reach the end... */
      if((fd.fd_status & FD_STATUS_C) != FD_STATUS_C)
        break;          /* This is how we exit the loop */
 
      nreaped++;
 
      /* Check if frame correctly received */
      if((fd.fd_status & (FD_STATUS_B | FD_STATUS_OK)) !=
         (FD_STATUS_B | FD_STATUS_OK))
        {
          /*
           * Not sure about this one -- it does not seem
           * to be an error so we will keep quiet about it.
           */
#ifndef IGNORE_NORMAL_XMIT_ERRS
#ifdef DEBUG_RX_ERROR
          if((fd.fd_status & FD_STATUS_B) != FD_STATUS_B)
            printk(KERN_INFO "%s: wv_receive(): frame not consumed by RU.\n",
                   dev->name);
#endif
#endif  /* IGNORE_NORMAL_XMIT_ERRS */
 
#ifdef DEBUG_RX_ERROR
          if((fd.fd_status & FD_STATUS_OK) != FD_STATUS_OK)
            printk(KERN_INFO "%s: wv_receive(): frame not received successfully.\n",
                   dev->name);
#endif
        }
 
      /* Were there problems in processing the frame?  Let's check. */
      if((fd.fd_status & (FD_STATUS_S6 | FD_STATUS_S7 | FD_STATUS_S8 |
                          FD_STATUS_S9 | FD_STATUS_S10 | FD_STATUS_S11))
         != 0)
        {
          lp->stats.rx_errors++;
 
#ifdef DEBUG_RX_ERROR
          if((fd.fd_status & FD_STATUS_S6) != 0)
            printk(KERN_INFO "%s: wv_receive(): no EOF flag.\n", dev->name);
#endif
 
          if((fd.fd_status & FD_STATUS_S7) != 0)
            {
              lp->stats.rx_length_errors++;
#ifdef DEBUG_RX_ERROR
              printk(KERN_INFO "%s: wv_receive(): frame too short.\n",
                     dev->name);
#endif
            }
 
          if((fd.fd_status & FD_STATUS_S8) != 0)
            {
              lp->stats.rx_over_errors++;
#ifdef DEBUG_RX_ERROR
              printk(KERN_INFO "%s: wv_receive(): rx DMA overrun.\n",
                     dev->name);
#endif
            }
 
          if((fd.fd_status & FD_STATUS_S9) != 0)
            {
              lp->stats.rx_fifo_errors++;
#ifdef DEBUG_RX_ERROR
              printk(KERN_INFO "%s: wv_receive(): ran out of resources.\n",
                     dev->name);
#endif
            }
 
          if((fd.fd_status & FD_STATUS_S10) != 0)
            {
              lp->stats.rx_frame_errors++;
#ifdef DEBUG_RX_ERROR
              printk(KERN_INFO "%s: wv_receive(): alignment error.\n",
                     dev->name);
#endif
            }
 
          if((fd.fd_status & FD_STATUS_S11) != 0)
            {
              lp->stats.rx_crc_errors++;
#ifdef DEBUG_RX_ERROR
              printk(KERN_INFO "%s: wv_receive(): CRC error.\n", dev->name);
#endif
            }
        }
 
      /* Does the frame contain a pointer to the data?  Let's check. */
      if(fd.fd_rbd_offset == I82586NULL)
#ifdef DEBUG_RX_ERROR
        printk(KERN_INFO "%s: wv_receive(): frame has no data.\n", dev->name);
#endif
      else
        {
          obram_read(ioaddr, fd.fd_rbd_offset,
                     (unsigned char *) &rbd, sizeof(rbd));
 
#ifdef DEBUG_RX_ERROR
          if((rbd.rbd_status & RBD_STATUS_EOF) != RBD_STATUS_EOF)
            printk(KERN_INFO "%s: wv_receive(): missing EOF flag.\n",
                   dev->name);
 
          if((rbd.rbd_status & RBD_STATUS_F) != RBD_STATUS_F)
            printk(KERN_INFO "%s: wv_receive(): missing F flag.\n",
                   dev->name);
#endif
 
          pkt_len = rbd.rbd_status & RBD_STATUS_ACNT;
 
          /* Read the packet and transmit to Linux */
          wv_packet_read(dev, rbd.rbd_bufl, pkt_len);
        }       /* if frame has data */
 
      fd.fd_status = 0;
      obram_write(ioaddr, fdoff(lp->rx_head, fd_status),
                  (unsigned char *) &fd.fd_status, sizeof(fd.fd_status));
 
      fd.fd_command = FD_COMMAND_EL;
      obram_write(ioaddr, fdoff(lp->rx_head, fd_command),
                  (unsigned char *) &fd.fd_command, sizeof(fd.fd_command));
 
      fd.fd_command = 0;
      obram_write(ioaddr, fdoff(lp->rx_last, fd_command),
                  (unsigned char *) &fd.fd_command, sizeof(fd.fd_command));
 
      lp->rx_last = lp->rx_head;
      lp->rx_head = fd.fd_link_offset;
    }   /* for(;;) -> loop on all frames */
 
#ifdef DEBUG_RX_INFO
  if(nreaped > 1)
    printk(KERN_DEBUG "%s: wv_receive(): reaped %d\n", dev->name, nreaped);
#endif
#ifdef DEBUG_RX_TRACE
  printk(KERN_DEBUG "%s: <-wv_receive()\n", dev->name);
#endif
}
 
/*********************** PACKET TRANSMISSION ***********************/
/*
 * This part deals with sending packet through the WaveLAN
 *
 */
 
/*------------------------------------------------------------------*/
/*
 * This routine fills in the appropriate registers and memory
 * locations on the WaveLAN card and starts the card off on
 * the transmit.
 *
 * The principle :
 * Each block contain a transmit command, a nop command,
 * a transmit block descriptor and a buffer.
 * The CU read the transmit block which point to the tbd,
 * read the tbd and the content of the buffer.
 * When it has finished with it, it goes to the next command
 * which in our case is the nop. The nop point on itself,
 * so the CU stop here.
 * When we add the next block, we modify the previous nop
 * to make it point on the new tx command.
 * Simple, isn't it ?
 *
 * (called in wavelan_packet_xmit())
 */
static inline void
wv_packet_write(device *        dev,
                void *  buf,
                short   length)
{
  net_local *           lp = (net_local *) dev->priv;
  u_long                ioaddr = dev->base_addr;
  unsigned short        txblock;
  unsigned short        txpred;
  unsigned short        tx_addr;
  unsigned short        nop_addr;
  unsigned short        tbd_addr;
  unsigned short        buf_addr;
  ac_tx_t               tx;
  ac_nop_t              nop;
  tbd_t                 tbd;
  int                   clen = length;
  unsigned long         x;
 
#ifdef DEBUG_TX_TRACE
  printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name, length);
#endif
 
  /* Check if we need some padding */
  if(clen < ETH_ZLEN)
    clen = ETH_ZLEN;
 
  x = wv_splhi();
 
  /* Calculate addresses of next block and previous block */
  txblock = lp->tx_first_free;
  txpred = txblock - TXBLOCKZ;
  if(txpred < OFFSET_CU)
    txpred += NTXBLOCKS * TXBLOCKZ;
  lp->tx_first_free += TXBLOCKZ;
  if(lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
    lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
 
/*
if (lp->tx_n_in_use > 0)
        printk("%c", "0123456789abcdefghijk"[lp->tx_n_in_use]);
*/
 
  lp->tx_n_in_use++;
 
  /* Calculate addresses of the differents part of the block */
  tx_addr = txblock;
  nop_addr = tx_addr + sizeof(tx);
  tbd_addr = nop_addr + sizeof(nop);
  buf_addr = tbd_addr + sizeof(tbd);
 
  /*
   * Transmit command.
   */
  tx.tx_h.ac_status = 0;
  obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status),
              (unsigned char *) &tx.tx_h.ac_status,
              sizeof(tx.tx_h.ac_status));
 
  /*
   * NOP command.
   */
  nop.nop_h.ac_status = 0;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
              (unsigned char *) &nop.nop_h.ac_status,
              sizeof(nop.nop_h.ac_status));
  nop.nop_h.ac_link = nop_addr;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
              (unsigned char *) &nop.nop_h.ac_link,
              sizeof(nop.nop_h.ac_link));
 
  /*
   * Transmit buffer descriptor
   */
  tbd.tbd_status = TBD_STATUS_EOF | (TBD_STATUS_ACNT & clen);
  tbd.tbd_next_bd_offset = I82586NULL;
  tbd.tbd_bufl = buf_addr;
  tbd.tbd_bufh = 0;
  obram_write(ioaddr, tbd_addr, (unsigned char *)&tbd, sizeof(tbd));
 
  /*
   * Data
   */
  obram_write(ioaddr, buf_addr, buf, clen);
 
  /*
   * Overwrite the predecessor NOP link
   * so that it points to this txblock.
   */
  nop_addr = txpred + sizeof(tx);
  nop.nop_h.ac_status = 0;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
              (unsigned char *)&nop.nop_h.ac_status,
              sizeof(nop.nop_h.ac_status));
  nop.nop_h.ac_link = txblock;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
              (unsigned char *) &nop.nop_h.ac_link,
              sizeof(nop.nop_h.ac_link));
 
  /* If watchdog not already active, activate it... */
  if(lp->watchdog.prev == (timer_list *) NULL)
    {
      /* set timer to expire in WATCHDOG_JIFFIES */
      lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES;
      add_timer(&lp->watchdog);
    }
 
  if(lp->tx_first_in_use == I82586NULL)
    lp->tx_first_in_use = txblock;
 
  if(lp->tx_n_in_use < NTXBLOCKS - 1)
    dev->tbusy = 0;
 
  wv_splx(x);
 
#ifdef DEBUG_TX_INFO
  wv_packet_info((u_char *) buf, length, dev->name, "wv_packet_write");
#endif  /* DEBUG_TX_INFO */
 
#ifdef DEBUG_TX_TRACE
  printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * This routine is called when we want to send a packet (NET3 callback)
 * In this routine, we check if the hardware is ready to accept
 * the packet. We also prevent reentrance. Then, we call the function
 * to send the packet...
 */
static int
wavelan_packet_xmit(struct sk_buff *    skb,
                    device *            dev)
{
  net_local *   lp = (net_local *)dev->priv;
 
#ifdef DEBUG_TX_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
         (unsigned) skb);
#endif
 
  /* This flag indicate that the hardware can't perform a transmission.
   * Theoretically, NET3 checks it before sending a packet to the driver,
   * but in fact it never does that and pool continuously.
   * As the watchdog will abort overly long transmissions, we are quite safe.
   */
  if(dev->tbusy)
    return 1;
 
  /*
   * If some higher layer thinks we've missed
   * a tx-done interrupt we are passed NULL.
   * Caution: dev_tint() handles the cli()/sti() itself.
   */
  if(skb == (struct sk_buff *)0)
    {
#ifdef DEBUG_TX_ERROR
      printk(KERN_INFO "%s: wavelan_packet_xmit(): skb == NULL\n", dev->name);
#endif
      dev_tint(dev);
      return 0;
    }
 
  /*
   * Block a timer-based transmit from overlapping.
   * In other words, prevent reentering this routine.
   */
  if(set_bit(0, (void *)&dev->tbusy) != 0)
#ifdef DEBUG_TX_ERROR
    printk(KERN_INFO "%s: Transmitter access conflict.\n", dev->name);
#endif
  else
    {
      /* If somebody has asked to reconfigure the controller,
       * we can do it now.
       */
      if(lp->reconfig_82586)
        {
          wv_82586_config(dev);
          if(dev->tbusy)
            return 1;
        }
 
#ifdef DEBUG_TX_ERROR
      if(skb->next)
        printk(KERN_INFO "skb has next\n");
#endif
 
      wv_packet_write(dev, skb->data, skb->len);
    }
 
  dev_kfree_skb(skb, FREE_WRITE);
 
#ifdef DEBUG_TX_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
#endif
  return 0;
}
 
/*********************** HARDWARE CONFIGURATION ***********************/
/*
 * This part does the real job of starting and configuring the hardware.
 */
 
/*--------------------------------------------------------------------*/
/*
 * Routine to initialize the Modem Management Controller.
 * (called by wv_hw_reset())
 */
static inline int
wv_mmc_init(device *    dev)
{
  u_long        ioaddr = dev->base_addr;
  net_local *   lp = (net_local *)dev->priv;
  psa_t         psa;
  mmw_t         m;
  int           configured;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_mmc_init()\n", dev->name);
#endif
 
  /* Read the parameter storage area */
  psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa));
 
#ifdef USE_PSA_CONFIG
  configured = psa.psa_conf_status & 1;
#else
  configured = 0;
#endif
 
  /* Is the PSA is not configured */
  if(!configured)
    {
      /* User will be able to configure NWID after (with iwconfig) */
      psa.psa_nwid[0] = 0;
      psa.psa_nwid[1] = 0;
 
      /* no NWID checking since NWID is not set */
      psa.psa_nwid_select = 0;
 
      /* Disable encryption */
      psa.psa_encryption_select = 0;
 
      /* Set to standard values
       * 0x04 for AT,
       * 0x01 for MCA,
       * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
       */
      if (psa.psa_comp_number & 1)
        psa.psa_thr_pre_set = 0x01;
      else
        psa.psa_thr_pre_set = 0x04;
      psa.psa_quality_thr = 0x03;
 
      /* It is configured */
      psa.psa_conf_status |= 1;
 
#ifdef USE_PSA_CONFIG
      /* Write the psa */
      psa_write(ioaddr, lp->hacr, (char *)psa.psa_nwid - (char *)&psa,
                (unsigned char *)psa.psa_nwid, 4);
      psa_write(ioaddr, lp->hacr, (char *)&psa.psa_thr_pre_set - (char *)&psa,
                (unsigned char *)&psa.psa_thr_pre_set, 1);
      psa_write(ioaddr, lp->hacr, (char *)&psa.psa_quality_thr - (char *)&psa,
                (unsigned char *)&psa.psa_quality_thr, 1);
      psa_write(ioaddr, lp->hacr, (char *)&psa.psa_conf_status - (char *)&psa,
                (unsigned char *)&psa.psa_conf_status, 1);
#ifdef SET_PSA_CRC
      /* update the Wavelan checksum */
      update_psa_checksum(dev, ioaddr, lp->hacr);
#endif
#endif
    }
 
  /* Zero the mmc structure */
  memset(&m, 0x00, sizeof(m));
 
  /* Copy PSA info to the mmc */
  m.mmw_netw_id_l = psa.psa_nwid[1];
  m.mmw_netw_id_h = psa.psa_nwid[0];
 
  if(psa.psa_nwid_select & 1)
    m.mmw_loopt_sel = 0x00;
  else
    m.mmw_loopt_sel = MMW_LOOPT_SEL_DIS_NWID;
 
  memcpy(&m.mmw_encr_key, &psa.psa_encryption_key,
         sizeof(m.mmw_encr_key));
 
  if(psa.psa_encryption_select)
    m.mmw_encr_enable = MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE;
  else
    m.mmw_encr_enable = 0;
 
  m.mmw_thr_pre_set = psa.psa_thr_pre_set & 0x3F;
  m.mmw_quality_thr = psa.psa_quality_thr & 0x0F;
 
  /*
   * Set default modem control parameters.
   * See NCR document 407-0024326 Rev. A.
   */
  m.mmw_jabber_enable = 0x01;
  m.mmw_freeze = 0;
  m.mmw_anten_sel = MMW_ANTEN_SEL_ALG_EN;
  m.mmw_ifs = 0x20;
  m.mmw_mod_delay = 0x04;
  m.mmw_jam_time = 0x38;
 
  m.mmw_des_io_invert = 0;
  m.mmw_decay_prm = 0;
  m.mmw_decay_updat_prm = 0;
 
  /* Write all info to MMC */
  mmc_write(ioaddr, 0, (u_char *)&m, sizeof(m));
 
  /* The following code starts the modem of the 2.00 frequency
   * selectable cards at power on. It's not strictly needed for the
   * following boots.
   * The original patch was by Joe Finney for the PCMCIA driver, but
   * I've cleaned it up a bit and added documentation.
   * Thanks to Loeke Brederveld from Lucent for the info.
   */
 
  /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
   * (does it work for everybody? -- especially old cards?) */
  /* Note: WFREQSEL verifies that it is able to read a sensible
   * frequency from EEPROM (address 0x00) and that MMR_FEE_STATUS_ID
   * is 0xA (Xilinx version) or 0xB (Ariadne version).
   * My test is more crude but does work. */
  if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) &
       (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
    {
      /* We must download the frequency parameters to the
       * synthesizers (from the EEPROM - area 1)
       * Note : as the EEPROM is auto decremented, we set the end
       * if the area... */
      m.mmw_fee_addr = 0x0F;
      m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
      mmc_write(ioaddr, (char *)&m.mmw_fee_ctrl - (char *)&m,
                (unsigned char *)&m.mmw_fee_ctrl, 2);
 
      /* Wait until the download is finished */
      fee_wait(ioaddr, 100, 100);
 
#ifdef DEBUG_CONFIG_INFO
      /* The frequency was in the last word downloaded. */
      mmc_read(ioaddr, (char *)&m.mmw_fee_data_l - (char *)&m,
               (unsigned char *)&m.mmw_fee_data_l, 2);
 
      /* Print some info for the user. */
      printk(KERN_DEBUG "%s: WaveLAN 2.00 recognised (frequency select) : Current frequency = %ld\n",
             dev->name,
             ((m.mmw_fee_data_h << 4) |
              (m.mmw_fee_data_l >> 4)) * 5 / 2 + 24000L);
#endif
 
      /* We must now download the power adjust value (gain) to
       * the synthesizers (from the EEPROM - area 7 - DAC) */
      m.mmw_fee_addr = 0x61;
      m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
      mmc_write(ioaddr, (char *)&m.mmw_fee_ctrl - (char *)&m,
                (unsigned char *)&m.mmw_fee_ctrl, 2);
 
      /* Wait until the download is finished */
    }   /* if 2.00 card */
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_mmc_init()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Construct the fd and rbd structures.
 * Start the receive unit.
 * (called by wv_hw_reset())
 */
static inline int
wv_ru_start(device *    dev)
{
  net_local *   lp = (net_local *) dev->priv;
  u_long        ioaddr = dev->base_addr;
  u_short       scb_cs;
  fd_t          fd;
  rbd_t         rbd;
  u_short       rx;
  u_short       rx_next;
  int           i;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name);
#endif
 
  obram_read(ioaddr, scboff(OFFSET_SCB, scb_status), (unsigned char *)&scb_cs, sizeof(scb_cs));
  if((scb_cs & SCB_ST_RUS) == SCB_ST_RUS_RDY)
    return 0;
 
  lp->rx_head = OFFSET_RU;
 
  for(i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next)
    {
      rx_next = (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
 
      fd.fd_status = 0;
      fd.fd_command = (i == NRXBLOCKS - 1) ? FD_COMMAND_EL : 0;
      fd.fd_link_offset = rx_next;
      fd.fd_rbd_offset = rx + sizeof(fd);
      obram_write(ioaddr, rx, (unsigned char *)&fd, sizeof(fd));
 
      rbd.rbd_status = 0;
      rbd.rbd_next_rbd_offset = I82586NULL;
      rbd.rbd_bufl = rx + sizeof(fd) + sizeof(rbd);
      rbd.rbd_bufh = 0;
      rbd.rbd_el_size = RBD_EL | (RBD_SIZE & MAXDATAZ);
      obram_write(ioaddr, rx + sizeof(fd),
                  (unsigned char *) &rbd, sizeof(rbd));
 
      lp->rx_last = rx;
    }
 
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset),
              (unsigned char *) &lp->rx_head, sizeof(lp->rx_head));
 
  scb_cs = SCB_CMD_RUC_GO;
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
              (unsigned char *) &scb_cs, sizeof(scb_cs));
 
  set_chan_attn(ioaddr, lp->hacr);
 
  for(i = 1000; i > 0; i--)
    {
      obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
                 (unsigned char *) &scb_cs, sizeof(scb_cs));
      if (scb_cs == 0)
        break;
 
      udelay(10);
    }
 
  if(i <= 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_INFO "%s: wavelan_ru_start(): board not accepting command.\n",
             dev->name);
#endif
      return -1;
    }
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Initialise the transmit blocks.
 * Start the command unit executing the NOP
 * self-loop of the first transmit block.
 *
 * Here, we create the list of send buffers used to transmit packets
 * between the PC and the command unit. For each buffer, we create a
 * buffer descriptor (pointing on the buffer), a transmit command
 * (pointing to the buffer descriptor) and a NOP command.
 * The transmit command is linked to the NOP, and the NOP to itself.
 * When we will have finished executing the transmit command, we will
 * then loop on the NOP. By releasing the NOP link to a new command,
 * we may send another buffer.
 *
 * (called by wv_hw_reset())
 */
static inline int
wv_cu_start(device *    dev)
{
  net_local *   lp = (net_local *) dev->priv;
  u_long        ioaddr = dev->base_addr;
  int           i;
  u_short       txblock;
  u_short       first_nop;
  u_short       scb_cs;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_cu_start()\n", dev->name);
#endif
 
  lp->tx_first_free = OFFSET_CU;
  lp->tx_first_in_use = I82586NULL;
 
  for(i = 0, txblock = OFFSET_CU;
      i < NTXBLOCKS;
      i++, txblock += TXBLOCKZ)
    {
      ac_tx_t           tx;
      ac_nop_t          nop;
      tbd_t             tbd;
      unsigned short    tx_addr;
      unsigned short    nop_addr;
      unsigned short    tbd_addr;
      unsigned short    buf_addr;
 
      tx_addr = txblock;
      nop_addr = tx_addr + sizeof(tx);
      tbd_addr = nop_addr + sizeof(nop);
      buf_addr = tbd_addr + sizeof(tbd);
 
      tx.tx_h.ac_status = 0;
      tx.tx_h.ac_command = acmd_transmit | AC_CFLD_I;
      tx.tx_h.ac_link = nop_addr;
      tx.tx_tbd_offset = tbd_addr;
      obram_write(ioaddr, tx_addr, (unsigned char *) &tx, sizeof(tx));
 
      nop.nop_h.ac_status = 0;
      nop.nop_h.ac_command = acmd_nop;
      nop.nop_h.ac_link = nop_addr;
      obram_write(ioaddr, nop_addr, (unsigned char *) &nop, sizeof(nop));
 
      tbd.tbd_status = TBD_STATUS_EOF;
      tbd.tbd_next_bd_offset = I82586NULL;
      tbd.tbd_bufl = buf_addr;
      tbd.tbd_bufh = 0;
      obram_write(ioaddr, tbd_addr, (unsigned char *) &tbd, sizeof(tbd));
    }
 
  first_nop = OFFSET_CU + (NTXBLOCKS - 1) * TXBLOCKZ + sizeof(ac_tx_t);
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_cbl_offset),
              (unsigned char *) &first_nop, sizeof(first_nop));
 
  scb_cs = SCB_CMD_CUC_GO;
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
              (unsigned char *) &scb_cs, sizeof(scb_cs));
 
  set_chan_attn(ioaddr, lp->hacr);
 
  for(i = 1000; i > 0; i--)
    {
      obram_read(ioaddr, scboff(OFFSET_SCB, scb_command),
                 (unsigned char *) &scb_cs, sizeof(scb_cs));
      if (scb_cs == 0)
        break;
 
      udelay(10);
    }
 
  if(i <= 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_INFO "%s: wavelan_cu_start(): board not accepting command.\n",
             dev->name);
#endif
      return -1;
    }
 
  lp->tx_n_in_use = 0;
  dev->tbusy = 0;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_cu_start()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * This routine does a standard config of the WaveLAN controler (i82586).
 *
 * It initialises the scp, iscp and scb structure
 * The first two are just pointers to the next.
 * The last one is used for basic configuration and for basic
 * communication (interrupt status).
 *
 * (called by wv_hw_reset())
 */
static inline int
wv_82586_start(device * dev)
{
  net_local *   lp = (net_local *) dev->priv;
  u_long        ioaddr = dev->base_addr;
  scp_t         scp;            /* system configuration pointer */
  iscp_t        iscp;           /* intermediate scp */
  scb_t         scb;            /* system control block */
  ach_t         cb;             /* Action command header */
  u_char        zeroes[512];
  int           i;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_82586_start()\n", dev->name);
#endif
 
  /*
   * Clear the onboard RAM.
   */
  memset(&zeroes[0], 0x00, sizeof(zeroes));
  for(i = 0; i < I82586_MEMZ; i += sizeof(zeroes))
    obram_write(ioaddr, i, &zeroes[0], sizeof(zeroes));
 
  /*
   * Construct the command unit structures:
   * scp, iscp, scb, cb.
   */
  memset(&scp, 0x00, sizeof(scp));
  scp.scp_sysbus = SCP_SY_16BBUS;
  scp.scp_iscpl = OFFSET_ISCP;
  obram_write(ioaddr, OFFSET_SCP, (unsigned char *)&scp, sizeof(scp));
 
  memset(&iscp, 0x00, sizeof(iscp));
  iscp.iscp_busy = 1;
  iscp.iscp_offset = OFFSET_SCB;
  obram_write(ioaddr, OFFSET_ISCP, (unsigned char *)&iscp, sizeof(iscp));
 
  /* Our first command is to reset the i82586. */
  memset(&scb, 0x00, sizeof(scb));
  scb.scb_command = SCB_CMD_RESET;
  scb.scb_cbl_offset = OFFSET_CU;
  scb.scb_rfa_offset = OFFSET_RU;
  obram_write(ioaddr, OFFSET_SCB, (unsigned char *)&scb, sizeof(scb));
 
  set_chan_attn(ioaddr, lp->hacr);
 
  /* Wait for command to finish. */
  for(i = 1000; i > 0; i--)
    {
      obram_read(ioaddr, OFFSET_ISCP, (unsigned char *) &iscp, sizeof(iscp));
 
      if(iscp.iscp_busy == (unsigned short) 0)
        break;
 
      udelay(10);
    }
 
  if(i <= 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_INFO "%s: wv_82586_start(): iscp_busy timeout.\n",
             dev->name);
#endif
      return -1;
    }
 
  /* Check command completion */
  for(i = 15; i > 0; i--)
    {
      obram_read(ioaddr, OFFSET_SCB, (unsigned char *) &scb, sizeof(scb));
 
      if (scb.scb_status == (SCB_ST_CX | SCB_ST_CNA))
        break;
 
      udelay(10);
    }
 
  if (i <= 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_INFO "%s: wv_82586_start(): status: expected 0x%02x, got 0x%02x.\n",
             dev->name, SCB_ST_CX | SCB_ST_CNA, scb.scb_status);
#endif
      return -1;
    }
 
  wv_ack(dev);
 
  /* Set the action command header. */
  memset(&cb, 0x00, sizeof(cb));
  cb.ac_command = AC_CFLD_EL | (AC_CFLD_CMD & acmd_diagnose);
  cb.ac_link = OFFSET_CU;
  obram_write(ioaddr, OFFSET_CU, (unsigned char *)&cb, sizeof(cb));
 
  if(wv_synchronous_cmd(dev, "diag()") == -1)
    return -1;
 
  obram_read(ioaddr, OFFSET_CU, (unsigned char *)&cb, sizeof(cb));
  if(cb.ac_status & AC_SFLD_FAIL)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_INFO "%s: wv_82586_start(): i82586 Self Test failed.\n",
             dev->name);
#endif
      return -1;
    }
 
#ifdef DEBUG_I82586_SHOW
  wv_scb_show(ioaddr);
#endif
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_82586_start()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * This routine does a standard configuration of the WaveLAN controller
 * (i82586).
 *
 * This routine is a violent hack. We use the first free transmit block
 * to make our configuration. In the buffer area, we create the three
 * configuration commands (linked). We make the previous NOP point to
 * the beginning of the buffer instead of the tx command. After, we go
 * as usual to the NOP command.
 * Note that only the last command (mc_set) will generate an interrupt.
 *
 * (called by wv_hw_reset(), wv_82586_reconfig())
 */
static void
wv_82586_config(device *        dev)
{
  net_local *           lp = (net_local *) dev->priv;
  u_long                ioaddr = dev->base_addr;
  unsigned short        txblock;
  unsigned short        txpred;
  unsigned short        tx_addr;
  unsigned short        nop_addr;
  unsigned short        tbd_addr;
  unsigned short        cfg_addr;
  unsigned short        ias_addr;
  unsigned short        mcs_addr;
  ac_tx_t               tx;
  ac_nop_t              nop;
  ac_cfg_t              cfg;            /* Configure action */
  ac_ias_t              ias;            /* IA-setup action */
  ac_mcs_t              mcs;            /* Multicast setup */
  struct dev_mc_list *  dmi;
  unsigned long         x;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_82586_config()\n", dev->name);
#endif
 
  x = wv_splhi();
 
  /* Calculate addresses of next block and previous block */
  txblock = lp->tx_first_free;
  txpred = txblock - TXBLOCKZ;
  if(txpred < OFFSET_CU)
    txpred += NTXBLOCKS * TXBLOCKZ;
  lp->tx_first_free += TXBLOCKZ;
  if(lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
    lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
 
  lp->tx_n_in_use++;
 
  /* Calculate addresses of the different parts of the block. */
  tx_addr = txblock;
  nop_addr = tx_addr + sizeof(tx);
  tbd_addr = nop_addr + sizeof(nop);
  cfg_addr = tbd_addr + sizeof(tbd_t);  /* beginning of the buffer */
  ias_addr = cfg_addr + sizeof(cfg);
  mcs_addr = ias_addr + sizeof(ias);
 
  /*
   * Transmit command
   */
  tx.tx_h.ac_status = 0xFFFF;   /* Fake completion value */
  obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status),
              (unsigned char *) &tx.tx_h.ac_status,
              sizeof(tx.tx_h.ac_status));
 
  /*
   * NOP command
   */
  nop.nop_h.ac_status = 0;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
              (unsigned char *) &nop.nop_h.ac_status,
              sizeof(nop.nop_h.ac_status));
  nop.nop_h.ac_link = nop_addr;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
              (unsigned char *) &nop.nop_h.ac_link,
              sizeof(nop.nop_h.ac_link));
 
  /* Create a configure action */
  memset(&cfg, 0x00, sizeof(cfg));
 
  /*
   * For Linux we invert AC_CFG_ALOC(..) so as to conform
   * to the way that net packets reach us from above.
   * (See also ac_tx_t.)
   *
   * Updated from Wavelan Manual WCIN085B
   */
  cfg.cfg_byte_cnt = AC_CFG_BYTE_CNT(sizeof(ac_cfg_t) - sizeof(ach_t));
  cfg.cfg_fifolim = AC_CFG_FIFOLIM(4);
  cfg.cfg_byte8 = AC_CFG_SAV_BF(1) |
                  AC_CFG_SRDY(0);
  cfg.cfg_byte9 = AC_CFG_ELPBCK(0) |
                  AC_CFG_ILPBCK(0) |
                  AC_CFG_PRELEN(AC_CFG_PLEN_2) |
                  AC_CFG_ALOC(1) |
                  AC_CFG_ADDRLEN(WAVELAN_ADDR_SIZE);
  cfg.cfg_byte10 = AC_CFG_BOFMET(1) |
                   AC_CFG_ACR(6) |
                   AC_CFG_LINPRIO(0);
  cfg.cfg_ifs = 0x20;
  cfg.cfg_slotl = 0x0C;
  cfg.cfg_byte13 = AC_CFG_RETRYNUM(15) |
                   AC_CFG_SLTTMHI(0);
  cfg.cfg_byte14 = AC_CFG_FLGPAD(0) |
                   AC_CFG_BTSTF(0) |
                   AC_CFG_CRC16(0) |
                   AC_CFG_NCRC(0) |
                   AC_CFG_TNCRS(1) |
                   AC_CFG_MANCH(0) |
                   AC_CFG_BCDIS(0) |
                   AC_CFG_PRM(lp->promiscuous);
  cfg.cfg_byte15 = AC_CFG_ICDS(0) |
                   AC_CFG_CDTF(0) |
                   AC_CFG_ICSS(0) |
                   AC_CFG_CSTF(0);
/*
  cfg.cfg_min_frm_len = AC_CFG_MNFRM(64);
*/
  cfg.cfg_min_frm_len = AC_CFG_MNFRM(8);
 
  cfg.cfg_h.ac_command = (AC_CFLD_CMD & acmd_configure);
  cfg.cfg_h.ac_link = ias_addr;
  obram_write(ioaddr, cfg_addr, (unsigned char *)&cfg, sizeof(cfg));
 
  /* Setup the MAC address */
  memset(&ias, 0x00, sizeof(ias));
  ias.ias_h.ac_command = (AC_CFLD_CMD & acmd_ia_setup);
  ias.ias_h.ac_link = mcs_addr;
  memcpy(&ias.ias_addr[0], (unsigned char *)&dev->dev_addr[0], sizeof(ias.ias_addr));
  obram_write(ioaddr, ias_addr, (unsigned char *)&ias, sizeof(ias));
 
  /* Initialize adapter's ethernet multicast addresses */
  memset(&mcs, 0x00, sizeof(mcs));
  mcs.mcs_h.ac_command = AC_CFLD_I | (AC_CFLD_CMD & acmd_mc_setup);
  mcs.mcs_h.ac_link = nop_addr;
  mcs.mcs_cnt = WAVELAN_ADDR_SIZE * lp->mc_count;
  obram_write(ioaddr, mcs_addr, (unsigned char *)&mcs, sizeof(mcs));
 
  /* If any address to set */
  if(lp->mc_count)
    {
      for(dmi=dev->mc_list; dmi; dmi=dmi->next)
        outsw(PIOP1(ioaddr), (u_short *) dmi->dmi_addr,
              WAVELAN_ADDR_SIZE >> 1);
 
#ifdef DEBUG_CONFIG_INFO
      printk(KERN_DEBUG "%s: wv_82586_config(): set %d multicast addresses:\n",
             dev->name, lp->mc_count);
      for(dmi=dev->mc_list; dmi; dmi=dmi->next)
        printk(KERN_DEBUG " %02x:%02x:%02x:%02x:%02x:%02x\n",
               dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2],
               dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5] );
#endif
    }
 
  /*
   * Overwrite the predecessor NOP link
   * so that it points to the configure action.
   */
  nop_addr = txpred + sizeof(tx);
  nop.nop_h.ac_status = 0;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status),
              (unsigned char *)&nop.nop_h.ac_status,
              sizeof(nop.nop_h.ac_status));
  nop.nop_h.ac_link = cfg_addr;
  obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link),
              (unsigned char *) &nop.nop_h.ac_link,
              sizeof(nop.nop_h.ac_link));
 
  /* If watchdog not already active, activate it... */
  if(lp->watchdog.prev == (timer_list *) NULL)
    {
      /* set timer to expire in WATCHDOG_JIFFIES */
      lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES;
      add_timer(&lp->watchdog);
    }
 
  lp->reconfig_82586 = 0;
 
  if(lp->tx_first_in_use == I82586NULL)
    lp->tx_first_in_use = txblock;
 
  if(lp->tx_n_in_use < NTXBLOCKS - 1)
    dev->tbusy = 0;
 
  wv_splx(x);
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_82586_config()\n", dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * This routine, called by wavelan_close(), gracefully stops the
 * WaveLAN controller (i82586).
 */
static inline void
wv_82586_stop(device *  dev)
{
  net_local *   lp = (net_local *) dev->priv;
  u_long        ioaddr = dev->base_addr;
  u_short       scb_cmd;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_82586_stop()\n", dev->name);
#endif
 
  /* Suspend both command unit and receive unit. */
  scb_cmd = (SCB_CMD_CUC & SCB_CMD_CUC_SUS) | (SCB_CMD_RUC & SCB_CMD_RUC_SUS);
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
              (unsigned char *)&scb_cmd, sizeof(scb_cmd));
  set_chan_attn(ioaddr, lp->hacr);
 
  /* No more interrupts */
  wv_ints_off(dev);
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_82586_stop()\n", dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * Totally reset the WaveLAN and restart it.
 * Performs the following actions:
 *      1. A power reset (reset DMA)
 *      2. Initialize the radio modem (using wv_mmc_init)
 *      3. Reset & Configure LAN controller (using wv_82586_start)
 *      4. Start the LAN controller's command unit
 *      5. Start the LAN controller's receive unit
 */
static int
wv_hw_reset(device *    dev)
{
  net_local *   lp = (net_local *)dev->priv;
  u_long        ioaddr = dev->base_addr;
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: ->wv_hw_reset(dev=0x%x)\n", dev->name,
         (unsigned int)dev);
#endif
 
  /* If watchdog was activated, kill it! */
  if(lp->watchdog.prev != (timer_list *) NULL)
    del_timer(&lp->watchdog);
 
  /* Increase the number of resets done */
  lp->nresets++;
 
  wv_hacr_reset(ioaddr);
  lp->hacr = HACR_DEFAULT;
 
  if((wv_mmc_init(dev) < 0) ||
     (wv_82586_start(dev) < 0))
    return -1;
 
  /* Enable the card to send interrupts */
  wv_ints_on(dev);
 
  /* Start card functions */
  if((wv_ru_start(dev) < 0) ||
     (wv_cu_start(dev) < 0))
    return -1;
 
  /* Finish configuration */
  wv_82586_config(dev);
 
#ifdef DEBUG_CONFIG_TRACE
  printk(KERN_DEBUG "%s: <-wv_hw_reset()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Check if there is a WaveLAN at the specific base address.
 * As a side effect, this reads the MAC address.
 * (called in wavelan_probe() and init_module())
 */
static int
wv_check_ioaddr(u_long          ioaddr,
                u_char *        mac)
{
  int           i;              /* Loop counter */
 
  /* Check if the base address if available */
  if(check_region(ioaddr, sizeof(ha_t)))
    return  EADDRINUSE;         /* ioaddr already used... */
 
  /* Reset host interface */
  wv_hacr_reset(ioaddr);
 
  /* Read the MAC address from the parameter storage area */
  psa_read(ioaddr, HACR_DEFAULT, psaoff(0, psa_univ_mac_addr),
           mac, 6);
 
  /*
   * Check the first three octets of the address for the manufacturer's code.
   * Note: If this can't find your WaveLAN card, you've got a
   * non-NCR/AT&T/Lucent ISA card.  See wavelan.p.h for details on
   * how to configure your card.
   */
  for(i = 0; i < (sizeof(MAC_ADDRESSES) / sizeof(char) / 3); i++)
    if((mac[0] == MAC_ADDRESSES[i][0]) &&
       (mac[1] == MAC_ADDRESSES[i][1]) &&
       (mac[2] == MAC_ADDRESSES[i][2]))
      return 0;
 
#ifdef DEBUG_CONFIG_INFO
  printk(KERN_WARNING "WaveLAN (0x%3X): your MAC address might be: %02X:%02X:%02X.\n",
         ioaddr, mac[0], mac[1], mac[2]);
#endif
    return ENODEV;
}
 
/************************ INTERRUPT HANDLING ************************/
 
/*
 * This function is the interrupt handler for the WaveLAN card. This
 * routine will be called whenever:
 */
static void
wavelan_interrupt(int                   irq,
                  void *                dev_id,
                  struct pt_regs *      regs)
{
  device *      dev;
  u_long        ioaddr;
  net_local *   lp;
  u_short       hasr;
  u_short       status;
  u_short       ack_cmd;
 
  if((dev = (device *) (irq2dev_map[irq])) == (device *) NULL)
    {
#ifdef DEBUG_INTERRUPT_ERROR
      printk(KERN_WARNING "wavelan_interrupt(): irq %d for unknown device.\n",
             irq);
#endif
      return;
    }
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_interrupt()\n", dev->name);
#endif
 
  lp = (net_local *) dev->priv;
  ioaddr = dev->base_addr;
 
  /* Prevent reentrance. What should we do here? */
#ifdef DEBUG_INTERRUPT_ERROR
  if(dev->interrupt)
    printk(KERN_INFO "%s: wavelan_interrupt(): Re-entering the interrupt handler.\n",
           dev->name);
#endif
  dev->interrupt = 1;
 
  if((hasr = hasr_read(ioaddr)) & HASR_MMC_INTR)
    {
      u_char    dce_status;
 
      /*
       * Interrupt from the modem management controller.
       * This will clear it -- ignored for now.
       */
      mmc_read(ioaddr, mmroff(0, mmr_dce_status), &dce_status, sizeof(dce_status));
#ifdef DEBUG_INTERRUPT_ERROR
      printk(KERN_INFO "%s: wavelan_interrupt(): unexpected mmc interrupt: status 0x%04x.\n",
             dev->name, dce_status);
#endif
    }
 
  if((hasr & HASR_82586_INTR) == 0)
    {
      dev->interrupt = 0;
#ifdef DEBUG_INTERRUPT_ERROR
      printk(KERN_INFO "%s: wavelan_interrupt(): interrupt not coming from i82586\n",
             dev->name);
#endif
      return;
    }
 
  /* Read interrupt data. */
  obram_read(ioaddr, scboff(OFFSET_SCB, scb_status),
             (unsigned char *) &status, sizeof(status));
 
  /*
   * Acknowledge the interrupt(s).
   */
  ack_cmd = status & SCB_ST_INT;
  obram_write(ioaddr, scboff(OFFSET_SCB, scb_command),
              (unsigned char *) &ack_cmd, sizeof(ack_cmd));
  set_chan_attn(ioaddr, lp->hacr);
 
#ifdef DEBUG_INTERRUPT_INFO
  printk(KERN_DEBUG "%s: wavelan_interrupt(): status 0x%04x.\n",
         dev->name, status);
#endif
 
  /* Command completed. */
  if((status & SCB_ST_CX) == SCB_ST_CX)
    {
#ifdef DEBUG_INTERRUPT_INFO
      printk(KERN_DEBUG "%s: wavelan_interrupt(): command completed.\n",
             dev->name);
#endif
      wv_complete(dev, ioaddr, lp);
 
      /* If watchdog was activated, kill it ! */
      if(lp->watchdog.prev != (timer_list *) NULL)
        del_timer(&lp->watchdog);
      if(lp->tx_n_in_use > 0)
        {
          /* set timer to expire in WATCHDOG_JIFFIES */
          lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES;
          add_timer(&lp->watchdog);
        }
    }
 
  /* Frame received. */
  if((status & SCB_ST_FR) == SCB_ST_FR)
    {
#ifdef DEBUG_INTERRUPT_INFO
      printk(KERN_DEBUG "%s: wavelan_interrupt(): received packet.\n",
             dev->name);
#endif
      wv_receive(dev);
    }
 
  /* Check the state of the command unit. */
  if(((status & SCB_ST_CNA) == SCB_ST_CNA) ||
     (((status & SCB_ST_CUS) != SCB_ST_CUS_ACTV) && dev->start))
    {
#ifdef DEBUG_INTERRUPT_ERROR
      printk(KERN_INFO "%s: wavelan_interrupt(): CU inactive -- restarting\n",
             dev->name);
#endif
      wv_hw_reset(dev);
    }
 
  /* Check the state of the command unit. */
  if(((status & SCB_ST_RNR) == SCB_ST_RNR) ||
     (((status & SCB_ST_RUS) != SCB_ST_RUS_RDY) && dev->start))
    {
#ifdef DEBUG_INTERRUPT_ERROR
      printk(KERN_INFO "%s: wavelan_interrupt(): RU not ready -- restarting\n",
             dev->name);
#endif
      wv_hw_reset(dev);
    }
 
  dev->interrupt = 0;
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_interrupt()\n", dev->name);
#endif
}
 
/*------------------------------------------------------------------*/
/*
 * Watchdog: when we start a transmission, we set a timer in the
 * kernel.  If the transmission completes, this timer is disabled. If
 * the timer expires, we try to unlock the hardware.
 *
 * Note: this watchdog doesn't work on the same principle as the
 * watchdog in the previous version of the ISA driver. I made it this
 * way because the overhead of add_timer() and del_timer() is nothing
 * and because it avoids calling the watchdog, saving some CPU time.
 */
static void
wavelan_watchdog(u_long         a)
{
  device *              dev;
  net_local *           lp;
  u_long                ioaddr;
  unsigned long         x;
  unsigned int          nreaped;
 
  dev = (device *) a;
  ioaddr = dev->base_addr;
  lp = (net_local *) dev->priv;
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_watchdog()\n", dev->name);
#endif
 
#ifdef DEBUG_INTERRUPT_ERROR
  printk(KERN_INFO "%s: wavelan_watchdog: watchdog timer expired\n",
         dev->name);
#endif
 
  x = wv_splhi();
 
  dev = (device *) a;
  ioaddr = dev->base_addr;
  lp = (net_local *) dev->priv;
 
  if(lp->tx_n_in_use <= 0)
    {
      wv_splx(x);
      return;
    }
 
  nreaped = wv_complete(dev, ioaddr, lp);
 
#ifdef DEBUG_INTERRUPT_INFO
  printk(KERN_DEBUG "%s: wavelan_watchdog(): %d reaped, %d remain.\n",
         dev->name, nreaped, lp->tx_n_in_use);
#endif
 
#ifdef DEBUG_PSA_SHOW
  {
    psa_t               psa;
    psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
    wv_psa_show(&psa);
  }
#endif
#ifdef DEBUG_MMC_SHOW
  wv_mmc_show(dev);
#endif
#ifdef DEBUG_I82586_SHOW
  wv_cu_show(dev);
#endif
 
  /* If no buffer has been freed */
  if(nreaped == 0)
    {
#ifdef DEBUG_INTERRUPT_ERROR
      printk(KERN_INFO "%s: wavelan_watchdog(): cleanup failed, trying reset\n",
             dev->name);
#endif
      wv_hw_reset(dev);
    }
  else
    /* Reset watchdog for next transmission. */
    if(lp->tx_n_in_use > 0)
      {
        /* set timer to expire in WATCHDOG_JIFFIES */
        lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES;
        add_timer(&lp->watchdog);
      }
 
  wv_splx(x);
 
#ifdef DEBUG_INTERRUPT_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_watchdog()\n", dev->name);
#endif
}
 
/********************* CONFIGURATION CALLBACKS *********************/
/*
 * Here are the functions called by the Linux networking code (NET3)
 * for initialization, configuration and deinstallations of the
 * WaveLAN ISA hardware.
 */
 
/*------------------------------------------------------------------*/
/*
 * Configure and start up the WaveLAN PCMCIA adaptor.
 * Called by NET3 when it "open" the device.
 */
static int
wavelan_open(device *   dev)
{
  u_long        x;
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_open(dev=0x%x)\n", dev->name,
         (unsigned int) dev);
#endif
 
  /* Check irq */
  if(dev->irq == 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_WARNING "%s: wavelan_open(): no IRQ\n", dev->name);
#endif
      return -ENXIO;
    }
 
  if((irq2dev_map[dev->irq] != (device *) NULL) ||
     /* This is always true, but avoid the false IRQ. */
     ((irq2dev_map[dev->irq] = dev) == (device *) NULL) ||
     (request_irq(dev->irq, &wavelan_interrupt, 0, "WaveLAN", NULL) != 0))
    {
      irq2dev_map[dev->irq] = (device *) NULL;
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_WARNING "%s: wavelan_open(): invalid IRQ\n", dev->name);
#endif
      return -EAGAIN;
    }
 
  x = wv_splhi();
  if(wv_hw_reset(dev) != -1)
    {
      dev->interrupt = 0;
      dev->start = 1;
    }
  else
    {
      free_irq(dev->irq, NULL);
      irq2dev_map[dev->irq] = (device *) NULL;
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_INFO "%s: wavelan_open(): impossible to start the card\n",
             dev->name);
#endif
      return -EAGAIN;
    }
  wv_splx(x);
 
  MOD_INC_USE_COUNT;
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_open()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Shut down the WaveLAN ISA card.
 * Called by NET3 when it "closes" the device.
 */
static int
wavelan_close(device *  dev)
{
  net_local *   lp = (net_local *)dev->priv;
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_close(dev=0x%x)\n", dev->name,
         (unsigned int) dev);
#endif
 
  /* Not do the job twice. */
  if(dev->start == 0)
    return 0;
 
  dev->tbusy = 1;
  dev->start = 0;
 
  /* If watchdog was activated, kill it! */
  if(lp->watchdog.prev != (timer_list *) NULL)
    del_timer(&lp->watchdog);
 
  /*
   * Flush the Tx and disable Rx.
   */
  wv_82586_stop(dev);
 
  free_irq(dev->irq, NULL);
  irq2dev_map[dev->irq] = (device *) NULL;
 
  MOD_DEC_USE_COUNT;
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_close()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Probe an I/O address, and if the WaveLAN is there configure the
 * device structure
 * (called by wavelan_probe() & via init_module())
 */
static int
wavelan_config(device * dev)
{
  u_long        ioaddr = dev->base_addr;
  u_char        irq_mask;
  int           irq;
  net_local *   lp;
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_config(dev=0x%x, ioaddr=0x%x)\n", dev->name,
         (unsigned int)dev, ioaddr);
#endif
 
  /* Check irq arg on command line */
  if(dev->irq != 0)
    {
      irq_mask = wv_irq_to_psa(dev->irq);
 
      if(irq_mask == 0)
        {
#ifdef DEBUG_CONFIG_ERROR
          printk(KERN_WARNING "%s: wavelan_config(): invalid irq %d -- ignored.\n",
                 dev->name, dev->irq);
#endif
          dev->irq = 0;
        }
      else
        {
#ifdef DEBUG_CONFIG_INFO
          printk(KERN_DEBUG "%s: wavelan_config(): changing irq to %d\n",
                 dev->name, dev->irq);
#endif
          psa_write(ioaddr, HACR_DEFAULT,
                    psaoff(0, psa_int_req_no), &irq_mask, 1);
#ifdef SET_PSA_CRC
          /* update the Wavelan checksum */
          update_psa_checksum(dev, ioaddr, HACR_DEFAULT);
#endif
          wv_hacr_reset(ioaddr);
        }
    }
 
  psa_read(ioaddr, HACR_DEFAULT, psaoff(0, psa_int_req_no), &irq_mask, 1);
  if((irq = wv_psa_to_irq(irq_mask)) == -1)
    {
#ifdef DEBUG_CONFIG_ERROR
      printk(KERN_INFO "%s: wavelan_config(): could not wavelan_map_irq(%d).\n",
             dev->name, irq_mask);
#endif
      return EAGAIN;
    }
 
  dev->irq = irq;
 
  request_region(ioaddr, sizeof(ha_t), "wavelan");
 
  dev->mem_start = 0x0000;
  dev->mem_end = 0x0000;
  dev->if_port = 0;
 
  /* Initialize device structures */
  dev->priv = kmalloc(sizeof(net_local), GFP_KERNEL);
  if(dev->priv == NULL)
    return -ENOMEM;
  memset(dev->priv, 0x00, sizeof(net_local));
  lp = (net_local *)dev->priv;
 
  /* Back link to the device structure. */
  lp->dev = dev;
  /* Add the device at the beginning of the linked list. */
  lp->next = wavelan_list;
  wavelan_list = lp;
 
  lp->hacr = HACR_DEFAULT;
 
  lp->watchdog.function = wavelan_watchdog;
  lp->watchdog.data = (unsigned long) dev;
  lp->promiscuous = 0;
  lp->mc_count = 0;
 
  /*
   * Fill in the fields of the device structure
   * with Ethernet-generic values.
   */
  ether_setup(dev);
 
  dev->open = wavelan_open;
  dev->stop = wavelan_close;
  dev->hard_start_xmit = wavelan_packet_xmit;
  dev->get_stats = wavelan_get_stats;
  dev->set_multicast_list = &wavelan_set_multicast_list;
  dev->set_mac_address = &wavelan_set_mac_address;
 
#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
  dev->do_ioctl = wavelan_ioctl;
  dev->get_wireless_stats = wavelan_get_wireless_stats;
#endif
 
  dev->mtu = WAVELAN_MTU;
 
  /* Display nice info */
  wv_init_info(dev);
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: <-wavelan_config()\n", dev->name);
#endif
  return 0;
}
 
/*------------------------------------------------------------------*/
/*
 * Check for a network adaptor of this type.  Return '0' iff one
 * exists.  (There seem to be different interpretations of
 * the initial value of dev->base_addr.
 * We follow the example in drivers/net/ne.c.)
 * (called in "Space.c")
 * As this function is called outside the wavelan module, it should be
 * declared extern, but it seem to cause troubles...
 */
/* extern */ int
wavelan_probe(device *  dev)
{
  short         base_addr;
  mac_addr      mac;            /* MAC address (check WaveLAN existence) */
  int           i;
  int           r;
 
#ifdef DEBUG_CALLBACK_TRACE
  printk(KERN_DEBUG "%s: ->wavelan_probe(dev=0x%x (base_addr=0x%x))\n",
         dev->name, (unsigned int)dev, (unsigned int)dev->base_addr);
#endif
 
#ifdef  STRUCT_CHECK
  if (wv_struct_check() != (char *) NULL)
    {
      printk(KERN_WARNING "%s: wavelan_probe(): structure/compiler botch: \"%s\"\n",
             dev->name, wv_struct_check());
      return ENODEV;
    }
#endif  /* STRUCT_CHECK */
 
  /* Check the value of the command line parameter for base address */
  base_addr = dev->base_addr;
 
  /* Don't probe at all. */
  if(base_addr < 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_WARNING "%s: wavelan_probe(): invalid base address\n",
             dev->name);
#endif
      return ENXIO;
    }
 
  /* Check a single specified location. */
  if(base_addr > 0x100)
    {
      /* Check if the is something at this base address */
      if((r = wv_check_ioaddr(base_addr, mac)) == 0)
        {
          memcpy(dev->dev_addr, mac, 6);        /* Copy MAC address */
          r = wavelan_config(dev);
        }
 
#ifdef DEBUG_CONFIG_INFO
      if(r != 0)
        printk(KERN_DEBUG "%s: wavelan_probe(): no device at specified base address (0x%X) or address already in use\n",
               dev->name, base_addr);
#endif
 
#ifdef DEBUG_CALLBACK_TRACE
      printk(KERN_DEBUG "%s: <-wavelan_probe()\n", dev->name);
#endif
      return r;
    }
 
  /* Scan all possible addresses of the WaveLAN hardware */
  for(i = 0; i < NELS(iobase); i++)
    {
      /* Check whether there is something at this base address */
      if(wv_check_ioaddr(iobase[i], mac) == 0)
        {
          dev->base_addr = iobase[i];           /* Copy base address. */
          memcpy(dev->dev_addr, mac, 6);        /* Copy MAC address. */
          if(wavelan_config(dev) == 0)
            {
#ifdef DEBUG_CALLBACK_TRACE
              printk(KERN_DEBUG "%s: <-wavelan_probe()\n", dev->name);
#endif
              return 0;
            }
        }
    }
 
  /* We may have touch base_addr: another driver may not like it. */
  dev->base_addr = base_addr;
 
#ifdef DEBUG_CONFIG_INFO
  printk(KERN_DEBUG "%s: wavelan_probe(): no device found\n",
         dev->name);
#endif
 
  return ENODEV;
}
 
/****************************** MODULE ******************************/
/*
 * Module entry point: insertion & removal
 */
 
#ifdef  MODULE
/*------------------------------------------------------------------*/
/*
 * Insertion of the module.
 * I'm now quite proud of the multi-device support.
 */
int
init_module(void)
{
  mac_addr      mac;            /* MAC address (check WaveLAN existence) */
  int           ret = -EIO;     /* Return error if no cards found */
  int           i;
 
#ifdef DEBUG_MODULE_TRACE
  printk(KERN_DEBUG "-> init_module()\n");
#endif
 
  /* If probing is asked */
  if(io[0] == 0)
    {
#ifdef DEBUG_CONFIG_ERRORS
      printk(KERN_WARNING "WaveLAN init_module(): doing device probing (bad !)\n");
      printk(KERN_WARNING "Specify base addresses while loading module to correct the problem\n");
#endif
 
      /* Copy the basic set of address to be probed. */
      for(i = 0; i < NELS(iobase); i++)
        io[i] = iobase[i];
    }
 
 
  /* Loop on all possible base addresses */
  i = -1;
  while((io[++i] != 0) && (i < NELS(io)))
    {
      /* Check if there is something at this base address. */
      if(wv_check_ioaddr(io[i], mac) == 0)
        {
          device *      dev;
 
          /* Create device and set basics args */
          dev = kmalloc(sizeof(struct device), GFP_KERNEL);
          memset(dev, 0x00, sizeof(struct device));
          dev->name = name[i];
          dev->base_addr = io[i];
          dev->irq = irq[i];
          dev->init = &wavelan_config;
          memcpy(dev->dev_addr, mac, 6);        /* Copy MAC address */
 
          /* Try to create the device */
          if(register_netdev(dev) != 0)
            {
              /* DeAllocate everything */
              /* Note : if dev->priv is mallocated, there is no way to fail */
              kfree_s(dev, sizeof(struct device));
            }
          else
            {
              /* If at least one device OK, we do not fail */
              ret = 0;
            }
        }       /* if there is something at the address */
    }           /* Loop on all addresses. */
 
#ifdef DEBUG_CONFIG_ERRORS
  if(wavelan_list == (net_local *) NULL)
    printk(KERN_WARNING "WaveLAN init_module(): no device found\n");
#endif
 
#ifdef DEBUG_MODULE_TRACE
  printk(KERN_DEBUG "<- init_module()\n");
#endif
  return ret;
}
 
/*------------------------------------------------------------------*/
/*
 * Removal of the module
 */
void
cleanup_module(void)
{
#ifdef DEBUG_MODULE_TRACE
  printk(KERN_DEBUG "-> cleanup_module()\n");
#endif
 
  /* Loop on all devices and release them. */
  while(wavelan_list != (net_local *) NULL)
    {
      device *  dev = wavelan_list->dev;
 
#ifdef DEBUG_CONFIG_INFO
      printk(KERN_DEBUG "%s: cleanup_module(): removing device at 0x%x\n",
             dev->name, (unsigned int) dev);
#endif
 
      /* Release the ioport-region. */
      release_region(dev->base_addr, sizeof(ha_t));
 
      /* Definitely remove the device. */
      unregister_netdev(dev);
 
      /* Unlink the device. */
      wavelan_list = wavelan_list->next;
 
      /* Free pieces. */
      kfree_s(dev->priv, sizeof(struct net_local));
      kfree_s(dev, sizeof(struct device));
    }
 
#ifdef DEBUG_MODULE_TRACE
  printk(KERN_DEBUG "<- cleanup_module()\n");
#endif
}
#endif  /* MODULE */
 
/*
 * This software may only be used and distributed
 * according to the terms of the GNU Public License.
 *
 * This software was developed as a component of the
 * Linux operating system.
 * It is based on other device drivers and information
 * either written or supplied by:
 *      Ajay Bakre (bakre@paul.rutgers.edu),
 *      Donald Becker (becker@cesdis.gsfc.nasa.gov),
 *      Loeke Brederveld (Loeke.Brederveld@Utrecht.NCR.com),
 *      Anders Klemets (klemets@it.kth.se),
 *      Vladimir V. Kolpakov (w@stier.koenig.ru),
 *      Marc Meertens (Marc.Meertens@Utrecht.NCR.com),
 *      Pauline Middelink (middelin@polyware.iaf.nl),
 *      Robert Morris (rtm@das.harvard.edu),
 *      Jean Tourrilhes (jt@hplb.hpl.hp.com),
 *      Girish Welling (welling@paul.rutgers.edu),
 *
 * Thanks go also to:
 *      James Ashton (jaa101@syseng.anu.edu.au),
 *      Alan Cox (iialan@iiit.swan.ac.uk),
 *      Allan Creighton (allanc@cs.usyd.edu.au),
 *      Matthew Geier (matthew@cs.usyd.edu.au),
 *      Remo di Giovanni (remo@cs.usyd.edu.au),
 *      Eckhard Grah (grah@wrcs1.urz.uni-wuppertal.de),
 *      Vipul Gupta (vgupta@cs.binghamton.edu),
 *      Mark Hagan (mhagan@wtcpost.daytonoh.NCR.COM),
 *      Tim Nicholson (tim@cs.usyd.edu.au),
 *      Ian Parkin (ian@cs.usyd.edu.au),
 *      John Rosenberg (johnr@cs.usyd.edu.au),
 *      George Rossi (george@phm.gov.au),
 *      Arthur Scott (arthur@cs.usyd.edu.au),
 *      Peter Storey,
 * for their assistance and advice.
 *
 * Please send bug reports, updates, comments to:
 *
 * Bruce Janson                                    Email:  bruce@cs.usyd.edu.au
 * Basser Department of Computer Science           Phone:  +61-2-9351-3423
 * University of Sydney, N.S.W., 2006, AUSTRALIA   Fax:    +61-2-9351-3838
 */
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [net/] [wavelan.c] - Blame information for rev 1777

Line No.	Rev	Author	Line
1	1626	jcastillo	`/*`
2			`* WaveLAN ISA driver`
3			`*`
4			`* Jean II - HPLB '96`
5			`*`
6			`* Reorganisation and extension of the driver.`
7			`* Original copyright follows (also see the end of this file).`
8			`* See wavelan.p.h for details.`
9			`*/`
10
11			`/*`
12			`* AT&T GIS (nee NCR) WaveLAN card:`
13			`* An Ethernet-like radio transceiver`
14			`* controlled by an Intel 82586 coprocessor.`
15			`*/`
16
17			`#include "wavelan.p.h" /* Private header */`
18
19			`/*********************** MISC SUBROUTINES ************************/`
20			`/*`
21			`* Subroutines which won't fit in one of the following category`
22			`* (WaveLAN modem or i82586)`
23			`*/`
24
25			`/------------------------------------------------------------------/`
26			`/*`
27			`* Wrapper for disabling interrupts.`
28			`*/`
29			`static inline unsigned long`
30			`wv_splhi(void)`
31			`{`
32			`unsigned long flags;`
33
34			`save_flags(flags);`
35			`cli();`
36
37			`return(flags);`
38			`}`
39
40			`/------------------------------------------------------------------/`