[net-next-2.6.git] / drivers / net / apne.c

/*
 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
 *
 * (C) Copyright 1997 Alain Malek
 *                    (Alain.Malek@cryogen.com)
 *
 * ----------------------------------------------------------------------------
 *
 * 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 (bhabbott@inhb.co.nz)
 *
 * ----------------------------------------------------------------------------
 *
 * 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, struct pt_regs *regs);

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 (Alain.Malek@cryogen.ch)\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);
	}
	SET_MODULE_OWNER(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;

    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 < sizeof(program_seq)/sizeof(program_seq[0]); 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;

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

    for(i = 0; i < ETHER_ADDR_LEN; i++) {
	printk(" %2.2x", SA_prom[i]);
	dev->dev_addr[i] = SA_prom[i];
    }

    printk("\n%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, struct pt_regs *regs)
{
    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, regs);
    pcmcia_ack_int(pcmcia_get_intreq());
    pcmcia_enable_irq();
    return IRQ_HANDLED;
}

#ifdef MODULE
static struct net_device *apne_dev;

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

void 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	* (Alain.Malek@cryogen.com)
	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 (bhabbott@inhb.co.nz)
	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);
	91	static irqreturn_t apne_interrupt(int irq, void dev_id, struct pt_regs regs);
	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 (Alain.Malek@cryogen.ch)\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	}
	151	SET_MODULE_OWNER(dev);
	152
	153	/* disable pcmcia irq for readtuple */
	154	pcmcia_disable_irq();
	155
	156	#ifndef MANUAL_CONFIG
	157	if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) \|\|
	158	(tuple[2] != CISTPL_FUNCID_NETWORK)) {
	159	printk("not an ethernet card\n");
	160	/* XXX: shouldn't we re-enable irq here? */
	161	free_netdev(dev);
	162	return ERR_PTR(-ENODEV);
	163	}
	164	#endif
	165
	166	printk("ethernet PCMCIA card inserted\n");
	167
	168	if (!init_pcmcia()) {
	169	/* XXX: shouldn't we re-enable irq here? */
	170	free_netdev(dev);
	171	return ERR_PTR(-ENODEV);
	172	}
	173
	174	if (!request_region(IOBASE, 0x20, DRV_NAME)) {
	175	free_netdev(dev);
	176	return ERR_PTR(-EBUSY);
	177	}
	178
	179	err = apne_probe1(dev, IOBASE);
	180	if (err) {
	181	release_region(IOBASE, 0x20);
	182	free_netdev(dev);
	183	return ERR_PTR(err);
	184	}
	185	err = register_netdev(dev);
	186	if (!err)
	187	return dev;
	188
	189	pcmcia_disable_irq();
	190	free_irq(IRQ_AMIGA_PORTS, dev);
	191	pcmcia_reset();
	192	release_region(IOBASE, 0x20);
	193	free_netdev(dev);
	194	return ERR_PTR(err);
	195	}
	196
	197	static int __init apne_probe1(struct net_device *dev, int ioaddr)
	198	{
	199	int i;
	200	unsigned char SA_prom[32];
	201	int wordlength = 2;
202	const char *name = NULL;
203	int start_page, stop_page;
204	#ifndef MANUAL_HWADDR0
205	int neX000, ctron;
206	#endif
207	static unsigned version_printed;
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	};
	250	for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) {
	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;
	314
	315	/* Install the Interrupt handler */
1fb9df5d	316	i = request_irq(IRQ_AMIGA_PORTS, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
1da177e4 LT	317	if (i) return i;
	318
	319	for(i = 0; i < ETHER_ADDR_LEN; i++) {
	320	printk(" %2.2x", SA_prom[i]);
	321	dev->dev_addr[i] = SA_prom[i];
	322	}
	323
	324	printk("\n%s: %s found.\n", dev->name, name);
	325
	326	ei_status.name = name;
	327	ei_status.tx_start_page = start_page;
	328	ei_status.stop_page = stop_page;
	329	ei_status.word16 = (wordlength == 2);
	330
	331	ei_status.rx_start_page = start_page + TX_PAGES;
	332
	333	ei_status.reset_8390 = &apne_reset_8390;
	334	ei_status.block_input = &apne_block_input;
	335	ei_status.block_output = &apne_block_output;
	336	ei_status.get_8390_hdr = &apne_get_8390_hdr;
	337	dev->open = &apne_open;
	338	dev->stop = &apne_close;
	339	#ifdef CONFIG_NET_POLL_CONTROLLER
	340	dev->poll_controller = ei_poll;
	341	#endif
	342	NS8390_init(dev, 0);
	343
	344	pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
	345	pcmcia_enable_irq();
	346
	347	apne_owned = 1;
	348
	349	return 0;
	350	}
	351
	352	static int
	353	apne_open(struct net_device *dev)
	354	{
	355	ei_open(dev);
	356	return 0;
	357	}
	358
	359	static int
	360	apne_close(struct net_device *dev)
	361	{
	362	if (ei_debug > 1)
	363	printk("%s: Shutting down ethercard.\n", dev->name);
	364	ei_close(dev);
	365	return 0;
	366	}
	367
	368	/* Hard reset the card. This used to pause for the same period that a
	369	8390 reset command required, but that shouldn't be necessary. */
	370	static void
	371	apne_reset_8390(struct net_device *dev)
	372	{
	373	unsigned long reset_start_time = jiffies;
	374
	375	init_pcmcia();
	376
	377	if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
	378
	379	outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
	380
381	ei_status.txing = 0;
382	ei_status.dmaing = 0;
383
384	/* This check _should_not_ be necessary, omit eventually. */
385	while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
ff5688ae	386	if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4 LT	387	printk("%s: ne_reset_8390() did not complete.\n", dev->name);
	388	break;
	389	}
	390	outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
	391	}
	392
	393	/* Grab the 8390 specific header. Similar to the block_input routine, but
	394	we don't need to be concerned with ring wrap as the header will be at
	395	the start of a page, so we optimize accordingly. */
	396
	397	static void
	398	apne_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	399	{
	400
	401	int nic_base = dev->base_addr;
	402	int cnt;
	403	char *ptrc;
	404	short *ptrs;
	405
	406	/* This shouldn't happen. If it does, it's the last thing you'll see */
	407	if (ei_status.dmaing) {
	408	printk("%s: DMAing conflict in ne_get_8390_hdr "
	409	"[DMAstat:%d][irqlock:%d][intr:%d].\n",
	410	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
	411	return;
	412	}
	413
	414	ei_status.dmaing \|= 0x01;
	415	outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
	416	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
	417	outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
	418	outb(0, nic_base + NE_EN0_RCNTHI);
	419	outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
	420	outb(ring_page, nic_base + NE_EN0_RSARHI);
	421	outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
	422
	423	if (ei_status.word16) {
	424	ptrs = (short*)hdr;
	425	for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
	426	*ptrs++ = inw(NE_BASE + NE_DATAPORT);
	427	} else {
	428	ptrc = (char*)hdr;
	429	for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
	430	*ptrc++ = inb(NE_BASE + NE_DATAPORT);
	431	}
	432
	433	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
	434	ei_status.dmaing &= ~0x01;
	435
	436	le16_to_cpus(&hdr->count);
	437	}
	438
	439	/* Block input and output, similar to the Crynwr packet driver. If you
	440	are porting to a new ethercard, look at the packet driver source for hints.
	441	The NEx000 doesn't share the on-board packet memory -- you have to put
	442	the packet out through the "remote DMA" dataport using outb. */
	443
	444	static void
	445	apne_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	446	{
	447	int nic_base = dev->base_addr;
	448	char *buf = skb->data;
	449	char *ptrc;
	450	short *ptrs;
451	int cnt;
452
453	/* This shouldn't happen. If it does, it's the last thing you'll see */
454	if (ei_status.dmaing) {
455	printk("%s: DMAing conflict in ne_block_input "
456	"[DMAstat:%d][irqlock:%d][intr:%d].\n",
457	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
458	return;
459	}
460	ei_status.dmaing \|= 0x01;
461	outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
462	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
463	outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
464	outb(count >> 8, nic_base + NE_EN0_RCNTHI);
465	outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
466	outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
467	outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
468	if (ei_status.word16) {
469	ptrs = (short*)buf;
470	for (cnt = 0; cnt < (count>>1); cnt++)
471	*ptrs++ = inw(NE_BASE + NE_DATAPORT);
472	if (count & 0x01) {
473	buf[count-1] = inb(NE_BASE + NE_DATAPORT);
474	}
475	} else {
476	ptrc = (char*)buf;
477	for (cnt = 0; cnt < count; cnt++)
478	*ptrc++ = inb(NE_BASE + NE_DATAPORT);
479	}
480
481	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
482	ei_status.dmaing &= ~0x01;
483	}
484
485	static void
486	apne_block_output(struct net_device *dev, int count,
487	const unsigned char *buf, const int start_page)
488	{
489	int nic_base = NE_BASE;
490	unsigned long dma_start;
491	char *ptrc;
492	short *ptrs;
493	int cnt;
494
495	/* Round the count up for word writes. Do we need to do this?
496	What effect will an odd byte count have on the 8390?
497	I should check someday. */
498	if (ei_status.word16 && (count & 0x01))
499	count++;
500
501	/* This shouldn't happen. If it does, it's the last thing you'll see */
502	if (ei_status.dmaing) {
503	printk("%s: DMAing conflict in ne_block_output."
504	"[DMAstat:%d][irqlock:%d][intr:%d]\n",
505	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
506	return;
507	}
508	ei_status.dmaing \|= 0x01;
509	/* We should already be in page 0, but to be safe... */
510	outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
511
512	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
513
514	/* Now the normal output. */
515	outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
516	outb(count >> 8, nic_base + NE_EN0_RCNTHI);
517	outb(0x00, nic_base + NE_EN0_RSARLO);
518	outb(start_page, nic_base + NE_EN0_RSARHI);
519
520	outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
521	if (ei_status.word16) {
522	ptrs = (short*)buf;
523	for (cnt = 0; cnt < count>>1; cnt++)
524	outw(*ptrs++, NE_BASE+NE_DATAPORT);
525	} else {
526	ptrc = (char*)buf;
527	for (cnt = 0; cnt < count; cnt++)
528	outb(*ptrc++, NE_BASE + NE_DATAPORT);
529	}
530
531	dma_start = jiffies;
532
533	while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
ff5688ae	534	if (time_after(jiffies, dma_start + 2HZ/100)) { / 20ms */
1da177e4 LT	535	printk("%s: timeout waiting for Tx RDC.\n", dev->name);
	536	apne_reset_8390(dev);
	537	NS8390_init(dev,1);
	538	break;
	539	}
	540
	541	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
	542	ei_status.dmaing &= ~0x01;
	543	return;
	544	}
	545
	546	static irqreturn_t apne_interrupt(int irq, void dev_id, struct pt_regs regs)
	547	{
	548	unsigned char pcmcia_intreq;
	549
	550	if (!(gayle.inten & GAYLE_IRQ_IRQ))
	551	return IRQ_NONE;
	552
	553	pcmcia_intreq = pcmcia_get_intreq();
	554
	555	if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
	556	pcmcia_ack_int(pcmcia_intreq);
	557	return IRQ_NONE;
	558	}
	559	if (ei_debug > 3)
	560	printk("pcmcia intreq = %x\n", pcmcia_intreq);
	561	pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
	562	ei_interrupt(irq, dev_id, regs);
	563	pcmcia_ack_int(pcmcia_get_intreq());
	564	pcmcia_enable_irq();
	565	return IRQ_HANDLED;
	566	}
	567
	568	#ifdef MODULE
	569	static struct net_device *apne_dev;
	570
	571	int init_module(void)
	572	{
	573	apne_dev = apne_probe(-1);
	574	if (IS_ERR(apne_dev))
	575	return PTR_ERR(apne_dev);
	576	return 0;
	577	}
	578
	579	void cleanup_module(void)
	580	{
	581	unregister_netdev(apne_dev);
	582
	583	pcmcia_disable_irq();
	584
	585	free_irq(IRQ_AMIGA_PORTS, apne_dev);
	586
	587	pcmcia_reset();
	588
	589	release_region(IOBASE, 0x20);
	590
	591	free_netdev(apne_dev);
	592	}
	593
	594	#endif
	595
	596	static int init_pcmcia(void)
	597	{
	598	u_char config;
599	#ifndef MANUAL_CONFIG
600	u_char tuple[32];
601	int offset_len;
602	#endif
603	u_long offset;
604
605	pcmcia_reset();
606	pcmcia_program_voltage(PCMCIA_0V);
607	pcmcia_access_speed(PCMCIA_SPEED_250NS);
608	pcmcia_write_enable();
609
610	#ifdef MANUAL_CONFIG
611	config = MANUAL_CONFIG;
612	#else
613	/* get and write config byte to enable IO port */
614
615	if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
616	return 0;
617
618	config = tuple[2] & 0x3f;
619	#endif
620	#ifdef MANUAL_OFFSET
621	offset = MANUAL_OFFSET;
622	#else
623	if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
624	return 0;
625
626	offset_len = (tuple[2] & 0x3) + 1;
627	offset = 0;
628	while(offset_len--) {
629	offset = (offset << 8) \| tuple[4+offset_len];
630	}
631	#endif
632
633	out_8(GAYLE_ATTRIBUTE+offset, config);
634
635	return 1;
636	}
637
638	MODULE_LICENSE("GPL");