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] =
117 unsigned long *shmems
;
118 void __iomem
**iomem
;
119 int numports
, numshmems
, *port
;
123 if (!io
&& !irq
&& !shmem
&& !*device
&& com90xx_skip_probe
)
126 shmems
= kzalloc(((0x100000 - 0xa0000) / 0x800) * sizeof(unsigned long),
130 iomem
= kzalloc(((0x100000 - 0xa0000) / 0x800) * sizeof(void __iomem
*),
137 BUGLVL(D_NORMAL
) printk(VERSION
);
139 /* set up the arrays where we'll store the possible probe addresses */
140 numports
= numshmems
= 0;
142 ports
[numports
++] = io
;
144 for (count
= 0x200; count
<= 0x3f0; count
+= 16)
145 ports
[numports
++] = count
;
147 shmems
[numshmems
++] = shmem
;
149 for (count
= 0xA0000; count
<= 0xFF800; count
+= 2048)
150 shmems
[numshmems
++] = count
;
152 /* Stage 1: abandon any reserved ports, or ones with status==0xFF
153 * (empty), and reset any others by reading the reset port.
156 for (port
= &ports
[0]; port
- ports
< numports
; port
++) {
160 BUGMSG2(D_INIT
, "\n");
161 BUGMSG2(D_INIT
, "S1: ");
163 BUGMSG2(D_INIT
, "%Xh ", *port
);
167 if (!request_region(*port
, ARCNET_TOTAL_SIZE
, "arcnet (90xx)")) {
168 BUGMSG2(D_INIT_REASONS
, "(request_region)\n");
169 BUGMSG2(D_INIT_REASONS
, "S1: ");
170 BUGLVL(D_INIT_REASONS
) numprint
= 0;
171 *port
-- = ports
[--numports
];
174 if (ASTATUS() == 0xFF) {
175 BUGMSG2(D_INIT_REASONS
, "(empty)\n");
176 BUGMSG2(D_INIT_REASONS
, "S1: ");
177 BUGLVL(D_INIT_REASONS
) numprint
= 0;
178 release_region(*port
, ARCNET_TOTAL_SIZE
);
179 *port
-- = ports
[--numports
];
182 inb(_RESET
); /* begin resetting card */
184 BUGMSG2(D_INIT_REASONS
, "\n");
185 BUGMSG2(D_INIT_REASONS
, "S1: ");
186 BUGLVL(D_INIT_REASONS
) numprint
= 0;
188 BUGMSG2(D_INIT
, "\n");
191 BUGMSG2(D_NORMAL
, "S1: No ARCnet cards found.\n");
196 /* Stage 2: we have now reset any possible ARCnet cards, so we can't
197 * do anything until they finish. If D_INIT, print the list of
198 * cards that are left.
201 for (port
= &ports
[0]; port
< ports
+ numports
; port
++) {
205 BUGMSG2(D_INIT
, "\n");
206 BUGMSG2(D_INIT
, "S2: ");
208 BUGMSG2(D_INIT
, "%Xh ", *port
);
210 BUGMSG2(D_INIT
, "\n");
213 /* Stage 3: abandon any shmem addresses that don't have the signature
214 * 0xD1 byte in the right place, or are read-only.
217 for (index
= 0, p
= &shmems
[0]; index
< numshmems
; p
++, index
++) {
223 BUGMSG2(D_INIT
, "\n");
224 BUGMSG2(D_INIT
, "S3: ");
226 BUGMSG2(D_INIT
, "%lXh ", *p
);
228 if (!request_mem_region(*p
, MIRROR_SIZE
, "arcnet (90xx)")) {
229 BUGMSG2(D_INIT_REASONS
, "(request_mem_region)\n");
230 BUGMSG2(D_INIT_REASONS
, "Stage 3: ");
231 BUGLVL(D_INIT_REASONS
) numprint
= 0;
234 base
= ioremap(*p
, MIRROR_SIZE
);
236 BUGMSG2(D_INIT_REASONS
, "(ioremap)\n");
237 BUGMSG2(D_INIT_REASONS
, "Stage 3: ");
238 BUGLVL(D_INIT_REASONS
) numprint
= 0;
241 if (readb(base
) != TESTvalue
) {
242 BUGMSG2(D_INIT_REASONS
, "(%02Xh != %02Xh)\n",
243 readb(base
), TESTvalue
);
244 BUGMSG2(D_INIT_REASONS
, "S3: ");
245 BUGLVL(D_INIT_REASONS
) numprint
= 0;
248 /* By writing 0x42 to the TESTvalue location, we also make
249 * sure no "mirror" shmem areas show up - if they occur
250 * in another pass through this loop, they will be discarded
251 * because *cptr != TESTvalue.
254 if (readb(base
) != 0x42) {
255 BUGMSG2(D_INIT_REASONS
, "(read only)\n");
256 BUGMSG2(D_INIT_REASONS
, "S3: ");
259 BUGMSG2(D_INIT_REASONS
, "\n");
260 BUGMSG2(D_INIT_REASONS
, "S3: ");
261 BUGLVL(D_INIT_REASONS
) numprint
= 0;
267 release_mem_region(*p
, MIRROR_SIZE
);
269 *p
-- = shmems
[--numshmems
];
272 BUGMSG2(D_INIT
, "\n");
275 BUGMSG2(D_NORMAL
, "S3: No ARCnet cards found.\n");
276 for (port
= &ports
[0]; port
< ports
+ numports
; port
++)
277 release_region(*port
, ARCNET_TOTAL_SIZE
);
282 /* Stage 4: something of a dummy, to report the shmems that are
283 * still possible after stage 3.
286 for (p
= &shmems
[0]; p
< shmems
+ numshmems
; p
++) {
290 BUGMSG2(D_INIT
, "\n");
291 BUGMSG2(D_INIT
, "S4: ");
293 BUGMSG2(D_INIT
, "%lXh ", *p
);
295 BUGMSG2(D_INIT
, "\n");
297 /* Stage 5: for any ports that have the correct status, can disable
298 * the RESET flag, and (if no irq is given) generate an autoirq,
299 * register an ARCnet device.
301 * Currently, we can only register one device per probe, so quit
302 * after the first one is found.
305 for (port
= &ports
[0]; port
< ports
+ numports
; port
++) {
311 BUGMSG2(D_INIT
, "\n");
312 BUGMSG2(D_INIT
, "S5: ");
314 BUGMSG2(D_INIT
, "%Xh ", *port
);
320 != (NORXflag
| RECONflag
| TXFREEflag
| RESETflag
)) {
321 BUGMSG2(D_INIT_REASONS
, "(status=%Xh)\n", status
);
322 BUGMSG2(D_INIT_REASONS
, "S5: ");
323 BUGLVL(D_INIT_REASONS
) numprint
= 0;
324 release_region(*port
, ARCNET_TOTAL_SIZE
);
325 *port
-- = ports
[--numports
];
328 ACOMMAND(CFLAGScmd
| RESETclear
| CONFIGclear
);
330 if (status
& RESETflag
) {
331 BUGMSG2(D_INIT_REASONS
, " (eternal reset, status=%Xh)\n",
333 BUGMSG2(D_INIT_REASONS
, "S5: ");
334 BUGLVL(D_INIT_REASONS
) numprint
= 0;
335 release_region(*port
, ARCNET_TOTAL_SIZE
);
336 *port
-- = ports
[--numports
];
339 /* skip this completely if an IRQ was given, because maybe
340 * we're on a machine that locks during autoirq!
343 /* if we do this, we're sure to get an IRQ since the
344 * card has just reset and the NORXflag is on until
345 * we tell it to start receiving.
347 airqmask
= probe_irq_on();
351 airq
= probe_irq_off(airqmask
);
354 BUGMSG2(D_INIT_REASONS
, "(airq=%d)\n", airq
);
355 BUGMSG2(D_INIT_REASONS
, "S5: ");
356 BUGLVL(D_INIT_REASONS
) numprint
= 0;
357 release_region(*port
, ARCNET_TOTAL_SIZE
);
358 *port
-- = ports
[--numports
];
365 BUGMSG2(D_INIT
, "(%d,", airq
);
368 /* Everything seems okay. But which shmem, if any, puts
369 * back its signature byte when the card is reset?
371 * If there are multiple cards installed, there might be
372 * multiple shmems still in the list.
375 if (numports
> 1 || numshmems
> 1) {
379 /* just one shmem and port, assume they match */
380 writeb(TESTvalue
, iomem
[0]);
387 for (index
= 0; index
< numshmems
; index
++) {
388 u_long ptr
= shmems
[index
];
389 void __iomem
*base
= iomem
[index
];
391 if (readb(base
) == TESTvalue
) { /* found one */
392 BUGMSG2(D_INIT
, "%lXh)\n", *p
);
395 /* register the card */
396 if (com90xx_found(*port
, airq
, ptr
, base
) == 0)
400 /* remove shmem from the list */
401 shmems
[index
] = shmems
[--numshmems
];
402 iomem
[index
] = iomem
[numshmems
];
403 break; /* go to the next I/O port */
405 BUGMSG2(D_INIT_REASONS
, "%Xh-", readb(base
));
410 BUGLVL(D_INIT
) printk("no matching shmem)\n");
411 BUGLVL(D_INIT_REASONS
) printk("S5: ");
412 BUGLVL(D_INIT_REASONS
) numprint
= 0;
415 release_region(*port
, ARCNET_TOTAL_SIZE
);
416 *port
-- = ports
[--numports
];
419 BUGLVL(D_INIT_REASONS
) printk("\n");
421 /* Now put back TESTvalue on all leftover shmems. */
422 for (index
= 0; index
< numshmems
; index
++) {
423 writeb(TESTvalue
, iomem
[index
]);
424 iounmap(iomem
[index
]);
425 release_mem_region(shmems
[index
], MIRROR_SIZE
);
431 static int check_mirror(unsigned long addr
, size_t size
)
436 if (!request_mem_region(addr
, size
, "arcnet (90xx)"))
439 p
= ioremap(addr
, size
);
441 if (readb(p
) == TESTvalue
)
448 release_mem_region(addr
, size
);
452 /* Set up the struct net_device associated with this card. Called after
455 static int __init
com90xx_found(int ioaddr
, int airq
, u_long shmem
, void __iomem
*p
)
457 struct net_device
*dev
= NULL
;
458 struct arcnet_local
*lp
;
459 u_long first_mirror
, last_mirror
;
462 /* allocate struct net_device */
463 dev
= alloc_arcdev(device
);
465 BUGMSG2(D_NORMAL
, "com90xx: Can't allocate device!\n");
467 release_mem_region(shmem
, MIRROR_SIZE
);
470 lp
= netdev_priv(dev
);
471 /* find the real shared memory start/end points, including mirrors */
473 /* guess the actual size of one "memory mirror" - the number of
474 * bytes between copies of the shared memory. On most cards, it's
475 * 2k (or there are no mirrors at all) but on some, it's 4k.
477 mirror_size
= MIRROR_SIZE
;
478 if (readb(p
) == TESTvalue
&&
479 check_mirror(shmem
- MIRROR_SIZE
, MIRROR_SIZE
) == 0 &&
480 check_mirror(shmem
- 2 * MIRROR_SIZE
, MIRROR_SIZE
) == 1)
481 mirror_size
= 2 * MIRROR_SIZE
;
483 first_mirror
= shmem
- mirror_size
;
484 while (check_mirror(first_mirror
, mirror_size
) == 1)
485 first_mirror
-= mirror_size
;
486 first_mirror
+= mirror_size
;
488 last_mirror
= shmem
+ mirror_size
;
489 while (check_mirror(last_mirror
, mirror_size
) == 1)
490 last_mirror
+= mirror_size
;
491 last_mirror
-= mirror_size
;
493 dev
->mem_start
= first_mirror
;
494 dev
->mem_end
= last_mirror
+ MIRROR_SIZE
- 1;
497 release_mem_region(shmem
, MIRROR_SIZE
);
499 if (!request_mem_region(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1, "arcnet (90xx)"))
502 /* reserve the irq */
503 if (request_irq(airq
, arcnet_interrupt
, 0, "arcnet (90xx)", dev
)) {
504 BUGMSG(D_NORMAL
, "Can't get IRQ %d!\n", airq
);
505 goto err_release_mem
;
509 /* Initialize the rest of the device structure. */
510 lp
->card_name
= "COM90xx";
511 lp
->hw
.command
= com90xx_command
;
512 lp
->hw
.status
= com90xx_status
;
513 lp
->hw
.intmask
= com90xx_setmask
;
514 lp
->hw
.reset
= com90xx_reset
;
515 lp
->hw
.owner
= THIS_MODULE
;
516 lp
->hw
.copy_to_card
= com90xx_copy_to_card
;
517 lp
->hw
.copy_from_card
= com90xx_copy_from_card
;
518 lp
->mem_start
= ioremap(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1);
519 if (!lp
->mem_start
) {
520 BUGMSG(D_NORMAL
, "Can't remap device memory!\n");
524 /* get and check the station ID from offset 1 in shmem */
525 dev
->dev_addr
[0] = readb(lp
->mem_start
+ 1);
527 dev
->base_addr
= ioaddr
;
529 BUGMSG(D_NORMAL
, "COM90xx station %02Xh found at %03lXh, IRQ %d, "
530 "ShMem %lXh (%ld*%xh).\n",
532 dev
->base_addr
, dev
->irq
, dev
->mem_start
,
533 (dev
->mem_end
- dev
->mem_start
+ 1) / mirror_size
, mirror_size
);
535 if (register_netdev(dev
))
538 cards
[numcards
++] = dev
;
542 iounmap(lp
->mem_start
);
544 free_irq(dev
->irq
, dev
);
546 release_mem_region(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1);
552 static void com90xx_command(struct net_device
*dev
, int cmd
)
554 short ioaddr
= dev
->base_addr
;
559 static int com90xx_status(struct net_device
*dev
)
561 short ioaddr
= dev
->base_addr
;
566 static void com90xx_setmask(struct net_device
*dev
, int mask
)
568 short ioaddr
= dev
->base_addr
;
574 * Do a hardware reset on the card, and set up necessary registers.
576 * This should be called as little as possible, because it disrupts the
577 * token on the network (causes a RECON) and requires a significant delay.
579 * However, it does make sure the card is in a defined state.
581 static int com90xx_reset(struct net_device
*dev
, int really_reset
)
583 struct arcnet_local
*lp
= netdev_priv(dev
);
584 short ioaddr
= dev
->base_addr
;
586 BUGMSG(D_INIT
, "Resetting (status=%02Xh)\n", ASTATUS());
593 ACOMMAND(CFLAGScmd
| RESETclear
); /* clear flags & end reset */
594 ACOMMAND(CFLAGScmd
| CONFIGclear
);
596 /* don't do this until we verify that it doesn't hurt older cards! */
597 /* outb(inb(_CONFIG) | ENABLE16flag, _CONFIG); */
599 /* verify that the ARCnet signature byte is present */
600 if (readb(lp
->mem_start
) != TESTvalue
) {
602 BUGMSG(D_NORMAL
, "reset failed: TESTvalue not present.\n");
605 /* enable extended (512-byte) packets */
606 ACOMMAND(CONFIGcmd
| EXTconf
);
608 /* clean out all the memory to make debugging make more sense :) */
610 memset_io(lp
->mem_start
, 0x42, 2048);
612 /* done! return success. */
616 static void com90xx_copy_to_card(struct net_device
*dev
, int bufnum
, int offset
,
617 void *buf
, int count
)
619 struct arcnet_local
*lp
= netdev_priv(dev
);
620 void __iomem
*memaddr
= lp
->mem_start
+ bufnum
* 512 + offset
;
622 TIME("memcpy_toio", count
, memcpy_toio(memaddr
, buf
, count
));
625 static void com90xx_copy_from_card(struct net_device
*dev
, int bufnum
, int offset
,
626 void *buf
, int count
)
628 struct arcnet_local
*lp
= netdev_priv(dev
);
629 void __iomem
*memaddr
= lp
->mem_start
+ bufnum
* 512 + offset
;
631 TIME("memcpy_fromio", count
, memcpy_fromio(buf
, memaddr
, count
));
634 MODULE_LICENSE("GPL");
636 static int __init
com90xx_init(void)
646 static void __exit
com90xx_exit(void)
648 struct net_device
*dev
;
649 struct arcnet_local
*lp
;
652 for (count
= 0; count
< numcards
; count
++) {
654 lp
= netdev_priv(dev
);
656 unregister_netdev(dev
);
657 free_irq(dev
->irq
, dev
);
658 iounmap(lp
->mem_start
);
659 release_region(dev
->base_addr
, ARCNET_TOTAL_SIZE
);
660 release_mem_region(dev
->mem_start
, dev
->mem_end
- dev
->mem_start
+ 1);
665 module_init(com90xx_init
);
666 module_exit(com90xx_exit
);
669 static int __init
com90xx_setup(char *s
)
673 s
= get_options(s
, 8, ints
);
674 if (!ints
[0] && !*s
) {
675 printk("com90xx: Disabled.\n");
681 printk("com90xx: Too many arguments.\n");
682 case 3: /* Mem address */
686 case 1: /* IO address */
691 snprintf(device
, sizeof(device
), "%s", s
);
696 __setup("com90xx=", com90xx_setup
);