blob: e7df9f4a183deaf19afe5ca633467e931c168ec5 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 if (ioaddr > 0x1ff) /* Check a single specified location. */
134 return es_probe1(dev, ioaddr);
135 else if (ioaddr > 0) /* Don't probe at all. */
136 return -ENXIO;
137
138 if (!EISA_bus) {
139#if ES_DEBUG & ES_D_PROBE
140 printk("es3210.c: Not EISA bus. Not probing high ports.\n");
141#endif
142 return -ENXIO;
143 }
144
145 /* EISA spec allows for up to 16 slots, but 8 is typical. */
146 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
147 if (es_probe1(dev, ioaddr) == 0)
148 return 0;
149 dev->irq = irq;
150 dev->mem_start = mem_start;
151 }
152
153 return -ENODEV;
154}
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156#ifndef MODULE
157struct net_device * __init es_probe(int unit)
158{
159 struct net_device *dev = alloc_ei_netdev();
160 int err;
161
162 if (!dev)
163 return ERR_PTR(-ENOMEM);
164
165 sprintf(dev->name, "eth%d", unit);
166 netdev_boot_setup_check(dev);
167
168 err = do_es_probe(dev);
169 if (err)
170 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172out:
173 free_netdev(dev);
174 return ERR_PTR(err);
175}
176#endif
177
178static int __init es_probe1(struct net_device *dev, int ioaddr)
179{
180 int i, retval;
181 unsigned long eisa_id;
182
183 if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
184 return -ENODEV;
185
186#if ES_DEBUG & ES_D_PROBE
187 printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
188 printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
189 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
190 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
191#endif
192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193/* Check the EISA ID of the card. */
194 eisa_id = inl(ioaddr + ES_ID_PORT);
195 if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
196 retval = -ENODEV;
197 goto out;
198 }
199
Joe Perches0795af52007-10-03 17:59:30 -0700200 for (i = 0; i < ETHER_ADDR_LEN ; i++)
201 dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203/* Check the Racal vendor ID as well. */
Joe Perches0795af52007-10-03 17:59:30 -0700204 if (dev->dev_addr[0] != ES_ADDR0 ||
205 dev->dev_addr[1] != ES_ADDR1 ||
206 dev->dev_addr[2] != ES_ADDR2) {
Johannes Berge1749612008-10-27 15:59:26 -0700207 printk("es3210.c: card not found %pM (invalid_prefix).\n",
208 dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 retval = -ENODEV;
210 goto out;
211 }
212
Johannes Berge1749612008-10-27 15:59:26 -0700213 printk("es3210.c: ES3210 rev. %ld at %#x, node %pM",
214 eisa_id>>24, ioaddr, dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216 /* Snarf the interrupt now. */
217 if (dev->irq == 0) {
218 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
219 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
220
221 if (hi_irq != 0) {
222 dev->irq = hi_irq_map[hi_irq - 1];
223 } else {
224 int i = 0;
225 while (lo_irq > (1<<i)) i++;
226 dev->irq = lo_irq_map[i];
227 }
228 printk(" using IRQ %d", dev->irq);
229#if ES_DEBUG & ES_D_PROBE
230 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
231 hi_irq, lo_irq, dev->irq);
232#endif
233 } else {
234 if (dev->irq == 2)
235 dev->irq = 9; /* Doh! */
236 printk(" assigning IRQ %d", dev->irq);
237 }
238
239 if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
240 printk (" unable to get IRQ %d.\n", dev->irq);
241 retval = -EAGAIN;
242 goto out;
243 }
244
245 if (dev->mem_start == 0) {
246 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
247 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
248
249 if (mem_enabled != 0x80) {
250 printk(" shared mem disabled - giving up\n");
251 retval = -ENXIO;
252 goto out1;
253 }
254 dev->mem_start = 0xC0000 + mem_bits*0x4000;
255 printk(" using ");
256 } else {
257 printk(" assigning ");
258 }
259
260 ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
261 if (!ei_status.mem) {
262 printk("ioremap failed - giving up\n");
263 retval = -ENXIO;
264 goto out1;
265 }
266
267 dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
268
269 printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
270
271#if ES_DEBUG & ES_D_PROBE
272 if (inb(ioaddr + ES_CFG5))
273 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
274#endif
275 /* Note, point at the 8390, and not the card... */
276 dev->base_addr = ioaddr + ES_NIC_OFFSET;
277
278 ei_status.name = "ES3210";
279 ei_status.tx_start_page = ES_START_PG;
280 ei_status.rx_start_page = ES_START_PG + TX_PAGES;
281 ei_status.stop_page = ES_STOP_PG;
282 ei_status.word16 = 1;
283
284 if (ei_debug > 0)
285 printk(version);
286
287 ei_status.reset_8390 = &es_reset_8390;
288 ei_status.block_input = &es_block_input;
289 ei_status.block_output = &es_block_output;
290 ei_status.get_8390_hdr = &es_get_8390_hdr;
291
292 dev->open = &es_open;
293 dev->stop = &es_close;
294#ifdef CONFIG_NET_POLL_CONTROLLER
295 dev->poll_controller = ei_poll;
296#endif
297 NS8390_init(dev, 0);
b1fc5502005-05-12 20:11:55 -0400298
299 retval = register_netdev(dev);
300 if (retval)
301 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 return 0;
303out1:
304 free_irq(dev->irq, dev);
305out:
306 release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
307 return retval;
308}
309
310/*
311 * Reset as per the packet driver method. Judging by the EISA cfg
312 * file, this just toggles the "Board Enable" bits (bit 2 and 0).
313 */
314
315static void es_reset_8390(struct net_device *dev)
316{
317 unsigned short ioaddr = dev->base_addr;
318 unsigned long end;
319
320 outb(0x04, ioaddr + ES_RESET_PORT);
321 if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
322
323 end = jiffies + 2*HZ/100;
324 while ((signed)(end - jiffies) > 0) continue;
325
326 ei_status.txing = 0;
327 outb(0x01, ioaddr + ES_RESET_PORT);
328 if (ei_debug > 1) printk("reset done\n");
329
330 return;
331}
332
333/*
334 * Note: In the following three functions is the implicit assumption
335 * that the associated memcpy will only use "rep; movsl" as long as
336 * we keep the counts as some multiple of doublewords. This is a
337 * requirement of the hardware, and also prevents us from using
338 * eth_io_copy_and_sum() since we can't guarantee it will limit
339 * itself to doubleword access.
340 */
341
342/*
343 * Grab the 8390 specific header. Similar to the block_input routine, but
344 * we don't need to be concerned with ring wrap as the header will be at
345 * the start of a page, so we optimize accordingly. (A single doubleword.)
346 */
347
348static void
349es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
350{
351 void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
352 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
353 hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
354}
355
356/*
357 * Block input and output are easy on shared memory ethercards, the only
358 * complication is when the ring buffer wraps. The count will already
359 * be rounded up to a doubleword value via es_get_8390_hdr() above.
360 */
361
362static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
363 int ring_offset)
364{
365 void __iomem *xfer_start = ei_status.mem + ring_offset - ES_START_PG*256;
366
367 if (ring_offset + count > ES_STOP_PG*256) {
368 /* Packet wraps over end of ring buffer. */
369 int semi_count = ES_STOP_PG*256 - ring_offset;
370 memcpy_fromio(skb->data, xfer_start, semi_count);
371 count -= semi_count;
372 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
373 } else {
374 /* Packet is in one chunk. */
Al Viro4ec03112007-02-09 16:38:30 +0000375 memcpy_fromio(skb->data, xfer_start, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 }
377}
378
379static void es_block_output(struct net_device *dev, int count,
380 const unsigned char *buf, int start_page)
381{
382 void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
383
384 count = (count + 3) & ~3; /* Round up to doubleword */
385 memcpy_toio(shmem, buf, count);
386}
387
388static int es_open(struct net_device *dev)
389{
390 ei_open(dev);
391 return 0;
392}
393
394static int es_close(struct net_device *dev)
395{
396
397 if (ei_debug > 1)
398 printk("%s: Shutting down ethercard.\n", dev->name);
399
400 ei_close(dev);
401 return 0;
402}
403
404#ifdef MODULE
405#define MAX_ES_CARDS 4 /* Max number of ES3210 cards per module */
406#define NAMELEN 8 /* # of chars for storing dev->name */
407static struct net_device *dev_es3210[MAX_ES_CARDS];
408static int io[MAX_ES_CARDS];
409static int irq[MAX_ES_CARDS];
410static int mem[MAX_ES_CARDS];
411
412module_param_array(io, int, NULL, 0);
413module_param_array(irq, int, NULL, 0);
414module_param_array(mem, int, NULL, 0);
415MODULE_PARM_DESC(io, "I/O base address(es)");
416MODULE_PARM_DESC(irq, "IRQ number(s)");
417MODULE_PARM_DESC(mem, "memory base address(es)");
418MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
419MODULE_LICENSE("GPL");
420
Andrew Morton5757f5c2006-08-14 23:00:02 -0700421int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 struct net_device *dev;
424 int this_dev, found = 0;
425
426 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
427 if (io[this_dev] == 0 && this_dev != 0)
428 break;
429 dev = alloc_ei_netdev();
430 if (!dev)
431 break;
432 dev->irq = irq[this_dev];
433 dev->base_addr = io[this_dev];
434 dev->mem_start = mem[this_dev];
435 if (do_es_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400436 dev_es3210[found++] = dev;
437 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
439 free_netdev(dev);
440 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
441 break;
442 }
443 if (found)
444 return 0;
445 return -ENXIO;
446}
447
Denis Vlasenko64916f12006-01-05 22:45:47 -0800448static void cleanup_card(struct net_device *dev)
449{
450 free_irq(dev->irq, dev);
451 release_region(dev->base_addr, ES_IO_EXTENT);
452 iounmap(ei_status.mem);
453}
454
Al Viroafc8eb42006-06-14 18:50:53 -0400455void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456cleanup_module(void)
457{
458 int this_dev;
459
460 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
461 struct net_device *dev = dev_es3210[this_dev];
462 if (dev) {
463 unregister_netdev(dev);
464 cleanup_card(dev);
465 free_netdev(dev);
466 }
467 }
468}
469#endif /* MODULE */
470