/*
 *	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 PSA_CRC
/*------------------------------------------------------------------*/
/*
 * Calculate the PSA CRC (not tested yet)
 * As the WaveLAN drivers don't use the CRC, I won't use it either.
 * 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)
 */
static u_short
psa_crc(u_short *	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 */
#endif	/* 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);
	}
      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);
      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);
	 }
       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);
      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;
  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);
#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;

  /* Missing: encryption stuff... */

  /*
   * Set default modem control parameters.
   * See NCR document 407-0024326 Rev. A.
   */
  m.mmw_jabber_enable = 0x01;
  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_encr_enable = 0;
  m.mmw_des_io_invert = 0;
  m.mmw_freeze = 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));

#if	0
  /*
   * The default board configuration
   */
  cfg.fifolim_bytecnt 	= 0x080c;
  cfg.addrlen_mode  	= 0x2600;
  cfg.linprio_interframe	= 0x7820;	/* IFS=120, ACS=2 */
  cfg.slot_time      	= 0xf00c;	/* slottime=12    */
  cfg.hardware	     	= 0x0008;	/* tx even without CD */
  cfg.min_frame_len   	= 0x0040;
#endif	/* 0 */

  /*
   * 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.)
   */
  cfg.cfg_byte_cnt = AC_CFG_BYTE_CNT(sizeof(ac_cfg_t) - sizeof(ach_t));
  cfg.cfg_fifolim = AC_CFG_FIFOLIM(8);
  cfg.cfg_byte8 = AC_CFG_SAV_BF(0) |
		  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(0) |
		   AC_CFG_ACR(0) |
		   AC_CFG_LINPRIO(0);
  cfg.cfg_ifs = 32;
  cfg.cfg_slotl = 0;
  cfg.cfg_byte13 = AC_CFG_RETRYNUM(15) |
		   AC_CFG_SLTTMHI(2);
  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);
	  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 = 0;
  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));
	      ret = -EIO;
	    }
	}	/* 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
 */
