[linux.git] / drivers / net / apne.c

/*
 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
 *
 * (C) Copyright 1997 Alain Malek
 *                    ([email protected])
 *
 * ----------------------------------------------------------------------------
 *
 * This program is based on
 *
 * ne.c:       A general non-shared-memory NS8390 ethernet driver for linux
 *             Written 1992-94 by Donald Becker.
 *
 * 8390.c:     A general NS8390 ethernet driver core for linux.
 *             Written 1992-94 by Donald Becker.
 *
 * cnetdevice: A Sana-II ethernet driver for AmigaOS
 *             Written by Bruce Abbott ([email protected])
 *
 * ----------------------------------------------------------------------------
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of the Linux
 * distribution for more details.
 *
 * ----------------------------------------------------------------------------
 *
 */


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/jiffies.h>

#include <asm/system.h>
#include <asm/io.h>
#include <asm/setup.h>
#include <asm/amigaints.h>
#include <asm/amigahw.h>
#include <asm/amigayle.h>
#include <asm/amipcmcia.h>

#include "8390.h"

/* ---- No user-serviceable parts below ---- */

#define DRV_NAME "apne"

#define NE_BASE	 (dev->base_addr)
#define NE_CMD	 		0x00
#define NE_DATAPORT		0x10            /* NatSemi-defined port window offset. */
#define NE_RESET		0x1f            /* Issue a read to reset, a write to clear. */
#define NE_IO_EXTENT	        0x20

#define NE_EN0_ISR		0x07
#define NE_EN0_DCFG		0x0e

#define NE_EN0_RSARLO	        0x08
#define NE_EN0_RSARHI	        0x09
#define NE_EN0_RCNTLO	        0x0a
#define NE_EN0_RXCR		0x0c
#define NE_EN0_TXCR		0x0d
#define NE_EN0_RCNTHI	        0x0b
#define NE_EN0_IMR		0x0f

#define NE1SM_START_PG	0x20	/* First page of TX buffer */
#define NE1SM_STOP_PG 	0x40	/* Last page +1 of RX ring */
#define NESM_START_PG	0x40	/* First page of TX buffer */
#define NESM_STOP_PG	0x80	/* Last page +1 of RX ring */


struct net_device * __init apne_probe(int unit);
static int apne_probe1(struct net_device *dev, int ioaddr);

static int apne_open(struct net_device *dev);
static int apne_close(struct net_device *dev);

static void apne_reset_8390(struct net_device *dev);
static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
			  int ring_page);
static void apne_block_input(struct net_device *dev, int count,
								struct sk_buff *skb, int ring_offset);
static void apne_block_output(struct net_device *dev, const int count,
							const unsigned char *buf, const int start_page);
static irqreturn_t apne_interrupt(int irq, void *dev_id);

static int init_pcmcia(void);

/* IO base address used for nic */

#define IOBASE 0x300

/*
   use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
   you can find the values to use by looking at the cnet.device
   config file example (the default values are for the CNET40BC card)
*/

/*
#define MANUAL_CONFIG 0x20
#define MANUAL_OFFSET 0x3f8

#define MANUAL_HWADDR0 0x00
#define MANUAL_HWADDR1 0x12
#define MANUAL_HWADDR2 0x34
#define MANUAL_HWADDR3 0x56
#define MANUAL_HWADDR4 0x78
#define MANUAL_HWADDR5 0x9a
*/

static const char version[] =
    "apne.c:v1.1 7/10/98 Alain Malek ([email protected])\n";

static int apne_owned;	/* signal if card already owned */

struct net_device * __init apne_probe(int unit)
{
	struct net_device *dev;
#ifndef MANUAL_CONFIG
	char tuple[8];
#endif
	int err;

	if (apne_owned)
		return ERR_PTR(-ENODEV);

	if ( !(AMIGAHW_PRESENT(PCMCIA)) )
		return ERR_PTR(-ENODEV);

	printk("Looking for PCMCIA ethernet card : ");

	/* check if a card is inserted */
	if (!(PCMCIA_INSERTED)) {
		printk("NO PCMCIA card inserted\n");
		return ERR_PTR(-ENODEV);
	}

	dev = alloc_ei_netdev();
	if (!dev)
		return ERR_PTR(-ENOMEM);
	if (unit >= 0) {
		sprintf(dev->name, "eth%d", unit);
		netdev_boot_setup_check(dev);
	}

	/* disable pcmcia irq for readtuple */
	pcmcia_disable_irq();

#ifndef MANUAL_CONFIG
	if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
		(tuple[2] != CISTPL_FUNCID_NETWORK)) {
		printk("not an ethernet card\n");
		/* XXX: shouldn't we re-enable irq here? */
		free_netdev(dev);
		return ERR_PTR(-ENODEV);
	}
