More meth updates.
[linux-2.6/linux-mips.git] / drivers / net / hp-plus.c
blob8533f8a825951dd178ccc66fffdc926224ef75e5
1 /* hp-plus.c: A HP PCLAN/plus ethernet driver for linux. */
2 /*
3 Written 1994 by Donald Becker.
5 This driver is for the Hewlett Packard PC LAN (27***) plus ethercards.
6 These cards are sold under several model numbers, usually 2724*.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
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
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.
21 static const char version[] =
22 "hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
24 #include <linux/module.h>
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>
35 #include <asm/system.h>
36 #include <asm/io.h>
38 #include "8390.h"
40 /* A zero-terminated list of I/O addresses to be probed. */
41 static unsigned int hpplus_portlist[] __initdata =
42 {0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0};
45 The HP EtherTwist chip implementation is a fairly routine DP8390
46 implementation. It allows both shared memory and programmed-I/O buffer
47 access, using a custom interface for both. The programmed-I/O mode is
48 entirely implemented in the HP EtherTwist chip, bypassing the problem
49 ridden built-in 8390 facilities used on NE2000 designs. The shared
50 memory mode is likewise special, with an offset register used to make
51 packets appear at the shared memory base. Both modes use a base and bounds
52 page register to hide the Rx ring buffer wrap -- a packet that spans the
53 end of physical buffer memory appears continuous to the driver. (c.f. the
54 3c503 and Cabletron E2100)
56 A special note: the internal buffer of the board is only 8 bits wide.
57 This lays several nasty traps for the unaware:
58 - the 8390 must be programmed for byte-wide operations
59 - all I/O and memory operations must work on whole words (the access
60 latches are serially preloaded and have no byte-swapping ability).
62 This board is laid out in I/O space much like the earlier HP boards:
63 the first 16 locations are for the board registers, and the second 16 are
64 for the 8390. The board is easy to identify, with both a dedicated 16 bit
65 ID register and a constant 0x530* value in the upper bits of the paging
66 register.
69 #define HP_ID 0x00 /* ID register, always 0x4850. */
70 #define HP_PAGING 0x02 /* Registers visible @ 8-f, see PageName. */
71 #define HPP_OPTION 0x04 /* Bitmapped options, see HP_Option. */
72 #define HPP_OUT_ADDR 0x08 /* I/O output location in Perf_Page. */
73 #define HPP_IN_ADDR 0x0A /* I/O input location in Perf_Page. */
74 #define HP_DATAPORT 0x0c /* I/O data transfer in Perf_Page. */
75 #define NIC_OFFSET 0x10 /* Offset to the 8390 registers. */
76 #define HP_IO_EXTENT 32
78 #define HP_START_PG 0x00 /* First page of TX buffer */
79 #define HP_STOP_PG 0x80 /* Last page +1 of RX ring */
81 /* The register set selected in HP_PAGING. */
82 enum PageName {
83 Perf_Page = 0, /* Normal operation. */
84 MAC_Page = 1, /* The ethernet address (+checksum). */
85 HW_Page = 2, /* EEPROM-loaded hardware parameters. */
86 LAN_Page = 4, /* Transceiver selection, testing, etc. */
87 ID_Page = 6 };
89 /* The bit definitions for the HPP_OPTION register. */
90 enum HP_Option {
91 NICReset = 1, ChipReset = 2, /* Active low, really UNreset. */
92 EnableIRQ = 4, FakeIntr = 8, BootROMEnb = 0x10, IOEnb = 0x20,
93 MemEnable = 0x40, ZeroWait = 0x80, MemDisable = 0x1000, };
95 int hp_plus_probe(struct net_device *dev);
96 static int hpp_probe1(struct net_device *dev, int ioaddr);
98 static void hpp_reset_8390(struct net_device *dev);
99 static int hpp_open(struct net_device *dev);
100 static int hpp_close(struct net_device *dev);
101 static void hpp_mem_block_input(struct net_device *dev, int count,
102 struct sk_buff *skb, int ring_offset);
103 static void hpp_mem_block_output(struct net_device *dev, int count,
104 const unsigned char *buf, int start_page);
105 static void hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
106 int ring_page);
107 static void hpp_io_block_input(struct net_device *dev, int count,
108 struct sk_buff *skb, int ring_offset);
109 static void hpp_io_block_output(struct net_device *dev, int count,
110 const unsigned char *buf, int start_page);
111 static void hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
112 int ring_page);
115 /* Probe a list of addresses for an HP LAN+ adaptor.
116 This routine is almost boilerplate. */
118 int __init hp_plus_probe(struct net_device *dev)
120 int i;
121 int base_addr = dev->base_addr;
123 SET_MODULE_OWNER(dev);
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;
130 for (i = 0; hpplus_portlist[i]; i++)
131 if (hpp_probe1(dev, hpplus_portlist[i]) == 0)
132 return 0;
134 return -ENODEV;
137 /* Do the interesting part of the probe at a single address. */
138 static int __init hpp_probe1(struct net_device *dev, int ioaddr)
140 int i, retval;
141 unsigned char checksum = 0;
142 const char name[] = "HP-PC-LAN+";
143 int mem_start;
144 static unsigned version_printed;
146 if (!request_region(ioaddr, HP_IO_EXTENT, dev->name))
147 return -EBUSY;
149 /* Check for the HP+ signature, 50 48 0x 53. */
150 if (inw(ioaddr + HP_ID) != 0x4850
151 || (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
152 retval = -ENODEV;
153 goto out;
156 if (ei_debug && version_printed++ == 0)
157 printk(version);
159 printk("%s: %s at %#3x,", dev->name, name, ioaddr);
161 /* Retrieve and checksum the station address. */
162 outw(MAC_Page, ioaddr + HP_PAGING);
164 for(i = 0; i < ETHER_ADDR_LEN; i++) {
165 unsigned char inval = inb(ioaddr + 8 + i);
166 dev->dev_addr[i] = inval;
167 checksum += inval;
168 printk(" %2.2x", inval);
170 checksum += inb(ioaddr + 14);
172 if (checksum != 0xff) {
173 printk(" bad checksum %2.2x.\n", checksum);
174 retval = -ENODEV;
175 goto out;
176 } else {
177 /* Point at the Software Configuration Flags. */
178 outw(ID_Page, ioaddr + HP_PAGING);
179 printk(" ID %4.4x", inw(ioaddr + 12));
182 /* Allocate dev->priv and fill in 8390 specific dev fields. */
183 if (ethdev_init(dev)) {
184 printk ("hp-plus.c: unable to allocate memory for dev->priv.\n");
185 retval = -ENOMEM;
186 goto out;
189 /* Read the IRQ line. */
190 outw(HW_Page, ioaddr + HP_PAGING);
192 int irq = inb(ioaddr + 13) & 0x0f;
193 int option = inw(ioaddr + HPP_OPTION);
195 dev->irq = irq;
196 if (option & MemEnable) {
197 mem_start = inw(ioaddr + 9) << 8;
198 printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
199 } else {
200 mem_start = 0;
201 printk(", IRQ %d, programmed-I/O mode.\n", irq);
205 /* Set the wrap registers for string I/O reads. */
206 outw((HP_START_PG + TX_2X_PAGES) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
208 /* Set the base address to point to the NIC, not the "real" base! */
209 dev->base_addr = ioaddr + NIC_OFFSET;
211 dev->open = &hpp_open;
212 dev->stop = &hpp_close;
214 ei_status.name = name;
215 ei_status.word16 = 0; /* Agggghhhhh! Debug time: 2 days! */
216 ei_status.tx_start_page = HP_START_PG;
217 ei_status.rx_start_page = HP_START_PG + TX_2X_PAGES;
218 ei_status.stop_page = HP_STOP_PG;
220 ei_status.reset_8390 = &hpp_reset_8390;
221 ei_status.block_input = &hpp_io_block_input;
222 ei_status.block_output = &hpp_io_block_output;
223 ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
225 /* Check if the memory_enable flag is set in the option register. */
226 if (mem_start) {
227 ei_status.block_input = &hpp_mem_block_input;
228 ei_status.block_output = &hpp_mem_block_output;
229 ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
230 dev->mem_start = mem_start;
231 ei_status.rmem_start = dev->mem_start + TX_2X_PAGES*256;
232 dev->mem_end = ei_status.rmem_end
233 = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
236 outw(Perf_Page, ioaddr + HP_PAGING);
237 NS8390_init(dev, 0);
238 /* Leave the 8390 and HP chip reset. */
239 outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
241 return 0;
242 out:
243 release_region(ioaddr, HP_IO_EXTENT);
244 return retval;
247 static int
248 hpp_open(struct net_device *dev)
250 int ioaddr = dev->base_addr - NIC_OFFSET;
251 int option_reg;
252 int retval;
254 if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
255 return retval;
258 /* Reset the 8390 and HP chip. */
259 option_reg = inw(ioaddr + HPP_OPTION);
260 outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
261 udelay(5);
262 /* Unreset the board and enable interrupts. */
263 outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
265 /* Set the wrap registers for programmed-I/O operation. */
266 outw(HW_Page, ioaddr + HP_PAGING);
267 outw((HP_START_PG + TX_2X_PAGES) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
269 /* Select the operational page. */
270 outw(Perf_Page, ioaddr + HP_PAGING);
272 ei_open(dev);
273 return 0;
276 static int
277 hpp_close(struct net_device *dev)
279 int ioaddr = dev->base_addr - NIC_OFFSET;
280 int option_reg = inw(ioaddr + HPP_OPTION);
282 free_irq(dev->irq, dev);
283 ei_close(dev);
284 outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset,
285 ioaddr + HPP_OPTION);
287 return 0;
290 static void
291 hpp_reset_8390(struct net_device *dev)
293 int ioaddr = dev->base_addr - NIC_OFFSET;
294 int option_reg = inw(ioaddr + HPP_OPTION);
296 if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies);
298 outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
299 /* Pause a few cycles for the hardware reset to take place. */
300 udelay(5);
301 ei_status.txing = 0;
302 outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
304 udelay(5);
307 if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
308 printk("%s: hp_reset_8390() did not complete.\n", dev->name);
310 if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
311 return;
314 /* The programmed-I/O version of reading the 4 byte 8390 specific header.
315 Note that transfer with the EtherTwist+ must be on word boundaries. */
317 static void
318 hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
320 int ioaddr = dev->base_addr - NIC_OFFSET;
322 outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
323 insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
326 /* Block input and output, similar to the Crynwr packet driver. */
328 static void
329 hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
331 int ioaddr = dev->base_addr - NIC_OFFSET;
332 char *buf = skb->data;
334 outw(ring_offset, ioaddr + HPP_IN_ADDR);
335 insw(ioaddr + HP_DATAPORT, buf, count>>1);
336 if (count & 0x01)
337 buf[count-1] = inw(ioaddr + HP_DATAPORT);
340 /* The corresponding shared memory versions of the above 2 functions. */
342 static void
343 hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
345 int ioaddr = dev->base_addr - NIC_OFFSET;
346 int option_reg = inw(ioaddr + HPP_OPTION);
348 outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
349 outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
350 isa_memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr));
351 outw(option_reg, ioaddr + HPP_OPTION);
352 hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3; /* Round up allocation. */
355 static void
356 hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
358 int ioaddr = dev->base_addr - NIC_OFFSET;
359 int option_reg = inw(ioaddr + HPP_OPTION);
361 outw(ring_offset, ioaddr + HPP_IN_ADDR);
363 outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
365 /* Caution: this relies on get_8390_hdr() rounding up count!
366 Also note that we *can't* use eth_io_copy_and_sum() because
367 it will not always copy "count" bytes (e.g. padded IP). */
369 isa_memcpy_fromio(skb->data, dev->mem_start, count);
370 outw(option_reg, ioaddr + HPP_OPTION);
373 /* A special note: we *must* always transfer >=16 bit words.
374 It's always safe to round up, so we do. */
375 static void
376 hpp_io_block_output(struct net_device *dev, int count,
377 const unsigned char *buf, int start_page)
379 int ioaddr = dev->base_addr - NIC_OFFSET;
380 outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
381 outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
382 return;
385 static void
386 hpp_mem_block_output(struct net_device *dev, int count,
387 const unsigned char *buf, int start_page)
389 int ioaddr = dev->base_addr - NIC_OFFSET;
390 int option_reg = inw(ioaddr + HPP_OPTION);
392 outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
393 outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
394 isa_memcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
395 outw(option_reg, ioaddr + HPP_OPTION);
397 return;
401 #ifdef MODULE
402 #define MAX_HPP_CARDS 4 /* Max number of HPP cards per module */
403 static struct net_device dev_hpp[MAX_HPP_CARDS];
404 static int io[MAX_HPP_CARDS];
405 static int irq[MAX_HPP_CARDS];
407 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_HPP_CARDS) "i");
408 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_HPP_CARDS) "i");
409 MODULE_PARM_DESC(io, "I/O port address(es)");
410 MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
411 MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
412 MODULE_LICENSE("GPL");
414 /* This is set up so that only a single autoprobe takes place per call.
415 ISA device autoprobes on a running machine are not recommended. */
417 init_module(void)
419 int this_dev, found = 0;
421 for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
422 struct net_device *dev = &dev_hpp[this_dev];
423 dev->irq = irq[this_dev];
424 dev->base_addr = io[this_dev];
425 dev->init = hp_plus_probe;
426 if (io[this_dev] == 0) {
427 if (this_dev != 0) break; /* only autoprobe 1st one */
428 printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
430 if (register_netdev(dev) != 0) {
431 printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
432 if (found != 0) { /* Got at least one. */
433 return 0;
435 return -ENXIO;
437 found++;
439 return 0;
442 void
443 cleanup_module(void)
445 int this_dev;
447 for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
448 struct net_device *dev = &dev_hpp[this_dev];
449 if (dev->priv != NULL) {
450 int ioaddr = dev->base_addr - NIC_OFFSET;
451 void *priv = dev->priv;
452 /* NB: hpp_close() handles free_irq */
453 release_region(ioaddr, HP_IO_EXTENT);
454 unregister_netdev(dev);
455 kfree(priv);
459 #endif /* MODULE */
463 * Local variables:
464 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c hp-plus.c"
465 * version-control: t
466 * kept-new-versions: 5
467 * tab-width: 4
468 * c-indent-level: 4
469 * End: