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