[deliverable/linux.git] / drivers / net / hp-plus.c

/* hp-plus.c: A HP PCLAN/plus ethernet driver for linux. */
/*
	Written 1994 by Donald Becker.

	This driver is for the Hewlett Packard PC LAN (27***) plus ethercards.
	These cards are sold under several model numbers, usually 2724*.

	This software may be used and distributed according to the terms
	of the GNU General Public License, incorporated herein by reference.

	The author may be reached as becker@scyld.com, or C/O
	Scyld Computing Corporation
	410 Severn Ave., Suite 210
	Annapolis MD 21403

	As is often the case, a great deal of credit is owed to Russ Nelson.
	The Crynwr packet driver was my primary source of HP-specific
	programming information.
*/

static const char version[] =
"hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";

#include <linux/module.h>

#include <linux/string.h>		/* Important -- this inlines word moves. */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/delay.h>

#include <asm/system.h>
#include <asm/io.h>

#include "8390.h"

#define DRV_NAME "hp-plus"

/* A zero-terminated list of I/O addresses to be probed. */
static unsigned int hpplus_portlist[] __initdata =
{0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0};

/*
   The HP EtherTwist chip implementation is a fairly routine DP8390
   implementation.  It allows both shared memory and programmed-I/O buffer
   access, using a custom interface for both.  The programmed-I/O mode is
   entirely implemented in the HP EtherTwist chip, bypassing the problem
   ridden built-in 8390 facilities used on NE2000 designs.  The shared
   memory mode is likewise special, with an offset register used to make
   packets appear at the shared memory base.  Both modes use a base and bounds
   page register to hide the Rx ring buffer wrap -- a packet that spans the
   end of physical buffer memory appears continuous to the driver. (c.f. the
   3c503 and Cabletron E2100)

   A special note: the internal buffer of the board is only 8 bits wide.
   This lays several nasty traps for the unaware:
   - the 8390 must be programmed for byte-wide operations
   - all I/O and memory operations must work on whole words (the access
     latches are serially preloaded and have no byte-swapping ability).

   This board is laid out in I/O space much like the earlier HP boards:
   the first 16 locations are for the board registers, and the second 16 are
   for the 8390.  The board is easy to identify, with both a dedicated 16 bit
   ID register and a constant 0x530* value in the upper bits of the paging
   register.
*/

#define HP_ID			0x00	/* ID register, always 0x4850. */
#define HP_PAGING		0x02	/* Registers visible @ 8-f, see PageName. */
#define HPP_OPTION		0x04	/* Bitmapped options, see HP_Option.	*/
#define HPP_OUT_ADDR	0x08	/* I/O output location in Perf_Page.	*/
#define HPP_IN_ADDR		0x0A	/* I/O input location in Perf_Page.		*/
#define HP_DATAPORT		0x0c	/* I/O data transfer in Perf_Page.		*/
#define NIC_OFFSET		0x10	/* Offset to the 8390 registers.		*/
#define HP_IO_EXTENT	32

#define HP_START_PG		0x00	/* First page of TX buffer */
#define HP_STOP_PG		0x80	/* Last page +1 of RX ring */

/* The register set selected in HP_PAGING. */
enum PageName {
	Perf_Page = 0,				/* Normal operation. */
	MAC_Page = 1,				/* The ethernet address (+checksum). */
	HW_Page = 2,				/* EEPROM-loaded hardware parameters. */
	LAN_Page = 4,				/* Transceiver selection, testing, etc. */
	ID_Page = 6 };

/* The bit definitions for the HPP_OPTION register. */
enum HP_Option {
	NICReset = 1, ChipReset = 2, 	/* Active low, really UNreset. */
	EnableIRQ = 4, FakeIntr = 8, BootROMEnb = 0x10, IOEnb = 0x20,
	MemEnable = 0x40, ZeroWait = 0x80, MemDisable = 0x1000, };

static int hpp_probe1(struct net_device *dev, int ioaddr);

static void hpp_reset_8390(struct net_device *dev);
static int hpp_open(struct net_device *dev);
static int hpp_close(struct net_device *dev);
static void hpp_mem_block_input(struct net_device *dev, int count,
						  struct sk_buff *skb, int ring_offset);
static void hpp_mem_block_output(struct net_device *dev, int count,
							const unsigned char *buf, int start_page);
static void hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
						  int ring_page);
static void hpp_io_block_input(struct net_device *dev, int count,
						  struct sk_buff *skb, int ring_offset);
