[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/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_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);
	return;
}

/* 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);
	return;
}

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);

	return;
}


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