#endif

	printk("ethernet PCMCIA card inserted\n");

	if (!init_pcmcia()) {
		/* XXX: shouldn't we re-enable irq here? */
		free_netdev(dev);
		return ERR_PTR(-ENODEV);
	}

	if (!request_region(IOBASE, 0x20, DRV_NAME)) {
		free_netdev(dev);
		return ERR_PTR(-EBUSY);
	}

	err = apne_probe1(dev, IOBASE);
	if (err) {
		release_region(IOBASE, 0x20);
		free_netdev(dev);
		return ERR_PTR(err);
	}
	err = register_netdev(dev);
	if (!err)
		return dev;

	pcmcia_disable_irq();
	free_irq(IRQ_AMIGA_PORTS, dev);
	pcmcia_reset();
	release_region(IOBASE, 0x20);
	free_netdev(dev);
	return ERR_PTR(err);
}

static int __init apne_probe1(struct net_device *dev, int ioaddr)
{
    int i;
    unsigned char SA_prom[32];
    int wordlength = 2;
    const char *name = NULL;
    int start_page, stop_page;
#ifndef MANUAL_HWADDR0
    int neX000, ctron;
#endif
    static unsigned version_printed;
    DECLARE_MAC_BUF(mac);

    if (ei_debug  &&  version_printed++ == 0)
	printk(version);

    printk("PCMCIA NE*000 ethercard probe");

    /* Reset card. Who knows what dain-bramaged state it was left in. */
    {	unsigned long reset_start_time = jiffies;

	outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);

	while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
		if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
			printk(" not found (no reset ack).\n");
			return -ENODEV;
		}

	outb(0xff, ioaddr + NE_EN0_ISR);		/* Ack all intr. */
    }

#ifndef MANUAL_HWADDR0

    /* Read the 16 bytes of station address PROM.
       We must first initialize registers, similar to NS8390_init(eifdev, 0).
       We can't reliably read the SAPROM address without this.
       (I learned the hard way!). */
    {
	struct {unsigned long value, offset; } program_seq[] = {
	    {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
	    {0x48,	NE_EN0_DCFG},	/* Set byte-wide (0x48) access. */
	    {0x00,	NE_EN0_RCNTLO},	/* Clear the count regs. */
	    {0x00,	NE_EN0_RCNTHI},
	    {0x00,	NE_EN0_IMR},	/* Mask completion irq. */
	    {0xFF,	NE_EN0_ISR},
	    {E8390_RXOFF, NE_EN0_RXCR},	/* 0x20  Set to monitor */
	    {E8390_TXOFF, NE_EN0_TXCR},	/* 0x02  and loopback mode. */
	    {32,	NE_EN0_RCNTLO},
	    {0x00,	NE_EN0_RCNTHI},
	    {0x00,	NE_EN0_RSARLO},	/* DMA starting at 0x0000. */
	    {0x00,	NE_EN0_RSARHI},
	    {E8390_RREAD+E8390_START, NE_CMD},
	};
	for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
	    outb(program_seq[i].value, ioaddr + program_seq[i].offset);
	}

    }
    for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
	SA_prom[i] = inb(ioaddr + NE_DATAPORT);
	SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
	if (SA_prom[i] != SA_prom[i+1])
	    wordlength = 1;
    }

    /*	At this point, wordlength *only* tells us if the SA_prom is doubled
	up or not because some broken PCI cards don't respect the byte-wide
	request in program_seq above, and hence don't have doubled up values.
	These broken cards would otherwise be detected as an ne1000.  */

    if (wordlength == 2)
	for (i = 0; i < 16; i++)
		SA_prom[i] = SA_prom[i+i];

    if (wordlength == 2) {
	/* We must set the 8390 for word mode. */
	outb(0x49, ioaddr + NE_EN0_DCFG);
	start_page = NESM_START_PG;
	stop_page = NESM_STOP_PG;
    } else {
	start_page = NE1SM_START_PG;
	stop_page = NE1SM_STOP_PG;
    }

    neX000 = (SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57);
    ctron =  (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);

    /* Set up the rest of the parameters. */
    if (neX000) {
	name = (wordlength == 2) ? "NE2000" : "NE1000";
    } else if (ctron) {
	name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
	start_page = 0x01;
	stop_page = (wordlength == 2) ? 0x40 : 0x20;
    } else {
	printk(" not found.\n");
	return -ENXIO;

    }

#else
    wordlength = 2;
    /* We must set the 8390 for word mode. */
    outb(0x49, ioaddr + NE_EN0_DCFG);
    start_page = NESM_START_PG;
    stop_page = NESM_STOP_PG;

    SA_prom[0] = MANUAL_HWADDR0;
    SA_prom[1] = MANUAL_HWADDR1;
    SA_prom[2] = MANUAL_HWADDR2;
    SA_prom[3] = MANUAL_HWADDR3;
    SA_prom[4] = MANUAL_HWADDR4;
    SA_prom[5] = MANUAL_HWADDR5;
    name = "NE2000";
#endif

    dev->base_addr = ioaddr;
    dev->irq = IRQ_AMIGA_PORTS;

    /* Install the Interrupt handler */
    i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
    if (i) return i;

    for(i = 0; i < ETHER_ADDR_LEN; i++)
	dev->dev_addr[i] = SA_prom[i];

    printk(" %s\n", print_mac(mac, dev->dev_addr));

    printk("%s: %s found.\n", dev->name, name);

    ei_status.name = name;
    ei_status.tx_start_page = start_page;
    ei_status.stop_page = stop_page;
    ei_status.word16 = (wordlength == 2);

    ei_status.rx_start_page = start_page + TX_PAGES;

    ei_status.reset_8390 = &apne_reset_8390;
    ei_status.block_input = &apne_block_input;
    ei_status.block_output = &apne_block_output;
    ei_status.get_8390_hdr = &apne_get_8390_hdr;
    dev->open = &apne_open;
    dev->stop = &apne_close;
