Loading...
1/* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
2 * driver for linux.
3 * Written 1996 by Russell Nelson, with reference to skeleton.c
4 * written 1993-1994 by Donald Becker.
5 *
6 * This software may be used and distributed according to the terms
7 * of the GNU General Public License, incorporated herein by reference.
8 *
9 * The author may be reached at nelson@crynwr.com, Crynwr
10 * Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
11 *
12 * Other contributors:
13 * Mike Cruse : mcruse@cti-ltd.com
14 * Russ Nelson
15 * Melody Lee : ethernet@crystal.cirrus.com
16 * Alan Cox
17 * Andrew Morton
18 * Oskar Schirmer : oskar@scara.com
19 * Deepak Saxena : dsaxena@plexity.net
20 * Dmitry Pervushin : dpervushin@ru.mvista.com
21 * Deepak Saxena : dsaxena@plexity.net
22 * Domenico Andreoli : cavokz@gmail.com
23 */
24
25
26/*
27 * Set this to zero to disable DMA code
28 *
29 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
30 * module options so we don't break any startup scripts.
31 */
32#ifndef CONFIG_ISA_DMA_API
33#define ALLOW_DMA 0
34#else
35#define ALLOW_DMA 1
36#endif
37
38/*
39 * Set this to zero to remove all the debug statements via
40 * dead code elimination
41 */
42#define DEBUGGING 1
43
44/* Sources:
45 * Crynwr packet driver epktisa.
46 * Crystal Semiconductor data sheets.
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/platform_device.h>
58#include <linux/kernel.h>
59#include <linux/types.h>
60#include <linux/fcntl.h>
61#include <linux/interrupt.h>
62#include <linux/ioport.h>
63#include <linux/in.h>
64#include <linux/jiffies.h>
65#include <linux/skbuff.h>
66#include <linux/spinlock.h>
67#include <linux/string.h>
68#include <linux/init.h>
69#include <linux/bitops.h>
70#include <linux/delay.h>
71#include <linux/gfp.h>
72#include <linux/io.h>
73
74#include <net/Space.h>
75
76#include <asm/irq.h>
77#include <linux/atomic.h>
78#if ALLOW_DMA
79#include <asm/dma.h>
80#endif
81
82#include "cs89x0.h"
83
84#define cs89_dbg(val, level, fmt, ...) \
85do { \
86 if (val <= net_debug) \
87 pr_##level(fmt, ##__VA_ARGS__); \
88} while (0)
89
90static char version[] __initdata =
91 "v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton";
92
93#define DRV_NAME "cs89x0"
94
95/* First, a few definitions that the brave might change.
96 * A zero-terminated list of I/O addresses to be probed. Some special flags..
97 * Addr & 1 = Read back the address port, look for signature and reset
98 * the page window before probing
99 * Addr & 3 = Reset the page window and probe
100 * The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
101 * but it is possible that a Cirrus board could be plugged into the ISA
102 * slots.
103 */
104/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
105 * them to system IRQ numbers. This mapping is card specific and is set to
106 * the configuration of the Cirrus Eval board for this chip.
107 */
108#if IS_ENABLED(CONFIG_CS89x0_ISA)
109static unsigned int netcard_portlist[] __used __initdata = {
110 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240,
111 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0
112};
113static unsigned int cs8900_irq_map[] = {
114 10, 11, 12, 5
115};
116#endif
117
118#if DEBUGGING
119static unsigned int net_debug = DEBUGGING;
120#else
121#define net_debug 0 /* gcc will remove all the debug code for us */
122#endif
123
124/* The number of low I/O ports used by the ethercard. */
125#define NETCARD_IO_EXTENT 16
126
127/* we allow the user to override various values normally set in the EEPROM */
128#define FORCE_RJ45 0x0001 /* pick one of these three */
129#define FORCE_AUI 0x0002
130#define FORCE_BNC 0x0004
131
132#define FORCE_AUTO 0x0010 /* pick one of these three */
133#define FORCE_HALF 0x0020
134#define FORCE_FULL 0x0030
135
136/* Information that need to be kept for each board. */
137struct net_local {
138 int chip_type; /* one of: CS8900, CS8920, CS8920M */
139 char chip_revision; /* revision letter of the chip ('A'...) */
140 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
141 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
142 int adapter_cnf; /* adapter configuration from EEPROM */
143 int isa_config; /* ISA configuration from EEPROM */
144 int irq_map; /* IRQ map from EEPROM */
145 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
146 int curr_rx_cfg; /* a copy of PP_RxCFG */
147 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
148 int send_underrun; /* keep track of how many underruns in a row we get */
149 int force; /* force various values; see FORCE* above. */
150 spinlock_t lock;
151 void __iomem *virt_addr;/* CS89x0 virtual address. */
152#if ALLOW_DMA
153 int use_dma; /* Flag: we're using dma */
154 int dma; /* DMA channel */
155 int dmasize; /* 16 or 64 */
156 unsigned char *dma_buff; /* points to the beginning of the buffer */
157 unsigned char *end_dma_buff; /* points to the end of the buffer */
158 unsigned char *rx_dma_ptr; /* points to the next packet */
159#endif
160};
161
162/* Example routines you must write ;->. */
163#define tx_done(dev) 1
164
165/*
166 * Permit 'cs89x0_dma=N' in the kernel boot environment
167 */
168#if !defined(MODULE)
169#if ALLOW_DMA
170static int g_cs89x0_dma;
171
172static int __init dma_fn(char *str)
173{
174 g_cs89x0_dma = simple_strtol(str, NULL, 0);
175 return 1;
176}
177
178__setup("cs89x0_dma=", dma_fn);
179#endif /* ALLOW_DMA */
180
181static int g_cs89x0_media__force;
182
183static int __init media_fn(char *str)
184{
185 if (!strcmp(str, "rj45"))
186 g_cs89x0_media__force = FORCE_RJ45;
187 else if (!strcmp(str, "aui"))
188 g_cs89x0_media__force = FORCE_AUI;
189 else if (!strcmp(str, "bnc"))
190 g_cs89x0_media__force = FORCE_BNC;
191
192 return 1;
193}
194
195__setup("cs89x0_media=", media_fn);
196#endif
197
198static void readwords(struct net_local *lp, int portno, void *buf, int length)
199{
200 u8 *buf8 = (u8 *)buf;
201
202 do {
203 u16 tmp16;
204
205 tmp16 = ioread16(lp->virt_addr + portno);
206 *buf8++ = (u8)tmp16;
207 *buf8++ = (u8)(tmp16 >> 8);
208 } while (--length);
209}
210
211static void writewords(struct net_local *lp, int portno, void *buf, int length)
212{
213 u8 *buf8 = (u8 *)buf;
214
215 do {
216 u16 tmp16;
217
218 tmp16 = *buf8++;
219 tmp16 |= (*buf8++) << 8;
220 iowrite16(tmp16, lp->virt_addr + portno);
221 } while (--length);
222}
223
224static u16
225readreg(struct net_device *dev, u16 regno)
226{
227 struct net_local *lp = netdev_priv(dev);
228
229 iowrite16(regno, lp->virt_addr + ADD_PORT);
230 return ioread16(lp->virt_addr + DATA_PORT);
231}
232
233static void
234writereg(struct net_device *dev, u16 regno, u16 value)
235{
236 struct net_local *lp = netdev_priv(dev);
237
238 iowrite16(regno, lp->virt_addr + ADD_PORT);
239 iowrite16(value, lp->virt_addr + DATA_PORT);
240}
241
242static int __init
243wait_eeprom_ready(struct net_device *dev)
244{
245 unsigned long timeout = jiffies;
246 /* check to see if the EEPROM is ready,
247 * a timeout is used just in case EEPROM is ready when
248 * SI_BUSY in the PP_SelfST is clear
249 */
250 while (readreg(dev, PP_SelfST) & SI_BUSY)
251 if (time_after_eq(jiffies, timeout + 40))
252 return -1;
253 return 0;
254}
255
256static int __init
257get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
258{
259 int i;
260
261 cs89_dbg(3, info, "EEPROM data from %x for %x:", off, len);
262 for (i = 0; i < len; i++) {
263 if (wait_eeprom_ready(dev) < 0)
264 return -1;
265 /* Now send the EEPROM read command and EEPROM location to read */
266 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
267 if (wait_eeprom_ready(dev) < 0)
268 return -1;
269 buffer[i] = readreg(dev, PP_EEData);
270 cs89_dbg(3, cont, " %04x", buffer[i]);
271 }
272 cs89_dbg(3, cont, "\n");
273 return 0;
274}
275
276static int __init
277get_eeprom_cksum(int off, int len, int *buffer)
278{
279 int i, cksum;
280
281 cksum = 0;
282 for (i = 0; i < len; i++)
283 cksum += buffer[i];
284 cksum &= 0xffff;
285 if (cksum == 0)
286 return 0;
287 return -1;
288}
289
290static void
291write_irq(struct net_device *dev, int chip_type, int irq)
292{
293 int i;
294
295 if (chip_type == CS8900) {
296#if IS_ENABLED(CONFIG_CS89x0_ISA)
297 /* Search the mapping table for the corresponding IRQ pin. */
298 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
299 if (cs8900_irq_map[i] == irq)
300 break;
301 /* Not found */
302 if (i == ARRAY_SIZE(cs8900_irq_map))
303 i = 3;
304#else
305 /* INTRQ0 pin is used for interrupt generation. */
306 i = 0;
307#endif
308 writereg(dev, PP_CS8900_ISAINT, i);
309 } else {
310 writereg(dev, PP_CS8920_ISAINT, irq);
311 }
312}
313
314static void
315count_rx_errors(int status, struct net_device *dev)
316{
317 dev->stats.rx_errors++;
318 if (status & RX_RUNT)
319 dev->stats.rx_length_errors++;
320 if (status & RX_EXTRA_DATA)
321 dev->stats.rx_length_errors++;
322 if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA | RX_RUNT)))
323 /* per str 172 */
324 dev->stats.rx_crc_errors++;
325 if (status & RX_DRIBBLE)
326 dev->stats.rx_frame_errors++;
327}
328
329/*********************************
330 * This page contains DMA routines
331 *********************************/
332
333#if ALLOW_DMA
334
335#define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
336
337static void
338get_dma_channel(struct net_device *dev)
339{
340 struct net_local *lp = netdev_priv(dev);
341
342 if (lp->dma) {
343 dev->dma = lp->dma;
344 lp->isa_config |= ISA_RxDMA;
345 } else {
346 if ((lp->isa_config & ANY_ISA_DMA) == 0)
347 return;
348 dev->dma = lp->isa_config & DMA_NO_MASK;
349 if (lp->chip_type == CS8900)
350 dev->dma += 5;
351 if (dev->dma < 5 || dev->dma > 7) {
352 lp->isa_config &= ~ANY_ISA_DMA;
353 return;
354 }
355 }
356}
357
358static void
359write_dma(struct net_device *dev, int chip_type, int dma)
360{
361 struct net_local *lp = netdev_priv(dev);
362 if ((lp->isa_config & ANY_ISA_DMA) == 0)
363 return;
364 if (chip_type == CS8900)
365 writereg(dev, PP_CS8900_ISADMA, dma - 5);
366 else
367 writereg(dev, PP_CS8920_ISADMA, dma);
368}
369
370static void
371set_dma_cfg(struct net_device *dev)
372{
373 struct net_local *lp = netdev_priv(dev);
374
375 if (lp->use_dma) {
376 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
377 cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
378 return;
379 }
380 if (lp->isa_config & ISA_RxDMA) {
381 lp->curr_rx_cfg |= RX_DMA_ONLY;
382 cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
383 } else {
384 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
385 cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
386 }
387 }
388}
389
390static int
391dma_bufcfg(struct net_device *dev)
392{
393 struct net_local *lp = netdev_priv(dev);
394 if (lp->use_dma)
395 return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
396 else
397 return 0;
398}
399
400static int
401dma_busctl(struct net_device *dev)
402{
403 int retval = 0;
404 struct net_local *lp = netdev_priv(dev);
405 if (lp->use_dma) {
406 if (lp->isa_config & ANY_ISA_DMA)
407 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
408 if (lp->isa_config & DMA_BURST)
409 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
410 if (lp->dmasize == 64)
411 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
412 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
413 }
414 return retval;
415}
416
417static void
418dma_rx(struct net_device *dev)
419{
420 struct net_local *lp = netdev_priv(dev);
421 struct sk_buff *skb;
422 int status, length;
423 unsigned char *bp = lp->rx_dma_ptr;
424
425 status = bp[0] + (bp[1] << 8);
426 length = bp[2] + (bp[3] << 8);
427 bp += 4;
428
429 cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
430 dev->name, (unsigned long)bp, status, length);
431
432 if ((status & RX_OK) == 0) {
433 count_rx_errors(status, dev);
434 goto skip_this_frame;
435 }
436
437 /* Malloc up new buffer. */
438 skb = netdev_alloc_skb(dev, length + 2);
439 if (skb == NULL) {
440 dev->stats.rx_dropped++;
441
442 /* AKPM: advance bp to the next frame */
443skip_this_frame:
444 bp += (length + 3) & ~3;
445 if (bp >= lp->end_dma_buff)
446 bp -= lp->dmasize * 1024;
447 lp->rx_dma_ptr = bp;
448 return;
449 }
450 skb_reserve(skb, 2); /* longword align L3 header */
451
452 if (bp + length > lp->end_dma_buff) {
453 int semi_cnt = lp->end_dma_buff - bp;
454 skb_put_data(skb, bp, semi_cnt);
455 skb_put_data(skb, lp->dma_buff, length - semi_cnt);
456 } else {
457 skb_put_data(skb, 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 /* ALLOW_DMA */
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 /* control the DC to DC convertor in the SelfControl register.
493 * Note: This is hooked up to a general purpose pin, might not
494 * always be a DC to DC convertor.
495 */
496
497 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
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 /* Wait for the DC/DC converter to power up - 500ms */
505 while (time_before(jiffies, timenow + HZ))
506 ;
507}
508
509/* send a test packet - return true if carrier bits are ok */
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, /* A 46 in network order */
517 0, 0, /* DSAP=0 & SSAP=0 fields */
518 0xf3, 0 /* Control (Test Req + P bit set) */
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 /* Test to see if the chip has allocated memory for the packet */
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; /* this shouldn't happen */
536
537 /* Write the contents of the packet */
538 writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
539
540 cs89_dbg(1, debug, "Sending test packet ");
541 /* wait a couple of jiffies for packet to be received */
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 /* If connected to another full duplex capable 10-Base-T card
568 * the link pulses seem to be lost when the auto detect bit in
569 * the LineCTL is set. To overcome this the auto detect bit will
570 * be cleared whilst testing the 10-Base-T interface. This would
571 * not be necessary for the sparrow chip but is simpler to do it
572 * anyway.
573 */
574 writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
575 control_dc_dc(dev, 0);
576
577 /* Delay for the hardware to work out if the TP cable is present
578 * - 150ms
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 /* CS8900 doesn't support AUTO, change to HALF*/
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/* We have a good packet(s), get it/them out of the buffers. */
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 /* Malloc up new buffer. */
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); /* longword align L3 header */
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/* The typical workload of the driver:
710 * Handle the network interface interrupts.
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 /* we MUST read all the events out of the ISQ, otherwise we'll never
723 * get interrupted again. As a consequence, we can't have any limit
724 * on the number of times we loop in the interrupt handler. The
725 * hardware guarantees that eventually we'll run out of events. Of
726 * course, if you're on a slow machine, and packets are arriving
727 * faster than you can read them off, you're screwed. Hasta la
728 * vista, baby!
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 /* Got a packet(s). */
736 net_rx(dev);
737 break;
738 case ISQ_TRANSMITTER_EVENT:
739 dev->stats.tx_packets++;
740 netif_wake_queue(dev); /* Inform upper layers. */
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 /* we tried to transmit a packet earlier,
761 * but inexplicably ran out of buffers.
762 * That shouldn't happen since we only ever
763 * load one packet. Shrug. Do the right
764 * thing anyway.
765 */
766 netif_wake_queue(dev); /* Inform upper layers. */
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 /* transmit cycle is done, although
777 * frame wasn't transmitted - this
778 * avoids having to wait for the upper
779 * layers to timeout on us, in the
780 * event of a tx underrun
781 */
782 netif_wake_queue(dev); /* Inform upper layers. */
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/* Open/initialize the board. This is called (in the current kernel)
818 sometime after booting when the 'ifconfig' program is run.
819
820 This routine should set everything up anew at each open, even
821 registers that "should" only need to be set once at boot, so that
822 there is non-reboot way to recover if something goes wrong.
823*/
824
825/* AKPM: do we need to do any locking here? */
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 /* Allow interrupts to be generated by the chip */
837/* Cirrus' release had this: */
838#if 0
839 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
840#endif
841/* And 2.3.47 had this: */
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 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
851 break;
852 }
853 }
854 }
855
856 if (i >= CS8920_NO_INTS) {
857 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
858 pr_err("can't get an interrupt\n");
859 ret = -EAGAIN;
860 goto bad_out;
861 }
862 } else {
863#if IS_ENABLED(CONFIG_CS89x0_ISA)
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/* FIXME: Cirrus' release had this: */
872 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ);
873/* And 2.3.47 had this: */
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); /* Why? */
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); /* auto_init as well */
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 /* ALLOW_DMA */
924
925 /* set the Ethernet address */
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 /* while we're testing the interface, leave interrupts disabled */
932 writereg(dev, PP_BusCTL, MEMORY_ON);
933
934 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
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 /* check to make sure that they have the "right" hardware available */
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 /* set the hardware to the configured choice */
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) /* check "ignore missing media" bit */
981 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
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) /* check "ignore missing media" bit */
989 result = DETECTED_AUI; /* Yes! I don't care if I see a carrier */
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) /* check "ignore missing media" bit */
997 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
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 /* Turn on both receive and transmit operations */
1040 writereg(dev, PP_LineCTL,
1041 readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1042
1043 /* Receive only error free packets addressed to this card */
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 /* now that we've got our act together, enable everything */
1073 writereg(dev, PP_BusCTL, (ENABLE_IRQ
1074 | (dev->mem_start ? MEMORY_ON : 0) /* turn memory on */
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/* The inverse routine to net_open(). */
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 /* Update the statistics here. */
1111 return 0;
1112}
1113
1114/* Get the current statistics.
1115 * This may be called with the card open or closed.
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 /* Update the statistics from the device registers. */
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, unsigned int txqueue)
1133{
1134 /* If we get here, some higher level has decided we are broken.
1135 There should really be a "kick me" function call instead. */
1136 cs89_dbg(0, err, "%s: transmit timed out, %s?\n",
1137 dev->name,
1138 tx_done(dev) ? "IRQ conflict" : "network cable problem");
1139 /* Try to restart the adaptor. */
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 /* keep the upload from being interrupted, since we
1154 * ask the chip to start transmitting before the
1155 * whole packet has been completely uploaded.
1156 */
1157
1158 spin_lock_irqsave(&lp->lock, flags);
1159 netif_stop_queue(dev);
1160
1161 /* initiate a transmit sequence */
1162 iowrite16(lp->send_cmd, lp->virt_addr + TX_CMD_PORT);
1163 iowrite16(skb->len, lp->virt_addr + TX_LEN_PORT);
1164
1165 /* Test to see if the chip has allocated memory for the packet */
1166 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1167 /* Gasp! It hasn't. But that shouldn't happen since
1168 * we're waiting for TxOk, so return 1 and requeue this packet.
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 /* Write the contents of the packet */
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 /* We DO NOT call netif_wake_queue() here.
1182 * We also DO NOT call netif_start_queue().
1183 *
1184 * Either of these would cause another bottom half run through
1185 * net_send_packet() before this packet has fully gone out.
1186 * That causes us to hit the "Gasp!" above and the send is rescheduled.
1187 * it runs like a dog. We just return and wait for the Tx completion
1188 * interrupt handler to restart the netdevice layer
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 /* The multicast-accept list is initialized to accept-all,
1205 * and we rely on higher-level filtering for now.
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 /* in promiscuous mode, we accept errored packets,
1214 * so we have to enable interrupts on them also
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 eth_hw_addr_set(dev, addr->sa_data);
1232
1233 cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
1234 dev->name, dev->dev_addr);
1235
1236 /* set the Ethernet address */
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 * Polling receive - used by netconsole and other diagnostic tools
1248 * to allow network i/o with interrupts disabled.
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_validate_addr = eth_validate_addr,
1270};
1271
1272static void __init reset_chip(struct net_device *dev)
1273{
1274#if !defined(CONFIG_MACH_MX31ADS)
1275 struct net_local *lp = netdev_priv(dev);
1276 unsigned long reset_start_time;
1277
1278 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
1279
1280 /* wait 30 ms */
1281 msleep(30);
1282
1283 if (lp->chip_type != CS8900) {
1284 /* Hardware problem requires PNP registers to be reconfigured after a reset */
1285 iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
1286 iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
1287 iowrite8(0, lp->virt_addr + DATA_PORT + 1);
1288
1289 iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT);
1290 iowrite8((dev->mem_start >> 16) & 0xff,
1291 lp->virt_addr + DATA_PORT);
1292 iowrite8((dev->mem_start >> 8) & 0xff,
1293 lp->virt_addr + DATA_PORT + 1);
1294 }
1295
1296 /* Wait until the chip is reset */
1297 reset_start_time = jiffies;
1298 while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
1299 time_before(jiffies, reset_start_time + 2))
1300 ;
1301#endif /* !CONFIG_MACH_MX31ADS */
1302}
1303
1304/* This is the real probe routine.
1305 * Linux has a history of friendly device probes on the ISA bus.
1306 * A good device probes avoids doing writes, and
1307 * verifies that the correct device exists and functions.
1308 * Return 0 on success.
1309 */
1310static int __init
1311cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
1312{
1313 struct net_local *lp = netdev_priv(dev);
1314 int i;
1315 int tmp;
1316 unsigned rev_type = 0;
1317 int eeprom_buff[CHKSUM_LEN];
1318 u8 addr[ETH_ALEN];
1319 int retval;
1320
1321 /* Initialize the device structure. */
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; /* Could make this an option... */
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 /* get the chip type */
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 /* Check the chip type and revision in order to set the correct
1358 * send command. CS8920 revision C and CS8900 revision F can use
1359 * the faster send.
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 /* Here we read the current configuration of the chip.
1379 * If there is no Extended EEPROM then the idea is to not disturb
1380 * the chip configuration, it should have been correctly setup by
1381 * automatic EEPROM read on reset. So, if the chip says it read
1382 * the EEPROM the driver will always do *something* instead of
1383 * complain that adapter_cnf is 0.
1384 */
1385
1386 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
1387 (EEPROM_OK | EEPROM_PRESENT)) {
1388 /* Load the MAC. */
1389 for (i = 0; i < ETH_ALEN / 2; i++) {
1390 unsigned int Addr;
1391 Addr = readreg(dev, PP_IA + i * 2);
1392 addr[i * 2] = Addr & 0xFF;
1393 addr[i * 2 + 1] = Addr >> 8;
1394 }
1395 eth_hw_addr_set(dev, addr);
1396
1397 /* Load the Adapter Configuration.
1398 * Note: Barring any more specific information from some
1399 * other source (ie EEPROM+Schematics), we would not know
1400 * how to operate a 10Base2 interface on the AUI port.
1401 * However, since we do read the status of HCB1 and use
1402 * settings that always result in calls to control_dc_dc(dev,0)
1403 * a BNC interface should work if the enable pin
1404 * (dc/dc converter) is on HCB1.
1405 * It will be called AUI however.
1406 */
1407
1408 lp->adapter_cnf = 0;
1409 i = readreg(dev, PP_LineCTL);
1410 /* Preserve the setting of the HCB1 pin. */
1411 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
1412 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
1413 /* Save the sqelch bit */
1414 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
1415 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
1416 /* Check if the card is in 10Base-t only mode */
1417 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
1418 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
1419 /* Check if the card is in AUI only mode */
1420 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
1421 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
1422 /* Check if the card is in Auto mode. */
1423 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
1424 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
1425 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
1426
1427 cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
1428 dev->name, i, lp->adapter_cnf);
1429
1430 /* IRQ. Other chips already probe, see below. */
1431 if (lp->chip_type == CS8900)
1432 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
1433
1434 pr_cont("[Cirrus EEPROM] ");
1435 }
1436
1437 pr_cont("\n");
1438
1439 /* First check to see if an EEPROM is attached. */
1440
1441 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
1442 pr_warn("No EEPROM, relying on command line....\n");
1443 else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1444 pr_warn("EEPROM read failed, relying on command line\n");
1445 } else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1446 /* Check if the chip was able to read its own configuration starting
1447 at 0 in the EEPROM*/
1448 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
1449 (EEPROM_OK | EEPROM_PRESENT))
1450 pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
1451
1452 } else {
1453 /* This reads an extended EEPROM that is not documented
1454 * in the CS8900 datasheet.
1455 */
1456
1457 /* get transmission control word but keep the autonegotiation bits */
1458 if (!lp->auto_neg_cnf)
1459 lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
1460 /* Store adapter configuration */
1461 if (!lp->adapter_cnf)
1462 lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
1463 /* Store ISA configuration */
1464 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
1465 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
1466
1467 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
1468 /* store the initial memory base address */
1469 for (i = 0; i < ETH_ALEN / 2; i++) {
1470 addr[i * 2] = eeprom_buff[i];
1471 addr[i * 2 + 1] = eeprom_buff[i] >> 8;
1472 }
1473 eth_hw_addr_set(dev, addr);
1474 cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
1475 dev->name, lp->adapter_cnf);
1476 }
1477
1478 /* allow them to force multiple transceivers. If they force multiple, autosense */
1479 {
1480 int count = 0;
1481 if (lp->force & FORCE_RJ45) {
1482 lp->adapter_cnf |= A_CNF_10B_T;
1483 count++;
1484 }
1485 if (lp->force & FORCE_AUI) {
1486 lp->adapter_cnf |= A_CNF_AUI;
1487 count++;
1488 }
1489 if (lp->force & FORCE_BNC) {
1490 lp->adapter_cnf |= A_CNF_10B_2;
1491 count++;
1492 }
1493 if (count > 1)
1494 lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
1495 else if (lp->force & FORCE_RJ45)
1496 lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
1497 else if (lp->force & FORCE_AUI)
1498 lp->adapter_cnf |= A_CNF_MEDIA_AUI;
1499 else if (lp->force & FORCE_BNC)
1500 lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
1501 }
1502
1503 cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
1504 dev->name, lp->force, lp->adapter_cnf);
1505
1506 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
1507
1508 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
1509
1510 /* FIXME: we don't set the Ethernet address on the command line. Use
1511 * ifconfig IFACE hw ether AABBCCDDEEFF
1512 */
1513
1514 pr_info("media %s%s%s",
1515 (lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
1516 (lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
1517 (lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
1518
1519 lp->irq_map = 0xffff;
1520
1521 /* If this is a CS8900 then no pnp soft */
1522 if (lp->chip_type != CS8900 &&
1523 /* Check if the ISA IRQ has been set */
1524 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
1525 (i != 0 && i < CS8920_NO_INTS))) {
1526 if (!dev->irq)
1527 dev->irq = i;
1528 } else {
1529 i = lp->isa_config & INT_NO_MASK;
1530#if IS_ENABLED(CONFIG_CS89x0_ISA)
1531 if (lp->chip_type == CS8900) {
1532 /* Translate the IRQ using the IRQ mapping table. */
1533 if (i >= ARRAY_SIZE(cs8900_irq_map))
1534 pr_err("invalid ISA interrupt number %d\n", i);
1535 else
1536 i = cs8900_irq_map[i];
1537
1538 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
1539 } else {
1540 int irq_map_buff[IRQ_MAP_LEN/2];
1541
1542 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
1543 IRQ_MAP_LEN / 2,
1544 irq_map_buff) >= 0) {
1545 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
1546 lp->irq_map = ((irq_map_buff[0] >> 8) |
1547 (irq_map_buff[1] << 8));
1548 }
1549 }
1550#endif
1551 if (!dev->irq)
1552 dev->irq = i;
1553 }
1554
1555 pr_cont(" IRQ %d", dev->irq);
1556
1557#if ALLOW_DMA
1558 if (lp->use_dma) {
1559 get_dma_channel(dev);
1560 pr_cont(", DMA %d", dev->dma);
1561 } else
1562#endif
1563 pr_cont(", programmed I/O");
1564
1565 /* print the ethernet address. */
1566 pr_cont(", MAC %pM\n", dev->dev_addr);
1567
1568 dev->netdev_ops = &net_ops;
1569 dev->watchdog_timeo = HZ;
1570
1571 cs89_dbg(0, info, "cs89x0_probe1() successful\n");
1572
1573 retval = register_netdev(dev);
1574 if (retval)
1575 goto out2;
1576 return 0;
1577out2:
1578 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1579out1:
1580 return retval;
1581}
1582
1583#if IS_ENABLED(CONFIG_CS89x0_ISA)
1584/*
1585 * This function converts the I/O port address used by the cs89x0_probe() and
1586 * init_module() functions to the I/O memory address used by the
1587 * cs89x0_probe1() function.
1588 */
1589static int __init
1590cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
1591{
1592 struct net_local *lp = netdev_priv(dev);
1593 int ret;
1594 void __iomem *io_mem;
1595
1596 if (!lp)
1597 return -ENOMEM;
1598
1599 dev->base_addr = ioport;
1600
1601 if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
1602 ret = -EBUSY;
1603 goto out;
1604 }
1605
1606 io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
1607 if (!io_mem) {
1608 ret = -ENOMEM;
1609 goto release;
1610 }
1611
1612 /* if they give us an odd I/O address, then do ONE write to
1613 * the address port, to get it back to address zero, where we
1614 * expect to find the EISA signature word. An IO with a base of 0x3
1615 * will skip the test for the ADD_PORT.
1616 */
1617 if (ioport & 1) {
1618 cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
1619 if ((ioport & 2) != 2) {
1620 if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
1621 ADD_SIG) {
1622 pr_err("%s: bad signature 0x%x\n",
1623 dev->name, ioread16(io_mem + ADD_PORT));
1624 ret = -ENODEV;
1625 goto unmap;
1626 }
1627 }
1628 }
1629
1630 ret = cs89x0_probe1(dev, io_mem, modular);
1631 if (!ret)
1632 goto out;
1633unmap:
1634 ioport_unmap(io_mem);
1635release:
1636 release_region(ioport, NETCARD_IO_EXTENT);
1637out:
1638 return ret;
1639}
1640
1641#ifndef MODULE
1642/* Check for a network adaptor of this type, and return '0' iff one exists.
1643 * If dev->base_addr == 0, probe all likely locations.
1644 * If dev->base_addr == 1, always return failure.
1645 * If dev->base_addr == 2, allocate space for the device and return success
1646 * (detachable devices only).
1647 * Return 0 on success.
1648 */
1649
1650struct net_device * __init cs89x0_probe(int unit)
1651{
1652 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1653 unsigned *port;
1654 int err = 0;
1655 int irq;
1656 int io;
1657
1658 if (!dev)
1659 return ERR_PTR(-ENODEV);
1660
1661 sprintf(dev->name, "eth%d", unit);
1662 netdev_boot_setup_check(dev);
1663 io = dev->base_addr;
1664 irq = dev->irq;
1665
1666 cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
1667
1668 if (io > 0x1ff) { /* Check a single specified location. */
1669 err = cs89x0_ioport_probe(dev, io, 0);
1670 } else if (io != 0) { /* Don't probe at all. */
1671 err = -ENXIO;
1672 } else {
1673 for (port = netcard_portlist; *port; port++) {
1674 if (cs89x0_ioport_probe(dev, *port, 0) == 0)
1675 break;
1676 dev->irq = irq;
1677 }
1678 if (!*port)
1679 err = -ENODEV;
1680 }
1681 if (err)
1682 goto out;
1683 return dev;
1684out:
1685 free_netdev(dev);
1686 pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
1687 return ERR_PTR(err);
1688}
1689#else
1690static struct net_device *dev_cs89x0;
1691
1692/* Support the 'debug' module parm even if we're compiled for non-debug to
1693 * avoid breaking someone's startup scripts
1694 */
1695
1696static int io;
1697static int irq;
1698static int debug;
1699static char media[8];
1700static int duplex = -1;
1701
1702static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1703static int dma;
1704static int dmasize = 16; /* or 64 */
1705
1706module_param_hw(io, int, ioport, 0);
1707module_param_hw(irq, int, irq, 0);
1708module_param(debug, int, 0);
1709module_param_string(media, media, sizeof(media), 0);
1710module_param(duplex, int, 0);
1711module_param_hw(dma , int, dma, 0);
1712module_param(dmasize , int, 0);
1713module_param(use_dma , int, 0);
1714MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1715MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1716#if DEBUGGING
1717MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1718#else
1719MODULE_PARM_DESC(debug, "(ignored)");
1720#endif
1721MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1722/* No other value than -1 for duplex seems to be currently interpreted */
1723MODULE_PARM_DESC(duplex, "(ignored)");
1724#if ALLOW_DMA
1725MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1726MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1727MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1728#else
1729MODULE_PARM_DESC(dma , "(ignored)");
1730MODULE_PARM_DESC(dmasize , "(ignored)");
1731MODULE_PARM_DESC(use_dma , "(ignored)");
1732#endif
1733
1734MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1735MODULE_LICENSE("GPL");
1736
1737/*
1738 * media=t - specify media type
1739 * or media=2
1740 * or media=aui
1741 * or medai=auto
1742 * duplex=0 - specify forced half/full/autonegotiate duplex
1743 * debug=# - debug level
1744 *
1745 * Default Chip Configuration:
1746 * DMA Burst = enabled
1747 * IOCHRDY Enabled = enabled
1748 * UseSA = enabled
1749 * CS8900 defaults to half-duplex if not specified on command-line
1750 * CS8920 defaults to autoneg if not specified on command-line
1751 * Use reset defaults for other config parameters
1752 *
1753 * Assumptions:
1754 * media type specified is supported (circuitry is present)
1755 * if memory address is > 1MB, then required mem decode hw is present
1756 * if 10B-2, then agent other than driver will enable DC/DC converter
1757 * (hw or software util)
1758 */
1759
1760static int __init cs89x0_isa_init_module(void)
1761{
1762 struct net_device *dev;
1763 struct net_local *lp;
1764 int ret = 0;
1765
1766#if DEBUGGING
1767 net_debug = debug;
1768#else
1769 debug = 0;
1770#endif
1771 dev = alloc_etherdev(sizeof(struct net_local));
1772 if (!dev)
1773 return -ENOMEM;
1774
1775 dev->irq = irq;
1776 dev->base_addr = io;
1777 lp = netdev_priv(dev);
1778
1779#if ALLOW_DMA
1780 if (use_dma) {
1781 lp->use_dma = use_dma;
1782 lp->dma = dma;
1783 lp->dmasize = dmasize;
1784 }
1785#endif
1786
1787 spin_lock_init(&lp->lock);
1788
1789 /* boy, they'd better get these right */
1790 if (!strcmp(media, "rj45"))
1791 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1792 else if (!strcmp(media, "aui"))
1793 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1794 else if (!strcmp(media, "bnc"))
1795 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1796 else
1797 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1798
1799 if (duplex == -1)
1800 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1801
1802 if (io == 0) {
1803 pr_err("Module autoprobing not allowed\n");
1804 pr_err("Append io=0xNNN\n");
1805 ret = -EPERM;
1806 goto out;
1807 } else if (io <= 0x1ff) {
1808 ret = -ENXIO;
1809 goto out;
1810 }
1811
1812#if ALLOW_DMA
1813 if (use_dma && dmasize != 16 && dmasize != 64) {
1814 pr_err("dma size must be either 16K or 64K, not %dK\n",
1815 dmasize);
1816 ret = -EPERM;
1817 goto out;
1818 }
1819#endif
1820 ret = cs89x0_ioport_probe(dev, io, 1);
1821 if (ret)
1822 goto out;
1823
1824 dev_cs89x0 = dev;
1825 return 0;
1826out:
1827 free_netdev(dev);
1828 return ret;
1829}
1830module_init(cs89x0_isa_init_module);
1831
1832static void __exit cs89x0_isa_cleanup_module(void)
1833{
1834 struct net_local *lp = netdev_priv(dev_cs89x0);
1835
1836 unregister_netdev(dev_cs89x0);
1837 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1838 ioport_unmap(lp->virt_addr);
1839 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1840 free_netdev(dev_cs89x0);
1841}
1842module_exit(cs89x0_isa_cleanup_module);
1843#endif /* MODULE */
1844#endif /* CONFIG_CS89x0_ISA */
1845
1846#if IS_ENABLED(CONFIG_CS89x0_PLATFORM)
1847static int __init cs89x0_platform_probe(struct platform_device *pdev)
1848{
1849 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1850 void __iomem *virt_addr;
1851 int err;
1852
1853 if (!dev)
1854 return -ENOMEM;
1855
1856 dev->irq = platform_get_irq(pdev, 0);
1857 if (dev->irq < 0) {
1858 err = dev->irq;
1859 goto free;
1860 }
1861
1862 virt_addr = devm_platform_ioremap_resource(pdev, 0);
1863 if (IS_ERR(virt_addr)) {
1864 err = PTR_ERR(virt_addr);
1865 goto free;
1866 }
1867
1868 err = cs89x0_probe1(dev, virt_addr, 0);
1869 if (err) {
1870 dev_warn(&dev->dev, "no cs8900 or cs8920 detected\n");
1871 goto free;
1872 }
1873
1874 platform_set_drvdata(pdev, dev);
1875 return 0;
1876
1877free:
1878 free_netdev(dev);
1879 return err;
1880}
1881
1882static void cs89x0_platform_remove(struct platform_device *pdev)
1883{
1884 struct net_device *dev = platform_get_drvdata(pdev);
1885
1886 /* This platform_get_resource() call will not return NULL, because
1887 * the same call in cs89x0_platform_probe() has returned a non NULL
1888 * value.
1889 */
1890 unregister_netdev(dev);
1891 free_netdev(dev);
1892}
1893
1894static const struct of_device_id __maybe_unused cs89x0_match[] = {
1895 { .compatible = "cirrus,cs8900", },
1896 { .compatible = "cirrus,cs8920", },
1897 { },
1898};
1899MODULE_DEVICE_TABLE(of, cs89x0_match);
1900
1901static struct platform_driver cs89x0_driver = {
1902 .driver = {
1903 .name = DRV_NAME,
1904 .of_match_table = of_match_ptr(cs89x0_match),
1905 },
1906 .remove_new = cs89x0_platform_remove,
1907};
1908
1909module_platform_driver_probe(cs89x0_driver, cs89x0_platform_probe);
1910
1911#endif /* CONFIG_CS89x0_PLATFORM */
1912
1913MODULE_LICENSE("GPL");
1914MODULE_DESCRIPTION("Crystal Semiconductor (Now Cirrus Logic) CS89[02]0 network driver");
1915MODULE_AUTHOR("Russell Nelson <nelson@crynwr.com>");
1/* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
2 * driver for linux.
3 * Written 1996 by Russell Nelson, with reference to skeleton.c
4 * written 1993-1994 by Donald Becker.
5 *
6 * This software may be used and distributed according to the terms
7 * of the GNU General Public License, incorporated herein by reference.
8 *
9 * The author may be reached at nelson@crynwr.com, Crynwr
10 * Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
11 *
12 * Other contributors:
13 * Mike Cruse : mcruse@cti-ltd.com
14 * Russ Nelson
15 * Melody Lee : ethernet@crystal.cirrus.com
16 * Alan Cox
17 * Andrew Morton
18 * Oskar Schirmer : oskar@scara.com
19 * Deepak Saxena : dsaxena@plexity.net
20 * Dmitry Pervushin : dpervushin@ru.mvista.com
21 * Deepak Saxena : dsaxena@plexity.net
22 * Domenico Andreoli : cavokz@gmail.com
23 */
24
25
26/*
27 * Set this to zero to disable DMA code
28 *
29 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
30 * module options so we don't break any startup scripts.
31 */
32#ifndef CONFIG_ISA_DMA_API
33#define ALLOW_DMA 0
34#else
35#define ALLOW_DMA 1
36#endif
37
38/*
39 * Set this to zero to remove all the debug statements via
40 * dead code elimination
41 */
42#define DEBUGGING 1
43
44/* Sources:
45 * Crynwr packet driver epktisa.
46 * Crystal Semiconductor data sheets.
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/platform_device.h>
57#include <linux/kernel.h>
58#include <linux/types.h>
59#include <linux/fcntl.h>
60#include <linux/interrupt.h>
61#include <linux/ioport.h>
62#include <linux/in.h>
63#include <linux/skbuff.h>
64#include <linux/spinlock.h>
65#include <linux/string.h>
66#include <linux/init.h>
67#include <linux/bitops.h>
68#include <linux/delay.h>
69#include <linux/gfp.h>
70#include <linux/io.h>
71
72#include <asm/irq.h>
73#include <linux/atomic.h>
74#if ALLOW_DMA
75#include <asm/dma.h>
76#endif
77
78#include "cs89x0.h"
79
80#define cs89_dbg(val, level, fmt, ...) \
81do { \
82 if (val <= net_debug) \
83 pr_##level(fmt, ##__VA_ARGS__); \
84} while (0)
85
86static char version[] __initdata =
87 "v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton";
88
89#define DRV_NAME "cs89x0"
90
91/* First, a few definitions that the brave might change.
92 * A zero-terminated list of I/O addresses to be probed. Some special flags..
93 * Addr & 1 = Read back the address port, look for signature and reset
94 * the page window before probing
95 * Addr & 3 = Reset the page window and probe
96 * The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
97 * but it is possible that a Cirrus board could be plugged into the ISA
98 * slots.
99 */
100/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
101 * them to system IRQ numbers. This mapping is card specific and is set to
102 * the configuration of the Cirrus Eval board for this chip.
103 */
104#if defined(CONFIG_MACH_IXDP2351)
105#define CS89x0_NONISA_IRQ
106static unsigned int netcard_portlist[] __used __initdata = {
107 IXDP2351_VIRT_CS8900_BASE, 0
108};
109static unsigned int cs8900_irq_map[] = {
110 IRQ_IXDP2351_CS8900, 0, 0, 0
111};
112#elif defined(CONFIG_ARCH_IXDP2X01)
113#define CS89x0_NONISA_IRQ
114static unsigned int netcard_portlist[] __used __initdata = {
115 IXDP2X01_CS8900_VIRT_BASE, 0
116};
117static unsigned int cs8900_irq_map[] = {
118 IRQ_IXDP2X01_CS8900, 0, 0, 0
119};
120#else
121#ifndef CONFIG_CS89x0_PLATFORM
122static unsigned int netcard_portlist[] __used __initdata = {
123 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240,
124 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0
125};
126static unsigned int cs8900_irq_map[] = {
127 10, 11, 12, 5
128};
129#endif
130#endif
131
132#if DEBUGGING
133static unsigned int net_debug = DEBUGGING;
134#else
135#define net_debug 0 /* gcc will remove all the debug code for us */
136#endif
137
138/* The number of low I/O ports used by the ethercard. */
139#define NETCARD_IO_EXTENT 16
140
141/* we allow the user to override various values normally set in the EEPROM */
142#define FORCE_RJ45 0x0001 /* pick one of these three */
143#define FORCE_AUI 0x0002
144#define FORCE_BNC 0x0004
145
146#define FORCE_AUTO 0x0010 /* pick one of these three */
147#define FORCE_HALF 0x0020
148#define FORCE_FULL 0x0030
149
150/* Information that need to be kept for each board. */
151struct net_local {
152 int chip_type; /* one of: CS8900, CS8920, CS8920M */
153 char chip_revision; /* revision letter of the chip ('A'...) */
154 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
155 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
156 int adapter_cnf; /* adapter configuration from EEPROM */
157 int isa_config; /* ISA configuration from EEPROM */
158 int irq_map; /* IRQ map from EEPROM */
159 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
160 int curr_rx_cfg; /* a copy of PP_RxCFG */
161 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
162 int send_underrun; /* keep track of how many underruns in a row we get */
163 int force; /* force various values; see FORCE* above. */
164 spinlock_t lock;
165 void __iomem *virt_addr;/* CS89x0 virtual address. */
166 unsigned long size; /* Length of CS89x0 memory region. */
167#if ALLOW_DMA
168 int use_dma; /* Flag: we're using dma */
169 int dma; /* DMA channel */
170 int dmasize; /* 16 or 64 */
171 unsigned char *dma_buff; /* points to the beginning of the buffer */
172 unsigned char *end_dma_buff; /* points to the end of the buffer */
173 unsigned char *rx_dma_ptr; /* points to the next packet */
174#endif
175};
176
177/* Example routines you must write ;->. */
178#define tx_done(dev) 1
179
180/*
181 * Permit 'cs89x0_dma=N' in the kernel boot environment
182 */
183#if !defined(MODULE)
184#if ALLOW_DMA
185static int g_cs89x0_dma;
186
187static int __init dma_fn(char *str)
188{
189 g_cs89x0_dma = simple_strtol(str, NULL, 0);
190 return 1;
191}
192
193__setup("cs89x0_dma=", dma_fn);
194#endif /* ALLOW_DMA */
195
196static int g_cs89x0_media__force;
197
198static int __init media_fn(char *str)
199{
200 if (!strcmp(str, "rj45"))
201 g_cs89x0_media__force = FORCE_RJ45;
202 else if (!strcmp(str, "aui"))
203 g_cs89x0_media__force = FORCE_AUI;
204 else if (!strcmp(str, "bnc"))
205 g_cs89x0_media__force = FORCE_BNC;
206
207 return 1;
208}
209
210__setup("cs89x0_media=", media_fn);
211#endif
212
213#if defined(CONFIG_MACH_IXDP2351)
214static u16
215readword(unsigned long base_addr, int portno)
216{
217 return __raw_readw(base_addr + (portno << 1));
218}
219
220static void
221writeword(unsigned long base_addr, int portno, u16 value)
222{
223 __raw_writew(value, base_addr + (portno << 1));
224}
225#elif defined(CONFIG_ARCH_IXDP2X01)
226static u16
227readword(unsigned long base_addr, int portno)
228{
229 return __raw_readl(base_addr + (portno << 1));
230}
231
232static void
233writeword(unsigned long base_addr, int portno, u16 value)
234{
235 __raw_writel(value, base_addr + (portno << 1));
236}
237#endif
238
239static void readwords(struct net_local *lp, int portno, void *buf, int length)
240{
241 u8 *buf8 = (u8 *)buf;
242
243 do {
244 u16 tmp16;
245
246 tmp16 = ioread16(lp->virt_addr + portno);
247 *buf8++ = (u8)tmp16;
248 *buf8++ = (u8)(tmp16 >> 8);
249 } while (--length);
250}
251
252static void writewords(struct net_local *lp, int portno, void *buf, int length)
253{
254 u8 *buf8 = (u8 *)buf;
255
256 do {
257 u16 tmp16;
258
259 tmp16 = *buf8++;
260 tmp16 |= (*buf8++) << 8;
261 iowrite16(tmp16, lp->virt_addr + portno);
262 } while (--length);
263}
264
265static u16
266readreg(struct net_device *dev, u16 regno)
267{
268 struct net_local *lp = netdev_priv(dev);
269
270 iowrite16(regno, lp->virt_addr + ADD_PORT);
271 return ioread16(lp->virt_addr + DATA_PORT);
272}
273
274static void
275writereg(struct net_device *dev, u16 regno, u16 value)
276{
277 struct net_local *lp = netdev_priv(dev);
278
279 iowrite16(regno, lp->virt_addr + ADD_PORT);
280 iowrite16(value, lp->virt_addr + DATA_PORT);
281}
282
283static int __init
284wait_eeprom_ready(struct net_device *dev)
285{
286 int timeout = jiffies;
287 /* check to see if the EEPROM is ready,
288 * a timeout is used just in case EEPROM is ready when
289 * SI_BUSY in the PP_SelfST is clear
290 */
291 while (readreg(dev, PP_SelfST) & SI_BUSY)
292 if (jiffies - timeout >= 40)
293 return -1;
294 return 0;
295}
296
297static int __init
298get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
299{
300 int i;
301
302 cs89_dbg(3, info, "EEPROM data from %x for %x:", off, len);
303 for (i = 0; i < len; i++) {
304 if (wait_eeprom_ready(dev) < 0)
305 return -1;
306 /* Now send the EEPROM read command and EEPROM location to read */
307 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
308 if (wait_eeprom_ready(dev) < 0)
309 return -1;
310 buffer[i] = readreg(dev, PP_EEData);
311 cs89_dbg(3, cont, " %04x", buffer[i]);
312 }
313 cs89_dbg(3, cont, "\n");
314 return 0;
315}
316
317static int __init
318get_eeprom_cksum(int off, int len, int *buffer)
319{
320 int i, cksum;
321
322 cksum = 0;
323 for (i = 0; i < len; i++)
324 cksum += buffer[i];
325 cksum &= 0xffff;
326 if (cksum == 0)
327 return 0;
328 return -1;
329}
330
331static void
332write_irq(struct net_device *dev, int chip_type, int irq)
333{
334 int i;
335
336 if (chip_type == CS8900) {
337#ifndef CONFIG_CS89x0_PLATFORM
338 /* Search the mapping table for the corresponding IRQ pin. */
339 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
340 if (cs8900_irq_map[i] == irq)
341 break;
342 /* Not found */
343 if (i == ARRAY_SIZE(cs8900_irq_map))
344 i = 3;
345#else
346 /* INTRQ0 pin is used for interrupt generation. */
347 i = 0;
348#endif
349 writereg(dev, PP_CS8900_ISAINT, i);
350 } else {
351 writereg(dev, PP_CS8920_ISAINT, irq);
352 }
353}
354
355static void
356count_rx_errors(int status, struct net_device *dev)
357{
358 dev->stats.rx_errors++;
359 if (status & RX_RUNT)
360 dev->stats.rx_length_errors++;
361 if (status & RX_EXTRA_DATA)
362 dev->stats.rx_length_errors++;
363 if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA | RX_RUNT)))
364 /* per str 172 */
365 dev->stats.rx_crc_errors++;
366 if (status & RX_DRIBBLE)
367 dev->stats.rx_frame_errors++;
368}
369
370/*********************************
371 * This page contains DMA routines
372 *********************************/
373
374#if ALLOW_DMA
375
376#define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
377
378static void
379get_dma_channel(struct net_device *dev)
380{
381 struct net_local *lp = netdev_priv(dev);
382
383 if (lp->dma) {
384 dev->dma = lp->dma;
385 lp->isa_config |= ISA_RxDMA;
386 } else {
387 if ((lp->isa_config & ANY_ISA_DMA) == 0)
388 return;
389 dev->dma = lp->isa_config & DMA_NO_MASK;
390 if (lp->chip_type == CS8900)
391 dev->dma += 5;
392 if (dev->dma < 5 || dev->dma > 7) {
393 lp->isa_config &= ~ANY_ISA_DMA;
394 return;
395 }
396 }
397}
398
399static void
400write_dma(struct net_device *dev, int chip_type, int dma)
401{
402 struct net_local *lp = netdev_priv(dev);
403 if ((lp->isa_config & ANY_ISA_DMA) == 0)
404 return;
405 if (chip_type == CS8900)
406 writereg(dev, PP_CS8900_ISADMA, dma - 5);
407 else
408 writereg(dev, PP_CS8920_ISADMA, dma);
409}
410
411static void
412set_dma_cfg(struct net_device *dev)
413{
414 struct net_local *lp = netdev_priv(dev);
415
416 if (lp->use_dma) {
417 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
418 cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
419 return;
420 }
421 if (lp->isa_config & ISA_RxDMA) {
422 lp->curr_rx_cfg |= RX_DMA_ONLY;
423 cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
424 } else {
425 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
426 cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
427 }
428 }
429}
430
431static int
432dma_bufcfg(struct net_device *dev)
433{
434 struct net_local *lp = netdev_priv(dev);
435 if (lp->use_dma)
436 return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
437 else
438 return 0;
439}
440
441static int
442dma_busctl(struct net_device *dev)
443{
444 int retval = 0;
445 struct net_local *lp = netdev_priv(dev);
446 if (lp->use_dma) {
447 if (lp->isa_config & ANY_ISA_DMA)
448 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
449 if (lp->isa_config & DMA_BURST)
450 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
451 if (lp->dmasize == 64)
452 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
453 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
454 }
455 return retval;
456}
457
458static void
459dma_rx(struct net_device *dev)
460{
461 struct net_local *lp = netdev_priv(dev);
462 struct sk_buff *skb;
463 int status, length;
464 unsigned char *bp = lp->rx_dma_ptr;
465
466 status = bp[0] + (bp[1] << 8);
467 length = bp[2] + (bp[3] << 8);
468 bp += 4;
469
470 cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
471 dev->name, (unsigned long)bp, status, length);
472
473 if ((status & RX_OK) == 0) {
474 count_rx_errors(status, dev);
475 goto skip_this_frame;
476 }
477
478 /* Malloc up new buffer. */
479 skb = netdev_alloc_skb(dev, length + 2);
480 if (skb == NULL) {
481 /* I don't think we want to do this to a stressed system */
482 cs89_dbg(0, err, "%s: Memory squeeze, dropping packet\n",
483 dev->name);
484 dev->stats.rx_dropped++;
485
486 /* AKPM: advance bp to the next frame */
487skip_this_frame:
488 bp += (length + 3) & ~3;
489 if (bp >= lp->end_dma_buff)
490 bp -= lp->dmasize * 1024;
491 lp->rx_dma_ptr = bp;
492 return;
493 }
494 skb_reserve(skb, 2); /* longword align L3 header */
495
496 if (bp + length > lp->end_dma_buff) {
497 int semi_cnt = lp->end_dma_buff - bp;
498 memcpy(skb_put(skb, semi_cnt), bp, semi_cnt);
499 memcpy(skb_put(skb, length - semi_cnt), lp->dma_buff,
500 length - semi_cnt);
501 } else {
502 memcpy(skb_put(skb, length), bp, length);
503 }
504 bp += (length + 3) & ~3;
505 if (bp >= lp->end_dma_buff)
506 bp -= lp->dmasize*1024;
507 lp->rx_dma_ptr = bp;
508
509 cs89_dbg(3, info, "%s: received %d byte DMA packet of type %x\n",
510 dev->name, length,
511 ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
512 skb->data[ETH_ALEN + ETH_ALEN + 1]));
513
514 skb->protocol = eth_type_trans(skb, dev);
515 netif_rx(skb);
516 dev->stats.rx_packets++;
517 dev->stats.rx_bytes += length;
518}
519
520static void release_dma_buff(struct net_local *lp)
521{
522 if (lp->dma_buff) {
523 free_pages((unsigned long)(lp->dma_buff),
524 get_order(lp->dmasize * 1024));
525 lp->dma_buff = NULL;
526 }
527}
528
529#endif /* ALLOW_DMA */
530
531static void
532control_dc_dc(struct net_device *dev, int on_not_off)
533{
534 struct net_local *lp = netdev_priv(dev);
535 unsigned int selfcontrol;
536 int timenow = jiffies;
537 /* control the DC to DC convertor in the SelfControl register.
538 * Note: This is hooked up to a general purpose pin, might not
539 * always be a DC to DC convertor.
540 */
541
542 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
543 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
544 selfcontrol |= HCB1;
545 else
546 selfcontrol &= ~HCB1;
547 writereg(dev, PP_SelfCTL, selfcontrol);
548
549 /* Wait for the DC/DC converter to power up - 500ms */
550 while (jiffies - timenow < HZ)
551 ;
552}
553
554/* send a test packet - return true if carrier bits are ok */
555static int
556send_test_pkt(struct net_device *dev)
557{
558 struct net_local *lp = netdev_priv(dev);
559 char test_packet[] = {
560 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
561 0, 46, /* A 46 in network order */
562 0, 0, /* DSAP=0 & SSAP=0 fields */
563 0xf3, 0 /* Control (Test Req + P bit set) */
564 };
565 long timenow = jiffies;
566
567 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
568
569 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
570 memcpy(test_packet + ETH_ALEN, dev->dev_addr, ETH_ALEN);
571
572 iowrite16(TX_AFTER_ALL, lp->virt_addr + TX_CMD_PORT);
573 iowrite16(ETH_ZLEN, lp->virt_addr + TX_LEN_PORT);
574
575 /* Test to see if the chip has allocated memory for the packet */
576 while (jiffies - timenow < 5)
577 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
578 break;
579 if (jiffies - timenow >= 5)
580 return 0; /* this shouldn't happen */
581
582 /* Write the contents of the packet */
583 writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
584
585 cs89_dbg(1, debug, "Sending test packet ");
586 /* wait a couple of jiffies for packet to be received */
587 for (timenow = jiffies; jiffies - timenow < 3;)
588 ;
589 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
590 cs89_dbg(1, cont, "succeeded\n");
591 return 1;
592 }
593 cs89_dbg(1, cont, "failed\n");
594 return 0;
595}
596
597#define DETECTED_NONE 0
598#define DETECTED_RJ45H 1
599#define DETECTED_RJ45F 2
600#define DETECTED_AUI 3
601#define DETECTED_BNC 4
602
603static int
604detect_tp(struct net_device *dev)
605{
606 struct net_local *lp = netdev_priv(dev);
607 int timenow = jiffies;
608 int fdx;
609
610 cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
611
612 /* If connected to another full duplex capable 10-Base-T card
613 * the link pulses seem to be lost when the auto detect bit in
614 * the LineCTL is set. To overcome this the auto detect bit will
615 * be cleared whilst testing the 10-Base-T interface. This would
616 * not be necessary for the sparrow chip but is simpler to do it
617 * anyway.
618 */
619 writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
620 control_dc_dc(dev, 0);
621
622 /* Delay for the hardware to work out if the TP cable is present
623 * - 150ms
624 */
625 for (timenow = jiffies; jiffies - timenow < 15;)
626 ;
627 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
628 return DETECTED_NONE;
629
630 if (lp->chip_type == CS8900) {
631 switch (lp->force & 0xf0) {
632#if 0
633 case FORCE_AUTO:
634 pr_info("%s: cs8900 doesn't autonegotiate\n",
635 dev->name);
636 return DETECTED_NONE;
637#endif
638 /* CS8900 doesn't support AUTO, change to HALF*/
639 case FORCE_AUTO:
640 lp->force &= ~FORCE_AUTO;
641 lp->force |= FORCE_HALF;
642 break;
643 case FORCE_HALF:
644 break;
645 case FORCE_FULL:
646 writereg(dev, PP_TestCTL,
647 readreg(dev, PP_TestCTL) | FDX_8900);
648 break;
649 }
650 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
651 } else {
652 switch (lp->force & 0xf0) {
653 case FORCE_AUTO:
654 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
655 break;
656 case FORCE_HALF:
657 lp->auto_neg_cnf = 0;
658 break;
659 case FORCE_FULL:
660 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
661 break;
662 }
663
664 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
665
666 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
667 pr_info("%s: negotiating duplex...\n", dev->name);
668 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
669 if (jiffies - timenow > 4000) {
670 pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
671 break;
672 }
673 }
674 }
675 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
676 }
677 if (fdx)
678 return DETECTED_RJ45F;
679 else
680 return DETECTED_RJ45H;
681}
682
683static int
684detect_bnc(struct net_device *dev)
685{
686 struct net_local *lp = netdev_priv(dev);
687
688 cs89_dbg(1, debug, "%s: Attempting BNC\n", dev->name);
689 control_dc_dc(dev, 1);
690
691 writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
692
693 if (send_test_pkt(dev))
694 return DETECTED_BNC;
695 else
696 return DETECTED_NONE;
697}
698
699static int
700detect_aui(struct net_device *dev)
701{
702 struct net_local *lp = netdev_priv(dev);
703
704 cs89_dbg(1, debug, "%s: Attempting AUI\n", dev->name);
705 control_dc_dc(dev, 0);
706
707 writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
708
709 if (send_test_pkt(dev))
710 return DETECTED_AUI;
711 else
712 return DETECTED_NONE;
713}
714
715/* We have a good packet(s), get it/them out of the buffers. */
716static void
717net_rx(struct net_device *dev)
718{
719 struct net_local *lp = netdev_priv(dev);
720 struct sk_buff *skb;
721 int status, length;
722
723 status = ioread16(lp->virt_addr + RX_FRAME_PORT);
724 length = ioread16(lp->virt_addr + RX_FRAME_PORT);
725
726 if ((status & RX_OK) == 0) {
727 count_rx_errors(status, dev);
728 return;
729 }
730
731 /* Malloc up new buffer. */
732 skb = netdev_alloc_skb(dev, length + 2);
733 if (skb == NULL) {
734#if 0 /* Again, this seems a cruel thing to do */
735 pr_warn("%s: Memory squeeze, dropping packet\n", dev->name);
736#endif
737 dev->stats.rx_dropped++;
738 return;
739 }
740 skb_reserve(skb, 2); /* longword align L3 header */
741
742 readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
743 if (length & 1)
744 skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
745
746 cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n",
747 dev->name, length,
748 (skb->data[ETH_ALEN + ETH_ALEN] << 8) |
749 skb->data[ETH_ALEN + ETH_ALEN + 1]);
750
751 skb->protocol = eth_type_trans(skb, dev);
752 netif_rx(skb);
753 dev->stats.rx_packets++;
754 dev->stats.rx_bytes += length;
755}
756
757/* The typical workload of the driver:
758 * Handle the network interface interrupts.
759 */
760
761static irqreturn_t net_interrupt(int irq, void *dev_id)
762{
763 struct net_device *dev = dev_id;
764 struct net_local *lp;
765 int status;
766 int handled = 0;
767
768 lp = netdev_priv(dev);
769
770 /* we MUST read all the events out of the ISQ, otherwise we'll never
771 * get interrupted again. As a consequence, we can't have any limit
772 * on the number of times we loop in the interrupt handler. The
773 * hardware guarantees that eventually we'll run out of events. Of
774 * course, if you're on a slow machine, and packets are arriving
775 * faster than you can read them off, you're screwed. Hasta la
776 * vista, baby!
777 */
778 while ((status = ioread16(lp->virt_addr + ISQ_PORT))) {
779 cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status);
780 handled = 1;
781 switch (status & ISQ_EVENT_MASK) {
782 case ISQ_RECEIVER_EVENT:
783 /* Got a packet(s). */
784 net_rx(dev);
785 break;
786 case ISQ_TRANSMITTER_EVENT:
787 dev->stats.tx_packets++;
788 netif_wake_queue(dev); /* Inform upper layers. */
789 if ((status & (TX_OK |
790 TX_LOST_CRS |
791 TX_SQE_ERROR |
792 TX_LATE_COL |
793 TX_16_COL)) != TX_OK) {
794 if ((status & TX_OK) == 0)
795 dev->stats.tx_errors++;
796 if (status & TX_LOST_CRS)
797 dev->stats.tx_carrier_errors++;
798 if (status & TX_SQE_ERROR)
799 dev->stats.tx_heartbeat_errors++;
800 if (status & TX_LATE_COL)
801 dev->stats.tx_window_errors++;
802 if (status & TX_16_COL)
803 dev->stats.tx_aborted_errors++;
804 }
805 break;
806 case ISQ_BUFFER_EVENT:
807 if (status & READY_FOR_TX) {
808 /* we tried to transmit a packet earlier,
809 * but inexplicably ran out of buffers.
810 * That shouldn't happen since we only ever
811 * load one packet. Shrug. Do the right
812 * thing anyway.
813 */
814 netif_wake_queue(dev); /* Inform upper layers. */
815 }
816 if (status & TX_UNDERRUN) {
817 cs89_dbg(0, err, "%s: transmit underrun\n",
818 dev->name);
819 lp->send_underrun++;
820 if (lp->send_underrun == 3)
821 lp->send_cmd = TX_AFTER_381;
822 else if (lp->send_underrun == 6)
823 lp->send_cmd = TX_AFTER_ALL;
824 /* transmit cycle is done, although
825 * frame wasn't transmitted - this
826 * avoids having to wait for the upper
827 * layers to timeout on us, in the
828 * event of a tx underrun
829 */
830 netif_wake_queue(dev); /* Inform upper layers. */
831 }
832#if ALLOW_DMA
833 if (lp->use_dma && (status & RX_DMA)) {
834 int count = readreg(dev, PP_DmaFrameCnt);
835 while (count) {
836 cs89_dbg(5, debug,
837 "%s: receiving %d DMA frames\n",
838 dev->name, count);
839 if (count > 1)
840 cs89_dbg(2, debug,
841 "%s: receiving %d DMA frames\n",
842 dev->name, count);
843 dma_rx(dev);
844 if (--count == 0)
845 count = readreg(dev, PP_DmaFrameCnt);
846 if (count > 0)
847 cs89_dbg(2, debug,
848 "%s: continuing with %d DMA frames\n",
849 dev->name, count);
850 }
851 }
852#endif
853 break;
854 case ISQ_RX_MISS_EVENT:
855 dev->stats.rx_missed_errors += (status >> 6);
856 break;
857 case ISQ_TX_COL_EVENT:
858 dev->stats.collisions += (status >> 6);
859 break;
860 }
861 }
862 return IRQ_RETVAL(handled);
863}
864
865/* Open/initialize the board. This is called (in the current kernel)
866 sometime after booting when the 'ifconfig' program is run.
867
868 This routine should set everything up anew at each open, even
869 registers that "should" only need to be set once at boot, so that
870 there is non-reboot way to recover if something goes wrong.
871*/
872
873/* AKPM: do we need to do any locking here? */
874
875static int
876net_open(struct net_device *dev)
877{
878 struct net_local *lp = netdev_priv(dev);
879 int result = 0;
880 int i;
881 int ret;
882
883 if (dev->irq < 2) {
884 /* Allow interrupts to be generated by the chip */
885/* Cirrus' release had this: */
886#if 0
887 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
888#endif
889/* And 2.3.47 had this: */
890 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
891
892 for (i = 2; i < CS8920_NO_INTS; i++) {
893 if ((1 << i) & lp->irq_map) {
894 if (request_irq(i, net_interrupt, 0, dev->name,
895 dev) == 0) {
896 dev->irq = i;
897 write_irq(dev, lp->chip_type, i);
898 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
899 break;
900 }
901 }
902 }
903
904 if (i >= CS8920_NO_INTS) {
905 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
906 pr_err("can't get an interrupt\n");
907 ret = -EAGAIN;
908 goto bad_out;
909 }
910 } else {
911#if !defined(CS89x0_NONISA_IRQ) && !defined(CONFIG_CS89x0_PLATFORM)
912 if (((1 << dev->irq) & lp->irq_map) == 0) {
913 pr_err("%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
914 dev->name, dev->irq, lp->irq_map);
915 ret = -EAGAIN;
916 goto bad_out;
917 }
918#endif
919/* FIXME: Cirrus' release had this: */
920 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ);
921/* And 2.3.47 had this: */
922#if 0
923 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
924#endif
925 write_irq(dev, lp->chip_type, dev->irq);
926 ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
927 if (ret) {
928 pr_err("request_irq(%d) failed\n", dev->irq);
929 goto bad_out;
930 }
931 }
932
933#if ALLOW_DMA
934 if (lp->use_dma && (lp->isa_config & ANY_ISA_DMA)) {
935 unsigned long flags;
936 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
937 get_order(lp->dmasize * 1024));
938 if (!lp->dma_buff) {
939 pr_err("%s: cannot get %dK memory for DMA\n",
940 dev->name, lp->dmasize);
941 goto release_irq;
942 }
943 cs89_dbg(1, debug, "%s: dma %lx %lx\n",
944 dev->name,
945 (unsigned long)lp->dma_buff,
946 (unsigned long)isa_virt_to_bus(lp->dma_buff));
947 if ((unsigned long)lp->dma_buff >= MAX_DMA_ADDRESS ||
948 !dma_page_eq(lp->dma_buff,
949 lp->dma_buff + lp->dmasize * 1024 - 1)) {
950 pr_err("%s: not usable as DMA buffer\n", dev->name);
951 goto release_irq;
952 }
953 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
954 if (request_dma(dev->dma, dev->name)) {
955 pr_err("%s: cannot get dma channel %d\n",
956 dev->name, dev->dma);
957 goto release_irq;
958 }
959 write_dma(dev, lp->chip_type, dev->dma);
960 lp->rx_dma_ptr = lp->dma_buff;
961 lp->end_dma_buff = lp->dma_buff + lp->dmasize * 1024;
962 spin_lock_irqsave(&lp->lock, flags);
963 disable_dma(dev->dma);
964 clear_dma_ff(dev->dma);
965 set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */
966 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
967 set_dma_count(dev->dma, lp->dmasize * 1024);
968 enable_dma(dev->dma);
969 spin_unlock_irqrestore(&lp->lock, flags);
970 }
971#endif /* ALLOW_DMA */
972
973 /* set the Ethernet address */
974 for (i = 0; i < ETH_ALEN / 2; i++)
975 writereg(dev, PP_IA + i * 2,
976 (dev->dev_addr[i * 2] |
977 (dev->dev_addr[i * 2 + 1] << 8)));
978
979 /* while we're testing the interface, leave interrupts disabled */
980 writereg(dev, PP_BusCTL, MEMORY_ON);
981
982 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
983 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) &&
984 (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
985 lp->linectl = LOW_RX_SQUELCH;
986 else
987 lp->linectl = 0;
988
989 /* check to make sure that they have the "right" hardware available */
990 switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
991 case A_CNF_MEDIA_10B_T:
992 result = lp->adapter_cnf & A_CNF_10B_T;
993 break;
994 case A_CNF_MEDIA_AUI:
995 result = lp->adapter_cnf & A_CNF_AUI;
996 break;
997 case A_CNF_MEDIA_10B_2:
998 result = lp->adapter_cnf & A_CNF_10B_2;
999 break;
1000 default:
1001 result = lp->adapter_cnf & (A_CNF_10B_T |
1002 A_CNF_AUI |
1003 A_CNF_10B_2);
1004 }
1005 if (!result) {
1006 pr_err("%s: EEPROM is configured for unavailable media\n",
1007 dev->name);
1008release_dma:
1009#if ALLOW_DMA
1010 free_dma(dev->dma);
1011release_irq:
1012 release_dma_buff(lp);
1013#endif
1014 writereg(dev, PP_LineCTL,
1015 readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1016 free_irq(dev->irq, dev);
1017 ret = -EAGAIN;
1018 goto bad_out;
1019 }
1020
1021 /* set the hardware to the configured choice */
1022 switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1023 case A_CNF_MEDIA_10B_T:
1024 result = detect_tp(dev);
1025 if (result == DETECTED_NONE) {
1026 pr_warn("%s: 10Base-T (RJ-45) has no cable\n",
1027 dev->name);
1028 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1029 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1030 }
1031 break;
1032 case A_CNF_MEDIA_AUI:
1033 result = detect_aui(dev);
1034 if (result == DETECTED_NONE) {
1035 pr_warn("%s: 10Base-5 (AUI) has no cable\n", dev->name);
1036 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1037 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1038 }
1039 break;
1040 case A_CNF_MEDIA_10B_2:
1041 result = detect_bnc(dev);
1042 if (result == DETECTED_NONE) {
1043 pr_warn("%s: 10Base-2 (BNC) has no cable\n", dev->name);
1044 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1045 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1046 }
1047 break;
1048 case A_CNF_MEDIA_AUTO:
1049 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1050 if (lp->adapter_cnf & A_CNF_10B_T) {
1051 result = detect_tp(dev);
1052 if (result != DETECTED_NONE)
1053 break;
1054 }
1055 if (lp->adapter_cnf & A_CNF_AUI) {
1056 result = detect_aui(dev);
1057 if (result != DETECTED_NONE)
1058 break;
1059 }
1060 if (lp->adapter_cnf & A_CNF_10B_2) {
1061 result = detect_bnc(dev);
1062 if (result != DETECTED_NONE)
1063 break;
1064 }
1065 pr_err("%s: no media detected\n", dev->name);
1066 goto release_dma;
1067 }
1068 switch (result) {
1069 case DETECTED_NONE:
1070 pr_err("%s: no network cable attached to configured media\n",
1071 dev->name);
1072 goto release_dma;
1073 case DETECTED_RJ45H:
1074 pr_info("%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1075 break;
1076 case DETECTED_RJ45F:
1077 pr_info("%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1078 break;
1079 case DETECTED_AUI:
1080 pr_info("%s: using 10Base-5 (AUI)\n", dev->name);
1081 break;
1082 case DETECTED_BNC:
1083 pr_info("%s: using 10Base-2 (BNC)\n", dev->name);
1084 break;
1085 }
1086
1087 /* Turn on both receive and transmit operations */
1088 writereg(dev, PP_LineCTL,
1089 readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1090
1091 /* Receive only error free packets addressed to this card */
1092 lp->rx_mode = 0;
1093 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1094
1095 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1096
1097 if (lp->isa_config & STREAM_TRANSFER)
1098 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1099#if ALLOW_DMA
1100 set_dma_cfg(dev);
1101#endif
1102 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1103
1104 writereg(dev, PP_TxCFG, (TX_LOST_CRS_ENBL |
1105 TX_SQE_ERROR_ENBL |
1106 TX_OK_ENBL |
1107 TX_LATE_COL_ENBL |
1108 TX_JBR_ENBL |
1109 TX_ANY_COL_ENBL |
1110 TX_16_COL_ENBL));
1111
1112 writereg(dev, PP_BufCFG, (READY_FOR_TX_ENBL |
1113 RX_MISS_COUNT_OVRFLOW_ENBL |
1114#if ALLOW_DMA
1115 dma_bufcfg(dev) |
1116#endif
1117 TX_COL_COUNT_OVRFLOW_ENBL |
1118 TX_UNDERRUN_ENBL));
1119
1120 /* now that we've got our act together, enable everything */
1121 writereg(dev, PP_BusCTL, (ENABLE_IRQ
1122 | (dev->mem_start ? MEMORY_ON : 0) /* turn memory on */
1123#if ALLOW_DMA
1124 | dma_busctl(dev)
1125#endif
1126 ));
1127 netif_start_queue(dev);
1128 cs89_dbg(1, debug, "net_open() succeeded\n");
1129 return 0;
1130bad_out:
1131 return ret;
1132}
1133
1134/* The inverse routine to net_open(). */
1135static int
1136net_close(struct net_device *dev)
1137{
1138#if ALLOW_DMA
1139 struct net_local *lp = netdev_priv(dev);
1140#endif
1141
1142 netif_stop_queue(dev);
1143
1144 writereg(dev, PP_RxCFG, 0);
1145 writereg(dev, PP_TxCFG, 0);
1146 writereg(dev, PP_BufCFG, 0);
1147 writereg(dev, PP_BusCTL, 0);
1148
1149 free_irq(dev->irq, dev);
1150
1151#if ALLOW_DMA
1152 if (lp->use_dma && lp->dma) {
1153 free_dma(dev->dma);
1154 release_dma_buff(lp);
1155 }
1156#endif
1157
1158 /* Update the statistics here. */
1159 return 0;
1160}
1161
1162/* Get the current statistics.
1163 * This may be called with the card open or closed.
1164 */
1165static struct net_device_stats *
1166net_get_stats(struct net_device *dev)
1167{
1168 struct net_local *lp = netdev_priv(dev);
1169 unsigned long flags;
1170
1171 spin_lock_irqsave(&lp->lock, flags);
1172 /* Update the statistics from the device registers. */
1173 dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1174 dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1175 spin_unlock_irqrestore(&lp->lock, flags);
1176
1177 return &dev->stats;
1178}
1179
1180static void net_timeout(struct net_device *dev)
1181{
1182 /* If we get here, some higher level has decided we are broken.
1183 There should really be a "kick me" function call instead. */
1184 cs89_dbg(0, err, "%s: transmit timed out, %s?\n",
1185 dev->name,
1186 tx_done(dev) ? "IRQ conflict" : "network cable problem");
1187 /* Try to restart the adaptor. */
1188 netif_wake_queue(dev);
1189}
1190
1191static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev)
1192{
1193 struct net_local *lp = netdev_priv(dev);
1194 unsigned long flags;
1195
1196 cs89_dbg(3, debug, "%s: sent %d byte packet of type %x\n",
1197 dev->name, skb->len,
1198 ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
1199 skb->data[ETH_ALEN + ETH_ALEN + 1]));
1200
1201 /* keep the upload from being interrupted, since we
1202 * ask the chip to start transmitting before the
1203 * whole packet has been completely uploaded.
1204 */
1205
1206 spin_lock_irqsave(&lp->lock, flags);
1207 netif_stop_queue(dev);
1208
1209 /* initiate a transmit sequence */
1210 iowrite16(lp->send_cmd, lp->virt_addr + TX_CMD_PORT);
1211 iowrite16(skb->len, lp->virt_addr + TX_LEN_PORT);
1212
1213 /* Test to see if the chip has allocated memory for the packet */
1214 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1215 /* Gasp! It hasn't. But that shouldn't happen since
1216 * we're waiting for TxOk, so return 1 and requeue this packet.
1217 */
1218
1219 spin_unlock_irqrestore(&lp->lock, flags);
1220 cs89_dbg(0, err, "Tx buffer not free!\n");
1221 return NETDEV_TX_BUSY;
1222 }
1223 /* Write the contents of the packet */
1224 writewords(lp, TX_FRAME_PORT, skb->data, (skb->len + 1) >> 1);
1225 spin_unlock_irqrestore(&lp->lock, flags);
1226 dev->stats.tx_bytes += skb->len;
1227 dev_kfree_skb(skb);
1228
1229 /* We DO NOT call netif_wake_queue() here.
1230 * We also DO NOT call netif_start_queue().
1231 *
1232 * Either of these would cause another bottom half run through
1233 * net_send_packet() before this packet has fully gone out.
1234 * That causes us to hit the "Gasp!" above and the send is rescheduled.
1235 * it runs like a dog. We just return and wait for the Tx completion
1236 * interrupt handler to restart the netdevice layer
1237 */
1238
1239 return NETDEV_TX_OK;
1240}
1241
1242static void set_multicast_list(struct net_device *dev)
1243{
1244 struct net_local *lp = netdev_priv(dev);
1245 unsigned long flags;
1246 u16 cfg;
1247
1248 spin_lock_irqsave(&lp->lock, flags);
1249 if (dev->flags & IFF_PROMISC)
1250 lp->rx_mode = RX_ALL_ACCEPT;
1251 else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev))
1252 /* The multicast-accept list is initialized to accept-all,
1253 * and we rely on higher-level filtering for now.
1254 */
1255 lp->rx_mode = RX_MULTCAST_ACCEPT;
1256 else
1257 lp->rx_mode = 0;
1258
1259 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1260
1261 /* in promiscuous mode, we accept errored packets,
1262 * so we have to enable interrupts on them also
1263 */
1264 cfg = lp->curr_rx_cfg;
1265 if (lp->rx_mode == RX_ALL_ACCEPT)
1266 cfg |= RX_CRC_ERROR_ENBL | RX_RUNT_ENBL | RX_EXTRA_DATA_ENBL;
1267 writereg(dev, PP_RxCFG, cfg);
1268 spin_unlock_irqrestore(&lp->lock, flags);
1269}
1270
1271static int set_mac_address(struct net_device *dev, void *p)
1272{
1273 int i;
1274 struct sockaddr *addr = p;
1275
1276 if (netif_running(dev))
1277 return -EBUSY;
1278
1279 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1280
1281 cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
1282 dev->name, dev->dev_addr);
1283
1284 /* set the Ethernet address */
1285 for (i = 0; i < ETH_ALEN / 2; i++)
1286 writereg(dev, PP_IA + i * 2,
1287 (dev->dev_addr[i * 2] |
1288 (dev->dev_addr[i * 2 + 1] << 8)));
1289
1290 return 0;
1291}
1292
1293#ifdef CONFIG_NET_POLL_CONTROLLER
1294/*
1295 * Polling receive - used by netconsole and other diagnostic tools
1296 * to allow network i/o with interrupts disabled.
1297 */
1298static void net_poll_controller(struct net_device *dev)
1299{
1300 disable_irq(dev->irq);
1301 net_interrupt(dev->irq, dev);
1302 enable_irq(dev->irq);
1303}
1304#endif
1305
1306static const struct net_device_ops net_ops = {
1307 .ndo_open = net_open,
1308 .ndo_stop = net_close,
1309 .ndo_tx_timeout = net_timeout,
1310 .ndo_start_xmit = net_send_packet,
1311 .ndo_get_stats = net_get_stats,
1312 .ndo_set_rx_mode = set_multicast_list,
1313 .ndo_set_mac_address = set_mac_address,
1314#ifdef CONFIG_NET_POLL_CONTROLLER
1315 .ndo_poll_controller = net_poll_controller,
1316#endif
1317 .ndo_change_mtu = eth_change_mtu,
1318 .ndo_validate_addr = eth_validate_addr,
1319};
1320
1321static void __init reset_chip(struct net_device *dev)
1322{
1323#if !defined(CONFIG_MACH_MX31ADS)
1324#if !defined(CS89x0_NONISA_IRQ)
1325 struct net_local *lp = netdev_priv(dev);
1326#endif /* CS89x0_NONISA_IRQ */
1327 int reset_start_time;
1328
1329 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
1330
1331 /* wait 30 ms */
1332 msleep(30);
1333
1334#if !defined(CS89x0_NONISA_IRQ)
1335 if (lp->chip_type != CS8900) {
1336 /* Hardware problem requires PNP registers to be reconfigured after a reset */
1337 iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
1338 iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
1339 iowrite8(0, lp->virt_addr + DATA_PORT + 1);
1340
1341 iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT);
1342 iowrite8((dev->mem_start >> 16) & 0xff,
1343 lp->virt_addr + DATA_PORT);
1344 iowrite8((dev->mem_start >> 8) & 0xff,
1345 lp->virt_addr + DATA_PORT + 1);
1346 }
1347#endif /* CS89x0_NONISA_IRQ */
1348
1349 /* Wait until the chip is reset */
1350 reset_start_time = jiffies;
1351 while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
1352 jiffies - reset_start_time < 2)
1353 ;
1354#endif /* !CONFIG_MACH_MX31ADS */
1355}
1356
1357/* This is the real probe routine.
1358 * Linux has a history of friendly device probes on the ISA bus.
1359 * A good device probes avoids doing writes, and
1360 * verifies that the correct device exists and functions.
1361 * Return 0 on success.
1362 */
1363static int __init
1364cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
1365{
1366 struct net_local *lp = netdev_priv(dev);
1367 int i;
1368 int tmp;
1369 unsigned rev_type = 0;
1370 int eeprom_buff[CHKSUM_LEN];
1371 int retval;
1372
1373 /* Initialize the device structure. */
1374 if (!modular) {
1375 memset(lp, 0, sizeof(*lp));
1376 spin_lock_init(&lp->lock);
1377#ifndef MODULE
1378#if ALLOW_DMA
1379 if (g_cs89x0_dma) {
1380 lp->use_dma = 1;
1381 lp->dma = g_cs89x0_dma;
1382 lp->dmasize = 16; /* Could make this an option... */
1383 }
1384#endif
1385 lp->force = g_cs89x0_media__force;
1386#endif
1387 }
1388
1389 pr_debug("PP_addr at %p[%x]: 0x%x\n",
1390 ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT));
1391 iowrite16(PP_ChipID, ioaddr + ADD_PORT);
1392
1393 tmp = ioread16(ioaddr + DATA_PORT);
1394 if (tmp != CHIP_EISA_ID_SIG) {
1395 pr_debug("%s: incorrect signature at %p[%x]: 0x%x!="
1396 CHIP_EISA_ID_SIG_STR "\n",
1397 dev->name, ioaddr, DATA_PORT, tmp);
1398 retval = -ENODEV;
1399 goto out1;
1400 }
1401
1402 lp->virt_addr = ioaddr;
1403
1404 /* get the chip type */
1405 rev_type = readreg(dev, PRODUCT_ID_ADD);
1406 lp->chip_type = rev_type & ~REVISON_BITS;
1407 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
1408
1409 /* Check the chip type and revision in order to set the correct
1410 * send command. CS8920 revision C and CS8900 revision F can use
1411 * the faster send.
1412 */
1413 lp->send_cmd = TX_AFTER_381;
1414 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
1415 lp->send_cmd = TX_NOW;
1416 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
1417 lp->send_cmd = TX_NOW;
1418
1419 pr_info_once("%s\n", version);
1420
1421 pr_info("%s: cs89%c0%s rev %c found at %p ",
1422 dev->name,
1423 lp->chip_type == CS8900 ? '0' : '2',
1424 lp->chip_type == CS8920M ? "M" : "",
1425 lp->chip_revision,
1426 lp->virt_addr);
1427
1428 reset_chip(dev);
1429
1430 /* Here we read the current configuration of the chip.
1431 * If there is no Extended EEPROM then the idea is to not disturb
1432 * the chip configuration, it should have been correctly setup by
1433 * automatic EEPROM read on reset. So, if the chip says it read
1434 * the EEPROM the driver will always do *something* instead of
1435 * complain that adapter_cnf is 0.
1436 */
1437
1438 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
1439 (EEPROM_OK | EEPROM_PRESENT)) {
1440 /* Load the MAC. */
1441 for (i = 0; i < ETH_ALEN / 2; i++) {
1442 unsigned int Addr;
1443 Addr = readreg(dev, PP_IA + i * 2);
1444 dev->dev_addr[i * 2] = Addr & 0xFF;
1445 dev->dev_addr[i * 2 + 1] = Addr >> 8;
1446 }
1447
1448 /* Load the Adapter Configuration.
1449 * Note: Barring any more specific information from some
1450 * other source (ie EEPROM+Schematics), we would not know
1451 * how to operate a 10Base2 interface on the AUI port.
1452 * However, since we do read the status of HCB1 and use
1453 * settings that always result in calls to control_dc_dc(dev,0)
1454 * a BNC interface should work if the enable pin
1455 * (dc/dc converter) is on HCB1.
1456 * It will be called AUI however.
1457 */
1458
1459 lp->adapter_cnf = 0;
1460 i = readreg(dev, PP_LineCTL);
1461 /* Preserve the setting of the HCB1 pin. */
1462 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
1463 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
1464 /* Save the sqelch bit */
1465 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
1466 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
1467 /* Check if the card is in 10Base-t only mode */
1468 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
1469 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
1470 /* Check if the card is in AUI only mode */
1471 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
1472 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
1473 /* Check if the card is in Auto mode. */
1474 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
1475 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
1476 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
1477
1478 cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
1479 dev->name, i, lp->adapter_cnf);
1480
1481 /* IRQ. Other chips already probe, see below. */
1482 if (lp->chip_type == CS8900)
1483 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
1484
1485 pr_cont("[Cirrus EEPROM] ");
1486 }
1487
1488 pr_cont("\n");
1489
1490 /* First check to see if an EEPROM is attached. */
1491
1492 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
1493 pr_warn("No EEPROM, relying on command line....\n");
1494 else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1495 pr_warn("EEPROM read failed, relying on command line\n");
1496 } else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1497 /* Check if the chip was able to read its own configuration starting
1498 at 0 in the EEPROM*/
1499 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
1500 (EEPROM_OK | EEPROM_PRESENT))
1501 pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
1502
1503 } else {
1504 /* This reads an extended EEPROM that is not documented
1505 * in the CS8900 datasheet.
1506 */
1507
1508 /* get transmission control word but keep the autonegotiation bits */
1509 if (!lp->auto_neg_cnf)
1510 lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
1511 /* Store adapter configuration */
1512 if (!lp->adapter_cnf)
1513 lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
1514 /* Store ISA configuration */
1515 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
1516 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
1517
1518 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
1519 /* store the initial memory base address */
1520 for (i = 0; i < ETH_ALEN / 2; i++) {
1521 dev->dev_addr[i * 2] = eeprom_buff[i];
1522 dev->dev_addr[i * 2 + 1] = eeprom_buff[i] >> 8;
1523 }
1524 cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
1525 dev->name, lp->adapter_cnf);
1526 }
1527
1528 /* allow them to force multiple transceivers. If they force multiple, autosense */
1529 {
1530 int count = 0;
1531 if (lp->force & FORCE_RJ45) {
1532 lp->adapter_cnf |= A_CNF_10B_T;
1533 count++;
1534 }
1535 if (lp->force & FORCE_AUI) {
1536 lp->adapter_cnf |= A_CNF_AUI;
1537 count++;
1538 }
1539 if (lp->force & FORCE_BNC) {
1540 lp->adapter_cnf |= A_CNF_10B_2;
1541 count++;
1542 }
1543 if (count > 1)
1544 lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
1545 else if (lp->force & FORCE_RJ45)
1546 lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
1547 else if (lp->force & FORCE_AUI)
1548 lp->adapter_cnf |= A_CNF_MEDIA_AUI;
1549 else if (lp->force & FORCE_BNC)
1550 lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
1551 }
1552
1553 cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
1554 dev->name, lp->force, lp->adapter_cnf);
1555
1556 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
1557
1558 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
1559
1560 /* FIXME: we don't set the Ethernet address on the command line. Use
1561 * ifconfig IFACE hw ether AABBCCDDEEFF
1562 */
1563
1564 pr_info("media %s%s%s",
1565 (lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
1566 (lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
1567 (lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
1568
1569 lp->irq_map = 0xffff;
1570
1571 /* If this is a CS8900 then no pnp soft */
1572 if (lp->chip_type != CS8900 &&
1573 /* Check if the ISA IRQ has been set */
1574 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
1575 (i != 0 && i < CS8920_NO_INTS))) {
1576 if (!dev->irq)
1577 dev->irq = i;
1578 } else {
1579 i = lp->isa_config & INT_NO_MASK;
1580#ifndef CONFIG_CS89x0_PLATFORM
1581 if (lp->chip_type == CS8900) {
1582#ifdef CS89x0_NONISA_IRQ
1583 i = cs8900_irq_map[0];
1584#else
1585 /* Translate the IRQ using the IRQ mapping table. */
1586 if (i >= ARRAY_SIZE(cs8900_irq_map))
1587 pr_err("invalid ISA interrupt number %d\n", i);
1588 else
1589 i = cs8900_irq_map[i];
1590
1591 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
1592 } else {
1593 int irq_map_buff[IRQ_MAP_LEN/2];
1594
1595 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
1596 IRQ_MAP_LEN / 2,
1597 irq_map_buff) >= 0) {
1598 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
1599 lp->irq_map = ((irq_map_buff[0] >> 8) |
1600 (irq_map_buff[1] << 8));
1601 }
1602#endif
1603 }
1604#endif
1605 if (!dev->irq)
1606 dev->irq = i;
1607 }
1608
1609 pr_cont(" IRQ %d", dev->irq);
1610
1611#if ALLOW_DMA
1612 if (lp->use_dma) {
1613 get_dma_channel(dev);
1614 pr_cont(", DMA %d", dev->dma);
1615 } else
1616#endif
1617 pr_cont(", programmed I/O");
1618
1619 /* print the ethernet address. */
1620 pr_cont(", MAC %pM\n", dev->dev_addr);
1621
1622 dev->netdev_ops = &net_ops;
1623 dev->watchdog_timeo = HZ;
1624
1625 cs89_dbg(0, info, "cs89x0_probe1() successful\n");
1626
1627 retval = register_netdev(dev);
1628 if (retval)
1629 goto out2;
1630 return 0;
1631out2:
1632 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1633out1:
1634 return retval;
1635}
1636
1637#ifndef CONFIG_CS89x0_PLATFORM
1638/*
1639 * This function converts the I/O port addres used by the cs89x0_probe() and
1640 * init_module() functions to the I/O memory address used by the
1641 * cs89x0_probe1() function.
1642 */
1643static int __init
1644cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
1645{
1646 struct net_local *lp = netdev_priv(dev);
1647 int ret;
1648 void __iomem *io_mem;
1649
1650 if (!lp)
1651 return -ENOMEM;
1652
1653 dev->base_addr = ioport;
1654
1655 if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
1656 ret = -EBUSY;
1657 goto out;
1658 }
1659
1660 io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
1661 if (!io_mem) {
1662 ret = -ENOMEM;
1663 goto release;
1664 }
1665
1666 /* if they give us an odd I/O address, then do ONE write to
1667 * the address port, to get it back to address zero, where we
1668 * expect to find the EISA signature word. An IO with a base of 0x3
1669 * will skip the test for the ADD_PORT.
1670 */
1671 if (ioport & 1) {
1672 cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
1673 if ((ioport & 2) != 2) {
1674 if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
1675 ADD_SIG) {
1676 pr_err("%s: bad signature 0x%x\n",
1677 dev->name, ioread16(io_mem + ADD_PORT));
1678 ret = -ENODEV;
1679 goto unmap;
1680 }
1681 }
1682 }
1683
1684 ret = cs89x0_probe1(dev, io_mem, modular);
1685 if (!ret)
1686 goto out;
1687unmap:
1688 ioport_unmap(io_mem);
1689release:
1690 release_region(ioport, NETCARD_IO_EXTENT);
1691out:
1692 return ret;
1693}
1694
1695#ifndef MODULE
1696/* Check for a network adaptor of this type, and return '0' iff one exists.
1697 * If dev->base_addr == 0, probe all likely locations.
1698 * If dev->base_addr == 1, always return failure.
1699 * If dev->base_addr == 2, allocate space for the device and return success
1700 * (detachable devices only).
1701 * Return 0 on success.
1702 */
1703
1704struct net_device * __init cs89x0_probe(int unit)
1705{
1706 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1707 unsigned *port;
1708 int err = 0;
1709 int irq;
1710 int io;
1711
1712 if (!dev)
1713 return ERR_PTR(-ENODEV);
1714
1715 sprintf(dev->name, "eth%d", unit);
1716 netdev_boot_setup_check(dev);
1717 io = dev->base_addr;
1718 irq = dev->irq;
1719
1720 cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
1721
1722 if (io > 0x1ff) { /* Check a single specified location. */
1723 err = cs89x0_ioport_probe(dev, io, 0);
1724 } else if (io != 0) { /* Don't probe at all. */
1725 err = -ENXIO;
1726 } else {
1727 for (port = netcard_portlist; *port; port++) {
1728 if (cs89x0_ioport_probe(dev, *port, 0) == 0)
1729 break;
1730 dev->irq = irq;
1731 }
1732 if (!*port)
1733 err = -ENODEV;
1734 }
1735 if (err)
1736 goto out;
1737 return dev;
1738out:
1739 free_netdev(dev);
1740 pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
1741 return ERR_PTR(err);
1742}
1743#endif
1744#endif
1745
1746#if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM)
1747
1748static struct net_device *dev_cs89x0;
1749
1750/* Support the 'debug' module parm even if we're compiled for non-debug to
1751 * avoid breaking someone's startup scripts
1752 */
1753
1754static int io;
1755static int irq;
1756static int debug;
1757static char media[8];
1758static int duplex = -1;
1759
1760static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1761static int dma;
1762static int dmasize = 16; /* or 64 */
1763
1764module_param(io, int, 0);
1765module_param(irq, int, 0);
1766module_param(debug, int, 0);
1767module_param_string(media, media, sizeof(media), 0);
1768module_param(duplex, int, 0);
1769module_param(dma , int, 0);
1770module_param(dmasize , int, 0);
1771module_param(use_dma , int, 0);
1772MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1773MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1774#if DEBUGGING
1775MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1776#else
1777MODULE_PARM_DESC(debug, "(ignored)");
1778#endif
1779MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1780/* No other value than -1 for duplex seems to be currently interpreted */
1781MODULE_PARM_DESC(duplex, "(ignored)");
1782#if ALLOW_DMA
1783MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1784MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1785MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1786#else
1787MODULE_PARM_DESC(dma , "(ignored)");
1788MODULE_PARM_DESC(dmasize , "(ignored)");
1789MODULE_PARM_DESC(use_dma , "(ignored)");
1790#endif
1791
1792MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1793MODULE_LICENSE("GPL");
1794
1795/*
1796 * media=t - specify media type
1797 * or media=2
1798 * or media=aui
1799 * or medai=auto
1800 * duplex=0 - specify forced half/full/autonegotiate duplex
1801 * debug=# - debug level
1802 *
1803 * Default Chip Configuration:
1804 * DMA Burst = enabled
1805 * IOCHRDY Enabled = enabled
1806 * UseSA = enabled
1807 * CS8900 defaults to half-duplex if not specified on command-line
1808 * CS8920 defaults to autoneg if not specified on command-line
1809 * Use reset defaults for other config parameters
1810 *
1811 * Assumptions:
1812 * media type specified is supported (circuitry is present)
1813 * if memory address is > 1MB, then required mem decode hw is present
1814 * if 10B-2, then agent other than driver will enable DC/DC converter
1815 * (hw or software util)
1816 */
1817
1818int __init init_module(void)
1819{
1820 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1821 struct net_local *lp;
1822 int ret = 0;
1823
1824#if DEBUGGING
1825 net_debug = debug;
1826#else
1827 debug = 0;
1828#endif
1829 if (!dev)
1830 return -ENOMEM;
1831
1832 dev->irq = irq;
1833 dev->base_addr = io;
1834 lp = netdev_priv(dev);
1835
1836#if ALLOW_DMA
1837 if (use_dma) {
1838 lp->use_dma = use_dma;
1839 lp->dma = dma;
1840 lp->dmasize = dmasize;
1841 }
1842#endif
1843
1844 spin_lock_init(&lp->lock);
1845
1846 /* boy, they'd better get these right */
1847 if (!strcmp(media, "rj45"))
1848 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1849 else if (!strcmp(media, "aui"))
1850 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1851 else if (!strcmp(media, "bnc"))
1852 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1853 else
1854 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1855
1856 if (duplex == -1)
1857 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1858
1859 if (io == 0) {
1860 pr_err("Module autoprobing not allowed\n");
1861 pr_err("Append io=0xNNN\n");
1862 ret = -EPERM;
1863 goto out;
1864 } else if (io <= 0x1ff) {
1865 ret = -ENXIO;
1866 goto out;
1867 }
1868
1869#if ALLOW_DMA
1870 if (use_dma && dmasize != 16 && dmasize != 64) {
1871 pr_err("dma size must be either 16K or 64K, not %dK\n",
1872 dmasize);
1873 ret = -EPERM;
1874 goto out;
1875 }
1876#endif
1877 ret = cs89x0_ioport_probe(dev, io, 1);
1878 if (ret)
1879 goto out;
1880
1881 dev_cs89x0 = dev;
1882 return 0;
1883out:
1884 free_netdev(dev);
1885 return ret;
1886}
1887
1888void __exit
1889cleanup_module(void)
1890{
1891 struct net_local *lp = netdev_priv(dev_cs89x0);
1892
1893 unregister_netdev(dev_cs89x0);
1894 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1895 ioport_unmap(lp->virt_addr);
1896 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1897 free_netdev(dev_cs89x0);
1898}
1899#endif /* MODULE && !CONFIG_CS89x0_PLATFORM */
1900
1901#ifdef CONFIG_CS89x0_PLATFORM
1902static int __init cs89x0_platform_probe(struct platform_device *pdev)
1903{
1904 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1905 struct net_local *lp;
1906 struct resource *mem_res;
1907 void __iomem *virt_addr;
1908 int err;
1909
1910 if (!dev)
1911 return -ENOMEM;
1912
1913 lp = netdev_priv(dev);
1914
1915 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1916 dev->irq = platform_get_irq(pdev, 0);
1917 if (mem_res == NULL || dev->irq <= 0) {
1918 dev_warn(&dev->dev, "memory/interrupt resource missing\n");
1919 err = -ENXIO;
1920 goto free;
1921 }
1922
1923 lp->size = resource_size(mem_res);
1924 if (!request_mem_region(mem_res->start, lp->size, DRV_NAME)) {
1925 dev_warn(&dev->dev, "request_mem_region() failed\n");
1926 err = -EBUSY;
1927 goto free;
1928 }
1929
1930 virt_addr = ioremap(mem_res->start, lp->size);
1931 if (!virt_addr) {
1932 dev_warn(&dev->dev, "ioremap() failed\n");
1933 err = -ENOMEM;
1934 goto release;
1935 }
1936
1937 err = cs89x0_probe1(dev, virt_addr, 0);
1938 if (err) {
1939 dev_warn(&dev->dev, "no cs8900 or cs8920 detected\n");
1940 goto unmap;
1941 }
1942
1943 platform_set_drvdata(pdev, dev);
1944 return 0;
1945
1946unmap:
1947 iounmap(virt_addr);
1948release:
1949 release_mem_region(mem_res->start, lp->size);
1950free:
1951 free_netdev(dev);
1952 return err;
1953}
1954
1955static int cs89x0_platform_remove(struct platform_device *pdev)
1956{
1957 struct net_device *dev = platform_get_drvdata(pdev);
1958 struct net_local *lp = netdev_priv(dev);
1959 struct resource *mem_res;
1960
1961 /* This platform_get_resource() call will not return NULL, because
1962 * the same call in cs89x0_platform_probe() has returned a non NULL
1963 * value.
1964 */
1965 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1966 unregister_netdev(dev);
1967 iounmap(lp->virt_addr);
1968 release_mem_region(mem_res->start, lp->size);
1969 free_netdev(dev);
1970 return 0;
1971}
1972
1973static struct platform_driver cs89x0_driver = {
1974 .driver = {
1975 .name = DRV_NAME,
1976 .owner = THIS_MODULE,
1977 },
1978 .remove = cs89x0_platform_remove,
1979};
1980
1981static int __init cs89x0_init(void)
1982{
1983 return platform_driver_probe(&cs89x0_driver, cs89x0_platform_probe);
1984}
1985
1986module_init(cs89x0_init);
1987
1988static void __exit cs89x0_cleanup(void)
1989{
1990 platform_driver_unregister(&cs89x0_driver);
1991}
1992
1993module_exit(cs89x0_cleanup);
1994
1995#endif /* CONFIG_CS89x0_PLATFORM */