aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/es3210.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/net/es3210.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/net/es3210.c')
-rw-r--r--drivers/net/es3210.c478
1 files changed, 478 insertions, 0 deletions
diff --git a/drivers/net/es3210.c b/drivers/net/es3210.c
new file mode 100644
index 000000000000..f1e8150ed2a0
--- /dev/null
+++ b/drivers/net/es3210.c
@@ -0,0 +1,478 @@
1/*
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
158static void cleanup_card(struct net_device *dev)
159{
160 free_irq(dev->irq, dev);
161 release_region(dev->base_addr, ES_IO_EXTENT);
162 iounmap(ei_status.mem);
163}
164
165#ifndef MODULE
166struct net_device * __init es_probe(int unit)
167{
168 struct net_device *dev = alloc_ei_netdev();
169 int err;
170
171 if (!dev)
172 return ERR_PTR(-ENOMEM);
173
174 sprintf(dev->name, "eth%d", unit);
175 netdev_boot_setup_check(dev);
176
177 err = do_es_probe(dev);
178 if (err)
179 goto out;
180 err = register_netdev(dev);
181 if (err)
182 goto out1;
183 return dev;
184out1:
185 cleanup_card(dev);
186out:
187 free_netdev(dev);
188 return ERR_PTR(err);
189}
190#endif
191
192static int __init es_probe1(struct net_device *dev, int ioaddr)
193{
194 int i, retval;
195 unsigned long eisa_id;
196
197 if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
198 return -ENODEV;
199
200#if ES_DEBUG & ES_D_PROBE
201 printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
202 printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
203 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
204 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
205#endif
206
207
208/* Check the EISA ID of the card. */
209 eisa_id = inl(ioaddr + ES_ID_PORT);
210 if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
211 retval = -ENODEV;
212 goto out;
213 }
214
215/* Check the Racal vendor ID as well. */
216 if (inb(ioaddr + ES_SA_PROM + 0) != ES_ADDR0
217 || inb(ioaddr + ES_SA_PROM + 1) != ES_ADDR1
218 || inb(ioaddr + ES_SA_PROM + 2) != ES_ADDR2 ) {
219 printk("es3210.c: card not found");
220 for(i = 0; i < ETHER_ADDR_LEN; i++)
221 printk(" %02x", inb(ioaddr + ES_SA_PROM + i));
222 printk(" (invalid prefix).\n");
223 retval = -ENODEV;
224 goto out;
225 }
226
227 printk("es3210.c: ES3210 rev. %ld at %#x, node", eisa_id>>24, ioaddr);
228 for(i = 0; i < ETHER_ADDR_LEN; i++)
229 printk(" %02x", (dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i)));
230
231 /* Snarf the interrupt now. */
232 if (dev->irq == 0) {
233 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
234 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
235
236 if (hi_irq != 0) {
237 dev->irq = hi_irq_map[hi_irq - 1];
238 } else {
239 int i = 0;
240 while (lo_irq > (1<<i)) i++;
241 dev->irq = lo_irq_map[i];
242 }
243 printk(" using IRQ %d", dev->irq);
244#if ES_DEBUG & ES_D_PROBE
245 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
246 hi_irq, lo_irq, dev->irq);
247#endif
248 } else {
249 if (dev->irq == 2)
250 dev->irq = 9; /* Doh! */
251 printk(" assigning IRQ %d", dev->irq);
252 }
253
254 if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
255 printk (" unable to get IRQ %d.\n", dev->irq);
256 retval = -EAGAIN;
257 goto out;
258 }
259
260 if (dev->mem_start == 0) {
261 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
262 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
263
264 if (mem_enabled != 0x80) {
265 printk(" shared mem disabled - giving up\n");
266 retval = -ENXIO;
267 goto out1;
268 }
269 dev->mem_start = 0xC0000 + mem_bits*0x4000;
270 printk(" using ");
271 } else {
272 printk(" assigning ");
273 }
274
275 ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
276 if (!ei_status.mem) {
277 printk("ioremap failed - giving up\n");
278 retval = -ENXIO;
279 goto out1;
280 }
281
282 dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
283
284 printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
285
286#if ES_DEBUG & ES_D_PROBE
287 if (inb(ioaddr + ES_CFG5))
288 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
289#endif
290 /* Note, point at the 8390, and not the card... */
291 dev->base_addr = ioaddr + ES_NIC_OFFSET;
292
293 ei_status.name = "ES3210";
294 ei_status.tx_start_page = ES_START_PG;
295 ei_status.rx_start_page = ES_START_PG + TX_PAGES;
296 ei_status.stop_page = ES_STOP_PG;
297 ei_status.word16 = 1;
298
299 if (ei_debug > 0)
300 printk(version);
301
302 ei_status.reset_8390 = &es_reset_8390;
303 ei_status.block_input = &es_block_input;
304 ei_status.block_output = &es_block_output;
305 ei_status.get_8390_hdr = &es_get_8390_hdr;
306
307 dev->open = &es_open;
308 dev->stop = &es_close;
309#ifdef CONFIG_NET_POLL_CONTROLLER
310 dev->poll_controller = ei_poll;
311#endif
312 NS8390_init(dev, 0);
313 return 0;
314out1:
315 free_irq(dev->irq, dev);
316out:
317 release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
318 return retval;
319}
320
321/*
322 * Reset as per the packet driver method. Judging by the EISA cfg
323 * file, this just toggles the "Board Enable" bits (bit 2 and 0).
324 */
325
326static void es_reset_8390(struct net_device *dev)
327{
328 unsigned short ioaddr = dev->base_addr;
329 unsigned long end;
330
331 outb(0x04, ioaddr + ES_RESET_PORT);
332 if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
333
334 end = jiffies + 2*HZ/100;
335 while ((signed)(end - jiffies) > 0) continue;
336
337 ei_status.txing = 0;
338 outb(0x01, ioaddr + ES_RESET_PORT);
339 if (ei_debug > 1) printk("reset done\n");
340
341 return;
342}
343
344/*
345 * Note: In the following three functions is the implicit assumption
346 * that the associated memcpy will only use "rep; movsl" as long as
347 * we keep the counts as some multiple of doublewords. This is a
348 * requirement of the hardware, and also prevents us from using
349 * eth_io_copy_and_sum() since we can't guarantee it will limit
350 * itself to doubleword access.
351 */
352
353/*
354 * Grab the 8390 specific header. Similar to the block_input routine, but
355 * we don't need to be concerned with ring wrap as the header will be at
356 * the start of a page, so we optimize accordingly. (A single doubleword.)
357 */
358
359static void
360es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
361{
362 void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
363 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
364 hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
365}
366
367/*
368 * Block input and output are easy on shared memory ethercards, the only
369 * complication is when the ring buffer wraps. The count will already
370 * be rounded up to a doubleword value via es_get_8390_hdr() above.
371 */
372
373static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
374 int ring_offset)
375{
376 void __iomem *xfer_start = ei_status.mem + ring_offset - ES_START_PG*256;
377
378 if (ring_offset + count > ES_STOP_PG*256) {
379 /* Packet wraps over end of ring buffer. */
380 int semi_count = ES_STOP_PG*256 - ring_offset;
381 memcpy_fromio(skb->data, xfer_start, semi_count);
382 count -= semi_count;
383 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
384 } else {
385 /* Packet is in one chunk. */
386 eth_io_copy_and_sum(skb, xfer_start, count, 0);
387 }
388}
389
390static void es_block_output(struct net_device *dev, int count,
391 const unsigned char *buf, int start_page)
392{
393 void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
394
395 count = (count + 3) & ~3; /* Round up to doubleword */
396 memcpy_toio(shmem, buf, count);
397}
398
399static int es_open(struct net_device *dev)
400{
401 ei_open(dev);
402 return 0;
403}
404
405static int es_close(struct net_device *dev)
406{
407
408 if (ei_debug > 1)
409 printk("%s: Shutting down ethercard.\n", dev->name);
410
411 ei_close(dev);
412 return 0;
413}
414
415#ifdef MODULE
416#define MAX_ES_CARDS 4 /* Max number of ES3210 cards per module */
417#define NAMELEN 8 /* # of chars for storing dev->name */
418static struct net_device *dev_es3210[MAX_ES_CARDS];
419static int io[MAX_ES_CARDS];
420static int irq[MAX_ES_CARDS];
421static int mem[MAX_ES_CARDS];
422
423module_param_array(io, int, NULL, 0);
424module_param_array(irq, int, NULL, 0);
425module_param_array(mem, int, NULL, 0);
426MODULE_PARM_DESC(io, "I/O base address(es)");
427MODULE_PARM_DESC(irq, "IRQ number(s)");
428MODULE_PARM_DESC(mem, "memory base address(es)");
429MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
430MODULE_LICENSE("GPL");
431
432int
433init_module(void)
434{
435 struct net_device *dev;
436 int this_dev, found = 0;
437
438 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
439 if (io[this_dev] == 0 && this_dev != 0)
440 break;
441 dev = alloc_ei_netdev();
442 if (!dev)
443 break;
444 dev->irq = irq[this_dev];
445 dev->base_addr = io[this_dev];
446 dev->mem_start = mem[this_dev];
447 if (do_es_probe(dev) == 0) {
448 if (register_netdev(dev) == 0) {
449 dev_es3210[found++] = dev;
450 continue;
451 }
452 cleanup_card(dev);
453 }
454 free_netdev(dev);
455 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
456 break;
457 }
458 if (found)
459 return 0;
460 return -ENXIO;
461}
462
463void
464cleanup_module(void)
465{
466 int this_dev;
467
468 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
469 struct net_device *dev = dev_es3210[this_dev];
470 if (dev) {
471 unregister_netdev(dev);
472 cleanup_card(dev);
473 free_netdev(dev);
474 }
475 }
476}
477#endif /* MODULE */
478