#ifdef CONFIG_NET_POLL_CONTROLLER
    dev->poll_controller = ei_poll;
#endif
    NS8390_init(dev, 0);

    pcmcia_ack_int(pcmcia_get_intreq());		/* ack PCMCIA int req */
    pcmcia_enable_irq();

    apne_owned = 1;

    return 0;
}

static int
apne_open(struct net_device *dev)
{
    ei_open(dev);
    return 0;
}

static int
apne_close(struct net_device *dev)
{
    if (ei_debug > 1)
	printk("%s: Shutting down ethercard.\n", dev->name);
    ei_close(dev);
    return 0;
}

/* Hard reset the card.  This used to pause for the same period that a
   8390 reset command required, but that shouldn't be necessary. */
static void
apne_reset_8390(struct net_device *dev)
{
    unsigned long reset_start_time = jiffies;

    init_pcmcia();

    if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);

    outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);

    ei_status.txing = 0;
    ei_status.dmaing = 0;

    /* This check _should_not_ be necessary, omit eventually. */
    while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
	if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
	    printk("%s: ne_reset_8390() did not complete.\n", dev->name);
	    break;
	}
    outb(ENISR_RESET, NE_BASE + NE_EN0_ISR);	/* Ack intr. */
}

/* Grab the 8390 specific header. Similar to the block_input routine, but
   we don't need to be concerned with ring wrap as the header will be at
   the start of a page, so we optimize accordingly. */

static void
apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
{

    int nic_base = dev->base_addr;
    int cnt;
    char *ptrc;
    short *ptrs;

    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
    if (ei_status.dmaing) {
	printk("%s: DMAing conflict in ne_get_8390_hdr "
	   "[DMAstat:%d][irqlock:%d][intr:%d].\n",
	   dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
	return;
    }

    ei_status.dmaing |= 0x01;
    outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
    outb(ENISR_RDC, nic_base + NE_EN0_ISR);
    outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
    outb(0, nic_base + NE_EN0_RCNTHI);
    outb(0, nic_base + NE_EN0_RSARLO);		/* On page boundary */
    outb(ring_page, nic_base + NE_EN0_RSARHI);
    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);

    if (ei_status.word16) {
        ptrs = (short*)hdr;
        for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
            *ptrs++ = inw(NE_BASE + NE_DATAPORT);
    } else {
        ptrc = (char*)hdr;
        for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
            *ptrc++ = inb(NE_BASE + NE_DATAPORT);
    }

    outb(ENISR_RDC, nic_base + NE_EN0_ISR);	/* Ack intr. */
    ei_status.dmaing &= ~0x01;

    le16_to_cpus(&hdr->count);
}

/* Block input and output, similar to the Crynwr packet driver.  If you
   are porting to a new ethercard, look at the packet driver source for hints.
   The NEx000 doesn't share the on-board packet memory -- you have to put
   the packet out through the "remote DMA" dataport using outb. */

