blob: 2d2ea94a00bb72cd7568d4a4f2d185be068aec8b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 es3210.c
3
4 Linux driver for Racal-Interlan ES3210 EISA Network Adapter
5
6 Copyright (C) 1996, Paul Gortmaker.
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 Information and Code Sources:
12
13 1) The existing myriad of Linux 8390 drivers written by Donald Becker.
14
15 2) Once again Russ Nelson's asm packet driver provided additional info.
16
17 3) Info for getting IRQ and sh-mem gleaned from the EISA cfg files.
18 Too bad it doesn't work -- see below.
19
20 The ES3210 is an EISA shared memory NS8390 implementation. Note
21 that all memory copies to/from the board must be 32bit transfers.
22 Which rules out using eth_io_copy_and_sum() in this driver.
23
24 Apparently there are two slightly different revisions of the
25 card, since there are two distinct EISA cfg files (!rii0101.cfg
26 and !rii0102.cfg) One has media select in the cfg file and the
27 other doesn't. Hopefully this will work with either.
28
29 That is about all I can tell you about it, having never actually
30 even seen one of these cards. :) Try http://www.interlan.com
31 if you want more info.
32
33 Thanks go to Mark Salazar for testing v0.02 of this driver.
34
35 Bugs, to-fix, etc:
36
37 1) The EISA cfg ports that are *supposed* to have the IRQ and shared
38 mem values just read 0xff all the time. Hrrmpf. Apparently the
39 same happens with the packet driver as the code for reading
40 these registers is disabled there. In the meantime, boot with:
41 ether=<IRQ>,0,0x<shared_mem_addr>,eth0 to override the IRQ and
42 shared memory detection. (The i/o port detection is okay.)
43
44 2) Module support currently untested. Probably works though.
45
46*/
47
48static const char version[] =
49 "es3210.c: Driver revision v0.03, 14/09/96\n";
50
51#include <linux/module.h>
52#include <linux/eisa.h>
53#include <linux/kernel.h>
54#include <linux/errno.h>
55#include <linux/string.h>
56#include <linux/init.h>
57#include <linux/netdevice.h>
58#include <linux/etherdevice.h>
59
60#include <asm/io.h>
61#include <asm/system.h>
62
63#include "8390.h"
64
65static int es_probe1(struct net_device *dev, int ioaddr);
66
67static int es_open(struct net_device *dev);
68static int es_close(struct net_device *dev);
69
70static void es_reset_8390(struct net_device *dev);
71
72static void es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
73static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
74static void es_block_output(struct net_device *dev, int count, const unsigned char *buf, int start_page);
75
76#define ES_START_PG 0x00 /* First page of TX buffer */
77#define ES_STOP_PG 0x40 /* Last page +1 of RX ring */
78
79#define ES_IO_EXTENT 0x37 /* The cfg file says 0xc90 -> 0xcc7 */
80#define ES_ID_PORT 0xc80 /* Same for all EISA cards */
81#define ES_SA_PROM 0xc90 /* Start of e'net addr. */
82#define ES_RESET_PORT 0xc84 /* From the packet driver source */
83#define ES_NIC_OFFSET 0xca0 /* Hello, the 8390 is *here* */
84
85#define ES_ADDR0 0x02 /* 3 byte vendor prefix */
86#define ES_ADDR1 0x07
87#define ES_ADDR2 0x01
88
89/*
90 * Two card revisions. EISA ID's are always rev. minor, rev. major,, and
91 * then the three vendor letters stored in 5 bits each, with an "a" = 1.
92 * For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
93 * config utility determines automagically what config file(s) to use.
94 */
95#define ES_EISA_ID1 0x01012949 /* !rii0101.cfg */
96#define ES_EISA_ID2 0x02012949 /* !rii0102.cfg */
97
98#define ES_CFG1 0xcc0 /* IOPORT(1) --> IOPORT(6) in cfg file */
99#define ES_CFG2 0xcc1
100#define ES_CFG3 0xcc2
101#define ES_CFG4 0xcc3
102#define ES_CFG5 0xcc4
103#define ES_CFG6 0xc84 /* NB: 0xc84 is also "reset" port. */
104
105/*
106 * You can OR any of the following bits together and assign it
107 * to ES_DEBUG to get verbose driver info during operation.
108 * Some of these don't do anything yet.
109 */
110
111#define ES_D_PROBE 0x01
112#define ES_D_RX_PKT 0x02
113#define ES_D_TX_PKT 0x04
114#define ED_D_IRQ 0x08
115
116#define ES_DEBUG 0
117
118static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
119static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};
120
121/*
122 * Probe for the card. The best way is to read the EISA ID if it
123 * is known. Then we check the prefix of the station address
124 * PROM for a match against the Racal-Interlan assigned value.
125 */
126
127static int __init do_es_probe(struct net_device *dev)
128{
129 unsigned short ioaddr = dev->base_addr;
130 int irq = dev->irq;
131 int mem_start = dev->mem_start;
132
133 SET_MODULE_OWNER(dev);
134
135 if (ioaddr > 0x1ff) /* Check a single specified location. */
136 return es_probe1(dev, ioaddr);
137 else if (ioaddr > 0) /* Don't probe at all. */
138 return -ENXIO;
139
140 if (!EISA_bus) {
141#if ES_DEBUG & ES_D_PROBE
142 printk("es3210.c: Not EISA bus. Not probing high ports.\n");
143#endif
144 return -ENXIO;
145 }
146
147 /* EISA spec allows for up to 16 slots, but 8 is typical. */
148 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
149 if (es_probe1(dev, ioaddr) == 0)
150 return 0;
151 dev->irq = irq;
152 dev->mem_start = mem_start;
153 }
154
155 return -ENODEV;
156}
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158#ifndef MODULE
159struct net_device * __init es_probe(int unit)
160{
161 struct net_device *dev = alloc_ei_netdev();
162 int err;
163
164 if (!dev)
165 return ERR_PTR(-ENOMEM);
166
167 sprintf(dev->name, "eth%d", unit);
168 netdev_boot_setup_check(dev);
169
170 err = do_es_probe(dev);
171 if (err)
172 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174out:
175 free_netdev(dev);
176 return ERR_PTR(err);
177}
178#endif
179
180static int __init es_probe1(struct net_device *dev, int ioaddr)
181{
182 int i, retval;
183 unsigned long eisa_id;
184
185 if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
186 return -ENODEV;
187
188#if ES_DEBUG & ES_D_PROBE
189 printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
190 printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
191 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
192 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
193#endif
194
195
196/* Check the EISA ID of the card. */
197 eisa_id = inl(ioaddr + ES_ID_PORT);
198 if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
199 retval = -ENODEV;
200 goto out;
201 }
202
203/* Check the Racal vendor ID as well. */
204 if (inb(ioaddr + ES_SA_PROM + 0) != ES_ADDR0
205 || inb(ioaddr + ES_SA_PROM + 1) != ES_ADDR1
206 || inb(ioaddr + ES_SA_PROM + 2) != ES_ADDR2 ) {
207 printk("es3210.c: card not found");
208 for(i = 0; i < ETHER_ADDR_LEN; i++)
209 printk(" %02x", inb(ioaddr + ES_SA_PROM + i));
210 printk(" (invalid prefix).\n");
211 retval = -ENODEV;
212 goto out;
213 }
214
215 printk("es3210.c: ES3210 rev. %ld at %#x, node", eisa_id>>24, ioaddr);
216 for(i = 0; i < ETHER_ADDR_LEN; i++)
217 printk(" %02x", (dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i)));
218
219 /* Snarf the interrupt now. */
220 if (dev->irq == 0) {
221 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
222 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
223
224 if (hi_irq != 0) {
225 dev->irq = hi_irq_map[hi_irq - 1];
226 } else {
227 int i = 0;
228 while (lo_irq > (1<<i)) i++;
229 dev->irq = lo_irq_map[i];
230 }
231 printk(" using IRQ %d", dev->irq);
232#if ES_DEBUG & ES_D_PROBE
233 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
234 hi_irq, lo_irq, dev->irq);
235#endif
236 } else {
237 if (dev->irq == 2)
238 dev->irq = 9; /* Doh! */
239 printk(" assigning IRQ %d", dev->irq);
240 }
241
242 if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
243 printk (" unable to get IRQ %d.\n", dev->irq);
244 retval = -EAGAIN;
245 goto out;
246 }
247
248 if (dev->mem_start == 0) {
249 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
250 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
251
252 if (mem_enabled != 0x80) {
253 printk(" shared mem disabled - giving up\n");
254 retval = -ENXIO;
255 goto out1;
256 }
257 dev->mem_start = 0xC0000 + mem_bits*0x4000;
258 printk(" using ");
259 } else {
260 printk(" assigning ");
261 }
262
263 ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
264 if (!ei_status.mem) {
265 printk("ioremap failed - giving up\n");
266 retval = -ENXIO;
267 goto out1;
268 }
269
270 dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
271
272 printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
273
274#if ES_DEBUG & ES_D_PROBE
275 if (inb(ioaddr + ES_CFG5))
276 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
277#endif
278 /* Note, point at the 8390, and not the card... */
279 dev->base_addr = ioaddr + ES_NIC_OFFSET;
280
281 ei_status.name = "ES3210";
282 ei_status.tx_start_page = ES_START_PG;
283 ei_status.rx_start_page = ES_START_PG + TX_PAGES;
284 ei_status.stop_page = ES_STOP_PG;
285 ei_status.word16 = 1;
286
287 if (ei_debug > 0)
288 printk(version);
289
290 ei_status.reset_8390 = &es_reset_8390;
291 ei_status.block_input = &es_block_input;
292 ei_status.block_output = &es_block_output;
293 ei_status.get_8390_hdr = &es_get_8390_hdr;
294
295 dev->open = &es_open;
296 dev->stop = &es_close;
297#ifdef CONFIG_NET_POLL_CONTROLLER
298 dev->poll_controller = ei_poll;
299#endif
300 NS8390_init(dev, 0);
b1fc5502005-05-12 20:11:55 -0400301
302 retval = register_netdev(dev);
303 if (retval)
304 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 return 0;
306out1:
307 free_irq(dev->irq, dev);
308out:
309 release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
310 return retval;
311}
312
313/*
314 * Reset as per the packet driver method. Judging by the EISA cfg
315 * file, this just toggles the "Board Enable" bits (bit 2 and 0).
316 */
317
318static void es_reset_8390(struct net_device *dev)
319{
320 unsigned short ioaddr = dev->base_addr;
321 unsigned long end;
322
323 outb(0x04, ioaddr + ES_RESET_PORT);
324 if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
325
326 end = jiffies + 2*HZ/100;
327 while ((signed)(end - jiffies) > 0) continue;
328
329 ei_status.txing = 0;
330 outb(0x01, ioaddr + ES_RESET_PORT);
331 if (ei_debug > 1) printk("reset done\n");
332
333 return;
334}
335
336/*
337 * Note: In the following three functions is the implicit assumption
338 * that the associated memcpy will only use "rep; movsl" as long as
339 * we keep the counts as some multiple of doublewords. This is a
340 * requirement of the hardware, and also prevents us from using
341 * eth_io_copy_and_sum() since we can't guarantee it will limit
342 * itself to doubleword access.
343 */
344
345/*
346 * Grab the 8390 specific header. Similar to the block_input routine, but
347 * we don't need to be concerned with ring wrap as the header will be at
348 * the start of a page, so we optimize accordingly. (A single doubleword.)
349 */
350
351static void
352es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
353{
354 void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
355 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
356 hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
357}
358
359/*
360 * Block input and output are easy on shared memory ethercards, the only
361 * complication is when the ring buffer wraps. The count will already
362 * be rounded up to a doubleword value via es_get_8390_hdr() above.
363 */
364
365static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
366 int ring_offset)
367{
368 void __iomem *xfer_start = ei_status.mem + ring_offset - ES_START_PG*256;
369
370 if (ring_offset + count > ES_STOP_PG*256) {
371 /* Packet wraps over end of ring buffer. */
372 int semi_count = ES_STOP_PG*256 - ring_offset;
373 memcpy_fromio(skb->data, xfer_start, semi_count);
374 count -= semi_count;
375 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
376 } else {
377 /* Packet is in one chunk. */
378 eth_io_copy_and_sum(skb, xfer_start, count, 0);
379 }
380}
381
382static void es_block_output(struct net_device *dev, int count,
383 const unsigned char *buf, int start_page)
384{
385 void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
386
387 count = (count + 3) & ~3; /* Round up to doubleword */
388 memcpy_toio(shmem, buf, count);
389}
390
391static int es_open(struct net_device *dev)
392{
393 ei_open(dev);
394 return 0;
395}
396
397static int es_close(struct net_device *dev)
398{
399
400 if (ei_debug > 1)
401 printk("%s: Shutting down ethercard.\n", dev->name);
402
403 ei_close(dev);
404 return 0;
405}
406
407#ifdef MODULE
408#define MAX_ES_CARDS 4 /* Max number of ES3210 cards per module */
409#define NAMELEN 8 /* # of chars for storing dev->name */
410static struct net_device *dev_es3210[MAX_ES_CARDS];
411static int io[MAX_ES_CARDS];
412static int irq[MAX_ES_CARDS];
413static int mem[MAX_ES_CARDS];
414
415module_param_array(io, int, NULL, 0);
416module_param_array(irq, int, NULL, 0);
417module_param_array(mem, int, NULL, 0);
418MODULE_PARM_DESC(io, "I/O base address(es)");
419MODULE_PARM_DESC(irq, "IRQ number(s)");
420MODULE_PARM_DESC(mem, "memory base address(es)");
421MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
422MODULE_LICENSE("GPL");
423
Andrew Morton5757f5c2006-08-14 23:00:02 -0700424int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
426 struct net_device *dev;
427 int this_dev, found = 0;
428
429 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
430 if (io[this_dev] == 0 && this_dev != 0)
431 break;
432 dev = alloc_ei_netdev();
433 if (!dev)
434 break;
435 dev->irq = irq[this_dev];
436 dev->base_addr = io[this_dev];
437 dev->mem_start = mem[this_dev];
438 if (do_es_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400439 dev_es3210[found++] = dev;
440 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 }
442 free_netdev(dev);
443 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
444 break;
445 }
446 if (found)
447 return 0;
448 return -ENXIO;
449}
450
Denis Vlasenko64916f12006-01-05 22:45:47 -0800451static void cleanup_card(struct net_device *dev)
452{
453 free_irq(dev->irq, dev);
454 release_region(dev->base_addr, ES_IO_EXTENT);
455 iounmap(ei_status.mem);
456}
457
Al Viroafc8eb42006-06-14 18:50:53 -0400458void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459cleanup_module(void)
460{
461 int this_dev;
462
463 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
464 struct net_device *dev = dev_es3210[this_dev];
465 if (dev) {
466 unregister_netdev(dev);
467 cleanup_card(dev);
468 free_netdev(dev);
469 }
470 }
471}
472#endif /* MODULE */
473