[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 [email protected], 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 ([email protected])\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_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);
	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_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 [email protected], 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 ([email protected])\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	168	.ndo_validate_addr = eth_validate_addr,
fe96aaa1	169	.ndo_set_mac_address = eth_mac_addr,
d4a97d42 SH	170	.ndo_change_mtu = eth_change_mtu,
d4a97d42 SH	171	#ifdef CONFIG_NET_POLL_CONTROLLER
5b9ab2ec	172	.ndo_poll_controller = eip_poll,
d4a97d42 SH	173	#endif
	174	};
	175
	176
1da177e4 LT	177	/* Do the interesting part of the probe at a single address. */
	178	static int __init hpp_probe1(struct net_device *dev, int ioaddr)
	179	{
	180	int i, retval;
	181	unsigned char checksum = 0;
	182	const char name[] = "HP-PC-LAN+";
	183	int mem_start;
	184	static unsigned version_printed;
	185
	186	if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME))
	187	return -EBUSY;
	188
	189	/* Check for the HP+ signature, 50 48 0x 53. */
	190	if (inw(ioaddr + HP_ID) != 0x4850
	191	\|\| (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
	192	retval = -ENODEV;
	193	goto out;
	194	}
	195
	196	if (ei_debug && version_printed++ == 0)
	197	printk(version);
	198
0795af57	199	printk("%s: %s at %#3x, ", dev->name, name, ioaddr);
1da177e4 LT	200
	201	/* Retrieve and checksum the station address. */
	202	outw(MAC_Page, ioaddr + HP_PAGING);
	203
	204	for(i = 0; i < ETHER_ADDR_LEN; i++) {
	205	unsigned char inval = inb(ioaddr + 8 + i);
	206	dev->dev_addr[i] = inval;
	207	checksum += inval;
1da177e4 LT	208	}
	209	checksum += inb(ioaddr + 14);
	210
e174961c	211	printk("%pM", dev->dev_addr);
0795af57	212
1da177e4 LT	213	if (checksum != 0xff) {
	214	printk(" bad checksum %2.2x.\n", checksum);
	215	retval = -ENODEV;
	216	goto out;
	217	} else {
	218	/* Point at the Software Configuration Flags. */
	219	outw(ID_Page, ioaddr + HP_PAGING);
	220	printk(" ID %4.4x", inw(ioaddr + 12));
	221	}
	222
	223	/* Read the IRQ line. */
	224	outw(HW_Page, ioaddr + HP_PAGING);
	225	{
	226	int irq = inb(ioaddr + 13) & 0x0f;
	227	int option = inw(ioaddr + HPP_OPTION);
	228
	229	dev->irq = irq;
	230	if (option & MemEnable) {
	231	mem_start = inw(ioaddr + 9) << 8;
	232	printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
	233	} else {
	234	mem_start = 0;
	235	printk(", IRQ %d, programmed-I/O mode.\n", irq);
	236	}
	237	}
	238
	239	/* Set the wrap registers for string I/O reads. */
	240	outw((HP_START_PG + TX_PAGES/2) \| ((HP_STOP_PG - 1) << 8), ioaddr + 14);
	241
	242	/* Set the base address to point to the NIC, not the "real" base! */
	243	dev->base_addr = ioaddr + NIC_OFFSET;
	244
d4a97d42	245	dev->netdev_ops = &hpp_netdev_ops;
1da177e4 LT	246
	247	ei_status.name = name;
	248	ei_status.word16 = 0; /* Agggghhhhh! Debug time: 2 days! */
	249	ei_status.tx_start_page = HP_START_PG;
	250	ei_status.rx_start_page = HP_START_PG + TX_PAGES/2;
	251	ei_status.stop_page = HP_STOP_PG;
	252
	253	ei_status.reset_8390 = &hpp_reset_8390;
	254	ei_status.block_input = &hpp_io_block_input;
	255	ei_status.block_output = &hpp_io_block_output;
	256	ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
	257
	258	/* Check if the memory_enable flag is set in the option register. */
	259	if (mem_start) {
	260	ei_status.block_input = &hpp_mem_block_input;
	261	ei_status.block_output = &hpp_mem_block_output;
	262	ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
	263	dev->mem_start = mem_start;
b336cea3 AV	264	ei_status.mem = ioremap(mem_start,
	265	(HP_STOP_PG - HP_START_PG)*256);
	266	if (!ei_status.mem) {
	267	retval = -ENOMEM;
	268	goto out;
	269	}
1da177e4 LT	270	ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
	271	dev->mem_end = ei_status.rmem_end
	272	= dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
	273	}
	274
	275	outw(Perf_Page, ioaddr + HP_PAGING);
f0084a36	276	NS8390p_init(dev, 0);
1da177e4 LT	277	/* Leave the 8390 and HP chip reset. */
	278	outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
	279
b1fc5505 HX	280	retval = register_netdev(dev);
b1fc5505 HX	281	if (retval)
b336cea3	282	goto out1;
1da177e4	283	return 0;
b336cea3 AV	284	out1:
b336cea3 AV	285	iounmap(ei_status.mem);
1da177e4 LT	286	out:
	287	release_region(ioaddr, HP_IO_EXTENT);
	288	return retval;
	289	}
	290
	291	static int
	292	hpp_open(struct net_device *dev)
	293	{
	294	int ioaddr = dev->base_addr - NIC_OFFSET;
	295	int option_reg;
	296	int retval;
	297
49f276be	298	if ((retval = request_irq(dev->irq, eip_interrupt, 0, dev->name, dev))) {
1da177e4 LT	299	return retval;
	300	}
	301
	302	/* Reset the 8390 and HP chip. */
	303	option_reg = inw(ioaddr + HPP_OPTION);
	304	outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
	305	udelay(5);
	306	/* Unreset the board and enable interrupts. */
	307	outw(option_reg \| (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
	308
	309	/* Set the wrap registers for programmed-I/O operation. */
	310	outw(HW_Page, ioaddr + HP_PAGING);
	311	outw((HP_START_PG + TX_PAGES/2) \| ((HP_STOP_PG - 1) << 8), ioaddr + 14);
	312
	313	/* Select the operational page. */
	314	outw(Perf_Page, ioaddr + HP_PAGING);
	315
d4a97d42	316	return eip_open(dev);
1da177e4 LT	317	}
	318
	319	static int
	320	hpp_close(struct net_device *dev)
	321	{
	322	int ioaddr = dev->base_addr - NIC_OFFSET;
	323	int option_reg = inw(ioaddr + HPP_OPTION);
	324
	325	free_irq(dev->irq, dev);
49f276be	326	eip_close(dev);
1da177e4 LT	327	outw((option_reg & ~EnableIRQ) \| MemDisable \| NICReset \| ChipReset,
	328	ioaddr + HPP_OPTION);
	329
	330	return 0;
	331	}
	332
	333	static void
	334	hpp_reset_8390(struct net_device *dev)
	335	{
	336	int ioaddr = dev->base_addr - NIC_OFFSET;
	337	int option_reg = inw(ioaddr + HPP_OPTION);
	338
	339	if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies);
	340
	341	outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
	342	/* Pause a few cycles for the hardware reset to take place. */
	343	udelay(5);
	344	ei_status.txing = 0;
	345	outw(option_reg \| (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
	346
	347	udelay(5);
	348
	349
	350	if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
	351	printk("%s: hp_reset_8390() did not complete.\n", dev->name);
	352
	353	if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
	354	return;
	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);
	425	return;
	426	}
	427
	428	static void
	429	hpp_mem_block_output(struct net_device *dev, int count,
	430	const unsigned char *buf, int start_page)
	431	{
	432	int ioaddr = dev->base_addr - NIC_OFFSET;
	433	int option_reg = inw(ioaddr + HPP_OPTION);
	434
	435	outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
	436	outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
b336cea3	437	memcpy_toio(ei_status.mem, buf, (count + 3) & ~3);
1da177e4 LT	438	outw(option_reg, ioaddr + HPP_OPTION);
	439
	440	return;
	441	}
	442
6aa20a22	443
1da177e4 LT	444	#ifdef MODULE
	445	#define MAX_HPP_CARDS 4 /* Max number of HPP cards per module */
	446	static struct net_device *dev_hpp[MAX_HPP_CARDS];
	447	static int io[MAX_HPP_CARDS];
	448	static int irq[MAX_HPP_CARDS];
	449
	450	module_param_array(io, int, NULL, 0);
	451	module_param_array(irq, int, NULL, 0);
	452	MODULE_PARM_DESC(io, "I/O port address(es)");
	453	MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
	454	MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
	455	MODULE_LICENSE("GPL");
	456
	457	/* This is set up so that only a single autoprobe takes place per call.
	458	ISA device autoprobes on a running machine are not recommended. */
29f9f6d2	459	int __init
1da177e4 LT	460	init_module(void)
	461	{
	462	struct net_device *dev;
	463	int this_dev, found = 0;
	464
	465	for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
	466	if (io[this_dev] == 0) {
	467	if (this_dev != 0) break; /* only autoprobe 1st one */
	468	printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
	469	}
9b58027b	470	dev = alloc_eip_netdev();
1da177e4 LT	471	if (!dev)
	472	break;
	473	dev->irq = irq[this_dev];
	474	dev->base_addr = io[this_dev];
	475	if (do_hpp_probe(dev) == 0) {
b1fc5505 HX	476	dev_hpp[found++] = dev;
b1fc5505 HX	477	continue;
1da177e4 LT	478	}
	479	free_netdev(dev);
	480	printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
	481	break;
	482	}
	483	if (found)
	484	return 0;
	485	return -ENXIO;
	486	}
	487
64916f1e DV	488	static void cleanup_card(struct net_device *dev)
	489	{
	490	/* NB: hpp_close() handles free_irq */
b336cea3	491	iounmap(ei_status.mem);
64916f1e DV	492	release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
	493	}
	494
afc8eb46	495	void __exit
1da177e4 LT	496	cleanup_module(void)
	497	{
	498	int this_dev;
	499
	500	for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
	501	struct net_device *dev = dev_hpp[this_dev];
	502	if (dev) {
	503	unregister_netdev(dev);
	504	cleanup_card(dev);
	505	free_netdev(dev);
	506	}
	507	}
	508	}
	509	#endif /* MODULE */