blob: 0abf5dd08b4c5030e4c1b26021eb7f969fef20d2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
21static 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. */
43static 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. */
84enum 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. */
92enum 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
97static int hpp_probe1(struct net_device *dev, int ioaddr);
98
99static void hpp_reset_8390(struct net_device *dev);
100static int hpp_open(struct net_device *dev);
101static int hpp_close(struct net_device *dev);
102static void hpp_mem_block_input(struct net_device *dev, int count,
103 struct sk_buff *skb, int ring_offset);
104static void hpp_mem_block_output(struct net_device *dev, int count,
105 const unsigned char *buf, int start_page);
106static void hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
107 int ring_page);
108static void hpp_io_block_input(struct net_device *dev, int count,
109 struct sk_buff *skb, int ring_offset);
110static void hpp_io_block_output(struct net_device *dev, int count,
111 const unsigned char *buf, int start_page);
112static void hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
113 int ring_page);
114
115
116/* Probe a list of addresses for an HP LAN+ adaptor.
117 This routine is almost boilerplate. */
118
119static 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
125 SET_MODULE_OWNER(dev);
126
127 if (base_addr > 0x1ff) /* Check a single specified location. */
128 return hpp_probe1(dev, base_addr);
129 else if (base_addr != 0) /* Don't probe at all. */
130 return -ENXIO;
131
132 for (i = 0; hpplus_portlist[i]; i++) {
133 if (hpp_probe1(dev, hpplus_portlist[i]) == 0)
134 return 0;
135 dev->irq = irq;
136 }
137
138 return -ENODEV;
139}
140
141static void cleanup_card(struct net_device *dev)
142{
143 /* NB: hpp_close() handles free_irq */
144 release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
145}
146
147#ifndef MODULE
148struct net_device * __init hp_plus_probe(int unit)
149{
150 struct net_device *dev = alloc_ei_netdev();
151 int err;
152
153 if (!dev)
154 return ERR_PTR(-ENOMEM);
155
156 sprintf(dev->name, "eth%d", unit);
157 netdev_boot_setup_check(dev);
158
159 err = do_hpp_probe(dev);
160 if (err)
161 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163out:
164 free_netdev(dev);
165 return ERR_PTR(err);
166}
167#endif
168
169/* Do the interesting part of the probe at a single address. */
170static int __init hpp_probe1(struct net_device *dev, int ioaddr)
171{
172 int i, retval;
173 unsigned char checksum = 0;
174 const char name[] = "HP-PC-LAN+";
175 int mem_start;
176 static unsigned version_printed;
177
178 if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME))
179 return -EBUSY;
180
181 /* Check for the HP+ signature, 50 48 0x 53. */
182 if (inw(ioaddr + HP_ID) != 0x4850
183 || (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
184 retval = -ENODEV;
185 goto out;
186 }
187
188 if (ei_debug && version_printed++ == 0)
189 printk(version);
190
191 printk("%s: %s at %#3x,", dev->name, name, ioaddr);
192
193 /* Retrieve and checksum the station address. */
194 outw(MAC_Page, ioaddr + HP_PAGING);
195
196 for(i = 0; i < ETHER_ADDR_LEN; i++) {
197 unsigned char inval = inb(ioaddr + 8 + i);
198 dev->dev_addr[i] = inval;
199 checksum += inval;
200 printk(" %2.2x", inval);
201 }
202 checksum += inb(ioaddr + 14);
203
204 if (checksum != 0xff) {
205 printk(" bad checksum %2.2x.\n", checksum);
206 retval = -ENODEV;
207 goto out;
208 } else {
209 /* Point at the Software Configuration Flags. */
210 outw(ID_Page, ioaddr + HP_PAGING);
211 printk(" ID %4.4x", inw(ioaddr + 12));
212 }
213
214 /* Read the IRQ line. */
215 outw(HW_Page, ioaddr + HP_PAGING);
216 {
217 int irq = inb(ioaddr + 13) & 0x0f;
218 int option = inw(ioaddr + HPP_OPTION);
219
220 dev->irq = irq;
221 if (option & MemEnable) {
222 mem_start = inw(ioaddr + 9) << 8;
223 printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
224 } else {
225 mem_start = 0;
226 printk(", IRQ %d, programmed-I/O mode.\n", irq);
227 }
228 }
229
230 /* Set the wrap registers for string I/O reads. */
231 outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
232
233 /* Set the base address to point to the NIC, not the "real" base! */
234 dev->base_addr = ioaddr + NIC_OFFSET;
235
236 dev->open = &hpp_open;
237 dev->stop = &hpp_close;
238#ifdef CONFIG_NET_POLL_CONTROLLER
239 dev->poll_controller = ei_poll;
240#endif
241
242 ei_status.name = name;
243 ei_status.word16 = 0; /* Agggghhhhh! Debug time: 2 days! */
244 ei_status.tx_start_page = HP_START_PG;
245 ei_status.rx_start_page = HP_START_PG + TX_PAGES/2;
246 ei_status.stop_page = HP_STOP_PG;
247
248 ei_status.reset_8390 = &hpp_reset_8390;
249 ei_status.block_input = &hpp_io_block_input;
250 ei_status.block_output = &hpp_io_block_output;
251 ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
252
253 /* Check if the memory_enable flag is set in the option register. */
254 if (mem_start) {
255 ei_status.block_input = &hpp_mem_block_input;
256 ei_status.block_output = &hpp_mem_block_output;
257 ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
258 dev->mem_start = mem_start;
259 ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
260 dev->mem_end = ei_status.rmem_end
261 = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
262 }
263
264 outw(Perf_Page, ioaddr + HP_PAGING);
265 NS8390_init(dev, 0);
266 /* Leave the 8390 and HP chip reset. */
267 outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
268
b1fc5502005-05-12 20:11:55 -0400269 retval = register_netdev(dev);
270 if (retval)
271 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return 0;
273out:
274 release_region(ioaddr, HP_IO_EXTENT);
275 return retval;
276}
277
278static int
279hpp_open(struct net_device *dev)
280{
281 int ioaddr = dev->base_addr - NIC_OFFSET;
282 int option_reg;
283 int retval;
284
285 if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
286 return retval;
287 }
288
289 /* Reset the 8390 and HP chip. */
290 option_reg = inw(ioaddr + HPP_OPTION);
291 outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
292 udelay(5);
293 /* Unreset the board and enable interrupts. */
294 outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
295
296 /* Set the wrap registers for programmed-I/O operation. */
297 outw(HW_Page, ioaddr + HP_PAGING);
298 outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
299
300 /* Select the operational page. */
301 outw(Perf_Page, ioaddr + HP_PAGING);
302
303 ei_open(dev);
304 return 0;
305}
306
307static int
308hpp_close(struct net_device *dev)
309{
310 int ioaddr = dev->base_addr - NIC_OFFSET;
311 int option_reg = inw(ioaddr + HPP_OPTION);
312
313 free_irq(dev->irq, dev);
314 ei_close(dev);
315 outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset,
316 ioaddr + HPP_OPTION);
317
318 return 0;
319}
320
321static void
322hpp_reset_8390(struct net_device *dev)
323{
324 int ioaddr = dev->base_addr - NIC_OFFSET;
325 int option_reg = inw(ioaddr + HPP_OPTION);
326
327 if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies);
328
329 outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
330 /* Pause a few cycles for the hardware reset to take place. */
331 udelay(5);
332 ei_status.txing = 0;
333 outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
334
335 udelay(5);
336
337
338 if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
339 printk("%s: hp_reset_8390() did not complete.\n", dev->name);
340
341 if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
342 return;
343}
344
345/* The programmed-I/O version of reading the 4 byte 8390 specific header.
346 Note that transfer with the EtherTwist+ must be on word boundaries. */
347
348static void
349hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
350{
351 int ioaddr = dev->base_addr - NIC_OFFSET;
352
353 outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
354 insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
355}
356
357/* Block input and output, similar to the Crynwr packet driver. */
358
359static void
360hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
361{
362 int ioaddr = dev->base_addr - NIC_OFFSET;
363 char *buf = skb->data;
364
365 outw(ring_offset, ioaddr + HPP_IN_ADDR);
366 insw(ioaddr + HP_DATAPORT, buf, count>>1);
367 if (count & 0x01)
368 buf[count-1] = inw(ioaddr + HP_DATAPORT);
369}
370
371/* The corresponding shared memory versions of the above 2 functions. */
372
373static void
374hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
375{
376 int ioaddr = dev->base_addr - NIC_OFFSET;
377 int option_reg = inw(ioaddr + HPP_OPTION);
378
379 outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
380 outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
381 isa_memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr));
382 outw(option_reg, ioaddr + HPP_OPTION);
383 hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3; /* Round up allocation. */
384}
385
386static void
387hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
388{
389 int ioaddr = dev->base_addr - NIC_OFFSET;
390 int option_reg = inw(ioaddr + HPP_OPTION);
391
392 outw(ring_offset, ioaddr + HPP_IN_ADDR);
393
394 outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
395
396 /* Caution: this relies on get_8390_hdr() rounding up count!
397 Also note that we *can't* use eth_io_copy_and_sum() because
398 it will not always copy "count" bytes (e.g. padded IP). */
399
400 isa_memcpy_fromio(skb->data, dev->mem_start, count);
401 outw(option_reg, ioaddr + HPP_OPTION);
402}
403
404/* A special note: we *must* always transfer >=16 bit words.
405 It's always safe to round up, so we do. */
406static void
407hpp_io_block_output(struct net_device *dev, int count,
408 const unsigned char *buf, int start_page)
409{
410 int ioaddr = dev->base_addr - NIC_OFFSET;
411 outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
412 outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
413 return;
414}
415
416static void
417hpp_mem_block_output(struct net_device *dev, int count,
418 const unsigned char *buf, int start_page)
419{
420 int ioaddr = dev->base_addr - NIC_OFFSET;
421 int option_reg = inw(ioaddr + HPP_OPTION);
422
423 outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
424 outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
425 isa_memcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
426 outw(option_reg, ioaddr + HPP_OPTION);
427
428 return;
429}
430
431
432#ifdef MODULE
433#define MAX_HPP_CARDS 4 /* Max number of HPP cards per module */
434static struct net_device *dev_hpp[MAX_HPP_CARDS];
435static int io[MAX_HPP_CARDS];
436static int irq[MAX_HPP_CARDS];
437
438module_param_array(io, int, NULL, 0);
439module_param_array(irq, int, NULL, 0);
440MODULE_PARM_DESC(io, "I/O port address(es)");
441MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
442MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
443MODULE_LICENSE("GPL");
444
445/* This is set up so that only a single autoprobe takes place per call.
446ISA device autoprobes on a running machine are not recommended. */
447int
448init_module(void)
449{
450 struct net_device *dev;
451 int this_dev, found = 0;
452
453 for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
454 if (io[this_dev] == 0) {
455 if (this_dev != 0) break; /* only autoprobe 1st one */
456 printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
457 }
458 dev = alloc_ei_netdev();
459 if (!dev)
460 break;
461 dev->irq = irq[this_dev];
462 dev->base_addr = io[this_dev];
463 if (do_hpp_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400464 dev_hpp[found++] = dev;
465 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
467 free_netdev(dev);
468 printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
469 break;
470 }
471 if (found)
472 return 0;
473 return -ENXIO;
474}
475
476void
477cleanup_module(void)
478{
479 int this_dev;
480
481 for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
482 struct net_device *dev = dev_hpp[this_dev];
483 if (dev) {
484 unregister_netdev(dev);
485 cleanup_card(dev);
486 free_netdev(dev);
487 }
488 }
489}
490#endif /* MODULE */