static void hpp_io_block_output(struct net_device *dev, int count,
							const unsigned char *buf, int start_page);
static void hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
						  int ring_page);


/*	Probe a list of addresses for an HP LAN+ adaptor.
	This routine is almost boilerplate. */

static int __init do_hpp_probe(struct net_device *dev)
{
	int i;
	int base_addr = dev->base_addr;
	int irq = dev->irq;

	if (base_addr > 0x1ff)		/* Check a single specified location. */
		return hpp_probe1(dev, base_addr);
	else if (base_addr != 0)	/* Don't probe at all. */
		return -ENXIO;

	for (i = 0; hpplus_portlist[i]; i++) {
		if (hpp_probe1(dev, hpplus_portlist[i]) == 0)
			return 0;
		dev->irq = irq;
	}

	return -ENODEV;
}

#ifndef MODULE
struct net_device * __init hp_plus_probe(int unit)
{
	struct net_device *dev = alloc_eip_netdev();
	int err;

	if (!dev)
		return ERR_PTR(-ENOMEM);

	sprintf(dev->name, "eth%d", unit);
	netdev_boot_setup_check(dev);

	err = do_hpp_probe(dev);
	if (err)
		goto out;
	return dev;
out:
	free_netdev(dev);
	return ERR_PTR(err);
}
#endif

static const struct net_device_ops hpp_netdev_ops = {
	.ndo_open		= hpp_open,
	.ndo_stop		= hpp_close,
	.ndo_start_xmit		= eip_start_xmit,
	.ndo_tx_timeout		= eip_tx_timeout,
	.ndo_get_stats		= eip_get_stats,
	.ndo_set_multicast_list = eip_set_multicast_list,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_change_mtu		= eth_change_mtu,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= eip_poll,
#endif
};


/* Do the interesting part of the probe at a single address. */
static int __init hpp_probe1(struct net_device *dev, int ioaddr)
{
	int i, retval;
	unsigned char checksum = 0;
	const char name[] = "HP-PC-LAN+";
	int mem_start;
	static unsigned version_printed;

	if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME))
		return -EBUSY;

	/* Check for the HP+ signature, 50 48 0x 53. */
	if (inw(ioaddr + HP_ID) != 0x4850 ||
	    (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
		retval = -ENODEV;
		goto out;
	}

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

	printk("%s: %s at %#3x, ", dev->name, name, ioaddr);

	/* Retrieve and checksum the station address. */
	outw(MAC_Page, ioaddr + HP_PAGING);

	for(i = 0; i < ETHER_ADDR_LEN; i++) {
		unsigned char inval = inb(ioaddr + 8 + i);
		dev->dev_addr[i] = inval;
		checksum += inval;
	}
	checksum += inb(ioaddr + 14);

	printk("%pM", dev->dev_addr);

	if (checksum != 0xff) {
		printk(" bad checksum %2.2x.\n", checksum);
		retval = -ENODEV;
		goto out;
	} else {
		/* Point at the Software Configuration Flags. */
		outw(ID_Page, ioaddr + HP_PAGING);
		printk(" ID %4.4x", inw(ioaddr + 12));
	}

	/* Read the IRQ line. */
	outw(HW_Page, ioaddr + HP_PAGING);
	{
		int irq = inb(ioaddr + 13) & 0x0f;
		int option = inw(ioaddr + HPP_OPTION);

		dev->irq = irq;
		if (option & MemEnable) {
			mem_start = inw(ioaddr + 9) << 8;
			printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
		} else {
			mem_start = 0;
			printk(", IRQ %d, programmed-I/O mode.\n", irq);
		}
	}

	/* Set the wrap registers for string I/O reads.   */
	outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);

	/* Set the base address to point to the NIC, not the "real" base! */
	dev->base_addr = ioaddr + NIC_OFFSET;

	dev->netdev_ops = &hpp_netdev_ops;

	ei_status.name = name;
	ei_status.word16 = 0;		/* Agggghhhhh! Debug time: 2 days! */
	ei_status.tx_start_page = HP_START_PG;
	ei_status.rx_start_page = HP_START_PG + TX_PAGES/2;
	ei_status.stop_page = HP_STOP_PG;

	ei_status.reset_8390 = &hpp_reset_8390;
	ei_status.block_input = &hpp_io_block_input;
	ei_status.block_output = &hpp_io_block_output;
	ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;

	/* Check if the memory_enable flag is set in the option register. */
	if (mem_start) {
		ei_status.block_input = &hpp_mem_block_input;
		ei_status.block_output = &hpp_mem_block_output;
		ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
		dev->mem_start = mem_start;
		ei_status.mem = ioremap(mem_start,
					(HP_STOP_PG - HP_START_PG)*256);
		if (!ei_status.mem) {
			retval = -ENOMEM;
			goto out;
		}
		ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
		dev->mem_end = ei_status.rmem_end
			= dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
	}

	outw(Perf_Page, ioaddr + HP_PAGING);
	NS8390p_init(dev, 0);
	/* Leave the 8390 and HP chip reset. */
	outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);

	retval = register_netdev(dev);
	if (retval)
		goto out1;
	return 0;
out1:
	iounmap(ei_status.mem);
out:
	release_region(ioaddr, HP_IO_EXTENT);
	return retval;
}

static int
hpp_open(struct net_device *dev)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	int option_reg;
	int retval;

	if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
	    return retval;
	}

	/* Reset the 8390 and HP chip. */
	option_reg = inw(ioaddr + HPP_OPTION);
	outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
	udelay(5);
	/* Unreset the board and enable interrupts. */
	outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);

	/* Set the wrap registers for programmed-I/O operation.   */
	outw(HW_Page, ioaddr + HP_PAGING);
	outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);

	/* Select the operational page. */
	outw(Perf_Page, ioaddr + HP_PAGING);

	return eip_open(dev);
}

static int
hpp_close(struct net_device *dev)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	int option_reg = inw(ioaddr + HPP_OPTION);

	free_irq(dev->irq, dev);
	eip_close(dev);
	outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset,
		 ioaddr + HPP_OPTION);

	return 0;
}

static void
hpp_reset_8390(struct net_device *dev)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	int option_reg = inw(ioaddr + HPP_OPTION);

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

	outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
	/* Pause a few cycles for the hardware reset to take place. */
	udelay(5);
	ei_status.txing = 0;
	outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);

	udelay(5);


	if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
		printk("%s: hp_reset_8390() did not complete.\n", dev->name);

	if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
}

/* The programmed-I/O version of reading the 4 byte 8390 specific header.
   Note that transfer with the EtherTwist+ must be on word boundaries. */

static void
hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;

	outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
	insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
}

/* Block input and output, similar to the Crynwr packet driver. */

static void
hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	char *buf = skb->data;

	outw(ring_offset, ioaddr + HPP_IN_ADDR);
	insw(ioaddr + HP_DATAPORT, buf, count>>1);
	if (count & 0x01)
        buf[count-1] = inw(ioaddr + HP_DATAPORT);
}

/* The corresponding shared memory versions of the above 2 functions. */

static void
hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	int option_reg = inw(ioaddr + HPP_OPTION);

	outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
	memcpy_fromio(hdr, ei_status.mem, sizeof(struct e8390_pkt_hdr));
	outw(option_reg, ioaddr + HPP_OPTION);
	hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3;	/* Round up allocation. */
}

static void
hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	int option_reg = inw(ioaddr + HPP_OPTION);

	outw(ring_offset, ioaddr + HPP_IN_ADDR);

	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);

	/* Caution: this relies on get_8390_hdr() rounding up count!
	   Also note that we *can't* use eth_io_copy_and_sum() because
	   it will not always copy "count" bytes (e.g. padded IP).  */

	memcpy_fromio(skb->data, ei_status.mem, count);
	outw(option_reg, ioaddr + HPP_OPTION);
}

/* A special note: we *must* always transfer >=16 bit words.
   It's always safe to round up, so we do. */
static void
hpp_io_block_output(struct net_device *dev, int count,
					const unsigned char *buf, int start_page)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
	outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
}

static void
hpp_mem_block_output(struct net_device *dev, int count,
				const unsigned char *buf, int start_page)
{
	int ioaddr = dev->base_addr - NIC_OFFSET;
	int option_reg = inw(ioaddr + HPP_OPTION);

	outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
	memcpy_toio(ei_status.mem, buf, (count + 3) & ~3);
	outw(option_reg, ioaddr + HPP_OPTION);
}


#ifdef MODULE
#define MAX_HPP_CARDS	4	/* Max number of HPP cards per module */
static struct net_device *dev_hpp[MAX_HPP_CARDS];
static int io[MAX_HPP_CARDS];
static int irq[MAX_HPP_CARDS];

