1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/module.h>
28#include <linux/moduleparam.h>
29#include <linux/init.h>
30#include <linux/ioport.h>
31#include <linux/delay.h>
32#include <linux/netdevice.h>
33#include <linux/slab.h>
34#include <asm/io.h>
35#include <linux/arcdevice.h>
36
37
38#define VERSION "arcnet: COM90xx chipset support\n"
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#undef FAST_PROBE
54
55
56
57static int com90xx_found(int ioaddr, int airq, u_long shmem, void __iomem *);
58static void com90xx_command(struct net_device *dev, int command);
59static int com90xx_status(struct net_device *dev);
60static void com90xx_setmask(struct net_device *dev, int mask);
61static int com90xx_reset(struct net_device *dev, int really_reset);
62static void com90xx_copy_to_card(struct net_device *dev, int bufnum, int offset,
63 void *buf, int count);
64static void com90xx_copy_from_card(struct net_device *dev, int bufnum, int offset,
65 void *buf, int count);
66
67
68
69static struct net_device *cards[16];
70static int numcards;
71
72
73
74
75#define ARCNET_TOTAL_SIZE 16
76
77
78#define BUFFER_SIZE (512)
79#define MIRROR_SIZE (BUFFER_SIZE*4)
80
81
82#define _INTMASK (ioaddr+0)
83#define _STATUS (ioaddr+0)
84#define _COMMAND (ioaddr+1)
85#define _CONFIG (ioaddr+2)
86#define _RESET (ioaddr+8)
87#define _MEMDATA (ioaddr+12)
88#define _ADDR_HI (ioaddr+15)
89#define _ADDR_LO (ioaddr+14)
90
91#undef ASTATUS
92#undef ACOMMAND
93#undef AINTMASK
94
95#define ASTATUS() inb(_STATUS)
96#define ACOMMAND(cmd) outb((cmd),_COMMAND)
97#define AINTMASK(msk) outb((msk),_INTMASK)
98
99
100static int com90xx_skip_probe __initdata = 0;
101
102
103
104static int io;
105static int irq;
106static int shmem;
107static char device[9];
108
109module_param(io, int, 0);
110module_param(irq, int, 0);
111module_param(shmem, int, 0);
112module_param_string(device, device, sizeof(device), 0);
113
114static void __init com90xx_probe(void)
115{
116 int count, status, ioaddr, numprint, airq, openparen = 0;
117 unsigned long airqmask;
118 int ports[(0x3f0 - 0x200) / 16 + 1] =
119 {0};
120 unsigned long *shmems;
121 void __iomem **iomem;
122 int numports, numshmems, *port;
123 u_long *p;
124 int index;
125
126 if (!io && !irq && !shmem && !*device && com90xx_skip_probe)
127 return;
128
129 shmems = kzalloc(((0x100000-0xa0000) / 0x800) * sizeof(unsigned long),
130 GFP_KERNEL);
131 if (!shmems)
132 return;
133 iomem = kzalloc(((0x100000-0xa0000) / 0x800) * sizeof(void __iomem *),
134 GFP_KERNEL);
135 if (!iomem) {
136 kfree(shmems);
137 return;
138 }
139
140 BUGLVL(D_NORMAL) printk(VERSION);
141
142
143 numports = numshmems = 0;
144 if (io)
145 ports[numports++] = io;
146 else
147 for (count = 0x200; count <= 0x3f0; count += 16)
148 ports[numports++] = count;
149 if (shmem)
150 shmems[numshmems++] = shmem;
151 else
152 for (count = 0xA0000; count <= 0xFF800; count += 2048)
153 shmems[numshmems++] = count;
154
155
156
157
158 numprint = -1;
159 for (port = &ports[0]; port - ports < numports; port++) {
160 numprint++;
161 numprint %= 8;
162 if (!numprint) {
163 BUGMSG2(D_INIT, "\n");
164 BUGMSG2(D_INIT, "S1: ");
165 }
166 BUGMSG2(D_INIT, "%Xh ", *port);
167
168 ioaddr = *port;
169
170 if (!request_region(*port, ARCNET_TOTAL_SIZE, "arcnet (90xx)")) {
171 BUGMSG2(D_INIT_REASONS, "(request_region)\n");
172 BUGMSG2(D_INIT_REASONS, "S1: ");
173 BUGLVL(D_INIT_REASONS) numprint = 0;
174 *port-- = ports[--numports];
175 continue;
176 }
177 if (ASTATUS() == 0xFF) {
178 BUGMSG2(D_INIT_REASONS, "(empty)\n");
179 BUGMSG2(D_INIT_REASONS, "S1: ");
180 BUGLVL(D_INIT_REASONS) numprint = 0;
181 release_region(*port, ARCNET_TOTAL_SIZE);
182 *port-- = ports[--numports];
183 continue;
184 }
185 inb(_RESET);
186
187 BUGMSG2(D_INIT_REASONS, "\n");
188 BUGMSG2(D_INIT_REASONS, "S1: ");
189 BUGLVL(D_INIT_REASONS) numprint = 0;
190 }
191 BUGMSG2(D_INIT, "\n");
192
193 if (!numports) {
194 BUGMSG2(D_NORMAL, "S1: No ARCnet cards found.\n");
195 kfree(shmems);
196 kfree(iomem);
197 return;
198 }
199
200
201
202
203 numprint = -1;
204 for (port = &ports[0]; port < ports + numports; port++) {
205 numprint++;
206 numprint %= 8;
207 if (!numprint) {
208 BUGMSG2(D_INIT, "\n");
209 BUGMSG2(D_INIT, "S2: ");
210 }
211 BUGMSG2(D_INIT, "%Xh ", *port);
212 }
213 BUGMSG2(D_INIT, "\n");
214 mdelay(RESETtime);
215
216
217
218
219 numprint = -1;
220 for (index = 0, p = &shmems[0]; index < numshmems; p++, index++) {
221 void __iomem *base;
222
223 numprint++;
224 numprint %= 8;
225 if (!numprint) {
226 BUGMSG2(D_INIT, "\n");
227 BUGMSG2(D_INIT, "S3: ");
228 }
229 BUGMSG2(D_INIT, "%lXh ", *p);
230
231 if (!request_mem_region(*p, MIRROR_SIZE, "arcnet (90xx)")) {
232 BUGMSG2(D_INIT_REASONS, "(request_mem_region)\n");
233 BUGMSG2(D_INIT_REASONS, "Stage 3: ");
234 BUGLVL(D_INIT_REASONS) numprint = 0;
235 goto out;
236 }
237 base = ioremap(*p, MIRROR_SIZE);
238 if (!base) {
239 BUGMSG2(D_INIT_REASONS, "(ioremap)\n");
240 BUGMSG2(D_INIT_REASONS, "Stage 3: ");
241 BUGLVL(D_INIT_REASONS) numprint = 0;
242 goto out1;
243 }
244 if (readb(base) != TESTvalue) {
245 BUGMSG2(D_INIT_REASONS, "(%02Xh != %02Xh)\n",
246 readb(base), TESTvalue);
247 BUGMSG2(D_INIT_REASONS, "S3: ");
248 BUGLVL(D_INIT_REASONS) numprint = 0;
249 goto out2;
250 }
251
252
253
254
255
256 writeb(0x42, base);
257 if (readb(base) != 0x42) {
258 BUGMSG2(D_INIT_REASONS, "(read only)\n");
259 BUGMSG2(D_INIT_REASONS, "S3: ");
260 goto out2;
261 }
262 BUGMSG2(D_INIT_REASONS, "\n");
263 BUGMSG2(D_INIT_REASONS, "S3: ");
264 BUGLVL(D_INIT_REASONS) numprint = 0;
265 iomem[index] = base;
266 continue;
267 out2:
268 iounmap(base);
269 out1:
270 release_mem_region(*p, MIRROR_SIZE);
271 out:
272 *p-- = shmems[--numshmems];
273 index--;
274 }
275 BUGMSG2(D_INIT, "\n");
276
277 if (!numshmems) {
278 BUGMSG2(D_NORMAL, "S3: No ARCnet cards found.\n");
279 for (port = &ports[0]; port < ports + numports; port++)
280 release_region(*port, ARCNET_TOTAL_SIZE);
281 kfree(shmems);
282 kfree(iomem);
283 return;
284 }
285
286
287
288 numprint = -1;
289 for (p = &shmems[0]; p < shmems + numshmems; p++) {
290 numprint++;
291 numprint %= 8;
292 if (!numprint) {
293 BUGMSG2(D_INIT, "\n");
294 BUGMSG2(D_INIT, "S4: ");
295 }
296 BUGMSG2(D_INIT, "%lXh ", *p);
297 }
298 BUGMSG2(D_INIT, "\n");
299
300
301
302
303
304
305
306
307 numprint = -1;
308 for (port = &ports[0]; port < ports + numports; port++) {
309 int found = 0;
310 numprint++;
311 numprint %= 8;
312 if (!numprint) {
313 BUGMSG2(D_INIT, "\n");
314 BUGMSG2(D_INIT, "S5: ");
315 }
316 BUGMSG2(D_INIT, "%Xh ", *port);
317
318 ioaddr = *port;
319 status = ASTATUS();
320
321 if ((status & 0x9D)
322 != (NORXflag | RECONflag | TXFREEflag | RESETflag)) {
323 BUGMSG2(D_INIT_REASONS, "(status=%Xh)\n", status);
324 BUGMSG2(D_INIT_REASONS, "S5: ");
325 BUGLVL(D_INIT_REASONS) numprint = 0;
326 release_region(*port, ARCNET_TOTAL_SIZE);
327 *port-- = ports[--numports];
328 continue;
329 }
330 ACOMMAND(CFLAGScmd | RESETclear | CONFIGclear);
331 status = ASTATUS();
332 if (status & RESETflag) {
333 BUGMSG2(D_INIT_REASONS, " (eternal reset, status=%Xh)\n",
334 status);
335 BUGMSG2(D_INIT_REASONS, "S5: ");
336 BUGLVL(D_INIT_REASONS) numprint = 0;
337 release_region(*port, ARCNET_TOTAL_SIZE);
338 *port-- = ports[--numports];
339 continue;
340 }
341
342
343
344 if (!irq) {
345
346
347
348
349 airqmask = probe_irq_on();
350 AINTMASK(NORXflag);
351 udelay(1);
352 AINTMASK(0);
353 airq = probe_irq_off(airqmask);
354
355 if (airq <= 0) {
356 BUGMSG2(D_INIT_REASONS, "(airq=%d)\n", airq);
357 BUGMSG2(D_INIT_REASONS, "S5: ");
358 BUGLVL(D_INIT_REASONS) numprint = 0;
359 release_region(*port, ARCNET_TOTAL_SIZE);
360 *port-- = ports[--numports];
361 continue;
362 }
363 } else {
364 airq = irq;
365 }
366
367 BUGMSG2(D_INIT, "(%d,", airq);
368 openparen = 1;
369
370
371
372
373
374
375
376#ifdef FAST_PROBE
377 if (numports > 1 || numshmems > 1) {
378 inb(_RESET);
379 mdelay(RESETtime);
380 } else {
381
382 writeb(TESTvalue, iomem[0]);
383 }
384#else
385 inb(_RESET);
386 mdelay(RESETtime);
387#endif
388
389 for (index = 0; index < numshmems; index++) {
390 u_long ptr = shmems[index];
391 void __iomem *base = iomem[index];
392
393 if (readb(base) == TESTvalue) {
394 BUGMSG2(D_INIT, "%lXh)\n", *p);
395 openparen = 0;
396
397
398 if (com90xx_found(*port, airq, ptr, base) == 0)
399 found = 1;
400 numprint = -1;
401
402
403 shmems[index] = shmems[--numshmems];
404 iomem[index] = iomem[numshmems];
405 break;
406 } else {
407 BUGMSG2(D_INIT_REASONS, "%Xh-", readb(base));
408 }
409 }
410
411 if (openparen) {
412 BUGLVL(D_INIT) printk("no matching shmem)\n");
413 BUGLVL(D_INIT_REASONS) printk("S5: ");
414 BUGLVL(D_INIT_REASONS) numprint = 0;
415 }
416 if (!found)
417 release_region(*port, ARCNET_TOTAL_SIZE);
418 *port-- = ports[--numports];
419 }
420
421 BUGLVL(D_INIT_REASONS) printk("\n");
422
423
424 for (index = 0; index < numshmems; index++) {
425 writeb(TESTvalue, iomem[index]);
426 iounmap(iomem[index]);
427 release_mem_region(shmems[index], MIRROR_SIZE);
428 }
429 kfree(shmems);
430 kfree(iomem);
431}
432
433static int check_mirror(unsigned long addr, size_t size)
434{
435 void __iomem *p;
436 int res = -1;
437
438 if (!request_mem_region(addr, size, "arcnet (90xx)"))
439 return -1;
440
441 p = ioremap(addr, size);
442 if (p) {
443 if (readb(p) == TESTvalue)
444 res = 1;
445 else
446 res = 0;
447 iounmap(p);
448 }
449
450 release_mem_region(addr, size);
451 return res;
452}
453
454
455
456
457static int __init com90xx_found(int ioaddr, int airq, u_long shmem, void __iomem *p)
458{
459 struct net_device *dev = NULL;
460 struct arcnet_local *lp;
461 u_long first_mirror, last_mirror;
462 int mirror_size;
463
464
465 dev = alloc_arcdev(device);
466 if (!dev) {
467 BUGMSG2(D_NORMAL, "com90xx: Can't allocate device!\n");
468 iounmap(p);
469 release_mem_region(shmem, MIRROR_SIZE);
470 return -ENOMEM;
471 }
472 lp = netdev_priv(dev);
473
474
475
476
477
478
479 mirror_size = MIRROR_SIZE;
480 if (readb(p) == TESTvalue &&
481 check_mirror(shmem - MIRROR_SIZE, MIRROR_SIZE) == 0 &&
482 check_mirror(shmem - 2 * MIRROR_SIZE, MIRROR_SIZE) == 1)
483 mirror_size = 2 * MIRROR_SIZE;
484
485 first_mirror = shmem - mirror_size;
486 while (check_mirror(first_mirror, mirror_size) == 1)
487 first_mirror -= mirror_size;
488 first_mirror += mirror_size;
489
490 last_mirror = shmem + mirror_size;
491 while (check_mirror(last_mirror, mirror_size) == 1)
492 last_mirror += mirror_size;
493 last_mirror -= mirror_size;
494
495 dev->mem_start = first_mirror;
496 dev->mem_end = last_mirror + MIRROR_SIZE - 1;
497
498 iounmap(p);
499 release_mem_region(shmem, MIRROR_SIZE);
500
501 if (!request_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1, "arcnet (90xx)"))
502 goto err_free_dev;
503
504
505 if (request_irq(airq, arcnet_interrupt, 0, "arcnet (90xx)", dev)) {
506 BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", airq);
507 goto err_release_mem;
508 }
509 dev->irq = airq;
510
511
512 lp->card_name = "COM90xx";
513 lp->hw.command = com90xx_command;
514 lp->hw.status = com90xx_status;
515 lp->hw.intmask = com90xx_setmask;
516 lp->hw.reset = com90xx_reset;
517 lp->hw.owner = THIS_MODULE;
518 lp->hw.copy_to_card = com90xx_copy_to_card;
519 lp->hw.copy_from_card = com90xx_copy_from_card;
520 lp->mem_start = ioremap(dev->mem_start, dev->mem_end - dev->mem_start + 1);
521 if (!lp->mem_start) {
522 BUGMSG(D_NORMAL, "Can't remap device memory!\n");
523 goto err_free_irq;
524 }
525
526
527 dev->dev_addr[0] = readb(lp->mem_start + 1);
528
529 dev->base_addr = ioaddr;
530
531 BUGMSG(D_NORMAL, "COM90xx station %02Xh found at %03lXh, IRQ %d, "
532 "ShMem %lXh (%ld*%xh).\n",
533 dev->dev_addr[0],
534 dev->base_addr, dev->irq, dev->mem_start,
535 (dev->mem_end - dev->mem_start + 1) / mirror_size, mirror_size);
536
537 if (register_netdev(dev))
538 goto err_unmap;
539
540 cards[numcards++] = dev;
541 return 0;
542
543err_unmap:
544 iounmap(lp->mem_start);
545err_free_irq:
546 free_irq(dev->irq, dev);
547err_release_mem:
548 release_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1);
549err_free_dev:
550 free_netdev(dev);
551 return -EIO;
552}
553
554
555static void com90xx_command(struct net_device *dev, int cmd)
556{
557 short ioaddr = dev->base_addr;
558
559 ACOMMAND(cmd);
560}
561
562
563static int com90xx_status(struct net_device *dev)
564{
565 short ioaddr = dev->base_addr;
566
567 return ASTATUS();
568}
569
570
571static void com90xx_setmask(struct net_device *dev, int mask)
572{
573 short ioaddr = dev->base_addr;
574
575 AINTMASK(mask);
576}
577
578
579
580
581
582
583
584
585
586
587static int com90xx_reset(struct net_device *dev, int really_reset)
588{
589 struct arcnet_local *lp = netdev_priv(dev);
590 short ioaddr = dev->base_addr;
591
592 BUGMSG(D_INIT, "Resetting (status=%02Xh)\n", ASTATUS());
593
594 if (really_reset) {
595
596 inb(_RESET);
597 mdelay(RESETtime);
598 }
599 ACOMMAND(CFLAGScmd | RESETclear);
600 ACOMMAND(CFLAGScmd | CONFIGclear);
601
602
603
604
605
606 if (readb(lp->mem_start) != TESTvalue) {
607 if (really_reset)
608 BUGMSG(D_NORMAL, "reset failed: TESTvalue not present.\n");
609 return 1;
610 }
611
612 ACOMMAND(CONFIGcmd | EXTconf);
613
614
615 BUGLVL(D_DURING)
616 memset_io(lp->mem_start, 0x42, 2048);
617
618
619 return 0;
620}
621
622static void com90xx_copy_to_card(struct net_device *dev, int bufnum, int offset,
623 void *buf, int count)
624{
625 struct arcnet_local *lp = netdev_priv(dev);
626 void __iomem *memaddr = lp->mem_start + bufnum * 512 + offset;
627 TIME("memcpy_toio", count, memcpy_toio(memaddr, buf, count));
628}
629
630
631static void com90xx_copy_from_card(struct net_device *dev, int bufnum, int offset,
632 void *buf, int count)
633{
634 struct arcnet_local *lp = netdev_priv(dev);
635 void __iomem *memaddr = lp->mem_start + bufnum * 512 + offset;
636 TIME("memcpy_fromio", count, memcpy_fromio(buf, memaddr, count));
637}
638
639
640MODULE_LICENSE("GPL");
641
642static int __init com90xx_init(void)
643{
644 if (irq == 2)
645 irq = 9;
646 com90xx_probe();
647 if (!numcards)
648 return -EIO;
649 return 0;
650}
651
652static void __exit com90xx_exit(void)
653{
654 struct net_device *dev;
655 struct arcnet_local *lp;
656 int count;
657
658 for (count = 0; count < numcards; count++) {
659 dev = cards[count];
660 lp = netdev_priv(dev);
661
662 unregister_netdev(dev);
663 free_irq(dev->irq, dev);
664 iounmap(lp->mem_start);
665 release_region(dev->base_addr, ARCNET_TOTAL_SIZE);
666 release_mem_region(dev->mem_start, dev->mem_end - dev->mem_start + 1);
667 free_netdev(dev);
668 }
669}
670
671module_init(com90xx_init);
672module_exit(com90xx_exit);
673
674#ifndef MODULE
675static int __init com90xx_setup(char *s)
676{
677 int ints[8];
678
679 s = get_options(s, 8, ints);
680 if (!ints[0] && !*s) {
681 printk("com90xx: Disabled.\n");
682 return 1;
683 }
684
685 switch (ints[0]) {
686 default:
687 printk("com90xx: Too many arguments.\n");
688 case 3:
689 shmem = ints[3];
690 case 2:
691 irq = ints[2];
692 case 1:
693 io = ints[1];
694 }
695
696 if (*s)
697 snprintf(device, sizeof(device), "%s", s);
698
699 return 1;
700}
701
702__setup("com90xx=", com90xx_setup);
703#endif
704