static void
apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
{
    int nic_base = dev->base_addr;
    char *buf = skb->data;
    char *ptrc;
    short *ptrs;
    int cnt;

    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
    if (ei_status.dmaing) {
	printk("%s: DMAing conflict in ne_block_input "
	   "[DMAstat:%d][irqlock:%d][intr:%d].\n",
	   dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
	return;
    }
    ei_status.dmaing |= 0x01;
    outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
    outb(ENISR_RDC, nic_base + NE_EN0_ISR);
    outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
    outb(count >> 8, nic_base + NE_EN0_RCNTHI);
    outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
    outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
    if (ei_status.word16) {
      ptrs = (short*)buf;
      for (cnt = 0; cnt < (count>>1); cnt++)
        *ptrs++ = inw(NE_BASE + NE_DATAPORT);
      if (count & 0x01) {
	buf[count-1] = inb(NE_BASE + NE_DATAPORT);
      }
    } else {
      ptrc = (char*)buf;
      for (cnt = 0; cnt < count; cnt++)
        *ptrc++ = inb(NE_BASE + NE_DATAPORT);
    }

    outb(ENISR_RDC, nic_base + NE_EN0_ISR);	/* Ack intr. */
    ei_status.dmaing &= ~0x01;
}

static void
apne_block_output(struct net_device *dev, int count,
		const unsigned char *buf, const int start_page)
{
    int nic_base = NE_BASE;
    unsigned long dma_start;
    char *ptrc;
    short *ptrs;
    int cnt;

    /* Round the count up for word writes.  Do we need to do this?
       What effect will an odd byte count have on the 8390?
       I should check someday. */
    if (ei_status.word16 && (count & 0x01))
      count++;

    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
    if (ei_status.dmaing) {
	printk("%s: DMAing conflict in ne_block_output."
	   "[DMAstat:%d][irqlock:%d][intr:%d]\n",
	   dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
	return;
    }
    ei_status.dmaing |= 0x01;
    /* We should already be in page 0, but to be safe... */
    outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);

    outb(ENISR_RDC, nic_base + NE_EN0_ISR);

   /* Now the normal output. */
    outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
    outb(count >> 8,   nic_base + NE_EN0_RCNTHI);
    outb(0x00, nic_base + NE_EN0_RSARLO);
    outb(start_page, nic_base + NE_EN0_RSARHI);

    outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
    if (ei_status.word16) {
        ptrs = (short*)buf;
        for (cnt = 0; cnt < count>>1; cnt++)
            outw(*ptrs++, NE_BASE+NE_DATAPORT);
    } else {
        ptrc = (char*)buf;
        for (cnt = 0; cnt < count; cnt++)
	    outb(*ptrc++, NE_BASE + NE_DATAPORT);
    }

    dma_start = jiffies;

    while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
	if (time_after(jiffies, dma_start + 2*HZ/100)) {	/* 20ms */
		printk("%s: timeout waiting for Tx RDC.\n", dev->name);
		apne_reset_8390(dev);
		NS8390_init(dev,1);
		break;
	}

    outb(ENISR_RDC, nic_base + NE_EN0_ISR);	/* Ack intr. */
    ei_status.dmaing &= ~0x01;
    return;
}

static irqreturn_t apne_interrupt(int irq, void *dev_id)
{
    unsigned char pcmcia_intreq;

    if (!(gayle.inten & GAYLE_IRQ_IRQ))
        return IRQ_NONE;

    pcmcia_intreq = pcmcia_get_intreq();

    if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
        pcmcia_ack_int(pcmcia_intreq);
        return IRQ_NONE;
    }
    if (ei_debug > 3)
        printk("pcmcia intreq = %x\n", pcmcia_intreq);
    pcmcia_disable_irq();			/* to get rid of the sti() within ei_interrupt */
    ei_interrupt(irq, dev_id);
    pcmcia_ack_int(pcmcia_get_intreq());
    pcmcia_enable_irq();
    return IRQ_HANDLED;
}

#ifdef MODULE
static struct net_device *apne_dev;

int __init init_module(void)
{
	apne_dev = apne_probe(-1);
	if (IS_ERR(apne_dev))
		return PTR_ERR(apne_dev);
	return 0;
}

void __exit cleanup_module(void)
{
	unregister_netdev(apne_dev);

	pcmcia_disable_irq();

	free_irq(IRQ_AMIGA_PORTS, apne_dev);

	pcmcia_reset();

	release_region(IOBASE, 0x20);

	free_netdev(apne_dev);
}

#endif

static int init_pcmcia(void)
{
	u_char config;
#ifndef MANUAL_CONFIG
	u_char tuple[32];
	int offset_len;
#endif
	u_long offset;

	pcmcia_reset();
	pcmcia_program_voltage(PCMCIA_0V);
	pcmcia_access_speed(PCMCIA_SPEED_250NS);
	pcmcia_write_enable();

#ifdef MANUAL_CONFIG
	config = MANUAL_CONFIG;
#else
	/* get and write config byte to enable IO port */

	if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
		return 0;

	config = tuple[2] & 0x3f;
#endif
#ifdef MANUAL_OFFSET
	offset = MANUAL_OFFSET;
#else
	if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
		return 0;

	offset_len = (tuple[2] & 0x3) + 1;
	offset = 0;
	while(offset_len--) {
		offset = (offset << 8) | tuple[4+offset_len];
	}
#endif

	out_8(GAYLE_ATTRIBUTE+offset, config);

	return 1;
}

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
	3	*
	4	* (C) Copyright 1997 Alain Malek
	5	* ([email protected])
	6	*
	7	* ----------------------------------------------------------------------------
	8	*
	9	* This program is based on
	10	*
	11	* ne.c: A general non-shared-memory NS8390 ethernet driver for linux
	12	* Written 1992-94 by Donald Becker.
	13	*
	14	* 8390.c: A general NS8390 ethernet driver core for linux.
	15	* Written 1992-94 by Donald Becker.
	16	*
	17	* cnetdevice: A Sana-II ethernet driver for AmigaOS
	18	* Written by Bruce Abbott ([email protected])
	19	*
	20	* ----------------------------------------------------------------------------
	21	*
	22	* This file is subject to the terms and conditions of the GNU General Public
	23	* License. See the file COPYING in the main directory of the Linux
	24	* distribution for more details.
	25	*
	26	* ----------------------------------------------------------------------------
	27	*
	28	*/
	29
	30
	31	#include <linux/module.h>
	32	#include <linux/kernel.h>
	33	#include <linux/errno.h>
	34	#include <linux/pci.h>
	35	#include <linux/init.h>
	36	#include <linux/delay.h>
	37	#include <linux/netdevice.h>
	38	#include <linux/etherdevice.h>
