[PATCH] drivers/net/s2io.c: make functions static
[linux-2.6] / drivers / net / e2100.c
1 /* e2100.c: A Cabletron E2100 series ethernet driver for linux. */
2 /*
3         Written 1993-1994 by Donald Becker.
4
5         Copyright 1994 by Donald Becker.
6         Copyright 1993 United States Government as represented by the
7         Director, National Security Agency.  This software may be used and
8         distributed according to the terms of the GNU General Public License,
9         incorporated herein by reference.
10
11         This is a driver for the Cabletron E2100 series ethercards.
12
13         The Author may be reached as becker@scyld.com, or C/O
14         Scyld Computing Corporation
15         410 Severn Ave., Suite 210
16         Annapolis MD 21403
17
18         The E2100 series ethercard is a fairly generic shared memory 8390
19         implementation.  The only unusual aspect is the way the shared memory
20         registers are set: first you do an inb() in what is normally the
21         station address region, and the low three bits of next outb() *address*
22         is used as the write value for that register.  Either someone wasn't
23         too used to dem bit en bites, or they were trying to obfuscate the
24         programming interface.
25
26         There is an additional complication when setting the window on the packet
27         buffer.  You must first do a read into the packet buffer region with the
28         low 8 address bits the address setting the page for the start of the packet
29         buffer window, and then do the above operation.  See mem_on() for details.
30
31         One bug on the chip is that even a hard reset won't disable the memory
32         window, usually resulting in a hung machine if mem_off() isn't called.
33         If this happens, you must power down the machine for about 30 seconds.
34 */
35
36 static const char version[] =
37         "e2100.c:v1.01 7/21/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
38
39 #include <linux/module.h>
40 #include <linux/kernel.h>
41 #include <linux/errno.h>
42 #include <linux/string.h>
43 #include <linux/ioport.h>
44 #include <linux/netdevice.h>
45 #include <linux/etherdevice.h>
46 #include <linux/init.h>
47 #include <linux/delay.h>
48
49 #include <asm/io.h>
50 #include <asm/system.h>
51
52 #include "8390.h"
53
54 #define DRV_NAME "e2100"
55
56 static int e21_probe_list[] = {0x300, 0x280, 0x380, 0x220, 0};
57
58 /* Offsets from the base_addr.
59    Read from the ASIC register, and the low three bits of the next outb()
60    address is used to set the corresponding register. */
61 #define E21_NIC_OFFSET  0               /* Offset to the 8390 NIC. */
62 #define E21_ASIC                0x10
63 #define E21_MEM_ENABLE  0x10
64 #define  E21_MEM_ON             0x05    /* Enable memory in 16 bit mode. */
65 #define  E21_MEM_ON_8   0x07    /* Enable memory in  8 bit mode. */
66 #define E21_MEM_BASE    0x11
67 #define E21_IRQ_LOW             0x12    /* The low three bits of the IRQ number. */
68 #define E21_IRQ_HIGH    0x14    /* The high IRQ bit and media select ...  */
69 #define E21_MEDIA               0x14    /* (alias). */
70 #define  E21_ALT_IFPORT 0x02    /* Set to use the other (BNC,AUI) port. */
71 #define  E21_BIG_MEM    0x04    /* Use a bigger (64K) buffer (we don't) */
72 #define E21_SAPROM              0x10    /* Offset to station address data. */
73 #define E21_IO_EXTENT    0x20
74
75 static inline void mem_on(short port, volatile char __iomem *mem_base,
76                                                   unsigned char start_page )
77 {
78         /* This is a little weird: set the shared memory window by doing a
79            read.  The low address bits specify the starting page. */
80         readb(mem_base+start_page);
81         inb(port + E21_MEM_ENABLE);
82         outb(E21_MEM_ON, port + E21_MEM_ENABLE + E21_MEM_ON);
83 }
84
85 static inline void mem_off(short port)
86 {
87         inb(port + E21_MEM_ENABLE);
88         outb(0x00, port + E21_MEM_ENABLE);
89 }
90
91 /* In other drivers I put the TX pages first, but the E2100 window circuitry
92    is designed to have a 4K Tx region last. The windowing circuitry wraps the
93    window at 0x2fff->0x0000 so that the packets at e.g. 0x2f00 in the RX ring
94    appear contiguously in the window. */
95 #define E21_RX_START_PG         0x00    /* First page of RX buffer */
96 #define E21_RX_STOP_PG          0x30    /* Last page +1 of RX ring */
97 #define E21_BIG_RX_STOP_PG      0xF0    /* Last page +1 of RX ring */
98 #define E21_TX_START_PG         E21_RX_STOP_PG  /* First page of TX buffer */
99
100 static int e21_probe1(struct net_device *dev, int ioaddr);
101
102 static int e21_open(struct net_device *dev);
103 static void e21_reset_8390(struct net_device *dev);
104 static void e21_block_input(struct net_device *dev, int count,
105                                                    struct sk_buff *skb, int ring_offset);
106 static void e21_block_output(struct net_device *dev, int count,
107                                                          const unsigned char *buf, int start_page);
108 static void e21_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
109                                                         int ring_page);
110
111 static int e21_close(struct net_device *dev);
112
113 \f
114 /*  Probe for the E2100 series ethercards.  These cards have an 8390 at the
115         base address and the station address at both offset 0x10 and 0x18.  I read
116         the station address from offset 0x18 to avoid the dataport of NE2000
117         ethercards, and look for Ctron's unique ID (first three octets of the
118         station address).
119  */
120
121 static int  __init do_e2100_probe(struct net_device *dev)
122 {
123         int *port;
124         int base_addr = dev->base_addr;
125         int irq = dev->irq;
126
127         SET_MODULE_OWNER(dev);
128
129         if (base_addr > 0x1ff)          /* Check a single specified location. */
130                 return e21_probe1(dev, base_addr);
131         else if (base_addr != 0)        /* Don't probe at all. */
132                 return -ENXIO;
133
134         for (port = e21_probe_list; *port; port++) {
135                 dev->irq = irq;
136                 if (e21_probe1(dev, *port) == 0)
137                         return 0;
138         }
139
140         return -ENODEV;
141 }
142
143 static void cleanup_card(struct net_device *dev)
144 {
145         /* NB: e21_close() handles free_irq */
146         iounmap(ei_status.mem);
147         release_region(dev->base_addr, E21_IO_EXTENT);
148 }
149
150 #ifndef MODULE
151 struct net_device * __init e2100_probe(int unit)
152 {
153         struct net_device *dev = alloc_ei_netdev();
154         int err;
155
156         if (!dev)
157                 return ERR_PTR(-ENOMEM);
158
159         sprintf(dev->name, "eth%d", unit);
160         netdev_boot_setup_check(dev);
161
162         err = do_e2100_probe(dev);
163         if (err)
164                 goto out;
165         return dev;
166 out:
167         free_netdev(dev);
168         return ERR_PTR(err);
169 }
170 #endif
171
172 static int __init e21_probe1(struct net_device *dev, int ioaddr)
173 {
174         int i, status, retval;
175         unsigned char *station_addr = dev->dev_addr;
176         static unsigned version_printed;
177
178         if (!request_region(ioaddr, E21_IO_EXTENT, DRV_NAME))
179                 return -EBUSY;
180
181         /* First check the station address for the Ctron prefix. */
182         if (inb(ioaddr + E21_SAPROM + 0) != 0x00
183                 || inb(ioaddr + E21_SAPROM + 1) != 0x00
184                 || inb(ioaddr + E21_SAPROM + 2) != 0x1d) {
185                 retval = -ENODEV;
186                 goto out;
187         }
188
189         /* Verify by making certain that there is a 8390 at there. */
190         outb(E8390_NODMA + E8390_STOP, ioaddr);
191         udelay(1);      /* we want to delay one I/O cycle - which is 2MHz */
192         status = inb(ioaddr);
193         if (status != 0x21 && status != 0x23) {
194                 retval = -ENODEV;
195                 goto out;
196         }
197
198         /* Read the station address PROM.  */
199         for (i = 0; i < 6; i++)
200                 station_addr[i] = inb(ioaddr + E21_SAPROM + i);
201
202         inb(ioaddr + E21_MEDIA);                /* Point to media selection. */
203         outb(0, ioaddr + E21_ASIC);     /* and disable the secondary interface. */
204
205         if (ei_debug  &&  version_printed++ == 0)
206                 printk(version);
207
208         for (i = 0; i < 6; i++)
209                 printk(" %02X", station_addr[i]);
210
211         if (dev->irq < 2) {
212                 int irqlist[] = {15,11,10,12,5,9,3,4}, i;
213                 for (i = 0; i < 8; i++)
214                         if (request_irq (irqlist[i], NULL, 0, "bogus", NULL) != -EBUSY) {
215                                 dev->irq = irqlist[i];
216                                 break;
217                         }
218                 if (i >= 8) {
219                         printk(" unable to get IRQ %d.\n", dev->irq);
220                         retval = -EAGAIN;
221                         goto out;
222                 }
223         } else if (dev->irq == 2)       /* Fixup luser bogosity: IRQ2 is really IRQ9 */
224                 dev->irq = 9;
225
226         /* The 8390 is at the base address. */
227         dev->base_addr = ioaddr;
228
229         ei_status.name = "E2100";
230         ei_status.word16 = 1;
231         ei_status.tx_start_page = E21_TX_START_PG;
232         ei_status.rx_start_page = E21_RX_START_PG;
233         ei_status.stop_page = E21_RX_STOP_PG;
234         ei_status.saved_irq = dev->irq;
235
236         /* Check the media port used.  The port can be passed in on the
237            low mem_end bits. */
238         if (dev->mem_end & 15)
239                 dev->if_port = dev->mem_end & 7;
240         else {
241                 dev->if_port = 0;
242                 inb(ioaddr + E21_MEDIA);        /* Turn automatic media detection on. */
243                 for(i = 0; i < 6; i++)
244                         if (station_addr[i] != inb(ioaddr + E21_SAPROM + 8 + i)) {
245                                 dev->if_port = 1;
246                                 break;
247                         }
248         }
249
250         /* Never map in the E21 shared memory unless you are actively using it.
251            Also, the shared memory has effective only one setting -- spread all
252            over the 128K region! */
253         if (dev->mem_start == 0)
254                 dev->mem_start = 0xd0000;
255
256         ei_status.mem = ioremap(dev->mem_start, 2*1024);
257         if (!ei_status.mem) {
258                 printk("unable to remap memory\n");
259                 retval = -EAGAIN;
260                 goto out;
261         }
262
263 #ifdef notdef
264         /* These values are unused.  The E2100 has a 2K window into the packet
265            buffer.  The window can be set to start on any page boundary. */
266         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
267         dev->mem_end = ei_status.rmem_end = dev->mem_start + 2*1024;
268 #endif
269
270         printk(", IRQ %d, %s media, memory @ %#lx.\n", dev->irq,
271                    dev->if_port ? "secondary" : "primary", dev->mem_start);
272
273         ei_status.reset_8390 = &e21_reset_8390;
274         ei_status.block_input = &e21_block_input;
275         ei_status.block_output = &e21_block_output;
276         ei_status.get_8390_hdr = &e21_get_8390_hdr;
277         dev->open = &e21_open;
278         dev->stop = &e21_close;
279 #ifdef CONFIG_NET_POLL_CONTROLLER
280         dev->poll_controller = ei_poll;
281 #endif
282         NS8390_init(dev, 0);
283
284         retval = register_netdev(dev);
285         if (retval)
286                 goto out;
287         return 0;
288 out:
289         release_region(ioaddr, E21_IO_EXTENT);
290         return retval;
291 }
292
293 static int
294 e21_open(struct net_device *dev)
295 {
296         short ioaddr = dev->base_addr;
297         int retval;
298
299         if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev)))
300                 return retval;
301
302         /* Set the interrupt line and memory base on the hardware. */
303         inb(ioaddr + E21_IRQ_LOW);
304         outb(0, ioaddr + E21_ASIC + (dev->irq & 7));
305         inb(ioaddr + E21_IRQ_HIGH);                     /* High IRQ bit, and if_port. */
306         outb(0, ioaddr + E21_ASIC + (dev->irq > 7 ? 1:0)
307                    + (dev->if_port ? E21_ALT_IFPORT : 0));
308         inb(ioaddr + E21_MEM_BASE);
309         outb(0, ioaddr + E21_ASIC + ((dev->mem_start >> 17) & 7));
310
311         ei_open(dev);
312         return 0;
313 }
314
315 static void
316 e21_reset_8390(struct net_device *dev)
317 {
318         short ioaddr = dev->base_addr;
319
320         outb(0x01, ioaddr);
321         if (ei_debug > 1) printk("resetting the E2180x3 t=%ld...", jiffies);
322         ei_status.txing = 0;
323
324         /* Set up the ASIC registers, just in case something changed them. */
325
326         if (ei_debug > 1) printk("reset done\n");
327         return;
328 }
329
330 /* Grab the 8390 specific header. We put the 2k window so the header page
331    appears at the start of the shared memory. */
332
333 static void
334 e21_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
335 {
336
337         short ioaddr = dev->base_addr;
338         char __iomem *shared_mem = ei_status.mem;
339
340         mem_on(ioaddr, shared_mem, ring_page);
341
342 #ifdef notdef
343         /* Officially this is what we are doing, but the readl() is faster */
344         memcpy_fromio(hdr, shared_mem, sizeof(struct e8390_pkt_hdr));
345 #else
346         ((unsigned int*)hdr)[0] = readl(shared_mem);
347 #endif
348
349         /* Turn off memory access: we would need to reprogram the window anyway. */
350         mem_off(ioaddr);
351
352 }
353
354 /*  Block input and output are easy on shared memory ethercards.
355         The E21xx makes block_input() especially easy by wrapping the top
356         ring buffer to the bottom automatically. */
357 static void
358 e21_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
359 {
360         short ioaddr = dev->base_addr;
361         char __iomem *shared_mem = ei_status.mem;
362
363         mem_on(ioaddr, shared_mem, (ring_offset>>8));
364
365         /* Packet is always in one chunk -- we can copy + cksum. */
366         eth_io_copy_and_sum(skb, ei_status.mem + (ring_offset & 0xff), count, 0);
367
368         mem_off(ioaddr);
369 }
370
371 static void
372 e21_block_output(struct net_device *dev, int count, const unsigned char *buf,
373                                  int start_page)
374 {
375         short ioaddr = dev->base_addr;
376         volatile char __iomem *shared_mem = ei_status.mem;
377
378         /* Set the shared memory window start by doing a read, with the low address
379            bits specifying the starting page. */
380         readb(shared_mem + start_page);
381         mem_on(ioaddr, shared_mem, start_page);
382
383         memcpy_toio(shared_mem, buf, count);
384         mem_off(ioaddr);
385 }
386
387 static int
388 e21_close(struct net_device *dev)
389 {
390         short ioaddr = dev->base_addr;
391
392         if (ei_debug > 1)
393                 printk("%s: Shutting down ethercard.\n", dev->name);
394
395         free_irq(dev->irq, dev);
396         dev->irq = ei_status.saved_irq;
397
398         /* Shut off the interrupt line and secondary interface. */
399         inb(ioaddr + E21_IRQ_LOW);
400         outb(0, ioaddr + E21_ASIC);
401         inb(ioaddr + E21_IRQ_HIGH);                     /* High IRQ bit, and if_port. */
402         outb(0, ioaddr + E21_ASIC);
403
404         ei_close(dev);
405
406         /* Double-check that the memory has been turned off, because really
407            really bad things happen if it isn't. */
408         mem_off(ioaddr);
409
410         return 0;
411 }
412
413 \f
414 #ifdef MODULE
415 #define MAX_E21_CARDS   4       /* Max number of E21 cards per module */
416 static struct net_device *dev_e21[MAX_E21_CARDS];
417 static int io[MAX_E21_CARDS];
418 static int irq[MAX_E21_CARDS];
419 static int mem[MAX_E21_CARDS];
420 static int xcvr[MAX_E21_CARDS];         /* choose int. or ext. xcvr */
421
422 module_param_array(io, int, NULL, 0);
423 module_param_array(irq, int, NULL, 0);
424 module_param_array(mem, int, NULL, 0);
425 module_param_array(xcvr, int, NULL, 0);
426 MODULE_PARM_DESC(io, "I/O base address(es)");
427 MODULE_PARM_DESC(irq, "IRQ number(s)");
428 MODULE_PARM_DESC(mem, " memory base address(es)");
429 MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
430 MODULE_DESCRIPTION("Cabletron E2100 ISA ethernet driver");
431 MODULE_LICENSE("GPL");
432
433 /* This is set up so that only a single autoprobe takes place per call.
434 ISA device autoprobes on a running machine are not recommended. */
435 int
436 init_module(void)
437 {
438         struct net_device *dev;
439         int this_dev, found = 0;
440
441         for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) {
442                 if (io[this_dev] == 0)  {
443                         if (this_dev != 0) break; /* only autoprobe 1st one */
444                         printk(KERN_NOTICE "e2100.c: Presently autoprobing (not recommended) for a single card.\n");
445                 }
446                 dev = alloc_ei_netdev();
447                 if (!dev)
448                         break;
449                 dev->irq = irq[this_dev];
450                 dev->base_addr = io[this_dev];
451                 dev->mem_start = mem[this_dev];
452                 dev->mem_end = xcvr[this_dev];  /* low 4bits = xcvr sel. */
453                 if (do_e2100_probe(dev) == 0) {
454                         dev_e21[found++] = dev;
455                         continue;
456                 }
457                 free_netdev(dev);
458                 printk(KERN_WARNING "e2100.c: No E2100 card found (i/o = 0x%x).\n", io[this_dev]);
459                 break;
460         }
461         if (found)
462                 return 0;
463         return -ENXIO;
464 }
465
466 void
467 cleanup_module(void)
468 {
469         int this_dev;
470
471         for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) {
472                 struct net_device *dev = dev_e21[this_dev];
473                 if (dev) {
474                         unregister_netdev(dev);
475                         cleanup_card(dev);
476                         free_netdev(dev);
477                 }
478         }
479 }
480 #endif /* MODULE */