source: trunk/minix/drivers/dpeth/ne.c@ 20

/*
**  File:       ne.c    Jun. 08, 2000
**
**  Driver for the NE*000 ethernet cards and derivates.
**  This file contains only the ne specific code,
**  the rest is in 8390.c   Code specific for ISA bus only
**
**  Created:    March 15, 1994 by Philip Homburg <philip@cs.vu.nl>
**  PchId:      ne2000.c,v 1.4 1996/01/19 23:30:34 philip Exp
**
**  Modified:   Jun. 08, 2000 by Giovanni Falzoni <gfalzoni@inwind.it>
**              Adapted to interface new main network task.
**
**  $Id: ne.c,v 1.3 2005/08/05 19:08:43 beng Exp $
*/

#include "drivers.h"
#include <net/gen/ether.h>
#include <net/gen/eth_io.h>
#include "dp.h"

#if (ENABLE_NE2000 == 1)

#include "8390.h"
#include "ne.h"

/*
**  Name:       void ne_reset(dpeth_t * dep);
**  Function:   Resets the board and checks if reset cycle completes
*/
static int ne_reset(dpeth_t * dep)
{
  int count = 0;

  /* Reset the ethernet card */
  outb_ne(dep, NE_RESET, inb_ne(dep, NE_RESET));
  do {
        if (++count > 10) return FALSE; /* 20 mSecs. timeout */
        milli_delay(2);
  } while ((inb_ne(dep, DP_ISR) & ISR_RST) == 0);
  return TRUE;
}

/*
**  Name:       void ne_close(dpeth_t * dep);
**  Function:   Stops the board by resetting it and masking interrupts.
*/
static void ne_close(dpeth_t * dep)
{

  (void)ne_reset(dep);
  outb_ne(dep, DP_ISR, 0xFF);
  sys_irqdisable(&dep->de_hook);
  return;
}

/* 
**  Name:       void ne_init(dpeth_t * dep);
**  Function:   Initialize the board making it ready to work.
*/
static void ne_init(dpeth_t * dep)
{
  int ix;

  dep->de_data_port = dep->de_base_port + NE_DATA;
  if (dep->de_16bit) {
        dep->de_ramsize = NE2000_SIZE;
        dep->de_offset_page = NE2000_START / DP_PAGESIZE;
  } else {
        dep->de_ramsize = NE1000_SIZE;
        dep->de_offset_page = NE1000_START / DP_PAGESIZE;
  }

  /* Allocates two send buffers from onboard RAM */
  dep->de_sendq_nr = SENDQ_NR;
  for (ix = 0; ix < SENDQ_NR; ix += 1) {
        dep->de_sendq[ix].sq_sendpage = dep->de_offset_page + ix * SENDQ_PAGES;
  }

  /* Remaining onboard RAM allocated for receiving */
  dep->de_startpage = dep->de_offset_page + ix * SENDQ_PAGES;
  dep->de_stoppage = dep->de_offset_page + dep->de_ramsize / DP_PAGESIZE;

  /* Can't override the default IRQ. */
  dep->de_irq &= NOT(DEI_DEFAULT);

  ns_init(dep);                 /* Initialize DP controller */

  printf("%s: NE%d000 (%dkB RAM) at %X:%d - ",
         dep->de_name,
         dep->de_16bit ? 2 : 1,
         dep->de_ramsize / 1024,
         dep->de_base_port, dep->de_irq);
  for (ix = 0; ix < SA_ADDR_LEN; ix += 1)
        printf("%02X%c", dep->de_address.ea_addr[ix], ix < SA_ADDR_LEN - 1 ? ':' : '\n');
  return;
}