module_param_array(io, int, NULL, 0);
module_param_array(irq, int, NULL, 0);
MODULE_PARM_DESC(io, "I/O port address(es)");
MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
MODULE_LICENSE("GPL");

/* This is set up so that only a single autoprobe takes place per call.
ISA device autoprobes on a running machine are not recommended. */
int __init
init_module(void)
{
	struct net_device *dev;
	int this_dev, found = 0;

	for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
		if (io[this_dev] == 0)  {
			if (this_dev != 0) break; /* only autoprobe 1st one */
			printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
		}
		dev = alloc_eip_netdev();
		if (!dev)
			break;
		dev->irq = irq[this_dev];
		dev->base_addr = io[this_dev];
		if (do_hpp_probe(dev) == 0) {
			dev_hpp[found++] = dev;
			continue;
		}
		free_netdev(dev);
		printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
		break;
	}
	if (found)
		return 0;
	return -ENXIO;
}

static void cleanup_card(struct net_device *dev)
{
	/* NB: hpp_close() handles free_irq */
	iounmap(ei_status.mem);
	release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
}

void __exit
cleanup_module(void)
{
	int this_dev;

	for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
		struct net_device *dev = dev_hpp[this_dev];
		if (dev) {
			unregister_netdev(dev);
			cleanup_card(dev);
			free_netdev(dev);
		}
	}
}
#endif /* MODULE */
Commit	Line	Data
1da177e4 LT	1	/* hp-plus.c: A HP PCLAN/plus ethernet driver for linux. */
	2	/*
	3	Written 1994 by Donald Becker.
	4
	5	This driver is for the Hewlett Packard PC LAN (27***) plus ethercards.
	6	These cards are sold under several model numbers, usually 2724*.
	7
	8	This software may be used and distributed according to the terms
	9	of the GNU General Public License, incorporated herein by reference.
	10
	11	The author may be reached as becker@scyld.com, or C/O
	12	Scyld Computing Corporation
	13	410 Severn Ave., Suite 210
	14	Annapolis MD 21403
	15
	16	As is often the case, a great deal of credit is owed to Russ Nelson.
	17	The Crynwr packet driver was my primary source of HP-specific
	18	programming information.
	19	*/
	20
	21	static const char version[] =
	22	"hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
	23
	24	#include <linux/module.h>
	25
	26	#include <linux/string.h> /* Important -- this inlines word moves. */
	27	#include <linux/kernel.h>
	28	#include <linux/errno.h>
	29	#include <linux/ioport.h>
	30	#include <linux/netdevice.h>
	31	#include <linux/etherdevice.h>
	32	#include <linux/init.h>
a6b7a407	33	#include <linux/interrupt.h>
1da177e4 LT	34	#include <linux/delay.h>
	35
	36	#include <asm/system.h>
	37	#include <asm/io.h>
	38
	39	#include "8390.h"
	40
	41	#define DRV_NAME "hp-plus"
	42
	43	/* A zero-terminated list of I/O addresses to be probed. */
	44	static unsigned int hpplus_portlist[] __initdata =
	45	{0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0};
	46
	47	/*
	48	The HP EtherTwist chip implementation is a fairly routine DP8390
	49	implementation. It allows both shared memory and programmed-I/O buffer
	50	access, using a custom interface for both. The programmed-I/O mode is
	51	entirely implemented in the HP EtherTwist chip, bypassing the problem
	52	ridden built-in 8390 facilities used on NE2000 designs. The shared
	53	memory mode is likewise special, with an offset register used to make
	54	packets appear at the shared memory base. Both modes use a base and bounds
	55	page register to hide the Rx ring buffer wrap -- a packet that spans the
	56	end of physical buffer memory appears continuous to the driver. (c.f. the
	57	3c503 and Cabletron E2100)
	58
	59	A special note: the internal buffer of the board is only 8 bits wide.
	60	This lays several nasty traps for the unaware:
	61	- the 8390 must be programmed for byte-wide operations
	62	- all I/O and memory operations must work on whole words (the access
	63	latches are serially preloaded and have no byte-swapping ability).
	64
	65	This board is laid out in I/O space much like the earlier HP boards:
	66	the first 16 locations are for the board registers, and the second 16 are
	67	for the 8390. The board is easy to identify, with both a dedicated 16 bit
	68	ID register and a constant 0x530* value in the upper bits of the paging
	69	register.
	70	*/
	71
	72	#define HP_ID 0x00 /* ID register, always 0x4850. */
	73	#define HP_PAGING 0x02 /* Registers visible @ 8-f, see PageName. */
	74	#define HPP_OPTION 0x04 /* Bitmapped options, see HP_Option. */
	75	#define HPP_OUT_ADDR 0x08 /* I/O output location in Perf_Page. */
	76	#define HPP_IN_ADDR 0x0A /* I/O input location in Perf_Page. */
	77	#define HP_DATAPORT 0x0c /* I/O data transfer in Perf_Page. */
	78	#define NIC_OFFSET 0x10 /* Offset to the 8390 registers. */
	79	#define HP_IO_EXTENT 32
	80
	81	#define HP_START_PG 0x00 /* First page of TX buffer */
	82	#define HP_STOP_PG 0x80 /* Last page +1 of RX ring */
	83
	84	/* The register set selected in HP_PAGING. */
	85	enum PageName {
	86	Perf_Page = 0, /* Normal operation. */
	87	MAC_Page = 1, /* The ethernet address (+checksum). */
	88	HW_Page = 2, /* EEPROM-loaded hardware parameters. */
	89	LAN_Page = 4, /* Transceiver selection, testing, etc. */
	90	ID_Page = 6 };
	91
	92	/* The bit definitions for the HPP_OPTION register. */
	93	enum HP_Option {
	94	NICReset = 1, ChipReset = 2, /* Active low, really UNreset. */
	95	EnableIRQ = 4, FakeIntr = 8, BootROMEnb = 0x10, IOEnb = 0x20,
	96	MemEnable = 0x40, ZeroWait = 0x80, MemDisable = 0x1000, };
	97
