[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 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 (!MACH_IS_AMIGA)
		return ERR_PTR(-ENODEV);

	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;

    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;
    dev->netdev_ops = &ei_netdev_ops;

    /* 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(" %pM\n", 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;

    NS8390_init(dev, 0);

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

    apne_owned = 1;

    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;

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

static void __exit apne_module_exit(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);
}
module_init(apne_module_init);
module_exit(apne_module_exit);
#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
1da177e4 LT	81	static void apne_reset_8390(struct net_device *dev);
	82	static void apne_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr,
	83	int ring_page);
	84	static void apne_block_input(struct net_device *dev, int count,
	85	struct sk_buff *skb, int ring_offset);
	86	static void apne_block_output(struct net_device *dev, const int count,
	87	const unsigned char *buf, const int start_page);
7d12e780	88	static irqreturn_t apne_interrupt(int irq, void *dev_id);
1da177e4 LT	89
	90	static int init_pcmcia(void);
	91
	92	/* IO base address used for nic */
	93
	94	#define IOBASE 0x300
	95
	96	/*
	97	use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
	98	you can find the values to use by looking at the cnet.device
	99	config file example (the default values are for the CNET40BC card)
	100	*/
	101
	102	/*
	103	#define MANUAL_CONFIG 0x20
	104	#define MANUAL_OFFSET 0x3f8
	105
	106	#define MANUAL_HWADDR0 0x00
	107	#define MANUAL_HWADDR1 0x12
	108	#define MANUAL_HWADDR2 0x34
	109	#define MANUAL_HWADDR3 0x56
	110	#define MANUAL_HWADDR4 0x78
	111	#define MANUAL_HWADDR5 0x9a
	112	*/
	113
	114	static const char version[] =
	115	"apne.c:v1.1 7/10/98 Alain Malek ([email protected])\n";
	116
	117	static int apne_owned; /* signal if card already owned */
	118
	119	struct net_device * __init apne_probe(int unit)
	120	{
	121	struct net_device *dev;
	122	#ifndef MANUAL_CONFIG
	123	char tuple[8];
	124	#endif
	125	int err;
	126
0f734484 GU	127	if (!MACH_IS_AMIGA)
	128	return ERR_PTR(-ENODEV);
	129
1da177e4 LT	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;
6aa20a22	207
1da177e4 LT	208	if (ei_debug && version_printed++ == 0)
	209	printk(version);
	210
	211	printk("PCMCIA NE*000 ethercard probe");
	212
	213	/* Reset card. Who knows what dain-bramaged state it was left in. */
	214	{ unsigned long reset_start_time = jiffies;
	215
	216	outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
	217
	218	while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
ff5688ae	219	if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4 LT	220	printk(" not found (no reset ack).\n");
	221	return -ENODEV;
	222	}
	223
	224	outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
	225	}
	226
	227	#ifndef MANUAL_HWADDR0
	228
	229	/* Read the 16 bytes of station address PROM.
	230	We must first initialize registers, similar to NS8390_init(eifdev, 0).
	231	We can't reliably read the SAPROM address without this.
	232	(I learned the hard way!). */
	233	{
	234	struct {unsigned long value, offset; } program_seq[] = {
	235	{E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
	236	{0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
	237	{0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
	238	{0x00, NE_EN0_RCNTHI},
	239	{0x00, NE_EN0_IMR}, /* Mask completion irq. */
	240	{0xFF, NE_EN0_ISR},
	241	{E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
	242	{E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
	243	{32, NE_EN0_RCNTLO},
	244	{0x00, NE_EN0_RCNTHI},
	245	{0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
	246	{0x00, NE_EN0_RSARHI},
	247	{E8390_RREAD+E8390_START, NE_CMD},
	248	};
ff8ac609	249	for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
1da177e4 LT	250	outb(program_seq[i].value, ioaddr + program_seq[i].offset);
	251	}
	252
	253	}
	254	for(i = 0; i < 32 /sizeof(SA_prom)/; i+=2) {
	255	SA_prom[i] = inb(ioaddr + NE_DATAPORT);
	256	SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
	257	if (SA_prom[i] != SA_prom[i+1])
	258	wordlength = 1;
	259	}
	260
	261	/* At this point, wordlength only tells us if the SA_prom is doubled
	262	up or not because some broken PCI cards don't respect the byte-wide
6aa20a22	263	request in program_seq above, and hence don't have doubled up values.
1da177e4 LT	264	These broken cards would otherwise be detected as an ne1000. */
	265
	266	if (wordlength == 2)
	267	for (i = 0; i < 16; i++)
	268	SA_prom[i] = SA_prom[i+i];
6aa20a22	269
1da177e4 LT	270	if (wordlength == 2) {
	271	/* We must set the 8390 for word mode. */
	272	outb(0x49, ioaddr + NE_EN0_DCFG);
	273	start_page = NESM_START_PG;
	274	stop_page = NESM_STOP_PG;
	275	} else {
	276	start_page = NE1SM_START_PG;
	277	stop_page = NE1SM_STOP_PG;
	278	}
	279
	280	neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
	281	ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
	282
	283	/* Set up the rest of the parameters. */
	284	if (neX000) {
	285	name = (wordlength == 2) ? "NE2000" : "NE1000";
	286	} else if (ctron) {
	287	name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
	288	start_page = 0x01;
	289	stop_page = (wordlength == 2) ? 0x40 : 0x20;
	290	} else {
	291	printk(" not found.\n");
	292	return -ENXIO;
	293
	294	}
	295
	296	#else
	297	wordlength = 2;
	298	/* We must set the 8390 for word mode. */
	299	outb(0x49, ioaddr + NE_EN0_DCFG);
	300	start_page = NESM_START_PG;
	301	stop_page = NESM_STOP_PG;
	302
	303	SA_prom[0] = MANUAL_HWADDR0;
	304	SA_prom[1] = MANUAL_HWADDR1;
	305	SA_prom[2] = MANUAL_HWADDR2;
	306	SA_prom[3] = MANUAL_HWADDR3;
	307	SA_prom[4] = MANUAL_HWADDR4;
	308	SA_prom[5] = MANUAL_HWADDR5;
	309	name = "NE2000";
	310	#endif
	311
	312	dev->base_addr = ioaddr;
d8a53b35	313	dev->irq = IRQ_AMIGA_PORTS;
7d359daa	314	dev->netdev_ops = &ei_netdev_ops;
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
e174961c	323	printk(" %pM\n", dev->dev_addr);
0795af57 JP	324
0795af57 JP	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;
7d359daa	338
1da177e4 LT	339	NS8390_init(dev, 0);
	340
	341	pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
	342	pcmcia_enable_irq();
	343
	344	apne_owned = 1;
	345
	346	return 0;
	347	}
	348
1da177e4 LT	349	/* Hard reset the card. This used to pause for the same period that a
	350	8390 reset command required, but that shouldn't be necessary. */
	351	static void
	352	apne_reset_8390(struct net_device *dev)
	353	{
	354	unsigned long reset_start_time = jiffies;
	355
	356	init_pcmcia();
	357
	358	if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
	359
	360	outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
	361
	362	ei_status.txing = 0;
	363	ei_status.dmaing = 0;
	364
	365	/* This check _should_not_ be necessary, omit eventually. */
	366	while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
ff5688ae	367	if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4 LT	368	printk("%s: ne_reset_8390() did not complete.\n", dev->name);
	369	break;
	370	}
	371	outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
	372	}
	373
	374	/* Grab the 8390 specific header. Similar to the block_input routine, but
	375	we don't need to be concerned with ring wrap as the header will be at
	376	the start of a page, so we optimize accordingly. */
	377
	378	static void
	379	apne_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	380	{
	381
	382	int nic_base = dev->base_addr;
	383	int cnt;
	384	char *ptrc;
	385	short *ptrs;
	386
	387	/* This shouldn't happen. If it does, it's the last thing you'll see */
	388	if (ei_status.dmaing) {
	389	printk("%s: DMAing conflict in ne_get_8390_hdr "
	390	"[DMAstat:%d][irqlock:%d][intr:%d].\n",
	391	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
	392	return;
	393	}
	394
	395	ei_status.dmaing \|= 0x01;
	396	outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
	397	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
	398	outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
	399	outb(0, nic_base + NE_EN0_RCNTHI);
	400	outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
	401	outb(ring_page, nic_base + NE_EN0_RSARHI);
	402	outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
	403
	404	if (ei_status.word16) {
	405	ptrs = (short*)hdr;
	406	for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
	407	*ptrs++ = inw(NE_BASE + NE_DATAPORT);
	408	} else {
	409	ptrc = (char*)hdr;
	410	for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
	411	*ptrc++ = inb(NE_BASE + NE_DATAPORT);
	412	}
	413
	414	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
	415	ei_status.dmaing &= ~0x01;
	416
	417	le16_to_cpus(&hdr->count);
	418	}
	419
	420	/* Block input and output, similar to the Crynwr packet driver. If you
	421	are porting to a new ethercard, look at the packet driver source for hints.
	422	The NEx000 doesn't share the on-board packet memory -- you have to put
	423	the packet out through the "remote DMA" dataport using outb. */
	424
	425	static void
	426	apne_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	427	{
	428	int nic_base = dev->base_addr;
	429	char *buf = skb->data;
	430	char *ptrc;
	431	short *ptrs;
432	int cnt;
433
434	/* This shouldn't happen. If it does, it's the last thing you'll see */
435	if (ei_status.dmaing) {
436	printk("%s: DMAing conflict in ne_block_input "
437	"[DMAstat:%d][irqlock:%d][intr:%d].\n",
438	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
439	return;
440	}
441	ei_status.dmaing \|= 0x01;
442	outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
443	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
444	outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
445	outb(count >> 8, nic_base + NE_EN0_RCNTHI);
446	outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
447	outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
448	outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
449	if (ei_status.word16) {
450	ptrs = (short*)buf;
451	for (cnt = 0; cnt < (count>>1); cnt++)
452	*ptrs++ = inw(NE_BASE + NE_DATAPORT);
453	if (count & 0x01) {
454	buf[count-1] = inb(NE_BASE + NE_DATAPORT);
455	}
456	} else {
457	ptrc = (char*)buf;
458	for (cnt = 0; cnt < count; cnt++)
459	*ptrc++ = inb(NE_BASE + NE_DATAPORT);
460	}
461
462	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
463	ei_status.dmaing &= ~0x01;
464	}
465
466	static void
467	apne_block_output(struct net_device *dev, int count,
468	const unsigned char *buf, const int start_page)
469	{
470	int nic_base = NE_BASE;
471	unsigned long dma_start;
472	char *ptrc;
473	short *ptrs;
474	int cnt;
475
476	/* Round the count up for word writes. Do we need to do this?
477	What effect will an odd byte count have on the 8390?
478	I should check someday. */
479	if (ei_status.word16 && (count & 0x01))
480	count++;
481
482	/* This shouldn't happen. If it does, it's the last thing you'll see */
483	if (ei_status.dmaing) {
484	printk("%s: DMAing conflict in ne_block_output."
485	"[DMAstat:%d][irqlock:%d][intr:%d]\n",
486	dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
487	return;
488	}
489	ei_status.dmaing \|= 0x01;
490	/* We should already be in page 0, but to be safe... */
491	outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
492
493	outb(ENISR_RDC, nic_base + NE_EN0_ISR);
494
495	/* Now the normal output. */
496	outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
497	outb(count >> 8, nic_base + NE_EN0_RCNTHI);
498	outb(0x00, nic_base + NE_EN0_RSARLO);
499	outb(start_page, nic_base + NE_EN0_RSARHI);
500
501	outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
502	if (ei_status.word16) {
503	ptrs = (short*)buf;
504	for (cnt = 0; cnt < count>>1; cnt++)
505	outw(*ptrs++, NE_BASE+NE_DATAPORT);
506	} else {
507	ptrc = (char*)buf;
508	for (cnt = 0; cnt < count; cnt++)
509	outb(*ptrc++, NE_BASE + NE_DATAPORT);
510	}
511
512	dma_start = jiffies;
513
514	while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
ff5688ae	515	if (time_after(jiffies, dma_start + 2HZ/100)) { / 20ms */
1da177e4 LT	516	printk("%s: timeout waiting for Tx RDC.\n", dev->name);
	517	apne_reset_8390(dev);
	518	NS8390_init(dev,1);
	519	break;
	520	}
	521
	522	outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
	523	ei_status.dmaing &= ~0x01;
	524	return;
	525	}
	526
7d12e780	527	static irqreturn_t apne_interrupt(int irq, void *dev_id)
1da177e4 LT	528	{
	529	unsigned char pcmcia_intreq;
	530
	531	if (!(gayle.inten & GAYLE_IRQ_IRQ))
	532	return IRQ_NONE;
	533
	534	pcmcia_intreq = pcmcia_get_intreq();
	535
	536	if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
	537	pcmcia_ack_int(pcmcia_intreq);
	538	return IRQ_NONE;
	539	}
	540	if (ei_debug > 3)
	541	printk("pcmcia intreq = %x\n", pcmcia_intreq);
	542	pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
7d12e780	543	ei_interrupt(irq, dev_id);
1da177e4 LT	544	pcmcia_ack_int(pcmcia_get_intreq());
	545	pcmcia_enable_irq();
	546	return IRQ_HANDLED;
	547	}
	548
	549	#ifdef MODULE
	550	static struct net_device *apne_dev;
	551
3cfbb677	552	static int __init apne_module_init(void)
1da177e4 LT	553	{
	554	apne_dev = apne_probe(-1);
	555	if (IS_ERR(apne_dev))
	556	return PTR_ERR(apne_dev);
	557	return 0;
	558	}
	559
3cfbb677	560	static void __exit apne_module_exit(void)
1da177e4 LT	561	{
	562	unregister_netdev(apne_dev);
	563
	564	pcmcia_disable_irq();
	565
	566	free_irq(IRQ_AMIGA_PORTS, apne_dev);
	567
	568	pcmcia_reset();
	569
	570	release_region(IOBASE, 0x20);
	571
	572	free_netdev(apne_dev);
	573	}
3cfbb677 JS	574	module_init(apne_module_init);
3cfbb677 JS	575	module_exit(apne_module_exit);
1da177e4 LT	576	#endif
	577
	578	static int init_pcmcia(void)
	579	{
	580	u_char config;
	581	#ifndef MANUAL_CONFIG
	582	u_char tuple[32];
	583	int offset_len;
	584	#endif
	585	u_long offset;
	586
	587	pcmcia_reset();
	588	pcmcia_program_voltage(PCMCIA_0V);
	589	pcmcia_access_speed(PCMCIA_SPEED_250NS);
	590	pcmcia_write_enable();
	591
	592	#ifdef MANUAL_CONFIG
	593	config = MANUAL_CONFIG;
	594	#else
	595	/* get and write config byte to enable IO port */
	596
	597	if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
	598	return 0;
	599
	600	config = tuple[2] & 0x3f;
	601	#endif
	602	#ifdef MANUAL_OFFSET
	603	offset = MANUAL_OFFSET;
	604	#else
	605	if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
	606	return 0;
	607
	608	offset_len = (tuple[2] & 0x3) + 1;
	609	offset = 0;
	610	while(offset_len--) {
	611	offset = (offset << 8) \| tuple[4+offset_len];
	612	}
	613	#endif
	614
	615	out_8(GAYLE_ATTRIBUTE+offset, config);
	616
	617	return 1;
	618	}
	619
	620	MODULE_LICENSE("GPL");