Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Linux ARCnet driver - COM90xx chipset (IO-mapped buffers) | |
cb334648 | 3 | * |
1da177e4 LT |
4 | * Written 1997 by David Woodhouse. |
5 | * Written 1994-1999 by Avery Pennarun. | |
6 | * Written 1999-2000 by Martin Mares <mj@ucw.cz>. | |
7 | * Derived from skeleton.c by Donald Becker. | |
8 | * | |
9 | * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com) | |
10 | * for sponsoring the further development of this driver. | |
11 | * | |
12 | * ********************** | |
13 | * | |
14 | * The original copyright of skeleton.c was as follows: | |
15 | * | |
16 | * skeleton.c Written 1993 by Donald Becker. | |
17 | * Copyright 1993 United States Government as represented by the | |
18 | * Director, National Security Agency. This software may only be used | |
19 | * and distributed according to the terms of the GNU General Public License as | |
20 | * modified by SRC, incorporated herein by reference. | |
21 | * | |
22 | * ********************** | |
23 | * | |
24 | * For more details, see drivers/net/arcnet.c | |
25 | * | |
26 | * ********************** | |
27 | */ | |
28 | #include <linux/kernel.h> | |
29 | #include <linux/module.h> | |
30 | #include <linux/moduleparam.h> | |
31 | #include <linux/ioport.h> | |
1da177e4 LT |
32 | #include <linux/delay.h> |
33 | #include <linux/netdevice.h> | |
34 | #include <linux/bootmem.h> | |
35 | #include <linux/init.h> | |
a6b7a407 | 36 | #include <linux/interrupt.h> |
5e7ef913 | 37 | #include <linux/io.h> |
1da177e4 LT |
38 | #include <linux/arcdevice.h> |
39 | ||
1da177e4 LT |
40 | #define VERSION "arcnet: COM90xx IO-mapped mode support (by David Woodhouse et el.)\n" |
41 | ||
1da177e4 LT |
42 | /* Internal function declarations */ |
43 | ||
44 | static int com90io_found(struct net_device *dev); | |
45 | static void com90io_command(struct net_device *dev, int command); | |
46 | static int com90io_status(struct net_device *dev); | |
47 | static void com90io_setmask(struct net_device *dev, int mask); | |
48 | static int com90io_reset(struct net_device *dev, int really_reset); | |
49 | static void com90io_copy_to_card(struct net_device *dev, int bufnum, int offset, | |
50 | void *buf, int count); | |
51 | static void com90io_copy_from_card(struct net_device *dev, int bufnum, int offset, | |
52 | void *buf, int count); | |
53 | ||
1da177e4 LT |
54 | /* Handy defines for ARCnet specific stuff */ |
55 | ||
56 | /* The number of low I/O ports used by the card. */ | |
57 | #define ARCNET_TOTAL_SIZE 16 | |
58 | ||
59 | /* COM 9026 controller chip --> ARCnet register addresses */ | |
cb334648 JP |
60 | #define _INTMASK (ioaddr + 0) /* writable */ |
61 | #define _STATUS (ioaddr + 0) /* readable */ | |
62 | #define _COMMAND (ioaddr + 1) /* writable, returns random vals on read (?) */ | |
63 | #define _RESET (ioaddr + 8) /* software reset (on read) */ | |
64 | #define _MEMDATA (ioaddr + 12) /* Data port for IO-mapped memory */ | |
65 | #define _ADDR_HI (ioaddr + 15) /* Control registers for said */ | |
66 | #define _ADDR_LO (ioaddr + 14) | |
67 | #define _CONFIG (ioaddr + 2) /* Configuration register */ | |
1da177e4 LT |
68 | |
69 | #undef ASTATUS | |
70 | #undef ACOMMAND | |
71 | #undef AINTMASK | |
72 | ||
73 | #define ASTATUS() inb(_STATUS) | |
cb334648 JP |
74 | #define ACOMMAND(cmd) outb((cmd), _COMMAND) |
75 | #define AINTMASK(msk) outb((msk), _INTMASK) | |
76 | #define SETCONF() outb((lp->config), _CONFIG) | |
1da177e4 | 77 | |
1da177e4 LT |
78 | /**************************************************************************** |
79 | * * | |
80 | * IO-mapped operation routines * | |
81 | * * | |
82 | ****************************************************************************/ | |
83 | ||
84 | #undef ONE_AT_A_TIME_TX | |
85 | #undef ONE_AT_A_TIME_RX | |
86 | ||
87 | static u_char get_buffer_byte(struct net_device *dev, unsigned offset) | |
88 | { | |
89 | int ioaddr = dev->base_addr; | |
90 | ||
91 | outb(offset >> 8, _ADDR_HI); | |
92 | outb(offset & 0xff, _ADDR_LO); | |
93 | ||
94 | return inb(_MEMDATA); | |
95 | } | |
96 | ||
97 | #ifdef ONE_AT_A_TIME_TX | |
98 | static void put_buffer_byte(struct net_device *dev, unsigned offset, u_char datum) | |
99 | { | |
100 | int ioaddr = dev->base_addr; | |
101 | ||
102 | outb(offset >> 8, _ADDR_HI); | |
103 | outb(offset & 0xff, _ADDR_LO); | |
104 | ||
105 | outb(datum, _MEMDATA); | |
106 | } | |
107 | ||
108 | #endif | |
109 | ||
1da177e4 LT |
110 | static void get_whole_buffer(struct net_device *dev, unsigned offset, unsigned length, char *dest) |
111 | { | |
112 | int ioaddr = dev->base_addr; | |
113 | ||
114 | outb((offset >> 8) | AUTOINCflag, _ADDR_HI); | |
115 | outb(offset & 0xff, _ADDR_LO); | |
116 | ||
117 | while (length--) | |
118 | #ifdef ONE_AT_A_TIME_RX | |
119 | *(dest++) = get_buffer_byte(dev, offset++); | |
120 | #else | |
121 | *(dest++) = inb(_MEMDATA); | |
122 | #endif | |
123 | } | |
124 | ||
125 | static void put_whole_buffer(struct net_device *dev, unsigned offset, unsigned length, char *dest) | |
126 | { | |
127 | int ioaddr = dev->base_addr; | |
128 | ||
129 | outb((offset >> 8) | AUTOINCflag, _ADDR_HI); | |
130 | outb(offset & 0xff, _ADDR_LO); | |
131 | ||
132 | while (length--) | |
133 | #ifdef ONE_AT_A_TIME_TX | |
134 | put_buffer_byte(dev, offset++, *(dest++)); | |
135 | #else | |
136 | outb(*(dest++), _MEMDATA); | |
137 | #endif | |
138 | } | |
139 | ||
140 | /* | |
141 | * We cannot probe for an IO mapped card either, although we can check that | |
142 | * it's where we were told it was, and even autoirq | |
143 | */ | |
144 | static int __init com90io_probe(struct net_device *dev) | |
145 | { | |
146 | int ioaddr = dev->base_addr, status; | |
147 | unsigned long airqmask; | |
148 | ||
149 | BUGLVL(D_NORMAL) printk(VERSION); | |
150 | BUGLVL(D_NORMAL) printk("E-mail me if you actually test this driver, please!\n"); | |
151 | ||
152 | if (!ioaddr) { | |
3b4e5551 | 153 | BUGMSG(D_NORMAL, "No autoprobe for IO mapped cards; you must specify the base address!\n"); |
1da177e4 LT |
154 | return -ENODEV; |
155 | } | |
156 | if (!request_region(ioaddr, ARCNET_TOTAL_SIZE, "com90io probe")) { | |
fb911ee8 | 157 | BUGMSG(D_INIT_REASONS, "IO request_region %x-%x failed.\n", |
1da177e4 LT |
158 | ioaddr, ioaddr + ARCNET_TOTAL_SIZE - 1); |
159 | return -ENXIO; | |
160 | } | |
161 | if (ASTATUS() == 0xFF) { | |
162 | BUGMSG(D_INIT_REASONS, "IO address %x empty\n", ioaddr); | |
163 | goto err_out; | |
164 | } | |
165 | inb(_RESET); | |
166 | mdelay(RESETtime); | |
167 | ||
168 | status = ASTATUS(); | |
169 | ||
170 | if ((status & 0x9D) != (NORXflag | RECONflag | TXFREEflag | RESETflag)) { | |
171 | BUGMSG(D_INIT_REASONS, "Status invalid (%Xh).\n", status); | |
172 | goto err_out; | |
173 | } | |
174 | BUGMSG(D_INIT_REASONS, "Status after reset: %X\n", status); | |
175 | ||
176 | ACOMMAND(CFLAGScmd | RESETclear | CONFIGclear); | |
177 | ||
178 | BUGMSG(D_INIT_REASONS, "Status after reset acknowledged: %X\n", status); | |
179 | ||
180 | status = ASTATUS(); | |
181 | ||
182 | if (status & RESETflag) { | |
183 | BUGMSG(D_INIT_REASONS, "Eternal reset (status=%Xh)\n", status); | |
184 | goto err_out; | |
185 | } | |
186 | outb((0x16 | IOMAPflag) & ~ENABLE16flag, _CONFIG); | |
187 | ||
188 | /* Read first loc'n of memory */ | |
189 | ||
190 | outb(AUTOINCflag, _ADDR_HI); | |
191 | outb(0, _ADDR_LO); | |
192 | ||
193 | if ((status = inb(_MEMDATA)) != 0xd1) { | |
3b4e5551 JP |
194 | BUGMSG(D_INIT_REASONS, "Signature byte not found (%Xh instead).\n", |
195 | status); | |
1da177e4 LT |
196 | goto err_out; |
197 | } | |
198 | if (!dev->irq) { | |
199 | /* | |
200 | * if we do this, we're sure to get an IRQ since the | |
201 | * card has just reset and the NORXflag is on until | |
202 | * we tell it to start receiving. | |
203 | */ | |
204 | ||
205 | airqmask = probe_irq_on(); | |
206 | outb(NORXflag, _INTMASK); | |
207 | udelay(1); | |
208 | outb(0, _INTMASK); | |
209 | dev->irq = probe_irq_off(airqmask); | |
210 | ||
0a6efc78 | 211 | if ((int)dev->irq <= 0) { |
1da177e4 LT |
212 | BUGMSG(D_INIT_REASONS, "Autoprobe IRQ failed\n"); |
213 | goto err_out; | |
214 | } | |
215 | } | |
216 | release_region(ioaddr, ARCNET_TOTAL_SIZE); /* end of probing */ | |
217 | return com90io_found(dev); | |
218 | ||
219 | err_out: | |
220 | release_region(ioaddr, ARCNET_TOTAL_SIZE); | |
221 | return -ENODEV; | |
222 | } | |
223 | ||
1da177e4 LT |
224 | /* Set up the struct net_device associated with this card. Called after |
225 | * probing succeeds. | |
226 | */ | |
227 | static int __init com90io_found(struct net_device *dev) | |
228 | { | |
229 | struct arcnet_local *lp; | |
230 | int ioaddr = dev->base_addr; | |
231 | int err; | |
232 | ||
233 | /* Reserve the irq */ | |
a0607fd3 | 234 | if (request_irq(dev->irq, arcnet_interrupt, 0, "arcnet (COM90xx-IO)", dev)) { |
1da177e4 LT |
235 | BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", dev->irq); |
236 | return -ENODEV; | |
237 | } | |
fb911ee8 | 238 | /* Reserve the I/O region */ |
1da177e4 LT |
239 | if (!request_region(dev->base_addr, ARCNET_TOTAL_SIZE, "arcnet (COM90xx-IO)")) { |
240 | free_irq(dev->irq, dev); | |
241 | return -EBUSY; | |
242 | } | |
243 | ||
454d7c9b | 244 | lp = netdev_priv(dev); |
1da177e4 LT |
245 | lp->card_name = "COM90xx I/O"; |
246 | lp->hw.command = com90io_command; | |
247 | lp->hw.status = com90io_status; | |
248 | lp->hw.intmask = com90io_setmask; | |
249 | lp->hw.reset = com90io_reset; | |
250 | lp->hw.owner = THIS_MODULE; | |
251 | lp->hw.copy_to_card = com90io_copy_to_card; | |
252 | lp->hw.copy_from_card = com90io_copy_from_card; | |
253 | ||
254 | lp->config = (0x16 | IOMAPflag) & ~ENABLE16flag; | |
255 | SETCONF(); | |
256 | ||
257 | /* get and check the station ID from offset 1 in shmem */ | |
258 | ||
259 | dev->dev_addr[0] = get_buffer_byte(dev, 1); | |
260 | ||
261 | err = register_netdev(dev); | |
262 | if (err) { | |
263 | outb((inb(_CONFIG) & ~IOMAPflag), _CONFIG); | |
264 | free_irq(dev->irq, dev); | |
265 | release_region(dev->base_addr, ARCNET_TOTAL_SIZE); | |
266 | return err; | |
267 | } | |
268 | ||
269 | BUGMSG(D_NORMAL, "COM90IO: station %02Xh found at %03lXh, IRQ %d.\n", | |
270 | dev->dev_addr[0], dev->base_addr, dev->irq); | |
271 | ||
272 | return 0; | |
273 | } | |
274 | ||
1da177e4 LT |
275 | /* |
276 | * Do a hardware reset on the card, and set up necessary registers. | |
277 | * | |
278 | * This should be called as little as possible, because it disrupts the | |
279 | * token on the network (causes a RECON) and requires a significant delay. | |
280 | * | |
281 | * However, it does make sure the card is in a defined state. | |
282 | */ | |
283 | static int com90io_reset(struct net_device *dev, int really_reset) | |
284 | { | |
454d7c9b | 285 | struct arcnet_local *lp = netdev_priv(dev); |
1da177e4 LT |
286 | short ioaddr = dev->base_addr; |
287 | ||
288 | BUGMSG(D_INIT, "Resetting %s (status=%02Xh)\n", dev->name, ASTATUS()); | |
289 | ||
290 | if (really_reset) { | |
291 | /* reset the card */ | |
292 | inb(_RESET); | |
293 | mdelay(RESETtime); | |
294 | } | |
295 | /* Set the thing to IO-mapped, 8-bit mode */ | |
296 | lp->config = (0x1C | IOMAPflag) & ~ENABLE16flag; | |
297 | SETCONF(); | |
298 | ||
299 | ACOMMAND(CFLAGScmd | RESETclear); /* clear flags & end reset */ | |
300 | ACOMMAND(CFLAGScmd | CONFIGclear); | |
301 | ||
302 | /* verify that the ARCnet signature byte is present */ | |
303 | if (get_buffer_byte(dev, 0) != TESTvalue) { | |
304 | BUGMSG(D_NORMAL, "reset failed: TESTvalue not present.\n"); | |
305 | return 1; | |
306 | } | |
307 | /* enable extended (512-byte) packets */ | |
308 | ACOMMAND(CONFIGcmd | EXTconf); | |
309 | ||
310 | /* done! return success. */ | |
311 | return 0; | |
312 | } | |
313 | ||
1da177e4 LT |
314 | static void com90io_command(struct net_device *dev, int cmd) |
315 | { | |
316 | short ioaddr = dev->base_addr; | |
317 | ||
318 | ACOMMAND(cmd); | |
319 | } | |
320 | ||
1da177e4 LT |
321 | static int com90io_status(struct net_device *dev) |
322 | { | |
323 | short ioaddr = dev->base_addr; | |
324 | ||
325 | return ASTATUS(); | |
326 | } | |
327 | ||
1da177e4 LT |
328 | static void com90io_setmask(struct net_device *dev, int mask) |
329 | { | |
330 | short ioaddr = dev->base_addr; | |
331 | ||
332 | AINTMASK(mask); | |
333 | } | |
334 | ||
335 | static void com90io_copy_to_card(struct net_device *dev, int bufnum, int offset, | |
336 | void *buf, int count) | |
337 | { | |
338 | TIME("put_whole_buffer", count, put_whole_buffer(dev, bufnum * 512 + offset, count, buf)); | |
339 | } | |
340 | ||
1da177e4 LT |
341 | static void com90io_copy_from_card(struct net_device *dev, int bufnum, int offset, |
342 | void *buf, int count) | |
343 | { | |
344 | TIME("get_whole_buffer", count, get_whole_buffer(dev, bufnum * 512 + offset, count, buf)); | |
345 | } | |
346 | ||
347 | static int io; /* use the insmod io= irq= shmem= options */ | |
348 | static int irq; | |
349 | static char device[9]; /* use eg. device=arc1 to change name */ | |
350 | ||
351 | module_param(io, int, 0); | |
352 | module_param(irq, int, 0); | |
353 | module_param_string(device, device, sizeof(device), 0); | |
354 | MODULE_LICENSE("GPL"); | |
355 | ||
356 | #ifndef MODULE | |
357 | static int __init com90io_setup(char *s) | |
358 | { | |
359 | int ints[4]; | |
01a1d5ac | 360 | |
1da177e4 LT |
361 | s = get_options(s, 4, ints); |
362 | if (!ints[0]) | |
363 | return 0; | |
364 | switch (ints[0]) { | |
365 | default: /* ERROR */ | |
366 | printk("com90io: Too many arguments.\n"); | |
367 | case 2: /* IRQ */ | |
368 | irq = ints[2]; | |
369 | case 1: /* IO address */ | |
370 | io = ints[1]; | |
371 | } | |
372 | if (*s) | |
373 | snprintf(device, sizeof(device), "%s", s); | |
374 | return 1; | |
375 | } | |
376 | __setup("com90io=", com90io_setup); | |
377 | #endif | |
378 | ||
379 | static struct net_device *my_dev; | |
380 | ||
381 | static int __init com90io_init(void) | |
382 | { | |
383 | struct net_device *dev; | |
384 | int err; | |
385 | ||
386 | dev = alloc_arcdev(device); | |
387 | if (!dev) | |
388 | return -ENOMEM; | |
389 | ||
1da177e4 LT |
390 | dev->base_addr = io; |
391 | dev->irq = irq; | |
392 | if (dev->irq == 2) | |
393 | dev->irq = 9; | |
394 | ||
395 | err = com90io_probe(dev); | |
396 | ||
397 | if (err) { | |
398 | free_netdev(dev); | |
399 | return err; | |
400 | } | |
401 | ||
402 | my_dev = dev; | |
403 | return 0; | |
404 | } | |
405 | ||
406 | static void __exit com90io_exit(void) | |
407 | { | |
408 | struct net_device *dev = my_dev; | |
409 | int ioaddr = dev->base_addr; | |
410 | ||
411 | unregister_netdev(dev); | |
412 | ||
413 | /* Set the thing back to MMAP mode, in case the old driver is loaded later */ | |
414 | outb((inb(_CONFIG) & ~IOMAPflag), _CONFIG); | |
415 | ||
416 | free_irq(dev->irq, dev); | |
417 | release_region(dev->base_addr, ARCNET_TOTAL_SIZE); | |
418 | free_netdev(dev); | |
419 | } | |
420 | ||
421 | module_init(com90io_init) | |
422 | module_exit(com90io_exit) |