98	static int hpp_probe1(struct net_device *dev, int ioaddr);
99
100	static void hpp_reset_8390(struct net_device *dev);
101	static int hpp_open(struct net_device *dev);
102	static int hpp_close(struct net_device *dev);
103	static void hpp_mem_block_input(struct net_device *dev, int count,
104	struct sk_buff *skb, int ring_offset);
105	static void hpp_mem_block_output(struct net_device *dev, int count,
106	const unsigned char *buf, int start_page);
107	static void hpp_mem_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr,
108	int ring_page);
109	static void hpp_io_block_input(struct net_device *dev, int count,
110	struct sk_buff *skb, int ring_offset);
111	static void hpp_io_block_output(struct net_device *dev, int count,
112	const unsigned char *buf, int start_page);
113	static void hpp_io_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr,
114	int ring_page);
115
6aa20a22	116
1da177e4 LT	117	/* Probe a list of addresses for an HP LAN+ adaptor.
	118	This routine is almost boilerplate. */
	119
	120	static int __init do_hpp_probe(struct net_device *dev)
	121	{
	122	int i;
	123	int base_addr = dev->base_addr;
	124	int irq = dev->irq;
	125
1da177e4 LT	126	if (base_addr > 0x1ff) /* Check a single specified location. */
	127	return hpp_probe1(dev, base_addr);
	128	else if (base_addr != 0) /* Don't probe at all. */
	129	return -ENXIO;
	130
	131	for (i = 0; hpplus_portlist[i]; i++) {
	132	if (hpp_probe1(dev, hpplus_portlist[i]) == 0)
	133	return 0;
	134	dev->irq = irq;
	135	}
	136
	137	return -ENODEV;
	138	}
	139
1da177e4 LT	140	#ifndef MODULE
	141	struct net_device * __init hp_plus_probe(int unit)
	142	{
49f276be	143	struct net_device *dev = alloc_eip_netdev();
1da177e4 LT	144	int err;
	145
	146	if (!dev)
	147	return ERR_PTR(-ENOMEM);
	148
	149	sprintf(dev->name, "eth%d", unit);
	150	netdev_boot_setup_check(dev);
	151
	152	err = do_hpp_probe(dev);
	153	if (err)
	154	goto out;
1da177e4	155	return dev;
1da177e4 LT	156	out:
	157	free_netdev(dev);
	158	return ERR_PTR(err);
	159	}
	160	#endif
	161
