2 * Linux ARCnet driver - COM90xx chipset (memory-mapped buffers)
4 * Written 1994-1999 by Avery Pennarun.
5 * Written 1999 by Martin Mares <mj@ucw.cz>.
6 * Derived from skeleton.c by Donald Becker.
8 * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
9 * for sponsoring the further development of this driver.
11 * **********************
13 * The original copyright of skeleton.c was as follows:
15 * skeleton.c Written 1993 by Donald Becker.
16 * Copyright 1993 United States Government as represented by the
17 * Director, National Security Agency. This software may only be used
18 * and distributed according to the terms of the GNU General Public License as
19 * modified by SRC, incorporated herein by reference.
21 * **********************
23 * For more details, see drivers/net/arcnet.c
25 * **********************
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/init.h>
30 #include <linux/interrupt.h>
31 #include <linux/ioport.h>
32 #include <linux/delay.h>
33 #include <linux/netdevice.h>
34 #include <linux/slab.h>
36 #include <linux/arcdevice.h>
38 #define VERSION "arcnet: COM90xx chipset support\n"
40 /* Define this to speed up the autoprobe by assuming if only one io port and
41 * shmem are left in the list at Stage 5, they must correspond to each
44 * This is undefined by default because it might not always be true, and the
45 * extra check makes the autoprobe even more careful. Speed demons can turn
46 * it on - I think it should be fine if you only have one ARCnet card
49 * If no ARCnet cards are installed, this delay never happens anyway and thus
50 * the option has no effect.
54 /* Internal function declarations */
55 static int com90xx_found(int ioaddr
, int airq
, u_long shmem
, void __iomem
*);
56 static void com90xx_command(struct net_device
*dev
, int command
);
57 static int com90xx_status(struct net_device
*dev
);
58 static void com90xx_setmask(struct net_device
*dev
, int mask
);
59 static int com90xx_reset(struct net_device
*dev
, int really_reset
);
60 static void com90xx_copy_to_card(struct net_device
*dev
, int bufnum
, int offset
,
61 void *buf
, int count
);
62 static void com90xx_copy_from_card(struct net_device
*dev
, int bufnum
, int offset
,
63 void *buf
, int count
);
65 /* Known ARCnet cards */
67 static struct net_device
*cards
[16];
70 /* Handy defines for ARCnet specific stuff */
72 /* The number of low I/O ports used by the card */
73 #define ARCNET_TOTAL_SIZE 16
75 /* Amount of I/O memory used by the card */
76 #define BUFFER_SIZE (512)
77 #define MIRROR_SIZE (BUFFER_SIZE * 4)
79 /* COM 9026 controller chip --> ARCnet register addresses */
80 #define _INTMASK (ioaddr + 0) /* writable */
81 #define _STATUS (ioaddr + 0) /* readable */
82 #define _COMMAND (ioaddr + 1) /* writable, returns random vals on read (?) */
83 #define _CONFIG (ioaddr + 2) /* Configuration register */
84 #define _RESET (ioaddr + 8) /* software reset (on read) */
85 #define _MEMDATA (ioaddr + 12) /* Data port for IO-mapped memory */
86 #define _ADDR_HI (ioaddr + 15) /* Control registers for said */
87 #define _ADDR_LO (ioaddr + 14)
93 #define ASTATUS() inb(_STATUS)
94 #define ACOMMAND(cmd) outb((cmd), _COMMAND)
95 #define AINTMASK(msk) outb((msk), _INTMASK)
97 static int com90xx_skip_probe __initdata
= 0;
99 /* Module parameters */
101 static int io
; /* use the insmod io= irq= shmem= options */
104 static char device
[9]; /* use eg. device=arc1 to change name */
106 module_param(io
, int, 0);
107 module_param(irq
, int, 0);
108 module_param(shmem
, int, 0);
109 module_param_string(device
, device
, sizeof(device
), 0);
111 static void __init
com90xx_probe(void)
113 int count
, status
, ioaddr
, numprint
, airq
, openparen
= 0;
114 unsigned long airqmask
;
115 int ports
[(0x3f0 - 0x200) / 16 + 1] = { 0 };
116 unsigned long *shmems
;
117 void __iomem
**iomem
;
118 int numports
, numshmems
, *port
;
122 if (!io
&& !irq
&& !shmem
&& !*device
&& com90xx_skip_probe
)
125 shmems
= kzalloc(((0x100000 - 0xa0000) / 0x800) * sizeof(unsigned long),
129 iomem
= kzalloc(((0x100000 - 0xa0000) / 0x800) * sizeof(void __iomem
*),
136 BUGLVL(D_NORMAL
) printk(VERSION
);
138 /* set up the arrays where we'll store the possible probe addresses */
139 numports
= numshmems
= 0;
141 ports
[numports
++] = io
;
143 for (count
= 0x200; count
<= 0x3f0; count
+= 16)
144 ports
[numports
++] = count
;
146 shmems
[numshmems
++] = shmem
;
148 for (count
= 0xA0000; count
<= 0xFF800; count
+= 2048)
149 shmems
[numshmems
++] = count
;
151 /* Stage 1: abandon any reserved ports, or ones with status==0xFF
152 * (empty), and reset any others by reading the reset port.
155 for (port
= &ports
[0]; port
- ports
< numports
; port
++) {
159 BUGMSG2(D_INIT
, "\n");
160 BUGMSG2(D_INIT
, "S1: ");
162 BUGMSG2(D_INIT
, "%Xh ", *port
);
166 if (!request_region(*port
, ARCNET_TOTAL_SIZE
, "arcnet (90xx)")) {
167 BUGMSG2(D_INIT_REASONS
, "(request_region)\n");
168 BUGMSG2(D_INIT_REASONS
, "S1: ");
169 BUGLVL(D_INIT_REASONS
) numprint
= 0;
170 *port
-- = ports
[--numports
];
173 if (ASTATUS() == 0xFF) {
174 BUGMSG2(D_INIT_REASONS
, "(empty)\n");
175 BUGMSG2(D_INIT_REASONS
, "S1: ");
176 BUGLVL(D_INIT_REASONS
) numprint
= 0;
177 release_region(*port
, ARCNET_TOTAL_SIZE
);
178 *port
-- = ports
[--numports
];
181 inb(_RESET
); /* begin resetting card */
183 BUGMSG2(D_INIT_REASONS
, "\n");
184 BUGMSG2(D_INIT_REASONS
, "S1: ");
185 BUGLVL(D_INIT_REASONS
) numprint
= 0;
187 BUGMSG2(D_INIT
, "\n");
190 BUGMSG2(D_NORMAL
, "S1: No ARCnet cards found.\n");
195 /* Stage 2: we have now reset any possible ARCnet cards, so we can't
196 * do anything until they finish. If D_INIT, print the list of
197 * cards that are left.
200 for (port
= &ports
[0]; port
< ports
+ numports
; port
++) {
204 BUGMSG2(D_INIT
, "\n");
205 BUGMSG2(D_INIT
, "S2: ");
207 BUGMSG2(D_INIT
, "%Xh ", *port
);
209 BUGMSG2(D_INIT
, "\n");
212 /* Stage 3: abandon any shmem addresses that don't have the signature
213 * 0xD1 byte in the right place, or are read-only.
216 for (index
= 0, p
= &shmems
[0]; index
< numshmems
; p
++, index
++) {
222 BUGMSG2(D_INIT
, "\n");
223 BUGMSG2(D_INIT
, "S3: ");
225 BUGMSG2(D_INIT
, "%lXh ", *p
);
227 if (!request_mem_region(*p
, MIRROR_SIZE
, "arcnet (90xx)")) {
228 BUGMSG2(D_INIT_REASONS
, "(request_mem_region)\n");
229 BUGMSG2(D_INIT_REASONS
, "Stage 3: ");
230 BUGLVL(D_INIT_REASONS
) numprint
= 0;
233 base
= ioremap(*p
, MIRROR_SIZE
);
235 BUGMSG2(D_INIT_REASONS
, "(ioremap)\n");
236 BUGMSG2(D_INIT_REASONS
, "Stage 3: ");
237 BUGLVL(D_INIT_REASONS
) numprint
= 0;
240 if (readb(base
) != TESTvalue
) {
241 BUGMSG2(D_INIT_REASONS
, "(%02Xh != %02Xh)\n",
242 readb(base
), TESTvalue
);
243 BUGMSG2(D_INIT_REASONS
, "S3: ");
244 BUGLVL(D_INIT_REASONS
) numprint
= 0;
247 /* By writing 0x42 to the TESTvalue location, we also make
248 * sure no "mirror" shmem areas show up - if they occur
249 * in another pass through this loop, they will be discarded
250 * because *cptr != TESTvalue.
253 if (readb(base
) != 0x42) {
254 BUGMSG2(D_INIT_REASONS
, "(read only)\n");
255 BUGMSG2(D_INIT_REASONS
, "S3: ");
258 BUGMSG2(D_INIT_REASONS
, "\n");
259 BUGMSG2(D_INIT_REASONS
, "S3: ");
260 BUGLVL(D_INIT_REASONS
) numprint
= 0;
266 release_mem_region(*p
, MIRROR_SIZE
);
268 *p
-- = shmems
[--numshmems
];
271 BUGMSG2(D_INIT
, "\n");
274 BUGMSG2(D_NORMAL
, "S3: No ARCnet cards found.\n");
275 for (port
= &ports
[0]; port
< ports
+ numports
; port
++)
276 release_region(*port
, ARCNET_TOTAL_SIZE
);
281 /* Stage 4: something of a dummy, to report the shmems that are
282 * still possible after stage 3.
285 for (p
= &shmems
[0]; p
< shmems
+ numshmems
; p
++) {
289 BUGMSG2(D_INIT
, "\n");
290 BUGMSG2(D_INIT
, "S4: ");
292 BUGMSG2(D_INIT
, "%lXh ", *p
);
294 BUGMSG2(D_INIT
, "\n");
296 /* Stage 5: for any ports that have the correct status, can disable
297 * the RESET flag, and (if no irq is given) generate an autoirq,
298 * register an ARCnet device.
300 * Currently, we can only register one device per probe, so quit
301 * after the first one is found.
304 for (port
= &ports
[0]; port
< ports
+ numports
; port
++) {
310 BUGMSG2(D_INIT
, "\n");
311 BUGMSG2(D_INIT
, "S5: ");
313 BUGMSG2(D_INIT
, "%Xh ", *port
);
319 != (NORXflag
| RECONflag
| TXFREEflag
| RESETflag
)) {
320 BUGMSG2(D_INIT_REASONS
, "(status=%Xh)\n", status
);
321 BUGMSG2(D_INIT_REASONS
, "S5: ");
322 BUGLVL(D_INIT_REASONS
) numprint
= 0;
323 release_region(*port
, ARCNET_TOTAL_SIZE
);
324 *port
-- = ports
[--numports
];
327 ACOMMAND(CFLAGScmd
| RESETclear
| CONFIGclear
);
329 if (status
& RESETflag
) {
330 BUGMSG2(D_INIT_REASONS
, " (eternal reset, status=%Xh)\n",
332 BUGMSG2(D_INIT_REASONS
, "S5: ");
333 BUGLVL(D_INIT_REASONS
) numprint
= 0;
334 release_region(*port
, ARCNET_TOTAL_SIZE
);
335 *port
-- = ports
[--numports
];
338 /* skip this completely if an IRQ was given, because maybe
339 * we're on a machine that locks during autoirq!
342 /* if we do this, we're sure to get an IRQ since the
343 * card has just reset and the NORXflag is on until
344 * we tell it to start receiving.
346 airqmask
= probe_irq_on();
350 airq
= probe_irq_off(airqmask
);
353 BUGMSG2(D_INIT_REASONS
, "(airq=%d)\n", airq
);
354 BUGMSG2(D_INIT_REASONS
, "S5: ");
355 BUGLVL(D_INIT_REASONS
) numprint
= 0;
356 release_region(*port
, ARCNET_TOTAL_SIZE
);
357 *port
-- = ports
[--numports
];
364 BUGMSG2(D_INIT
, "(%d,", airq
);
367 /* Everything seems okay. But which shmem, if any, puts
368 * back its signature byte when the card is reset?
370 * If there are multiple cards installed, there might be
371 * multiple shmems still in the list.
374 if (numports
> 1 || numshmems
> 1) {
378 /* just one shmem and port, assume they match */
379 writeb(TESTvalue
, iomem
[0]);
386 for (index
= 0; index
< numshmems
; index
++) {
387 u_long ptr
= shmems
[index
];
388 void __iomem
*base
= iomem
[index
];
390 if (readb(base
) == TESTvalue
) { /* found one */
391 BUGMSG2(D_INIT
, "%lXh)\n", *p
);
394 /* register the card */
395 if (com90xx_found(*port
, airq
, ptr
, base
) == 0)
399 /* remove shmem from the list */
400 shmems
[index
] = shmems
[--numshmems
];
401 iomem
[index
] = iomem
[numshmems
];
402 break; /* go to the next I/O port */
404 BUGMSG2(D_INIT_REASONS
, "%Xh-", readb(base
));
409 BUGLVL(D_INIT
) printk("no matching shmem)\n");
410 BUGLVL(D_INIT_REASONS
) printk("S5: ");
411 BUGLVL(D_INIT_REASONS
) numprint
= 0;
414 release_region(*port
, ARCNET_TOTAL_SIZE
);
415 *port
-- = ports
[--numports
];
418 BUGLVL(D_INIT_REASONS
) printk("\n");
420 /* Now put back TESTvalue on all leftover shmems. */
421 for (index
= 0; index
< numshmems
; index
++) {
422 writeb(TESTvalue
, iomem
[index
]);
423 iounmap(iomem
[index
]);
424 release_mem_region(shmems
[index
], MIRROR_SIZE
);
430 static int check_mirror(unsigned long addr
, size_t size
)
435 if (!request_mem_region(addr
, size
, "arcnet (90xx)"))
438 p
= ioremap(addr
, size
);
440 if (readb(p
) == TESTvalue
)
447 release_mem_region(addr
, size
);
451 /* Set up the struct net_device associated with this card. Called after
454 static int __init
com90xx_found(int ioaddr
, int airq
, u_long shmem
, void __iomem
*p
)
456 struct net_device
*dev
= NULL
;
457 struct arcnet_local
*lp
;
458 u_long first_mirror
, last_mirror
;
461 /* allocate struct net_device */
462 dev
= alloc_arcdev(device
);
464 BUGMSG2(D_NORMAL
, "com90xx: Can't allocate device!\n");
466 release_mem_region(shmem
, MIRROR_SIZE
);
469 lp
= netdev_priv(dev
);
470 /* find the real shared memory start/end points, including mirrors */
472 /* guess the actual size of one "memory mirror" - the number of
473 * bytes between copies of the shared memory. On most cards, it's
474 * 2k (or there are no mirrors at all) but on some, it's 4k.
476 mirror_size
= MIRROR_SIZE
;
477 if (readb(p
) == TESTvalue
&&
478 check_mirror(shmem
- MIRROR_SIZE
, MIRROR_SIZE
) == 0 &&
479 check_mirror(shmem
- 2 * MIRROR_SIZE
, MIRROR_SIZE
) == 1)
480 mirror_size
= 2 * MIRROR_SIZE
;
482 first_mirror
= shmem
- mirror_size
;
483 while (check_mirror(first_mirror
, mirror_size
) == 1)
484 first_mirror
-= mirror_size
;
485 first_mirror
+= mirror_size
;
487 last_mirror
= shmem
+ mirror_size
;
488 while (check_mirror(last_mirror
, mirror_size
) == 1)
489 last_mirror
+= mirror_size
;
490 last_mirror
-= mirror_size
;
492 dev
->mem_start
= first_mirror
;
493 dev
->mem_end
= last_mirror
+ MIRROR_SIZE
- 1;
496 release_mem_region(shmem
, MIRROR_SIZE
);
498 if (!request_mem_region(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1, "arcnet (90xx)"))
501 /* reserve the irq */
502 if (request_irq(airq
, arcnet_interrupt
, 0, "arcnet (90xx)", dev
)) {
503 BUGMSG(D_NORMAL
, "Can't get IRQ %d!\n", airq
);
504 goto err_release_mem
;
508 /* Initialize the rest of the device structure. */
509 lp
->card_name
= "COM90xx";
510 lp
->hw
.command
= com90xx_command
;
511 lp
->hw
.status
= com90xx_status
;
512 lp
->hw
.intmask
= com90xx_setmask
;
513 lp
->hw
.reset
= com90xx_reset
;
514 lp
->hw
.owner
= THIS_MODULE
;
515 lp
->hw
.copy_to_card
= com90xx_copy_to_card
;
516 lp
->hw
.copy_from_card
= com90xx_copy_from_card
;
517 lp
->mem_start
= ioremap(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1);
518 if (!lp
->mem_start
) {
519 BUGMSG(D_NORMAL
, "Can't remap device memory!\n");
523 /* get and check the station ID from offset 1 in shmem */
524 dev
->dev_addr
[0] = readb(lp
->mem_start
+ 1);
526 dev
->base_addr
= ioaddr
;
528 BUGMSG(D_NORMAL
, "COM90xx station %02Xh found at %03lXh, IRQ %d, ShMem %lXh (%ld*%xh).\n",
530 dev
->base_addr
, dev
->irq
, dev
->mem_start
,
531 (dev
->mem_end
- dev
->mem_start
+ 1) / mirror_size
, mirror_size
);
533 if (register_netdev(dev
))
536 cards
[numcards
++] = dev
;
540 iounmap(lp
->mem_start
);
542 free_irq(dev
->irq
, dev
);
544 release_mem_region(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1);
550 static void com90xx_command(struct net_device
*dev
, int cmd
)
552 short ioaddr
= dev
->base_addr
;
557 static int com90xx_status(struct net_device
*dev
)
559 short ioaddr
= dev
->base_addr
;
564 static void com90xx_setmask(struct net_device
*dev
, int mask
)
566 short ioaddr
= dev
->base_addr
;
572 * Do a hardware reset on the card, and set up necessary registers.
574 * This should be called as little as possible, because it disrupts the
575 * token on the network (causes a RECON) and requires a significant delay.
577 * However, it does make sure the card is in a defined state.
579 static int com90xx_reset(struct net_device
*dev
, int really_reset
)
581 struct arcnet_local
*lp
= netdev_priv(dev
);
582 short ioaddr
= dev
->base_addr
;
584 BUGMSG(D_INIT
, "Resetting (status=%02Xh)\n", ASTATUS());
591 ACOMMAND(CFLAGScmd
| RESETclear
); /* clear flags & end reset */
592 ACOMMAND(CFLAGScmd
| CONFIGclear
);
594 /* don't do this until we verify that it doesn't hurt older cards! */
595 /* outb(inb(_CONFIG) | ENABLE16flag, _CONFIG); */
597 /* verify that the ARCnet signature byte is present */
598 if (readb(lp
->mem_start
) != TESTvalue
) {
600 BUGMSG(D_NORMAL
, "reset failed: TESTvalue not present.\n");
603 /* enable extended (512-byte) packets */
604 ACOMMAND(CONFIGcmd
| EXTconf
);
606 /* clean out all the memory to make debugging make more sense :) */
608 memset_io(lp
->mem_start
, 0x42, 2048);
610 /* done! return success. */
614 static void com90xx_copy_to_card(struct net_device
*dev
, int bufnum
, int offset
,
615 void *buf
, int count
)
617 struct arcnet_local
*lp
= netdev_priv(dev
);
618 void __iomem
*memaddr
= lp
->mem_start
+ bufnum
* 512 + offset
;
620 TIME("memcpy_toio", count
, memcpy_toio(memaddr
, buf
, count
));
623 static void com90xx_copy_from_card(struct net_device
*dev
, int bufnum
, int offset
,
624 void *buf
, int count
)
626 struct arcnet_local
*lp
= netdev_priv(dev
);
627 void __iomem
*memaddr
= lp
->mem_start
+ bufnum
* 512 + offset
;
629 TIME("memcpy_fromio", count
, memcpy_fromio(buf
, memaddr
, count
));
632 MODULE_LICENSE("GPL");
634 static int __init
com90xx_init(void)
644 static void __exit
com90xx_exit(void)
646 struct net_device
*dev
;
647 struct arcnet_local
*lp
;
650 for (count
= 0; count
< numcards
; count
++) {
652 lp
= netdev_priv(dev
);
654 unregister_netdev(dev
);
655 free_irq(dev
->irq
, dev
);
656 iounmap(lp
->mem_start
);
657 release_region(dev
->base_addr
, ARCNET_TOTAL_SIZE
);
658 release_mem_region(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1);
663 module_init(com90xx_init
);
664 module_exit(com90xx_exit
);
667 static int __init
com90xx_setup(char *s
)
671 s
= get_options(s
, 8, ints
);
672 if (!ints
[0] && !*s
) {
673 printk("com90xx: Disabled.\n");
679 printk("com90xx: Too many arguments.\n");
680 case 3: /* Mem address */
684 case 1: /* IO address */
689 snprintf(device
, sizeof(device
), "%s", s
);
694 __setup("com90xx=", com90xx_setup
);