net: convert print_mac to %pM
[linux-2.6.git] / drivers / net / es3210.c
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
48 static 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
65 static int es_probe1(struct net_device *dev, int ioaddr);
66
67 static int es_open(struct net_device *dev);
68 static int es_close(struct net_device *dev);
69
70 static void es_reset_8390(struct net_device *dev);
71
72 static void es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
73 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
74 static 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
118 static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
119 static 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
127 static 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         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
156 #ifndef MODULE
157 struct 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;
171         return dev;
172 out:
173         free_netdev(dev);
174         return ERR_PTR(err);
175 }
176 #endif
177
178 static 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
193 /*      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
200         for (i = 0; i < ETHER_ADDR_LEN ; i++)
201                 dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);
202
203 /*      Check the Racal vendor ID as well. */
204         if (dev->dev_addr[0] != ES_ADDR0 ||
205             dev->dev_addr[1] != ES_ADDR1 ||
206             dev->dev_addr[2] != ES_ADDR2) {
207                 printk("es3210.c: card not found %pM (invalid_prefix).\n",
208                        dev->dev_addr);
209                 retval = -ENODEV;
210                 goto out;
211         }
212
213         printk("es3210.c: ES3210 rev. %ld at %#x, node %pM",
214                eisa_id>>24, ioaddr, dev->dev_addr);
215
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);
298
299         retval = register_netdev(dev);
300         if (retval)
301                 goto out1;
302         return 0;
303 out1:
304         free_irq(dev->irq, dev);
305 out:
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
315 static 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
348 static void
349 es_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
362 static 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. */
375                 memcpy_fromio(skb->data, xfer_start, count);
376         }
377 }
378
379 static 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
388 static int es_open(struct net_device *dev)
389 {
390         ei_open(dev);
391         return 0;
392 }
393
394 static 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 */
407 static struct net_device *dev_es3210[MAX_ES_CARDS];
408 static int io[MAX_ES_CARDS];
409 static int irq[MAX_ES_CARDS];
410 static int mem[MAX_ES_CARDS];
411
412 module_param_array(io, int, NULL, 0);
413 module_param_array(irq, int, NULL, 0);
414 module_param_array(mem, int, NULL, 0);
415 MODULE_PARM_DESC(io, "I/O base address(es)");
416 MODULE_PARM_DESC(irq, "IRQ number(s)");
417 MODULE_PARM_DESC(mem, "memory base address(es)");
418 MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
419 MODULE_LICENSE("GPL");
420
421 int __init init_module(void)
422 {
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) {
436                         dev_es3210[found++] = dev;
437                         continue;
438                 }
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
448 static 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
455 void __exit
456 cleanup_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