/*
**  Name:       int ne_probe(dpeth_t * dep);
**  Function:   Probe for the presence of a NE*000 card by testing
**              whether the board is reachable through the dp8390.
**              Note that the NE1000 is an 8bit card and has a memory
**              region distict from the 16bit NE2000.
*/
PUBLIC int ne_probe(dpeth_t * dep)
{
  int ix, wd, loc1, loc2;
  char EPROM[32];
  static const struct {
        unsigned char offset;
        unsigned char value;
  } InitSeq[] =
  {
        {       /* Selects page 0. */
                DP_CR, (CR_NO_DMA | CR_PS_P0 | CR_STP),
        },
        {       /* Set byte-wide access and 8 bytes burst mode. */
                DP_DCR, (DCR_8BYTES | DCR_BMS), 
        },
        {       /* Clears the count registers. */
                DP_RBCR0, 0x00, }, {    DP_RBCR1, 0x00,
        },
        {       /* Mask completion irq. */
                DP_IMR, 0x00, }, {      DP_ISR, 0xFF,
        },
        {       /* Set receiver to monitor */
                DP_RCR, RCR_MON, 
        },
        {       /* and transmitter to loopback mode. */
                DP_TCR, TCR_INTERNAL, 
        },
        {       /* Transmit 32 bytes */
                DP_RBCR0, 32, }, { DP_RBCR1, 0,
        },
        {       /* DMA starting at 0x0000. */
                DP_RSAR0, 0x00, }, { DP_RSAR1, 0x00,
        },
        {                       /* Start board (reads) */
                DP_CR, (CR_PS_P0 | CR_DM_RR | CR_STA),
        },
  };

  dep->de_dp8390_port = dep->de_base_port + NE_DP8390;

  if ((loc1 = inb_ne(dep, NE_DP8390)) == 0xFF) return FALSE;

  /* Check if the dp8390 is really there */
  outb_ne(dep, DP_CR, CR_STP | CR_NO_DMA | CR_PS_P1);
  loc2 = inb_ne(dep, DP_MAR5);  /* Saves one byte of the address */
  outb_ne(dep, DP_MAR5, 0xFF);  /* Write 0xFF to it (same offset as DP_CNTR0) */
  outb_ne(dep, DP_CR, CR_NO_DMA | CR_PS_P0);    /* Back to page 0 */
  inb_ne(dep, DP_CNTR0);        /* Reading counter resets it */
  if (inb_ne(dep, DP_CNTR0) != 0) {
        outb_ne(dep, NE_DP8390, loc1);  /* Try to restore modified bytes */
        outb_ne(dep, DP_TCR, loc2);
        return FALSE;
  }

  /* Try to reset the board */
  if (ne_reset(dep) == FALSE) return FALSE;

  /* Checks whether the board is 8/16bits and a real NE*000 or clone */
  for (ix = 0; ix < sizeof(InitSeq)/sizeof(InitSeq[0]); ix += 1) {
        outb_ne(dep, InitSeq[ix].offset, InitSeq[ix].value);
  }
  for (ix = 0, wd = 1; ix < 32; ix += 2) {
        EPROM[ix + 0] = inb_ne(dep, NE_DATA);
        EPROM[ix + 1] = inb_ne(dep, NE_DATA);
        /* NE2000s and clones read same value for even and odd addresses */
        if (EPROM[ix + 0] != EPROM[ix + 1]) wd = 0;
  }
  if (wd == 1) {        /* Normalize EPROM contents for NE2000 */
        for (ix = 0; ix < 16; ix += 1) EPROM[ix] = EPROM[ix * 2];
  }
  /* Real NE*000 and good clones have '0x57' at locations 14 and 15 */
  if (EPROM[14] != 0x57 || EPROM[15] != 0x57) return FALSE;

  /* Setup the ethernet address. */
  for (ix = 0; ix < SA_ADDR_LEN; ix += 1) {
        dep->de_address.ea_addr[ix] = EPROM[ix];
  }
  dep->de_16bit = wd;
  dep->de_linmem = 0;           /* Uses Programmed I/O only */
  dep->de_prog_IO = 1;
  dep->de_initf = ne_init;
  dep->de_stopf = ne_close;
  return TRUE;
}

#endif                          /* ENABLE_NE2000 */

/** ne.c **/