d4a97d42 SH	162	static const struct net_device_ops hpp_netdev_ops = {
	163	.ndo_open = hpp_open,
	164	.ndo_stop = hpp_close,
5b9ab2ec DM	165	.ndo_start_xmit = eip_start_xmit,
	166	.ndo_tx_timeout = eip_tx_timeout,
	167	.ndo_get_stats = eip_get_stats,
	168	.ndo_set_multicast_list = eip_set_multicast_list,
d4a97d42	169	.ndo_validate_addr = eth_validate_addr,
fe96aaa1	170	.ndo_set_mac_address = eth_mac_addr,
d4a97d42 SH	171	.ndo_change_mtu = eth_change_mtu,
d4a97d42 SH	172	#ifdef CONFIG_NET_POLL_CONTROLLER
5b9ab2ec	173	.ndo_poll_controller = eip_poll,
d4a97d42 SH	174	#endif
	175	};
	176
	177
1da177e4 LT	178	/* Do the interesting part of the probe at a single address. */
	179	static int __init hpp_probe1(struct net_device *dev, int ioaddr)
	180	{
	181	int i, retval;
	182	unsigned char checksum = 0;
	183	const char name[] = "HP-PC-LAN+";
	184	int mem_start;
	185	static unsigned version_printed;
	186
	187	if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME))
	188	return -EBUSY;
	189
	190	/* Check for the HP+ signature, 50 48 0x 53. */
