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