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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102#include <linux/module.h>
103
104
105
106
107
108
109
110#ifndef CONFIG_ISA_DMA_API
111#define ALLOW_DMA 0
112#else
113#define ALLOW_DMA 1
114#endif
115
116
117
118
119
120#define DEBUGGING 1
121
122
123
124
125
126
127
128
129
130
131#include <linux/errno.h>
132#include <linux/netdevice.h>
133#include <linux/etherdevice.h>
134#include <linux/kernel.h>
135#include <linux/types.h>
136#include <linux/fcntl.h>
137#include <linux/interrupt.h>
138#include <linux/ioport.h>
139#include <linux/in.h>
140#include <linux/skbuff.h>
141#include <linux/slab.h>
142#include <linux/spinlock.h>
143#include <linux/string.h>
144#include <linux/init.h>
145#include <linux/bitops.h>
146#include <linux/delay.h>
147
148#include <asm/system.h>
149#include <asm/io.h>
150#include <asm/irq.h>
151#if ALLOW_DMA
152#include <asm/dma.h>
153#endif
154
155#include "cs89x0.h"
156
157static char version[] __initdata =
158"cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton\n";
159
160#define DRV_NAME "cs89x0"
161
162
163
164
165
166
167
168
169
170
171
172
173#if defined(CONFIG_SH_HICOSH4)
174static unsigned int netcard_portlist[] __used __initdata =
175 { 0x0300, 0};
176static unsigned int cs8900_irq_map[] = {1,0,0,0};
177#elif defined(CONFIG_MACH_IXDP2351)
178static unsigned int netcard_portlist[] __used __initdata = {IXDP2351_VIRT_CS8900_BASE, 0};
179static unsigned int cs8900_irq_map[] = {IRQ_IXDP2351_CS8900, 0, 0, 0};
180#elif defined(CONFIG_ARCH_IXDP2X01)
181static unsigned int netcard_portlist[] __used __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0};
182static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0};
183#elif defined(CONFIG_ARCH_PNX010X)
184#include <mach/gpio.h>
185#define CIRRUS_DEFAULT_BASE IO_ADDRESS(EXT_STATIC2_s0_BASE + 0x200000)
186#define CIRRUS_DEFAULT_IRQ VH_INTC_INT_NUM_CASCADED_INTERRUPT_1
187static unsigned int netcard_portlist[] __used __initdata = {CIRRUS_DEFAULT_BASE, 0};
188static unsigned int cs8900_irq_map[] = {CIRRUS_DEFAULT_IRQ, 0, 0, 0};
189#elif defined(CONFIG_MACH_MX31ADS)
190#include <mach/board-mx31ads.h>
191static unsigned int netcard_portlist[] __used __initdata = {
192 PBC_BASE_ADDRESS + PBC_CS8900A_IOBASE + 0x300, 0
193};
194static unsigned cs8900_irq_map[] = {EXPIO_INT_ENET_INT, 0, 0, 0};
195#else
196static unsigned int netcard_portlist[] __used __initdata =
197 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
198static unsigned int cs8900_irq_map[] = {10,11,12,5};
199#endif
200
201#if DEBUGGING
202static unsigned int net_debug = DEBUGGING;
203#else
204#define net_debug 0
205#endif
206
207
208#define NETCARD_IO_EXTENT 16
209
210
211#define FORCE_RJ45 0x0001
212#define FORCE_AUI 0x0002
213#define FORCE_BNC 0x0004
214
215#define FORCE_AUTO 0x0010
216#define FORCE_HALF 0x0020
217#define FORCE_FULL 0x0030
218
219
220struct net_local {
221 struct net_device_stats stats;
222 int chip_type;
223 char chip_revision;
224 int send_cmd;
225 int auto_neg_cnf;
226 int adapter_cnf;
227 int isa_config;
228 int irq_map;
229 int rx_mode;
230 int curr_rx_cfg;
231 int linectl;
232 int send_underrun;
233 int force;
234 spinlock_t lock;
235#if ALLOW_DMA
236 int use_dma;
237 int dma;
238 int dmasize;
239 unsigned char *dma_buff;
240 unsigned char *end_dma_buff;
241 unsigned char *rx_dma_ptr;
242#endif
243};
244
245
246
247static int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular);
248static int net_open(struct net_device *dev);
249static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev);
250static irqreturn_t net_interrupt(int irq, void *dev_id);
251static void set_multicast_list(struct net_device *dev);
252static void net_timeout(struct net_device *dev);
253static void net_rx(struct net_device *dev);
254static int net_close(struct net_device *dev);
255static struct net_device_stats *net_get_stats(struct net_device *dev);
256static void reset_chip(struct net_device *dev);
257static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
258static int get_eeprom_cksum(int off, int len, int *buffer);
259static int set_mac_address(struct net_device *dev, void *addr);
260static void count_rx_errors(int status, struct net_local *lp);
261#ifdef CONFIG_NET_POLL_CONTROLLER
262static void net_poll_controller(struct net_device *dev);
263#endif
264#if ALLOW_DMA
265static void get_dma_channel(struct net_device *dev);
266static void release_dma_buff(struct net_local *lp);
267#endif
268
269
270#define tx_done(dev) 1
271
272
273
274
275#if !defined(MODULE) && (ALLOW_DMA != 0)
276static int g_cs89x0_dma;
277
278static int __init dma_fn(char *str)
279{
280 g_cs89x0_dma = simple_strtol(str,NULL,0);
281 return 1;
282}
283
284__setup("cs89x0_dma=", dma_fn);
285#endif
286
287#ifndef MODULE
288static int g_cs89x0_media__force;
289
290static int __init media_fn(char *str)
291{
292 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
293 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
294 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
295 return 1;
296}
297
298__setup("cs89x0_media=", media_fn);
299
300
301
302
303
304
305
306
307
308
309struct net_device * __init cs89x0_probe(int unit)
310{
311 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
312 unsigned *port;
313 int err = 0;
314 int irq;
315 int io;
316
317 if (!dev)
318 return ERR_PTR(-ENODEV);
319
320 sprintf(dev->name, "eth%d", unit);
321 netdev_boot_setup_check(dev);
322 io = dev->base_addr;
323 irq = dev->irq;
324
325 if (net_debug)
326 printk("cs89x0:cs89x0_probe(0x%x)\n", io);
327
328 if (io > 0x1ff) {
329 err = cs89x0_probe1(dev, io, 0);
330 } else if (io != 0) {
331 err = -ENXIO;
332 } else {
333 for (port = netcard_portlist; *port; port++) {
334 if (cs89x0_probe1(dev, *port, 0) == 0)
335 break;
336 dev->irq = irq;
337 }
338 if (!*port)
339 err = -ENODEV;
340 }
341 if (err)
342 goto out;
343 return dev;
344out:
345 free_netdev(dev);
346 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
347 return ERR_PTR(err);
348}
349#endif
350
351#if defined(CONFIG_MACH_IXDP2351)
352static u16
353readword(unsigned long base_addr, int portno)
354{
355 return __raw_readw(base_addr + (portno << 1));
356}
357
358static void
359writeword(unsigned long base_addr, int portno, u16 value)
360{
361 __raw_writew(value, base_addr + (portno << 1));
362}
363#elif defined(CONFIG_ARCH_IXDP2X01)
364static u16
365readword(unsigned long base_addr, int portno)
366{
367 return __raw_readl(base_addr + (portno << 1));
368}
369
370static void
371writeword(unsigned long base_addr, int portno, u16 value)
372{
373 __raw_writel(value, base_addr + (portno << 1));
374}
375#elif defined(CONFIG_ARCH_PNX010X)
376static u16
377readword(unsigned long base_addr, int portno)
378{
379 return inw(base_addr + (portno << 1));
380}
381
382static void
383writeword(unsigned long base_addr, int portno, u16 value)
384{
385 outw(value, base_addr + (portno << 1));
386}
387#else
388static u16
389readword(unsigned long base_addr, int portno)
390{
391 return inw(base_addr + portno);
392}
393
394static void
395writeword(unsigned long base_addr, int portno, u16 value)
396{
397 outw(value, base_addr + portno);
398}
399#endif
400
401static void
402readwords(unsigned long base_addr, int portno, void *buf, int length)
403{
404 u8 *buf8 = (u8 *)buf;
405
406 do {
407 u16 tmp16;
408
409 tmp16 = readword(base_addr, portno);
410 *buf8++ = (u8)tmp16;
411 *buf8++ = (u8)(tmp16 >> 8);
412 } while (--length);
413}
414
415static void
416writewords(unsigned long base_addr, int portno, void *buf, int length)
417{
418 u8 *buf8 = (u8 *)buf;
419
420 do {
421 u16 tmp16;
422
423 tmp16 = *buf8++;
424 tmp16 |= (*buf8++) << 8;
425 writeword(base_addr, portno, tmp16);
426 } while (--length);
427}
428
429static u16
430readreg(struct net_device *dev, u16 regno)
431{
432 writeword(dev->base_addr, ADD_PORT, regno);
433 return readword(dev->base_addr, DATA_PORT);
434}
435
436static void
437writereg(struct net_device *dev, u16 regno, u16 value)
438{
439 writeword(dev->base_addr, ADD_PORT, regno);
440 writeword(dev->base_addr, DATA_PORT, value);
441}
442
443static int __init
444wait_eeprom_ready(struct net_device *dev)
445{
446 int timeout = jiffies;
447
448
449
450 while(readreg(dev, PP_SelfST) & SI_BUSY)
451 if (jiffies - timeout >= 40)
452 return -1;
453 return 0;
454}
455
456static int __init
457get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
458{
459 int i;
460
461 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
462 for (i = 0; i < len; i++) {
463 if (wait_eeprom_ready(dev) < 0) return -1;
464
465 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
466 if (wait_eeprom_ready(dev) < 0) return -1;
467 buffer[i] = readreg(dev, PP_EEData);
468 if (net_debug > 3) printk("%04x ", buffer[i]);
469 }
470 if (net_debug > 3) printk("\n");
471 return 0;
472}
473
474static int __init
475get_eeprom_cksum(int off, int len, int *buffer)
476{
477 int i, cksum;
478
479 cksum = 0;
480 for (i = 0; i < len; i++)
481 cksum += buffer[i];
482 cksum &= 0xffff;
483 if (cksum == 0)
484 return 0;
485 return -1;
486}
487
488#ifdef CONFIG_NET_POLL_CONTROLLER
489
490
491
492
493static void net_poll_controller(struct net_device *dev)
494{
495 disable_irq(dev->irq);
496 net_interrupt(dev->irq, dev);
497 enable_irq(dev->irq);
498}
499#endif
500
501static const struct net_device_ops net_ops = {
502 .ndo_open = net_open,
503 .ndo_stop = net_close,
504 .ndo_tx_timeout = net_timeout,
505 .ndo_start_xmit = net_send_packet,
506 .ndo_get_stats = net_get_stats,
507 .ndo_set_multicast_list = set_multicast_list,
508 .ndo_set_mac_address = set_mac_address,
509#ifdef CONFIG_NET_POLL_CONTROLLER
510 .ndo_poll_controller = net_poll_controller,
511#endif
512 .ndo_change_mtu = eth_change_mtu,
513 .ndo_validate_addr = eth_validate_addr,
514};
515
516
517
518
519
520
521
522static int __init
523cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
524{
525 struct net_local *lp = netdev_priv(dev);
526 static unsigned version_printed;
527 int i;
528 int tmp;
529 unsigned rev_type = 0;
530 int eeprom_buff[CHKSUM_LEN];
531 int retval;
532
533
534 if (!modular) {
535 memset(lp, 0, sizeof(*lp));
536 spin_lock_init(&lp->lock);
537#ifndef MODULE
538#if ALLOW_DMA
539 if (g_cs89x0_dma) {
540 lp->use_dma = 1;
541 lp->dma = g_cs89x0_dma;
542 lp->dmasize = 16;
543 }
544#endif
545 lp->force = g_cs89x0_media__force;
546#endif
547 }
548
549#ifdef CONFIG_ARCH_PNX010X
550 initialize_ebi();
551
552
553 if (map_cirrus_gpio() < 0)
554 return -ENODEV;
555
556 reset_cirrus();
557
558
559 if (map_event_router() < 0)
560 return -ENODEV;
561
562 enable_cirrus_irq();
563
564 unmap_cirrus_gpio();
565 unmap_event_router();
566
567 dev->base_addr = ioaddr;
568
569 for (i = 0 ; i < 3 ; i++)
570 readreg(dev, 0);
571#endif
572
573
574
575 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, DRV_NAME)) {
576 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",
577 DRV_NAME, ioaddr, NETCARD_IO_EXTENT);
578 retval = -EBUSY;
579 goto out1;
580 }
581
582#ifdef CONFIG_SH_HICOSH4
583
584 writeword(ioaddr, ADD_PORT, 0x0114);
585 writeword(ioaddr, DATA_PORT, 0x0040);
586#endif
587
588
589
590
591
592 if (ioaddr & 1) {
593 if (net_debug > 1)
594 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);
595 if ((ioaddr & 2) != 2)
596 if ((readword(ioaddr & ~3, ADD_PORT) & ADD_MASK) != ADD_SIG) {
597 printk(KERN_ERR "%s: bad signature 0x%x\n",
598 dev->name, readword(ioaddr & ~3, ADD_PORT));
599 retval = -ENODEV;
600 goto out2;
601 }
602 }
603
604 ioaddr &= ~3;
605 printk(KERN_DEBUG "PP_addr at %x[%x]: 0x%x\n",
606 ioaddr, ADD_PORT, readword(ioaddr, ADD_PORT));
607 writeword(ioaddr, ADD_PORT, PP_ChipID);
608
609 tmp = readword(ioaddr, DATA_PORT);
610 if (tmp != CHIP_EISA_ID_SIG) {
611 printk(KERN_DEBUG "%s: incorrect signature at %x[%x]: 0x%x!="
612 CHIP_EISA_ID_SIG_STR "\n",
613 dev->name, ioaddr, DATA_PORT, tmp);
614 retval = -ENODEV;
615 goto out2;
616 }
617
618
619 dev->base_addr = ioaddr;
620
621
622 rev_type = readreg(dev, PRODUCT_ID_ADD);
623 lp->chip_type = rev_type &~ REVISON_BITS;
624 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
625
626
627
628 lp->send_cmd = TX_AFTER_381;
629 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
630 lp->send_cmd = TX_NOW;
631 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
632 lp->send_cmd = TX_NOW;
633
634 if (net_debug && version_printed++ == 0)
635 printk(version);
636
637 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
638 dev->name,
639 lp->chip_type==CS8900?'0':'2',
640 lp->chip_type==CS8920M?"M":"",
641 lp->chip_revision,
642 dev->base_addr);
643
644 reset_chip(dev);
645
646
647
648
649
650
651
652
653#ifdef CONFIG_SH_HICOSH4
654 if (1) {
655
656
657
658 __u16 *confd;
659 short cnt;
660 if (((* (volatile __u32 *) 0xa0013ff0) & 0x00ffffff)
661 == 0x006c3000) {
662 confd = (__u16*) 0xa0013fc0;
663 } else {
664 confd = (__u16*) 0xa001ffc0;
665 }
666 cnt = (*confd++ & 0x00ff) >> 1;
667 while (--cnt > 0) {
668 __u16 j = *confd++;
669
670 switch (j & 0x0fff) {
671 case PP_IA:
672 for (i = 0; i < ETH_ALEN/2; i++) {
673 dev->dev_addr[i*2] = confd[i] & 0xFF;
674 dev->dev_addr[i*2+1] = confd[i] >> 8;
675 }
676 break;
677 }
678 j = (j >> 12) + 1;
679 confd += j;
680 cnt -= j;
681 }
682 } else
683#endif
684
685 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
686 (EEPROM_OK|EEPROM_PRESENT)) {
687
688 for (i=0; i < ETH_ALEN/2; i++) {
689 unsigned int Addr;
690 Addr = readreg(dev, PP_IA+i*2);
691 dev->dev_addr[i*2] = Addr & 0xFF;
692 dev->dev_addr[i*2+1] = Addr >> 8;
693 }
694
695
696
697
698
699
700
701
702
703
704
705 lp->adapter_cnf = 0;
706 i = readreg(dev, PP_LineCTL);
707
708 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
709 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
710
711 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
712 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
713
714 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
715 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
716
717 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
718 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
719
720 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
721 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
722 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
723
724 if (net_debug > 1)
725 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
726 dev->name, i, lp->adapter_cnf);
727
728
729 if (lp->chip_type == CS8900)
730 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
731
732 printk( "[Cirrus EEPROM] ");
733 }
734
735 printk("\n");
736
737
738#ifdef CONFIG_SH_HICOSH4
739 if (1) {
740 printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");
741 } else
742#endif
743 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
744 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
745 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
746 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
747 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
748
749
750 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
751 (EEPROM_OK|EEPROM_PRESENT))
752 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
753
754 } else {
755
756
757
758
759 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
760
761 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
762
763 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
764 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
765
766
767
768 for (i = 0; i < ETH_ALEN/2; i++) {
769 dev->dev_addr[i*2] = eeprom_buff[i];
770 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
771 }
772 if (net_debug > 1)
773 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
774 dev->name, lp->adapter_cnf);
775 }
776
777
778 {
779 int count = 0;
780 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
781 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
782 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
783 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
784 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
785 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
786 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
787 }
788
789 if (net_debug > 1)
790 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
791 dev->name, lp->force, lp->adapter_cnf);
792
793
794
795
796
797
798
799
800 printk(KERN_INFO "cs89x0 media %s%s%s",
801 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
802 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
803 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
804
805 lp->irq_map = 0xffff;
806
807
808 if (lp->chip_type != CS8900 &&
809
810 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
811 (i != 0 && i < CS8920_NO_INTS))) {
812 if (!dev->irq)
813 dev->irq = i;
814 } else {
815 i = lp->isa_config & INT_NO_MASK;
816 if (lp->chip_type == CS8900) {
817#ifdef CONFIG_CS89x0_NONISA_IRQ
818 i = cs8900_irq_map[0];
819#else
820
821 if (i >= ARRAY_SIZE(cs8900_irq_map))
822 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
823 else
824 i = cs8900_irq_map[i];
825
826 lp->irq_map = CS8900_IRQ_MAP;
827 } else {
828 int irq_map_buff[IRQ_MAP_LEN/2];
829
830 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
831 IRQ_MAP_LEN/2,
832 irq_map_buff) >= 0) {
833 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
834 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
835 }
836#endif
837 }
838 if (!dev->irq)
839 dev->irq = i;
840 }
841
842 printk(" IRQ %d", dev->irq);
843
844#if ALLOW_DMA
845 if (lp->use_dma) {
846 get_dma_channel(dev);
847 printk(", DMA %d", dev->dma);
848 }
849 else
850#endif
851 {
852 printk(", programmed I/O");
853 }
854
855
856 printk(", MAC %pM", dev->dev_addr);
857
858 dev->netdev_ops = &net_ops;
859 dev->watchdog_timeo = HZ;
860
861 printk("\n");
862 if (net_debug)
863 printk("cs89x0_probe1() successful\n");
864
865 retval = register_netdev(dev);
866 if (retval)
867 goto out3;
868 return 0;
869out3:
870 writeword(dev->base_addr, ADD_PORT, PP_ChipID);
871out2:
872 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
873out1:
874 return retval;
875}
876
877
878
879
880
881
882#if ALLOW_DMA
883
884#define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
885
886static void
887get_dma_channel(struct net_device *dev)
888{
889 struct net_local *lp = netdev_priv(dev);
890
891 if (lp->dma) {
892 dev->dma = lp->dma;
893 lp->isa_config |= ISA_RxDMA;
894 } else {
895 if ((lp->isa_config & ANY_ISA_DMA) == 0)
896 return;
897 dev->dma = lp->isa_config & DMA_NO_MASK;
898 if (lp->chip_type == CS8900)
899 dev->dma += 5;
900 if (dev->dma < 5 || dev->dma > 7) {
901 lp->isa_config &= ~ANY_ISA_DMA;
902 return;
903 }
904 }
905 return;
906}
907
908static void
909write_dma(struct net_device *dev, int chip_type, int dma)
910{
911 struct net_local *lp = netdev_priv(dev);
912 if ((lp->isa_config & ANY_ISA_DMA) == 0)
913 return;
914 if (chip_type == CS8900) {
915 writereg(dev, PP_CS8900_ISADMA, dma-5);
916 } else {
917 writereg(dev, PP_CS8920_ISADMA, dma);
918 }
919}
920
921static void
922set_dma_cfg(struct net_device *dev)
923{
924 struct net_local *lp = netdev_priv(dev);
925
926 if (lp->use_dma) {
927 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
928 if (net_debug > 3)
929 printk("set_dma_cfg(): no DMA\n");
930 return;
931 }
932 if (lp->isa_config & ISA_RxDMA) {
933 lp->curr_rx_cfg |= RX_DMA_ONLY;
934 if (net_debug > 3)
935 printk("set_dma_cfg(): RX_DMA_ONLY\n");
936 } else {
937 lp->curr_rx_cfg |= AUTO_RX_DMA;
938 if (net_debug > 3)
939 printk("set_dma_cfg(): AUTO_RX_DMA\n");
940 }
941 }
942}
943
944static int
945dma_bufcfg(struct net_device *dev)
946{
947 struct net_local *lp = netdev_priv(dev);
948 if (lp->use_dma)
949 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
950 else
951 return 0;
952}
953
954static int
955dma_busctl(struct net_device *dev)
956{
957 int retval = 0;
958 struct net_local *lp = netdev_priv(dev);
959 if (lp->use_dma) {
960 if (lp->isa_config & ANY_ISA_DMA)
961 retval |= RESET_RX_DMA;
962 if (lp->isa_config & DMA_BURST)
963 retval |= DMA_BURST_MODE;
964 if (lp->dmasize == 64)
965 retval |= RX_DMA_SIZE_64K;
966 retval |= MEMORY_ON;
967 }
968 return retval;
969}
970
971static void
972dma_rx(struct net_device *dev)
973{
974 struct net_local *lp = netdev_priv(dev);
975 struct sk_buff *skb;
976 int status, length;
977 unsigned char *bp = lp->rx_dma_ptr;
978
979 status = bp[0] + (bp[1]<<8);
980 length = bp[2] + (bp[3]<<8);
981 bp += 4;
982 if (net_debug > 5) {
983 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n",
984 dev->name, (unsigned long)bp, status, length);
985 }
986 if ((status & RX_OK) == 0) {
987 count_rx_errors(status, lp);
988 goto skip_this_frame;
989 }
990
991
992 skb = dev_alloc_skb(length + 2);
993 if (skb == NULL) {
994 if (net_debug)
995 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
996 lp->stats.rx_dropped++;
997
998
999skip_this_frame:
1000 bp += (length + 3) & ~3;
1001 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
1002 lp->rx_dma_ptr = bp;
1003 return;
1004 }
1005 skb_reserve(skb, 2);
1006
1007 if (bp + length > lp->end_dma_buff) {
1008 int semi_cnt = lp->end_dma_buff - bp;
1009 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
1010 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
1011 length - semi_cnt);
1012 } else {
1013 memcpy(skb_put(skb,length), bp, length);
1014 }
1015 bp += (length + 3) & ~3;
1016 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
1017 lp->rx_dma_ptr = bp;
1018
1019 if (net_debug > 3) {
1020 printk( "%s: received %d byte DMA packet of type %x\n",
1021 dev->name, length,
1022 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1023 }
1024 skb->protocol=eth_type_trans(skb,dev);
1025 netif_rx(skb);
1026 lp->stats.rx_packets++;
1027 lp->stats.rx_bytes += length;
1028}
1029
1030#endif
1031
1032static void __init reset_chip(struct net_device *dev)
1033{
1034#if !defined(CONFIG_MACH_MX31ADS)
1035#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01)
1036 struct net_local *lp = netdev_priv(dev);
1037 int ioaddr = dev->base_addr;
1038#endif
1039 int reset_start_time;
1040
1041 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
1042
1043
1044 msleep(30);
1045
1046#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01)
1047 if (lp->chip_type != CS8900) {
1048
1049 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAINT);
1050 outb(dev->irq, ioaddr + DATA_PORT);
1051 outb(0, ioaddr + DATA_PORT + 1);
1052
1053 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAMemB);
1054 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
1055 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
1056 }
1057#endif
1058
1059
1060 reset_start_time = jiffies;
1061 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
1062 ;
1063#endif
1064}
1065
1066
1067static void
1068control_dc_dc(struct net_device *dev, int on_not_off)
1069{
1070 struct net_local *lp = netdev_priv(dev);
1071 unsigned int selfcontrol;
1072 int timenow = jiffies;
1073
1074
1075
1076
1077 selfcontrol = HCB1_ENBL;
1078 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
1079 selfcontrol |= HCB1;
1080 else
1081 selfcontrol &= ~HCB1;
1082 writereg(dev, PP_SelfCTL, selfcontrol);
1083
1084
1085 while (jiffies - timenow < HZ)
1086 ;
1087}
1088
1089#define DETECTED_NONE 0
1090#define DETECTED_RJ45H 1
1091#define DETECTED_RJ45F 2
1092#define DETECTED_AUI 3
1093#define DETECTED_BNC 4
1094
1095static int
1096detect_tp(struct net_device *dev)
1097{
1098 struct net_local *lp = netdev_priv(dev);
1099 int timenow = jiffies;
1100 int fdx;
1101
1102 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);
1103
1104
1105
1106
1107
1108
1109 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
1110 control_dc_dc(dev, 0);
1111
1112
1113 for (timenow = jiffies; jiffies - timenow < 15; )
1114 ;
1115 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
1116 return DETECTED_NONE;
1117
1118 if (lp->chip_type == CS8900) {
1119 switch (lp->force & 0xf0) {
1120#if 0
1121 case FORCE_AUTO:
1122 printk("%s: cs8900 doesn't autonegotiate\n",dev->name);
1123 return DETECTED_NONE;
1124#endif
1125
1126 case FORCE_AUTO:
1127 lp->force &= ~FORCE_AUTO;
1128 lp->force |= FORCE_HALF;
1129 break;
1130 case FORCE_HALF:
1131 break;
1132 case FORCE_FULL:
1133 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
1134 break;
1135 }
1136 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
1137 } else {
1138 switch (lp->force & 0xf0) {
1139 case FORCE_AUTO:
1140 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1141 break;
1142 case FORCE_HALF:
1143 lp->auto_neg_cnf = 0;
1144 break;
1145 case FORCE_FULL:
1146 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
1147 break;
1148 }
1149
1150 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
1151
1152 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
1153 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name);
1154 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
1155 if (jiffies - timenow > 4000) {
1156 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n");
1157 break;
1158 }
1159 }
1160 }
1161 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
1162 }
1163 if (fdx)
1164 return DETECTED_RJ45F;
1165 else
1166 return DETECTED_RJ45H;
1167}
1168
1169
1170static int
1171send_test_pkt(struct net_device *dev)
1172{
1173 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
1174 0, 46,
1175 0, 0,
1176 0xf3, 0 };
1177 long timenow = jiffies;
1178
1179 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
1180
1181 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
1182 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);
1183
1184 writeword(dev->base_addr, TX_CMD_PORT, TX_AFTER_ALL);
1185 writeword(dev->base_addr, TX_LEN_PORT, ETH_ZLEN);
1186
1187
1188 while (jiffies - timenow < 5)
1189 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
1190 break;
1191 if (jiffies - timenow >= 5)
1192 return 0;
1193
1194
1195 writewords(dev->base_addr, TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
1196
1197 if (net_debug > 1) printk("Sending test packet ");
1198
1199 for (timenow = jiffies; jiffies - timenow < 3; )
1200 ;
1201 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
1202 if (net_debug > 1) printk("succeeded\n");
1203 return 1;
1204 }
1205 if (net_debug > 1) printk("failed\n");
1206 return 0;
1207}
1208
1209
1210static int
1211detect_aui(struct net_device *dev)
1212{
1213 struct net_local *lp = netdev_priv(dev);
1214
1215 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);
1216 control_dc_dc(dev, 0);
1217
1218 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1219
1220 if (send_test_pkt(dev))
1221 return DETECTED_AUI;
1222 else
1223 return DETECTED_NONE;
1224}
1225
1226static int
1227detect_bnc(struct net_device *dev)
1228{
1229 struct net_local *lp = netdev_priv(dev);
1230
1231 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);
1232 control_dc_dc(dev, 1);
1233
1234 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1235
1236 if (send_test_pkt(dev))
1237 return DETECTED_BNC;
1238 else
1239 return DETECTED_NONE;
1240}
1241
1242
1243static void
1244write_irq(struct net_device *dev, int chip_type, int irq)
1245{
1246 int i;
1247
1248 if (chip_type == CS8900) {
1249
1250 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
1251 if (cs8900_irq_map[i] == irq)
1252 break;
1253
1254 if (i == ARRAY_SIZE(cs8900_irq_map))
1255 i = 3;
1256 writereg(dev, PP_CS8900_ISAINT, i);
1257 } else {
1258 writereg(dev, PP_CS8920_ISAINT, irq);
1259 }
1260}
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272static int
1273net_open(struct net_device *dev)
1274{
1275 struct net_local *lp = netdev_priv(dev);
1276 int result = 0;
1277 int i;
1278 int ret;
1279
1280#if !defined(CONFIG_SH_HICOSH4) && !defined(CONFIG_ARCH_PNX010X)
1281 if (dev->irq < 2) {
1282
1283
1284#if 0
1285 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1286#endif
1287
1288 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1289
1290 for (i = 2; i < CS8920_NO_INTS; i++) {
1291 if ((1 << i) & lp->irq_map) {
1292 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1293 dev->irq = i;
1294 write_irq(dev, lp->chip_type, i);
1295
1296 break;
1297 }
1298 }
1299 }
1300
1301 if (i >= CS8920_NO_INTS) {
1302 writereg(dev, PP_BusCTL, 0);
1303 printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1304 ret = -EAGAIN;
1305 goto bad_out;
1306 }
1307 }
1308 else
1309#endif
1310 {
1311#ifndef CONFIG_CS89x0_NONISA_IRQ
1312 if (((1 << dev->irq) & lp->irq_map) == 0) {
1313 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1314 dev->name, dev->irq, lp->irq_map);
1315 ret = -EAGAIN;
1316 goto bad_out;
1317 }
1318#endif
1319
1320 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1321
1322#if 0
1323 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1324#endif
1325 write_irq(dev, lp->chip_type, dev->irq);
1326 ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
1327 if (ret) {
1328 if (net_debug)
1329 printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
1330 goto bad_out;
1331 }
1332 }
1333
1334#if ALLOW_DMA
1335 if (lp->use_dma) {
1336 if (lp->isa_config & ANY_ISA_DMA) {
1337 unsigned long flags;
1338 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1339 get_order(lp->dmasize * 1024));
1340
1341 if (!lp->dma_buff) {
1342 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1343 goto release_irq;
1344 }
1345 if (net_debug > 1) {
1346 printk( "%s: dma %lx %lx\n",
1347 dev->name,
1348 (unsigned long)lp->dma_buff,
1349 (unsigned long)isa_virt_to_bus(lp->dma_buff));
1350 }
1351 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1352 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1353 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1354 goto release_irq;
1355 }
1356 memset(lp->dma_buff, 0, lp->dmasize * 1024);
1357 if (request_dma(dev->dma, dev->name)) {
1358 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1359 goto release_irq;
1360 }
1361 write_dma(dev, lp->chip_type, dev->dma);
1362 lp->rx_dma_ptr = lp->dma_buff;
1363 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1364 spin_lock_irqsave(&lp->lock, flags);
1365 disable_dma(dev->dma);
1366 clear_dma_ff(dev->dma);
1367 set_dma_mode(dev->dma, DMA_RX_MODE);
1368 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
1369 set_dma_count(dev->dma, lp->dmasize*1024);
1370 enable_dma(dev->dma);
1371 spin_unlock_irqrestore(&lp->lock, flags);
1372 }
1373 }
1374#endif
1375
1376
1377 for (i=0; i < ETH_ALEN/2; i++)
1378 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1379
1380
1381 writereg(dev, PP_BusCTL, MEMORY_ON);
1382
1383
1384 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1385 lp->linectl = LOW_RX_SQUELCH;
1386 else
1387 lp->linectl = 0;
1388
1389
1390 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1391 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1392 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
1393 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1394 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1395 }
1396#ifdef CONFIG_ARCH_PNX010X
1397 result = A_CNF_10B_T;
1398#endif
1399 if (!result) {
1400 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1401release_dma:
1402#if ALLOW_DMA
1403 free_dma(dev->dma);
1404release_irq:
1405 release_dma_buff(lp);
1406#endif
1407 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1408 free_irq(dev->irq, dev);
1409 ret = -EAGAIN;
1410 goto bad_out;
1411 }
1412
1413
1414 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1415 case A_CNF_MEDIA_10B_T:
1416 result = detect_tp(dev);
1417 if (result==DETECTED_NONE) {
1418 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1419 if (lp->auto_neg_cnf & IMM_BIT)
1420 result = DETECTED_RJ45H;
1421 }
1422 break;
1423 case A_CNF_MEDIA_AUI:
1424 result = detect_aui(dev);
1425 if (result==DETECTED_NONE) {
1426 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1427 if (lp->auto_neg_cnf & IMM_BIT)
1428 result = DETECTED_AUI;
1429 }
1430 break;
1431 case A_CNF_MEDIA_10B_2:
1432 result = detect_bnc(dev);
1433 if (result==DETECTED_NONE) {
1434 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1435 if (lp->auto_neg_cnf & IMM_BIT)
1436 result = DETECTED_BNC;
1437 }
1438 break;
1439 case A_CNF_MEDIA_AUTO:
1440 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1441 if (lp->adapter_cnf & A_CNF_10B_T)
1442 if ((result = detect_tp(dev)) != DETECTED_NONE)
1443 break;
1444 if (lp->adapter_cnf & A_CNF_AUI)
1445 if ((result = detect_aui(dev)) != DETECTED_NONE)
1446 break;
1447 if (lp->adapter_cnf & A_CNF_10B_2)
1448 if ((result = detect_bnc(dev)) != DETECTED_NONE)
1449 break;
1450 printk(KERN_ERR "%s: no media detected\n", dev->name);
1451 goto release_dma;
1452 }
1453 switch(result) {
1454 case DETECTED_NONE:
1455 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1456 goto release_dma;
1457 case DETECTED_RJ45H:
1458 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1459 break;
1460 case DETECTED_RJ45F:
1461 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1462 break;
1463 case DETECTED_AUI:
1464 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1465 break;
1466 case DETECTED_BNC:
1467 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1468 break;
1469 }
1470
1471
1472 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1473
1474
1475 lp->rx_mode = 0;
1476 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1477
1478 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1479
1480 if (lp->isa_config & STREAM_TRANSFER)
1481 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1482#if ALLOW_DMA
1483 set_dma_cfg(dev);
1484#endif
1485 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1486
1487 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1488 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1489
1490 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1491#if ALLOW_DMA
1492 dma_bufcfg(dev) |
1493#endif
1494 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1495
1496
1497 writereg(dev, PP_BusCTL, ENABLE_IRQ
1498 | (dev->mem_start?MEMORY_ON : 0)
1499#if ALLOW_DMA
1500 | dma_busctl(dev)
1501#endif
1502 );
1503 netif_start_queue(dev);
1504 if (net_debug > 1)
1505 printk("cs89x0: net_open() succeeded\n");
1506 return 0;
1507bad_out:
1508 return ret;
1509}
1510
1511static void net_timeout(struct net_device *dev)
1512{
1513
1514
1515 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1516 tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1517
1518 netif_wake_queue(dev);
1519}
1520
1521static netdev_tx_t net_send_packet(struct sk_buff *skb,struct net_device *dev)
1522{
1523 struct net_local *lp = netdev_priv(dev);
1524 unsigned long flags;
1525
1526 if (net_debug > 3) {
1527 printk("%s: sent %d byte packet of type %x\n",
1528 dev->name, skb->len,
1529 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1530 }
1531
1532
1533
1534
1535
1536 spin_lock_irqsave(&lp->lock, flags);
1537 netif_stop_queue(dev);
1538
1539
1540 writeword(dev->base_addr, TX_CMD_PORT, lp->send_cmd);
1541 writeword(dev->base_addr, TX_LEN_PORT, skb->len);
1542
1543
1544 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1545
1546
1547
1548
1549
1550 spin_unlock_irqrestore(&lp->lock, flags);
1551 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1552 return NETDEV_TX_BUSY;
1553 }
1554
1555 writewords(dev->base_addr, TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1556 spin_unlock_irqrestore(&lp->lock, flags);
1557 lp->stats.tx_bytes += skb->len;
1558 dev->trans_start = jiffies;
1559 dev_kfree_skb (skb);
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572 return NETDEV_TX_OK;
1573}
1574
1575
1576
1577
1578static irqreturn_t net_interrupt(int irq, void *dev_id)
1579{
1580 struct net_device *dev = dev_id;
1581 struct net_local *lp;
1582 int ioaddr, status;
1583 int handled = 0;
1584
1585 ioaddr = dev->base_addr;
1586 lp = netdev_priv(dev);
1587
1588
1589
1590
1591
1592
1593
1594
1595 while ((status = readword(dev->base_addr, ISQ_PORT))) {
1596 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1597 handled = 1;
1598 switch(status & ISQ_EVENT_MASK) {
1599 case ISQ_RECEIVER_EVENT:
1600
1601 net_rx(dev);
1602 break;
1603 case ISQ_TRANSMITTER_EVENT:
1604 lp->stats.tx_packets++;
1605 netif_wake_queue(dev);
1606 if ((status & ( TX_OK |
1607 TX_LOST_CRS |
1608 TX_SQE_ERROR |
1609 TX_LATE_COL |
1610 TX_16_COL)) != TX_OK) {
1611 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
1612 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
1613 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
1614 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
1615 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
1616 }
1617 break;
1618 case ISQ_BUFFER_EVENT:
1619 if (status & READY_FOR_TX) {
1620
1621
1622
1623
1624
1625 netif_wake_queue(dev);
1626 }
1627 if (status & TX_UNDERRUN) {
1628 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1629 lp->send_underrun++;
1630 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1631 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1632
1633
1634
1635
1636
1637 netif_wake_queue(dev);
1638 }
1639#if ALLOW_DMA
1640 if (lp->use_dma && (status & RX_DMA)) {
1641 int count = readreg(dev, PP_DmaFrameCnt);
1642 while(count) {
1643 if (net_debug > 5)
1644 printk("%s: receiving %d DMA frames\n", dev->name, count);
1645 if (net_debug > 2 && count >1)
1646 printk("%s: receiving %d DMA frames\n", dev->name, count);
1647 dma_rx(dev);
1648 if (--count == 0)
1649 count = readreg(dev, PP_DmaFrameCnt);
1650 if (net_debug > 2 && count > 0)
1651 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1652 }
1653 }
1654#endif
1655 break;
1656 case ISQ_RX_MISS_EVENT:
1657 lp->stats.rx_missed_errors += (status >>6);
1658 break;
1659 case ISQ_TX_COL_EVENT:
1660 lp->stats.collisions += (status >>6);
1661 break;
1662 }
1663 }
1664 return IRQ_RETVAL(handled);
1665}
1666
1667static void
1668count_rx_errors(int status, struct net_local *lp)
1669{
1670 lp->stats.rx_errors++;
1671 if (status & RX_RUNT) lp->stats.rx_length_errors++;
1672 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
1673 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
1674
1675 lp->stats.rx_crc_errors++;
1676 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
1677 return;
1678}
1679
1680
1681static void
1682net_rx(struct net_device *dev)
1683{
1684 struct net_local *lp = netdev_priv(dev);
1685 struct sk_buff *skb;
1686 int status, length;
1687
1688 int ioaddr = dev->base_addr;
1689 status = readword(ioaddr, RX_FRAME_PORT);
1690 length = readword(ioaddr, RX_FRAME_PORT);
1691
1692 if ((status & RX_OK) == 0) {
1693 count_rx_errors(status, lp);
1694 return;
1695 }
1696
1697
1698 skb = dev_alloc_skb(length + 2);
1699 if (skb == NULL) {
1700#if 0
1701 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1702#endif
1703 lp->stats.rx_dropped++;
1704 return;
1705 }
1706 skb_reserve(skb, 2);
1707
1708 readwords(ioaddr, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1709 if (length & 1)
1710 skb->data[length-1] = readword(ioaddr, RX_FRAME_PORT);
1711
1712 if (net_debug > 3) {
1713 printk( "%s: received %d byte packet of type %x\n",
1714 dev->name, length,
1715 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1716 }
1717
1718 skb->protocol=eth_type_trans(skb,dev);
1719 netif_rx(skb);
1720 lp->stats.rx_packets++;
1721 lp->stats.rx_bytes += length;
1722}
1723
1724#if ALLOW_DMA
1725static void release_dma_buff(struct net_local *lp)
1726{
1727 if (lp->dma_buff) {
1728 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1729 lp->dma_buff = NULL;
1730 }
1731}
1732#endif
1733
1734
1735static int
1736net_close(struct net_device *dev)
1737{
1738#if ALLOW_DMA
1739 struct net_local *lp = netdev_priv(dev);
1740#endif
1741
1742 netif_stop_queue(dev);
1743
1744 writereg(dev, PP_RxCFG, 0);
1745 writereg(dev, PP_TxCFG, 0);
1746 writereg(dev, PP_BufCFG, 0);
1747 writereg(dev, PP_BusCTL, 0);
1748
1749 free_irq(dev->irq, dev);
1750
1751#if ALLOW_DMA
1752 if (lp->use_dma && lp->dma) {
1753 free_dma(dev->dma);
1754 release_dma_buff(lp);
1755 }
1756#endif
1757
1758
1759 return 0;
1760}
1761
1762
1763
1764static struct net_device_stats *
1765net_get_stats(struct net_device *dev)
1766{
1767 struct net_local *lp = netdev_priv(dev);
1768 unsigned long flags;
1769
1770 spin_lock_irqsave(&lp->lock, flags);
1771
1772 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1773 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1774 spin_unlock_irqrestore(&lp->lock, flags);
1775
1776 return &lp->stats;
1777}
1778
1779static void set_multicast_list(struct net_device *dev)
1780{
1781 struct net_local *lp = netdev_priv(dev);
1782 unsigned long flags;
1783
1784 spin_lock_irqsave(&lp->lock, flags);
1785 if(dev->flags&IFF_PROMISC)
1786 {
1787 lp->rx_mode = RX_ALL_ACCEPT;
1788 }
1789 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
1790 {
1791
1792
1793 lp->rx_mode = RX_MULTCAST_ACCEPT;
1794 }
1795 else
1796 lp->rx_mode = 0;
1797
1798 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1799
1800
1801 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1802 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1803 spin_unlock_irqrestore(&lp->lock, flags);
1804}
1805
1806
1807static int set_mac_address(struct net_device *dev, void *p)
1808{
1809 int i;
1810 struct sockaddr *addr = p;
1811
1812 if (netif_running(dev))
1813 return -EBUSY;
1814
1815 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1816
1817 if (net_debug)
1818 printk("%s: Setting MAC address to %pM.\n",
1819 dev->name, dev->dev_addr);
1820
1821
1822 for (i=0; i < ETH_ALEN/2; i++)
1823 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1824
1825 return 0;
1826}
1827
1828#ifdef MODULE
1829
1830static struct net_device *dev_cs89x0;
1831
1832
1833
1834
1835
1836
1837static int io;
1838static int irq;
1839static int debug;
1840static char media[8];
1841static int duplex=-1;
1842
1843static int use_dma;
1844static int dma;
1845static int dmasize=16;
1846
1847module_param(io, int, 0);
1848module_param(irq, int, 0);
1849module_param(debug, int, 0);
1850module_param_string(media, media, sizeof(media), 0);
1851module_param(duplex, int, 0);
1852module_param(dma , int, 0);
1853module_param(dmasize , int, 0);
1854module_param(use_dma , int, 0);
1855MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1856MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1857#if DEBUGGING
1858MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1859#else
1860MODULE_PARM_DESC(debug, "(ignored)");
1861#endif
1862MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1863
1864MODULE_PARM_DESC(duplex, "(ignored)");
1865#if ALLOW_DMA
1866MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1867MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1868MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1869#else
1870MODULE_PARM_DESC(dma , "(ignored)");
1871MODULE_PARM_DESC(dmasize , "(ignored)");
1872MODULE_PARM_DESC(use_dma , "(ignored)");
1873#endif
1874
1875MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1876MODULE_LICENSE("GPL");
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905int __init init_module(void)
1906{
1907 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1908 struct net_local *lp;
1909 int ret = 0;
1910
1911#if DEBUGGING
1912 net_debug = debug;
1913#else
1914 debug = 0;
1915#endif
1916 if (!dev)
1917 return -ENOMEM;
1918
1919 dev->irq = irq;
1920 dev->base_addr = io;
1921 lp = netdev_priv(dev);
1922
1923#if ALLOW_DMA
1924 if (use_dma) {
1925 lp->use_dma = use_dma;
1926 lp->dma = dma;
1927 lp->dmasize = dmasize;
1928 }
1929#endif
1930
1931 spin_lock_init(&lp->lock);
1932
1933
1934 if (!strcmp(media, "rj45"))
1935 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1936 else if (!strcmp(media, "aui"))
1937 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1938 else if (!strcmp(media, "bnc"))
1939 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1940 else
1941 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1942
1943 if (duplex==-1)
1944 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1945
1946 if (io == 0) {
1947 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1948 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1949 ret = -EPERM;
1950 goto out;
1951 } else if (io <= 0x1ff) {
1952 ret = -ENXIO;
1953 goto out;
1954 }
1955
1956#if ALLOW_DMA
1957 if (use_dma && dmasize != 16 && dmasize != 64) {
1958 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1959 ret = -EPERM;
1960 goto out;
1961 }
1962#endif
1963 ret = cs89x0_probe1(dev, io, 1);
1964 if (ret)
1965 goto out;
1966
1967 dev_cs89x0 = dev;
1968 return 0;
1969out:
1970 free_netdev(dev);
1971 return ret;
1972}
1973
1974void __exit
1975cleanup_module(void)
1976{
1977 unregister_netdev(dev_cs89x0);
1978 writeword(dev_cs89x0->base_addr, ADD_PORT, PP_ChipID);
1979 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1980 free_netdev(dev_cs89x0);
1981}
1982#endif
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993