ff5688ae	39	#include <linux/jiffies.h>
1da177e4 LT	40
	41	#include <asm/system.h>
	42	#include <asm/io.h>
	43	#include <asm/setup.h>
	44	#include <asm/amigaints.h>
	45	#include <asm/amigahw.h>
	46	#include <asm/amigayle.h>
	47	#include <asm/amipcmcia.h>
	48
	49	#include "8390.h"
	50
	51	/* ---- No user-serviceable parts below ---- */
	52
	53	#define DRV_NAME "apne"
	54
	55	#define NE_BASE (dev->base_addr)
	56	#define NE_CMD 0x00
	57	#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
	58	#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
	59	#define NE_IO_EXTENT 0x20
	60
	61	#define NE_EN0_ISR 0x07
	62	#define NE_EN0_DCFG 0x0e
	63
	64	#define NE_EN0_RSARLO 0x08
	65	#define NE_EN0_RSARHI 0x09
	66	#define NE_EN0_RCNTLO 0x0a
	67	#define NE_EN0_RXCR 0x0c
	68	#define NE_EN0_TXCR 0x0d
	69	#define NE_EN0_RCNTHI 0x0b
	70	#define NE_EN0_IMR 0x0f
	71
	72	#define NE1SM_START_PG 0x20 /* First page of TX buffer */
	73	#define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
	74	#define NESM_START_PG 0x40 /* First page of TX buffer */
	75	#define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
	76
	77
	78	struct net_device * __init apne_probe(int unit);
	79	static int apne_probe1(struct net_device *dev, int ioaddr);
	80
	81	static int apne_open(struct net_device *dev);
	82	static int apne_close(struct net_device *dev);
	83
	84	static void apne_reset_8390(struct net_device *dev);
	85	static void apne_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr,
	86	int ring_page);
	87	static void apne_block_input(struct net_device *dev, int count,
	88	struct sk_buff *skb, int ring_offset);
	89	static void apne_block_output(struct net_device *dev, const int count,
	90	const unsigned char *buf, const int start_page);