8e95a202 JP	191	if (inw(ioaddr + HP_ID) != 0x4850 \|\|
8e95a202 JP	192	(inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
1da177e4 LT	193	retval = -ENODEV;
	194	goto out;
	195	}
	196
	197	if (ei_debug && version_printed++ == 0)
	198	printk(version);
	199
0795af57	200	printk("%s: %s at %#3x, ", dev->name, name, ioaddr);
1da177e4 LT	201
	202	/* Retrieve and checksum the station address. */
	203	outw(MAC_Page, ioaddr + HP_PAGING);
	204
	205	for(i = 0; i < ETHER_ADDR_LEN; i++) {
	206	unsigned char inval = inb(ioaddr + 8 + i);
	207	dev->dev_addr[i] = inval;
	208	checksum += inval;
1da177e4 LT	209	}
	210	checksum += inb(ioaddr + 14);
	211
e174961c	212	printk("%pM", dev->dev_addr);
0795af57	213
1da177e4 LT	214	if (checksum != 0xff) {
	215	printk(" bad checksum %2.2x.\n", checksum);
	216	retval = -ENODEV;
	217	goto out;
	218	} else {
	219	/* Point at the Software Configuration Flags. */
	220	outw(ID_Page, ioaddr + HP_PAGING);
	221	printk(" ID %4.4x", inw(ioaddr + 12));
	222	}
	223
	224	/* Read the IRQ line. */
	225	outw(HW_Page, ioaddr + HP_PAGING);
	226	{
	227	int irq = inb(ioaddr + 13) & 0x0f;
	228	int option = inw(ioaddr + HPP_OPTION);
	229
	230	dev->irq = irq;
	231	if (option & MemEnable) {
	232	mem_start = inw(ioaddr + 9) << 8;
	233	printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
	234	} else {
	235	mem_start = 0;
	236	printk(", IRQ %d, programmed-I/O mode.\n", irq);
	237	}
	238	}
	239
	240	/* Set the wrap registers for string I/O reads. */
	241	outw((HP_START_PG + TX_PAGES/2) \| ((HP_STOP_PG - 1) << 8), ioaddr + 14);
	242
	243	/* Set the base address to point to the NIC, not the "real" base! */
	244	dev->base_addr = ioaddr + NIC_OFFSET;
	245
d4a97d42	246	dev->netdev_ops = &hpp_netdev_ops;
1da177e4 LT	247
	248	ei_status.name = name;
	249	ei_status.word16 = 0; /* Agggghhhhh! Debug time: 2 days! */
	250	ei_status.tx_start_page = HP_START_PG;
	251	ei_status.rx_start_page = HP_START_PG + TX_PAGES/2;
	252	ei_status.stop_page = HP_STOP_PG;
	253
	254	ei_status.reset_8390 = &hpp_reset_8390;
	255	ei_status.block_input = &hpp_io_block_input;
	256	ei_status.block_output = &hpp_io_block_output;
	257	ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
	258
	259	/* Check if the memory_enable flag is set in the option register. */
	260	if (mem_start) {
	261	ei_status.block_input = &hpp_mem_block_input;
	262	ei_status.block_output = &hpp_mem_block_output;
	263	ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
	264	dev->mem_start = mem_start;
b336cea3 AV	265	ei_status.mem = ioremap(mem_start,
	266	(HP_STOP_PG - HP_START_PG)*256);
	267	if (!ei_status.mem) {
	268	retval = -ENOMEM;
	269	goto out;
	270	}
1da177e4 LT	271	ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
	272	dev->mem_end = ei_status.rmem_end
	273	= dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
	274	}
	275
	276	outw(Perf_Page, ioaddr + HP_PAGING);
f0084a36	277	NS8390p_init(dev, 0);
1da177e4 LT	278	/* Leave the 8390 and HP chip reset. */
	279	outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
	280
b1fc5505	281	retval = register_netdev(dev);
b1fc5505	282	if (retval)
b336cea3	283	goto out1;
1da177e4	284	return 0;
b336cea3 AV	285	out1:
b336cea3 AV	286	iounmap(ei_status.mem);
1da177e4 LT	287	out:
	288	release_region(ioaddr, HP_IO_EXTENT);
	289	return retval;
	290	}
	291
	292	static int
	293	hpp_open(struct net_device *dev)
	294	{
	295	int ioaddr = dev->base_addr - NIC_OFFSET;
	296	int option_reg;
	297	int retval;
	298
49f276be	299	if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
1da177e4 LT	300	return retval;
	301	}
	302
	303	/* Reset the 8390 and HP chip. */
	304	option_reg = inw(ioaddr + HPP_OPTION);
	305	outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
	306	udelay(5);
	307	/* Unreset the board and enable interrupts. */
	308	outw(option_reg \| (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
	309
	310	/* Set the wrap registers for programmed-I/O operation. */
	311	outw(HW_Page, ioaddr + HP_PAGING);
	312	outw((HP_START_PG + TX_PAGES/2) \| ((HP_STOP_PG - 1) << 8), ioaddr + 14);
	313
	314	/* Select the operational page. */
	315	outw(Perf_Page, ioaddr + HP_PAGING);
	316
d4a97d42	317	return eip_open(dev);
1da177e4 LT	318	}
	319
	320	static int
	321	hpp_close(struct net_device *dev)
	322	{
	323	int ioaddr = dev->base_addr - NIC_OFFSET;
	324	int option_reg = inw(ioaddr + HPP_OPTION);
	325
	326	free_irq(dev->irq, dev);
49f276be	327	eip_close(dev);
1da177e4 LT	328	outw((option_reg & ~EnableIRQ) \| MemDisable \| NICReset \| ChipReset,
	329	ioaddr + HPP_OPTION);
	330
	331	return 0;
	332	}
	333
	334	static void
	335	hpp_reset_8390(struct net_device *dev)
	336	{
	337	int ioaddr = dev->base_addr - NIC_OFFSET;
	338	int option_reg = inw(ioaddr + HPP_OPTION);
	339
	340	if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies);
	341
	342	outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
	343	/* Pause a few cycles for the hardware reset to take place. */
	344	udelay(5);
	345	ei_status.txing = 0;
	346	outw(option_reg \| (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
	347
	348	udelay(5);
	349
	350
	351	if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
	352	printk("%s: hp_reset_8390() did not complete.\n", dev->name);
	353
	354	if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
1da177e4 LT	355	}
	356
	357	/* The programmed-I/O version of reading the 4 byte 8390 specific header.
	358	Note that transfer with the EtherTwist+ must be on word boundaries. */
	359
	360	static void
	361	hpp_io_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	362	{
	363	int ioaddr = dev->base_addr - NIC_OFFSET;
	364
	365	outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
	366	insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
	367	}
	368
	369	/* Block input and output, similar to the Crynwr packet driver. */
	370
	371	static void
	372	hpp_io_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	373	{
	374	int ioaddr = dev->base_addr - NIC_OFFSET;
	375	char *buf = skb->data;
	376
	377	outw(ring_offset, ioaddr + HPP_IN_ADDR);
	378	insw(ioaddr + HP_DATAPORT, buf, count>>1);
	379	if (count & 0x01)
	380	buf[count-1] = inw(ioaddr + HP_DATAPORT);
	381	}
	382
	383	/* The corresponding shared memory versions of the above 2 functions. */
	384
	385	static void
	386	hpp_mem_get_8390_hdr(struct net_device dev, struct e8390_pkt_hdr hdr, int ring_page)
	387	{
	388	int ioaddr = dev->base_addr - NIC_OFFSET;
	389	int option_reg = inw(ioaddr + HPP_OPTION);
	390
	391	outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
	392	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
b336cea3	393	memcpy_fromio(hdr, ei_status.mem, sizeof(struct e8390_pkt_hdr));
1da177e4 LT	394	outw(option_reg, ioaddr + HPP_OPTION);
	395	hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3; /* Round up allocation. */
	396	}
	397
	398	static void
	399	hpp_mem_block_input(struct net_device dev, int count, struct sk_buff skb, int ring_offset)
	400	{
	401	int ioaddr = dev->base_addr - NIC_OFFSET;
	402	int option_reg = inw(ioaddr + HPP_OPTION);
	403
	404	outw(ring_offset, ioaddr + HPP_IN_ADDR);
	405
	406	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
	407
	408	/* Caution: this relies on get_8390_hdr() rounding up count!
	409	Also note that we can't use eth_io_copy_and_sum() because
	410	it will not always copy "count" bytes (e.g. padded IP). */
	411
b336cea3	412	memcpy_fromio(skb->data, ei_status.mem, count);
1da177e4 LT	413	outw(option_reg, ioaddr + HPP_OPTION);
	414	}
	415
	416	/* A special note: we must always transfer >=16 bit words.
	417	It's always safe to round up, so we do. */
	418	static void
	419	hpp_io_block_output(struct net_device *dev, int count,
	420	const unsigned char *buf, int start_page)
	421	{
	422	int ioaddr = dev->base_addr - NIC_OFFSET;
	423	outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
	424	outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
1da177e4 LT	425	}
	426
	427	static void
	428	hpp_mem_block_output(struct net_device *dev, int count,
	429	const unsigned char *buf, int start_page)
	430	{
	431	int ioaddr = dev->base_addr - NIC_OFFSET;
	432	int option_reg = inw(ioaddr + HPP_OPTION);
	433
	434	outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
	435	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
b336cea3	436	memcpy_toio(ei_status.mem, buf, (count + 3) & ~3);
1da177e4	437	outw(option_reg, ioaddr + HPP_OPTION);
1da177e4 LT	438	}
1da177e4 LT	439
6aa20a22	440
1da177e4 LT	441	#ifdef MODULE
	442	#define MAX_HPP_CARDS 4 /* Max number of HPP cards per module */
	443	static struct net_device *dev_hpp[MAX_HPP_CARDS];
	444	static int io[MAX_HPP_CARDS];
	445	static int irq[MAX_HPP_CARDS];
	446
	447	module_param_array(io, int, NULL, 0);
	448	module_param_array(irq, int, NULL, 0);
	449	MODULE_PARM_DESC(io, "I/O port address(es)");
	450	MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
	451	MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
	452	MODULE_LICENSE("GPL");
	453
	454	/* This is set up so that only a single autoprobe takes place per call.
	455	ISA device autoprobes on a running machine are not recommended. */
29f9f6d2	456	int __init
1da177e4 LT	457	init_module(void)
	458	{
	459	struct net_device *dev;
	460	int this_dev, found = 0;
	461
	462	for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
	463	if (io[this_dev] == 0) {
	464	if (this_dev != 0) break; /* only autoprobe 1st one */
	465	printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
	466	}
9b58027b	467	dev = alloc_eip_netdev();
1da177e4 LT	468	if (!dev)
	469	break;
	470	dev->irq = irq[this_dev];
	471	dev->base_addr = io[this_dev];
	472	if (do_hpp_probe(dev) == 0) {
b1fc5505	473	dev_hpp[found++] = dev;
b1fc5505	474	continue;
1da177e4 LT	475	}
	476	free_netdev(dev);
	477	printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
	478	break;
	479	}
	480	if (found)
	481	return 0;
	482	return -ENXIO;
	483	}
	484
64916f1e DV	485	static void cleanup_card(struct net_device *dev)
	486	{
	487	/* NB: hpp_close() handles free_irq */
b336cea3	488	iounmap(ei_status.mem);
64916f1e DV	489	release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
	490	}
	491
afc8eb46	492	void __exit
1da177e4 LT	493	cleanup_module(void)
	494	{
	495	int this_dev;
	496
	497	for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
	498	struct net_device *dev = dev_hpp[this_dev];
	499	if (dev) {
	500	unregister_netdev(dev);
	501	cleanup_card(dev);
	502	free_netdev(dev);
	503	}
	504	}
	505	}
	506	#endif /* MODULE */