2 * proteon.c: A network driver for Proteon ISA token ring cards.
4 * Based on tmspci written 1999 by Adam Fritzler
6 * Written 2003 by Jochen Friedrich
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
11 * This driver module supports the following cards:
12 * - Proteon 1392, 1392+
15 * AF Adam Fritzler mid@auk.cx
16 * JF Jochen Friedrich jochen@scram.de
18 * Modification History:
19 * 02-Jan-03 JF Created
22 static const char version[] = "proteon.c: v1.00 02/01/2003 by Jochen Friedrich\n";
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/delay.h>
27 #include <linux/errno.h>
28 #include <linux/pci.h>
29 #include <linux/init.h>
30 #include <linux/netdevice.h>
31 #include <linux/trdevice.h>
33 #include <asm/system.h>
41 #define PROTEON_IO_EXTENT 32
43 /* A zero-terminated list of I/O addresses to be probed. */
44 static unsigned int portlist[] __initdata = {
45 0x0A20, 0x0E20, 0x1A20, 0x1E20, 0x2A20, 0x2E20, 0x3A20, 0x3E20,// Prot.
46 0x4A20, 0x4E20, 0x5A20, 0x5E20, 0x6A20, 0x6E20, 0x7A20, 0x7E20,// Prot.
47 0x8A20, 0x8E20, 0x9A20, 0x9E20, 0xAA20, 0xAE20, 0xBA20, 0xBE20,// Prot.
48 0xCA20, 0xCE20, 0xDA20, 0xDE20, 0xEA20, 0xEE20, 0xFA20, 0xFE20,// Prot.
52 /* A zero-terminated list of IRQs to be probed. */
53 static unsigned short irqlist[] = {
54 7, 6, 5, 4, 3, 12, 11, 10, 9,
58 /* A zero-terminated list of DMAs to be probed. */
59 static int dmalist[] __initdata = {
64 static char cardname[] = "Proteon 1392\0";
66 struct net_device *proteon_probe(int unit);
67 static int proteon_open(struct net_device *dev);
68 static void proteon_read_eeprom(struct net_device *dev);
69 static unsigned short proteon_setnselout_pins(struct net_device *dev);
71 static unsigned short proteon_sifreadb(struct net_device *dev, unsigned short reg)
73 return inb(dev->base_addr + reg);
76 static unsigned short proteon_sifreadw(struct net_device *dev, unsigned short reg)
78 return inw(dev->base_addr + reg);
81 static void proteon_sifwriteb(struct net_device *dev, unsigned short val, unsigned short reg)
83 outb(val, dev->base_addr + reg);
86 static void proteon_sifwritew(struct net_device *dev, unsigned short val, unsigned short reg)
88 outw(val, dev->base_addr + reg);
91 static int __init proteon_probe1(struct net_device *dev, int ioaddr)
93 unsigned char chk1, chk2;
96 if (!request_region(ioaddr, PROTEON_IO_EXTENT, cardname))
100 chk1 = inb(ioaddr + 0x1f); /* Get Proteon ID reg 1 */
104 chk1 = inb(ioaddr + 0x1e) & 0x07; /* Get Proteon ID reg 0 */
105 for (i=0; i<16; i++) {
106 chk2 = inb(ioaddr + 0x1e) & 0x07;
107 if (((chk1 + 1) & 0x07) != chk2)
112 dev->base_addr = ioaddr;
115 release_region(ioaddr, PROTEON_IO_EXTENT);
119 static int __init setup_card(struct net_device *dev)
121 struct net_local *tp;
122 static int versionprinted;
123 const unsigned *port;
129 SET_MODULE_OWNER(dev);
130 if (dev->base_addr) /* probe specific location */
131 err = proteon_probe1(dev, dev->base_addr);
133 for (port = portlist; *port; port++) {
134 err = proteon_probe1(dev, *port);
142 /* At this point we have found a valid card. */
144 if (versionprinted++ == 0)
145 printk(KERN_DEBUG "%s", version);
148 if (tmsdev_init(dev, ISA_MAX_ADDRESS, NULL))
151 dev->base_addr &= ~3;
153 proteon_read_eeprom(dev);
155 printk(KERN_DEBUG "%s: Ring Station Address: ", dev->name);
156 printk("%2.2x", dev->dev_addr[0]);
157 for (j = 1; j < 6; j++)
158 printk(":%2.2x", dev->dev_addr[j]);
161 tp = netdev_priv(dev);
162 tp->setnselout = proteon_setnselout_pins;
164 tp->sifreadb = proteon_sifreadb;
165 tp->sifreadw = proteon_sifreadw;
166 tp->sifwriteb = proteon_sifwriteb;
167 tp->sifwritew = proteon_sifwritew;
169 memcpy(tp->ProductID, cardname, PROD_ID_SIZE + 1);
173 dev->open = proteon_open;
174 dev->stop = tms380tr_close;
178 for(j = 0; irqlist[j] != 0; j++)
180 dev->irq = irqlist[j];
181 if (!request_irq(dev->irq, tms380tr_interrupt, 0,
188 printk(KERN_INFO "%s: AutoSelect no IRQ available\n", dev->name);
194 for(j = 0; irqlist[j] != 0; j++)
195 if (irqlist[j] == dev->irq)
199 printk(KERN_INFO "%s: Illegal IRQ %d specified\n",
200 dev->name, dev->irq);
203 if (request_irq(dev->irq, tms380tr_interrupt, 0,
206 printk(KERN_INFO "%s: Selected IRQ %d not available\n",
207 dev->name, dev->irq);
214 for(j = 0; dmalist[j] != 0; j++)
216 dev->dma = dmalist[j];
217 if (!request_dma(dev->dma, cardname))
223 printk(KERN_INFO "%s: AutoSelect no DMA available\n", dev->name);
229 for(j = 0; dmalist[j] != 0; j++)
230 if (dmalist[j] == dev->dma)
234 printk(KERN_INFO "%s: Illegal DMA %d specified\n",
235 dev->name, dev->dma);
238 if (request_dma(dev->dma, cardname))
240 printk(KERN_INFO "%s: Selected DMA %d not available\n",
241 dev->name, dev->dma);
246 printk(KERN_DEBUG "%s: IO: %#4lx IRQ: %d DMA: %d\n",
247 dev->name, dev->base_addr, dev->irq, dev->dma);
249 err = register_netdev(dev);
257 free_irq(dev->irq, dev);
261 release_region(dev->base_addr, PROTEON_IO_EXTENT);
265 struct net_device * __init proteon_probe(int unit)
267 struct net_device *dev = alloc_trdev(sizeof(struct net_local));
271 return ERR_PTR(-ENOMEM);
274 sprintf(dev->name, "tr%d", unit);
275 netdev_boot_setup_check(dev);
278 err = setup_card(dev);
290 * Reads MAC address from adapter RAM, which should've read it from
293 * Calling this on a board that does not support it can be a very
294 * dangerous thing. The Madge board, for instance, will lock your
295 * machine hard when this is called. Luckily, its supported in a
296 * separate driver. --ASF
298 static void proteon_read_eeprom(struct net_device *dev)
302 /* Address: 0000:0000 */
303 proteon_sifwritew(dev, 0, SIFADX);
304 proteon_sifwritew(dev, 0, SIFADR);
306 /* Read six byte MAC address data */
308 for(i = 0; i < 6; i++)
309 dev->dev_addr[i] = proteon_sifreadw(dev, SIFINC) >> 8;
312 unsigned short proteon_setnselout_pins(struct net_device *dev)
317 static int proteon_open(struct net_device *dev)
319 struct net_local *tp = netdev_priv(dev);
320 unsigned short val = 0;
323 /* Proteon reset sequence */
324 outb(0, dev->base_addr + 0x11);
326 outb(0x04, dev->base_addr + 0x11);
328 outb(0, dev->base_addr + 0x11);
331 /* set control/status reg */
332 val = inb(dev->base_addr + 0x11);
335 if(tp->DataRate == SPEED_4)
340 outb(val, dev->base_addr + 0x11);
341 outb(0xff, dev->base_addr + 0x12);
342 for(i = 0; irqlist[i] != 0; i++)
344 if(irqlist[i] == dev->irq)
348 i = (7 - dev->dma) << 4;
350 outb(val, dev->base_addr + 0x13);
352 return tms380tr_open(dev);
357 #define ISATR_MAX_ADAPTERS 3
359 static int io[ISATR_MAX_ADAPTERS];
360 static int irq[ISATR_MAX_ADAPTERS];
361 static int dma[ISATR_MAX_ADAPTERS];
363 MODULE_LICENSE("GPL");
365 module_param_array(io, int, NULL, 0);
366 module_param_array(irq, int, NULL, 0);
367 module_param_array(dma, int, NULL, 0);
369 static struct net_device *proteon_dev[ISATR_MAX_ADAPTERS];
371 int init_module(void)
373 struct net_device *dev;
374 int i, num = 0, err = 0;
376 for (i = 0; i < ISATR_MAX_ADAPTERS ; i++) {
377 dev = alloc_trdev(sizeof(struct net_local));
381 dev->base_addr = io[i];
384 err = setup_card(dev);
386 proteon_dev[i] = dev;
393 printk(KERN_NOTICE "proteon.c: %d cards found.\n", num);
394 /* Probe for cards. */
396 printk(KERN_NOTICE "proteon.c: No cards found.\n");
402 void cleanup_module(void)
406 for (i = 0; i < ISATR_MAX_ADAPTERS ; i++) {
407 struct net_device *dev = proteon_dev[i];
412 unregister_netdev(dev);
413 release_region(dev->base_addr, PROTEON_IO_EXTENT);
414 free_irq(dev->irq, dev);