7d12e780	91	static irqreturn_t apne_interrupt(int irq, void *dev_id);
1da177e4 LT	92
	93	static int init_pcmcia(void);
	94
	95	/* IO base address used for nic */
	96
	97	#define IOBASE 0x300
	98
	99	/*
	100	use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
	101	you can find the values to use by looking at the cnet.device
	102	config file example (the default values are for the CNET40BC card)
	103	*/
	104
	105	/*
	106	#define MANUAL_CONFIG 0x20
	107	#define MANUAL_OFFSET 0x3f8
	108
	109	#define MANUAL_HWADDR0 0x00
	110	#define MANUAL_HWADDR1 0x12
	111	#define MANUAL_HWADDR2 0x34
	112	#define MANUAL_HWADDR3 0x56
	113	#define MANUAL_HWADDR4 0x78
	114	#define MANUAL_HWADDR5 0x9a
	115	*/
	116
	117	static const char version[] =
	118	"apne.c:v1.1 7/10/98 Alain Malek ([email protected])\n";
	119
	120	static int apne_owned; /* signal if card already owned */
	121
	122	struct net_device * __init apne_probe(int unit)
	123	{
	124	struct net_device *dev;
	125	#ifndef MANUAL_CONFIG
	126	char tuple[8];
	127	#endif
	128	int err;
	129
	130	if (apne_owned)
	131	return ERR_PTR(-ENODEV);
	132
	133	if ( !(AMIGAHW_PRESENT(PCMCIA)) )
	134	return ERR_PTR(-ENODEV);
6aa20a22	135
1da177e4	136	printk("Looking for PCMCIA ethernet card : ");
6aa20a22	137
1da177e4 LT	138	/* check if a card is inserted */
	139	if (!(PCMCIA_INSERTED)) {
	140	printk("NO PCMCIA card inserted\n");
	141	return ERR_PTR(-ENODEV);
	142	}
	143
	144	dev = alloc_ei_netdev();
	145	if (!dev)
	146	return ERR_PTR(-ENOMEM);
	147	if (unit >= 0) {
	148	sprintf(dev->name, "eth%d", unit);
	149	netdev_boot_setup_check(dev);
	150	}
1da177e4 LT	151
	152	/* disable pcmcia irq for readtuple */
	153	pcmcia_disable_irq();
	154
	155	#ifndef MANUAL_CONFIG
	156	if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) \|\|
	157	(tuple[2] != CISTPL_FUNCID_NETWORK)) {
	158	printk("not an ethernet card\n");
	159	/* XXX: shouldn't we re-enable irq here? */
	160	free_netdev(dev);
	161	return ERR_PTR(-ENODEV);
	162	}
	163	#endif
	164
	165	printk("ethernet PCMCIA card inserted\n");
	166
	167	if (!init_pcmcia()) {
	168	/* XXX: shouldn't we re-enable irq here? */
	169	free_netdev(dev);
	170	return ERR_PTR(-ENODEV);
	171	}
	172
	173	if (!request_region(IOBASE, 0x20, DRV_NAME)) {
	174	free_netdev(dev);
	175	return ERR_PTR(-EBUSY);
	176	}
	177
	178	err = apne_probe1(dev, IOBASE);
	179	if (err) {
	180	release_region(IOBASE, 0x20);
	181	free_netdev(dev);
	182	return ERR_PTR(err);
	183	}
	184	err = register_netdev(dev);
	185	if (!err)
	186	return dev;
	187
	188	pcmcia_disable_irq();
	189	free_irq(IRQ_AMIGA_PORTS, dev);
	190	pcmcia_reset();
	191	release_region(IOBASE, 0x20);
	192	free_netdev(dev);
	193	return ERR_PTR(err);
	194	}
	195
	196	static int __init apne_probe1(struct net_device *dev, int ioaddr)
	197	{
	198	int i;
	199	unsigned char SA_prom[32];
	200	int wordlength = 2;
	201	const char *name = NULL;
	202	int start_page, stop_page;
	203	#ifndef MANUAL_HWADDR0
	204	int neX000, ctron;
	205	#endif
	206	static unsigned version_printed;
0795af57	207	DECLARE_MAC_BUF(mac);
6aa20a22	208
1da177e4 LT	209	if (ei_debug && version_printed++ == 0)
	210	printk(version);
	211
	212	printk("PCMCIA NE*000 ethercard probe");
	213
	214	/* Reset card. Who knows what dain-bramaged state it was left in. */
	215	{ unsigned long reset_start_time = jiffies;
	216
	217	outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
	218
	219	while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
ff5688ae	220	if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4 LT	221	printk(" not found (no reset ack).\n");
	222	return -ENODEV;
	223	}
	224
	225	outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
	226	}
	227
	228	#ifndef MANUAL_HWADDR0
	229
	230	/* Read the 16 bytes of station address PROM.
	231	We must first initialize registers, similar to NS8390_init(eifdev, 0).
	232	We can't reliably read the SAPROM address without this.
	233	(I learned the hard way!). */
	234	{
	235	struct {unsigned long value, offset; } program_seq[] = {
	236	{E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
	237	{0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
	238	{0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
	239	{0x00, NE_EN0_RCNTHI},
	240	{0x00, NE_EN0_IMR}, /* Mask completion irq. */
	241	{0xFF, NE_EN0_ISR},
	242	{E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
	243	{E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
	244	{32, NE_EN0_RCNTLO},
	245	{0x00, NE_EN0_RCNTHI},
	246	{0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
	247	{0x00, NE_EN0_RSARHI},
	248	{E8390_RREAD+E8390_START, NE_CMD},
	249	};
ff8ac609	250	for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
1da177e4 LT	251	outb(program_seq[i].value, ioaddr + program_seq[i].offset);
	252	}
	253
	254	}
	255	for(i = 0; i < 32 /sizeof(SA_prom)/; i+=2) {
	256	SA_prom[i] = inb(ioaddr + NE_DATAPORT);
	257	SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
	258	if (SA_prom[i] != SA_prom[i+1])
	259	wordlength = 1;
	260	}
	261
	262	/* At this point, wordlength only tells us if the SA_prom is doubled
	263	up or not because some broken PCI cards don't respect the byte-wide
6aa20a22	264	request in program_seq above, and hence don't have doubled up values.
1da177e4 LT	265	These broken cards would otherwise be detected as an ne1000. */
	266
	267	if (wordlength == 2)
	268	for (i = 0; i < 16; i++)
	269	SA_prom[i] = SA_prom[i+i];
6aa20a22	270
1da177e4 LT	271	if (wordlength == 2) {
	272	/* We must set the 8390 for word mode. */
	273	outb(0x49, ioaddr + NE_EN0_DCFG);
	274	start_page = NESM_START_PG;
	275	stop_page = NESM_STOP_PG;
	276	} else {
	277	start_page = NE1SM_START_PG;
	278	stop_page = NE1SM_STOP_PG;
	279	}
	280
	281	neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
	282	ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
	283
	284	/* Set up the rest of the parameters. */
	285	if (neX000) {
	286	name = (wordlength == 2) ? "NE2000" : "NE1000";
	287	} else if (ctron) {
	288	name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
	289	start_page = 0x01;
	290	stop_page = (wordlength == 2) ? 0x40 : 0x20;
	291	} else {
	292	printk(" not found.\n");
	293	return -ENXIO;
	294
	295	}
	296
	297	#else
	298	wordlength = 2;
	299	/* We must set the 8390 for word mode. */
	300	outb(0x49, ioaddr + NE_EN0_DCFG);
	301	start_page = NESM_START_PG;
	302	stop_page = NESM_STOP_PG;
	303
	304	SA_prom[0] = MANUAL_HWADDR0;
	305	SA_prom[1] = MANUAL_HWADDR1;
	306	SA_prom[2] = MANUAL_HWADDR2;
	307	SA_prom[3] = MANUAL_HWADDR3;
	308	SA_prom[4] = MANUAL_HWADDR4;
	309	SA_prom[5] = MANUAL_HWADDR5;
	310	name = "NE2000";
	311	#endif
	312
	313	dev->base_addr = ioaddr;
d8a53b35	314	dev->irq = IRQ_AMIGA_PORTS;
1da177e4 LT	315
1da177e4 LT	316	/* Install the Interrupt handler */
d8a53b35	317	i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
1da177e4 LT	318	if (i) return i;
1da177e4 LT	319
0795af57	320	for(i = 0; i < ETHER_ADDR_LEN; i++)
1da177e4	321	dev->dev_addr[i] = SA_prom[i];
1da177e4	322
0795af57 JP	323	printk(" %s\n", print_mac(mac, dev->dev_addr));
	324
	325	printk("%s: %s found.\n", dev->name, name);
1da177e4 LT	326
	327	ei_status.name = name;
	328	ei_status.tx_start_page = start_page;
	329	ei_status.stop_page = stop_page;
	330	ei_status.word16 = (wordlength == 2);
	331
	332	ei_status.rx_start_page = start_page + TX_PAGES;
	333
	334	ei_status.reset_8390 = &apne_reset_8390;
	335	ei_status.block_input = &apne_block_input;
	336	ei_status.block_output = &apne_block_output;
	337	ei_status.get_8390_hdr = &apne_get_8390_hdr;
	338	dev->open = &apne_open;
	339	dev->stop = &apne_close;
	340	#ifdef CONFIG_NET_POLL_CONTROLLER
	341	dev->poll_controller = ei_poll;
	342	#endif
	343	NS8390_init(dev, 0);
	344
	345	pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
	346	pcmcia_enable_irq();
	347
	348	apne_owned = 1;
	349
	350	return 0;
	351	}
	352
	353	static int
	354	apne_open(struct net_device *dev)
	355	{
	356	ei_open(dev);
	357	return 0;
	358	}
	359
	360	static int
	361	apne_close(struct net_device *dev)
	362	{
	363	if (ei_debug > 1)
	364	printk("%s: Shutting down ethercard.\n", dev->name);
	365	ei_close(dev);
	366	return 0;
	367	}
	368
	369	/* Hard reset the card. This used to pause for the same period that a
	370	8390 reset command required, but that shouldn't be necessary. */
	371	static void
	372	apne_reset_8390(struct net_device *dev)
	373	{
	374	unsigned long reset_start_time = jiffies;
	375
	376	init_pcmcia();
	377
	378	if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
	379
	380	outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
	381
	382	ei_status.txing = 0;
	383	ei_status.dmaing = 0;
	384
	385	/* This check _should_not_ be necessary, omit eventually. */
	386	while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
ff5688ae	387	if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4 LT	388	printk("%s: ne_reset_8390() did not complete.\n", dev->name);
	389	break;
	390	}
	391	outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
	392	}
	393
	394	/* Grab the 8390 specific header. Similar to the block_input routine, but
	395	we don't need to be concerned with ring wrap as the header will be at
	396	the start of a page, so we optimize accordingly. */
	397
	398	static void
	399	apne_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	400	{
	401
	402	int nic_base = dev->base_addr;
	403	int cnt;
	404	char *ptrc;
	405	short *ptrs;
	406
	407	/* This shouldn't happen. If it does, it's the last thing you'll see */
	408	if (ei_status.dmaing) {
	409	printk("%s: DMAing conflict in ne_get_8390_hdr "
	410	"[DMAstat:%d][irqlock:%d][intr:%d].\n",
	411	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
	412	return;
	413	}
	414
	415	ei_status.dmaing \|= 0x01;
	416	outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
	417	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
	418	outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
	419	outb(0, nic_base + NE_EN0_RCNTHI);
	420	outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
	421	outb(ring_page, nic_base + NE_EN0_RSARHI);
	422	outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
	423
	424	if (ei_status.word16) {
	425	ptrs = (short*)hdr;
	426	for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
	427	*ptrs++ = inw(NE_BASE + NE_DATAPORT);
	428	} else {
	429	ptrc = (char*)hdr;
	430	for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
	431	*ptrc++ = inb(NE_BASE + NE_DATAPORT);
	432	}
	433
	434	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
	435	ei_status.dmaing &= ~0x01;
	436
	437	le16_to_cpus(&hdr->count);
	438	}
	439
	440	/* Block input and output, similar to the Crynwr packet driver. If you
	441	are porting to a new ethercard, look at the packet driver source for hints.
	442	The NEx000 doesn't share the on-board packet memory -- you have to put
	443	the packet out through the "remote DMA" dataport using outb. */
	444
	445	static void
	446	apne_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	447	{
	448	int nic_base = dev->base_addr;
	449	char *buf = skb->data;
	450	char *ptrc;
	451	short *ptrs;
452	int cnt;
453
454	/* This shouldn't happen. If it does, it's the last thing you'll see */
455	if (ei_status.dmaing) {
456	printk("%s: DMAing conflict in ne_block_input "
457	"[DMAstat:%d][irqlock:%d][intr:%d].\n",
458	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
459	return;
460	}
461	ei_status.dmaing \|= 0x01;
462	outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
463	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
464	outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
465	outb(count >> 8, nic_base + NE_EN0_RCNTHI);
466	outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
467	outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
468	outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
469	if (ei_status.word16) {
470	ptrs = (short*)buf;
471	for (cnt = 0; cnt < (count>>1); cnt++)
472	*ptrs++ = inw(NE_BASE + NE_DATAPORT);
473	if (count & 0x01) {
474	buf[count-1] = inb(NE_BASE + NE_DATAPORT);
475	}
476	} else {
477	ptrc = (char*)buf;
478	for (cnt = 0; cnt < count; cnt++)
479	*ptrc++ = inb(NE_BASE + NE_DATAPORT);
480	}
481
482	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
483	ei_status.dmaing &= ~0x01;
484	}
485
486	static void
487	apne_block_output(struct net_device *dev, int count,
488	const unsigned char *buf, const int start_page)
489	{
490	int nic_base = NE_BASE;
491	unsigned long dma_start;
492	char *ptrc;
493	short *ptrs;
494	int cnt;
495
496	/* Round the count up for word writes. Do we need to do this?
497	What effect will an odd byte count have on the 8390?
498	I should check someday. */
499	if (ei_status.word16 && (count & 0x01))
500	count++;
501
502	/* This shouldn't happen. If it does, it's the last thing you'll see */
503	if (ei_status.dmaing) {
504	printk("%s: DMAing conflict in ne_block_output."
505	"[DMAstat:%d][irqlock:%d][intr:%d]\n",
506	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
507	return;
508	}
509	ei_status.dmaing \|= 0x01;
510	/* We should already be in page 0, but to be safe... */
511	outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
512
513	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
514
515	/* Now the normal output. */
516	outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
517	outb(count >> 8, nic_base + NE_EN0_RCNTHI);
518	outb(0x00, nic_base + NE_EN0_RSARLO);
519	outb(start_page, nic_base + NE_EN0_RSARHI);
520
521	outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
522	if (ei_status.word16) {
523	ptrs = (short*)buf;
524	for (cnt = 0; cnt < count>>1; cnt++)
525	outw(*ptrs++, NE_BASE+NE_DATAPORT);
526	} else {
527	ptrc = (char*)buf;
528	for (cnt = 0; cnt < count; cnt++)
529	outb(*ptrc++, NE_BASE + NE_DATAPORT);
530	}
531
532	dma_start = jiffies;
533
534	while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
ff5688ae	535	if (time_after(jiffies, dma_start + 2HZ/100)) { / 20ms */
1da177e4 LT	536	printk("%s: timeout waiting for Tx RDC.\n", dev->name);
	537	apne_reset_8390(dev);
	538	NS8390_init(dev,1);
	539	break;
	540	}
	541
	542	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
	543	ei_status.dmaing &= ~0x01;
	544	return;
	545	}
	546
7d12e780	547	static irqreturn_t apne_interrupt(int irq, void *dev_id)
1da177e4 LT	548	{
	549	unsigned char pcmcia_intreq;
	550
	551	if (!(gayle.inten & GAYLE_IRQ_IRQ))
	552	return IRQ_NONE;
	553
	554	pcmcia_intreq = pcmcia_get_intreq();
	555
	556	if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
	557	pcmcia_ack_int(pcmcia_intreq);
	558	return IRQ_NONE;
	559	}
	560	if (ei_debug > 3)
	561	printk("pcmcia intreq = %x\n", pcmcia_intreq);
	562	pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
7d12e780	563	ei_interrupt(irq, dev_id);
1da177e4 LT	564	pcmcia_ack_int(pcmcia_get_intreq());
	565	pcmcia_enable_irq();
	566	return IRQ_HANDLED;
	567	}
	568
	569	#ifdef MODULE
	570	static struct net_device *apne_dev;
	571
afc8eb46	572	int __init init_module(void)
1da177e4 LT	573	{
	574	apne_dev = apne_probe(-1);
	575	if (IS_ERR(apne_dev))
	576	return PTR_ERR(apne_dev);
	577	return 0;
	578	}
	579
afc8eb46	580	void __exit cleanup_module(void)
1da177e4 LT	581	{
	582	unregister_netdev(apne_dev);
	583
	584	pcmcia_disable_irq();
	585
	586	free_irq(IRQ_AMIGA_PORTS, apne_dev);
	587
	588	pcmcia_reset();
	589
	590	release_region(IOBASE, 0x20);
	591
	592	free_netdev(apne_dev);
	593	}
	594
	595	#endif
	596
	597	static int init_pcmcia(void)
	598	{
	599	u_char config;
	600	#ifndef MANUAL_CONFIG
	601	u_char tuple[32];
	602	int offset_len;
	603	#endif
	604	u_long offset;
	605
	606	pcmcia_reset();
	607	pcmcia_program_voltage(PCMCIA_0V);
	608	pcmcia_access_speed(PCMCIA_SPEED_250NS);
	609	pcmcia_write_enable();
	610
	611	#ifdef MANUAL_CONFIG
	612	config = MANUAL_CONFIG;
	613	#else
	614	/* get and write config byte to enable IO port */
	615
	616	if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
	617	return 0;
	618
	619	config = tuple[2] & 0x3f;
	620	#endif
	621	#ifdef MANUAL_OFFSET
	622	offset = MANUAL_OFFSET;
	623	#else
	624	if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
	625	return 0;
	626
	627	offset_len = (tuple[2] & 0x3) + 1;
	628	offset = 0;
	629	while(offset_len--) {
	630	offset = (offset << 8) \| tuple[4+offset_len];
	631	}
	632	#endif
	633
	634	out_8(GAYLE_ATTRIBUTE+offset, config);
	635
	636	return 1;
	637	}
	638
	639	MODULE_LICENSE("GPL");