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+
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>
32 #include <linux/platform_device.h>
34 #include <asm/system.h>
42 #define PROTEON_IO_EXTENT 32
44 /* A zero-terminated list of I/O addresses to be probed. */
45 static unsigned int portlist
[] __initdata
= {
46 0x0A20, 0x0E20, 0x1A20, 0x1E20, 0x2A20, 0x2E20, 0x3A20, 0x3E20,// Prot.
47 0x4A20, 0x4E20, 0x5A20, 0x5E20, 0x6A20, 0x6E20, 0x7A20, 0x7E20,// Prot.
48 0x8A20, 0x8E20, 0x9A20, 0x9E20, 0xAA20, 0xAE20, 0xBA20, 0xBE20,// Prot.
49 0xCA20, 0xCE20, 0xDA20, 0xDE20, 0xEA20, 0xEE20, 0xFA20, 0xFE20,// Prot.
53 /* A zero-terminated list of IRQs to be probed. */
54 static unsigned short irqlist
[] = {
55 7, 6, 5, 4, 3, 12, 11, 10, 9,
59 /* A zero-terminated list of DMAs to be probed. */
60 static int dmalist
[] __initdata
= {
65 static char cardname
[] = "Proteon 1392\0";
66 static u64 dma_mask
= ISA_MAX_ADDRESS
;
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
, struct device
*pdev
)
121 struct net_local
*tp
;
122 static int versionprinted
;
123 const unsigned *port
;
129 if (dev
->base_addr
) /* probe specific location */
130 err
= proteon_probe1(dev
, dev
->base_addr
);
132 for (port
= portlist
; *port
; port
++) {
133 err
= proteon_probe1(dev
, *port
);
141 /* At this point we have found a valid card. */
143 if (versionprinted
++ == 0)
144 printk(KERN_DEBUG
"%s", version
);
147 pdev
->dma_mask
= &dma_mask
;
148 if (tmsdev_init(dev
, pdev
))
151 dev
->base_addr
&= ~3;
153 proteon_read_eeprom(dev
);
155 printk(KERN_DEBUG
"proteon.c: Ring Station Address: %pM\n",
158 tp
= netdev_priv(dev
);
159 tp
->setnselout
= proteon_setnselout_pins
;
161 tp
->sifreadb
= proteon_sifreadb
;
162 tp
->sifreadw
= proteon_sifreadw
;
163 tp
->sifwriteb
= proteon_sifwriteb
;
164 tp
->sifwritew
= proteon_sifwritew
;
166 memcpy(tp
->ProductID
, cardname
, PROD_ID_SIZE
+ 1);
170 dev
->open
= proteon_open
;
171 dev
->stop
= tms380tr_close
;
175 for(j
= 0; irqlist
[j
] != 0; j
++)
177 dev
->irq
= irqlist
[j
];
178 if (!request_irq(dev
->irq
, tms380tr_interrupt
, 0,
185 printk(KERN_INFO
"proteon.c: AutoSelect no IRQ available\n");
191 for(j
= 0; irqlist
[j
] != 0; j
++)
192 if (irqlist
[j
] == dev
->irq
)
196 printk(KERN_INFO
"proteon.c: Illegal IRQ %d specified\n",
200 if (request_irq(dev
->irq
, tms380tr_interrupt
, 0,
203 printk(KERN_INFO
"proteon.c: Selected IRQ %d not available\n",
211 for(j
= 0; dmalist
[j
] != 0; j
++)
213 dev
->dma
= dmalist
[j
];
214 if (!request_dma(dev
->dma
, cardname
))
220 printk(KERN_INFO
"proteon.c: AutoSelect no DMA available\n");
226 for(j
= 0; dmalist
[j
] != 0; j
++)
227 if (dmalist
[j
] == dev
->dma
)
231 printk(KERN_INFO
"proteon.c: Illegal DMA %d specified\n",
235 if (request_dma(dev
->dma
, cardname
))
237 printk(KERN_INFO
"proteon.c: Selected DMA %d not available\n",
243 err
= register_netdev(dev
);
247 printk(KERN_DEBUG
"%s: IO: %#4lx IRQ: %d DMA: %d\n",
248 dev
->name
, dev
->base_addr
, dev
->irq
, dev
->dma
);
254 free_irq(dev
->irq
, dev
);
258 release_region(dev
->base_addr
, PROTEON_IO_EXTENT
);
264 * Reads MAC address from adapter RAM, which should've read it from
267 * Calling this on a board that does not support it can be a very
268 * dangerous thing. The Madge board, for instance, will lock your
269 * machine hard when this is called. Luckily, its supported in a
270 * separate driver. --ASF
272 static void proteon_read_eeprom(struct net_device
*dev
)
276 /* Address: 0000:0000 */
277 proteon_sifwritew(dev
, 0, SIFADX
);
278 proteon_sifwritew(dev
, 0, SIFADR
);
280 /* Read six byte MAC address data */
282 for(i
= 0; i
< 6; i
++)
283 dev
->dev_addr
[i
] = proteon_sifreadw(dev
, SIFINC
) >> 8;
286 static unsigned short proteon_setnselout_pins(struct net_device
*dev
)
291 static int proteon_open(struct net_device
*dev
)
293 struct net_local
*tp
= netdev_priv(dev
);
294 unsigned short val
= 0;
297 /* Proteon reset sequence */
298 outb(0, dev
->base_addr
+ 0x11);
300 outb(0x04, dev
->base_addr
+ 0x11);
302 outb(0, dev
->base_addr
+ 0x11);
305 /* set control/status reg */
306 val
= inb(dev
->base_addr
+ 0x11);
309 if(tp
->DataRate
== SPEED_4
)
314 outb(val
, dev
->base_addr
+ 0x11);
315 outb(0xff, dev
->base_addr
+ 0x12);
316 for(i
= 0; irqlist
[i
] != 0; i
++)
318 if(irqlist
[i
] == dev
->irq
)
322 i
= (7 - dev
->dma
) << 4;
324 outb(val
, dev
->base_addr
+ 0x13);
326 return tms380tr_open(dev
);
329 #define ISATR_MAX_ADAPTERS 3
331 static int io
[ISATR_MAX_ADAPTERS
];
332 static int irq
[ISATR_MAX_ADAPTERS
];
333 static int dma
[ISATR_MAX_ADAPTERS
];
335 MODULE_LICENSE("GPL");
337 module_param_array(io
, int, NULL
, 0);
338 module_param_array(irq
, int, NULL
, 0);
339 module_param_array(dma
, int, NULL
, 0);
341 static struct platform_device
*proteon_dev
[ISATR_MAX_ADAPTERS
];
343 static struct platform_driver proteon_driver
= {
349 static int __init
proteon_init(void)
351 struct net_device
*dev
;
352 struct platform_device
*pdev
;
353 int i
, num
= 0, err
= 0;
355 err
= platform_driver_register(&proteon_driver
);
359 for (i
= 0; i
< ISATR_MAX_ADAPTERS
; i
++) {
360 dev
= alloc_trdev(sizeof(struct net_local
));
364 dev
->base_addr
= io
[i
];
367 pdev
= platform_device_register_simple("proteon",
373 err
= setup_card(dev
, &pdev
->dev
);
375 proteon_dev
[i
] = pdev
;
376 platform_set_drvdata(pdev
, dev
);
379 platform_device_unregister(pdev
);
384 printk(KERN_NOTICE
"proteon.c: %d cards found.\n", num
);
385 /* Probe for cards. */
387 printk(KERN_NOTICE
"proteon.c: No cards found.\n");
388 platform_driver_unregister(&proteon_driver
);
394 static void __exit
proteon_cleanup(void)
396 struct net_device
*dev
;
399 for (i
= 0; i
< ISATR_MAX_ADAPTERS
; i
++) {
400 struct platform_device
*pdev
= proteon_dev
[i
];
404 dev
= platform_get_drvdata(pdev
);
405 unregister_netdev(dev
);
406 release_region(dev
->base_addr
, PROTEON_IO_EXTENT
);
407 free_irq(dev
->irq
, dev
);
411 platform_set_drvdata(pdev
, NULL
);
412 platform_device_unregister(pdev
);
414 platform_driver_unregister(&proteon_driver
);
417 module_init(proteon_init
);
418 module_exit(proteon_cleanup
);