?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] USB: Rename hcd->hub_suspend to hcd->bus_suspend
[linux/fpc-iii.git] / drivers / net / au1000_eth.c
blob78506911d6566d96efdadf6464b828ebd4d3d6cb
1 /*
2 *
3 * Alchemy Au1x00 ethernet driver
4 *
5 * Copyright 2001,2002,2003 MontaVista Software Inc.
6 * Copyright 2002 TimeSys Corp.
7 * Added ethtool/mii-tool support,
8 * Copyright 2004 Matt Porter <mporter@kernel.crashing.org>
9 * Update: 2004 Bjoern Riemer, riemer@fokus.fraunhofer.de
10 * or riemer@riemer-nt.de: fixed the link beat detection with
11 * ioctls (SIOCGMIIPHY)
12 * Author: MontaVista Software, Inc.
13 * ppopov@mvista.com or source@mvista.com
14 *
15 * ########################################################################
16 *
17 * This program is free software; you can distribute it and/or modify it
18 * under the terms of the GNU General Public License (Version 2) as
19 * published by the Free Software Foundation.
20 *
21 * This program is distributed in the hope it will be useful, but WITHOUT
22 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
23 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24 * for more details.
25 *
26 * You should have received a copy of the GNU General Public License along
27 * with this program; if not, write to the Free Software Foundation, Inc.,
28 * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
29 *
30 * ########################################################################
31 *
32 *
33 */
34
35 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/sched.h>
38 #include <linux/string.h>
39 #include <linux/timer.h>
40 #include <linux/errno.h>
41 #include <linux/in.h>
42 #include <linux/ioport.h>
43 #include <linux/bitops.h>
44 #include <linux/slab.h>
45 #include <linux/interrupt.h>
46 #include <linux/pci.h>
47 #include <linux/init.h>
48 #include <linux/netdevice.h>
49 #include <linux/etherdevice.h>
50 #include <linux/ethtool.h>
51 #include <linux/mii.h>
52 #include <linux/skbuff.h>
53 #include <linux/delay.h>
54 #include <asm/mipsregs.h>
55 #include <asm/irq.h>
56 #include <asm/io.h>
57 #include <asm/processor.h>
58
59 #include <asm/mach-au1x00/au1000.h>
60 #include <asm/cpu.h>
61 #include "au1000_eth.h"
62
63 #ifdef AU1000_ETH_DEBUG
64 static int au1000_debug = 5;
65 #else
66 static int au1000_debug = 3;
67 #endif
68
69 #define DRV_NAME "au1000eth"
70 #define DRV_VERSION "1.5"
71 #define DRV_AUTHOR "Pete Popov <ppopov@embeddedalley.com>"
72 #define DRV_DESC "Au1xxx on-chip Ethernet driver"
73
74 MODULE_AUTHOR(DRV_AUTHOR);
75 MODULE_DESCRIPTION(DRV_DESC);
76 MODULE_LICENSE("GPL");
77
78 // prototypes
79 static void hard_stop(struct net_device *);
80 static void enable_rx_tx(struct net_device *dev);
81 static struct net_device * au1000_probe(u32 ioaddr, int irq, int port_num);
82 static int au1000_init(struct net_device *);
83 static int au1000_open(struct net_device *);
84 static int au1000_close(struct net_device *);
85 static int au1000_tx(struct sk_buff *, struct net_device *);
86 static int au1000_rx(struct net_device *);
87 static irqreturn_t au1000_interrupt(int, void *, struct pt_regs *);
88 static void au1000_tx_timeout(struct net_device *);
89 static int au1000_set_config(struct net_device *dev, struct ifmap *map);
90 static void set_rx_mode(struct net_device *);
91 static struct net_device_stats *au1000_get_stats(struct net_device *);
92 static inline void update_tx_stats(struct net_device *, u32, u32);
93 static inline void update_rx_stats(struct net_device *, u32);
94 static void au1000_timer(unsigned long);
95 static int au1000_ioctl(struct net_device *, struct ifreq *, int);
96 static int mdio_read(struct net_device *, int, int);
97 static void mdio_write(struct net_device *, int, int, u16);
98 static void dump_mii(struct net_device *dev, int phy_id);
99
100 // externs
101 extern void ack_rise_edge_irq(unsigned int);
102 extern int get_ethernet_addr(char *ethernet_addr);
103 extern void str2eaddr(unsigned char *ea, unsigned char *str);
104 extern char * __init prom_getcmdline(void);
105
106 /*
107 * Theory of operation
108 *
109 * The Au1000 MACs use a simple rx and tx descriptor ring scheme.
110 * There are four receive and four transmit descriptors. These
111 * descriptors are not in memory; rather, they are just a set of
112 * hardware registers.
113 *
114 * Since the Au1000 has a coherent data cache, the receive and
115 * transmit buffers are allocated from the KSEG0 segment. The
116 * hardware registers, however, are still mapped at KSEG1 to
117 * make sure there's no out-of-order writes, and that all writes
118 * complete immediately.
119 */
120
121 /* These addresses are only used if yamon doesn't tell us what
122 * the mac address is, and the mac address is not passed on the
123 * command line.
124 */
125 static unsigned char au1000_mac_addr[6] __devinitdata = {
126 0x00, 0x50, 0xc2, 0x0c, 0x30, 0x00
127 };
128
129 #define nibswap(x) ((((x) >> 4) & 0x0f) | (((x) << 4) & 0xf0))
130 #define RUN_AT(x) (jiffies + (x))
131
132 // For reading/writing 32-bit words from/to DMA memory
133 #define cpu_to_dma32 cpu_to_be32
134 #define dma32_to_cpu be32_to_cpu
135
136 struct au1000_private *au_macs[NUM_ETH_INTERFACES];
137
138 /* FIXME
139 * All of the PHY code really should be detached from the MAC
140 * code.
141 */
142
143 /* Default advertise */
144 #define GENMII_DEFAULT_ADVERTISE \
145 ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \
146 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \
147 ADVERTISED_Autoneg
148
149 #define GENMII_DEFAULT_FEATURES \
150 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | \
151 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | \
152 SUPPORTED_Autoneg
153
154 int bcm_5201_init(struct net_device *dev, int phy_addr)
155 {
156 s16 data;
157
158 /* Stop auto-negotiation */
159 data = mdio_read(dev, phy_addr, MII_CONTROL);
160 mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO);
161
162 /* Set advertisement to 10/100 and Half/Full duplex
163 * (full capabilities) */
164 data = mdio_read(dev, phy_addr, MII_ANADV);
165 data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T;
166 mdio_write(dev, phy_addr, MII_ANADV, data);
167
168 /* Restart auto-negotiation */
169 data = mdio_read(dev, phy_addr, MII_CONTROL);
170 data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO;
171 mdio_write(dev, phy_addr, MII_CONTROL, data);
172
173 if (au1000_debug > 4)
174 dump_mii(dev, phy_addr);
175 return 0;
176 }
177
178 int bcm_5201_reset(struct net_device *dev, int phy_addr)
179 {
180 s16 mii_control, timeout;
181
182 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
183 mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
184 mdelay(1);
185 for (timeout = 100; timeout > 0; --timeout) {
186 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
187 if ((mii_control & MII_CNTL_RESET) == 0)
188 break;
189 mdelay(1);
190 }
191 if (mii_control & MII_CNTL_RESET) {
192 printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
193 return -1;
194 }
195 return 0;
196 }
197
198 int
199 bcm_5201_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
200 {
201 u16 mii_data;
202 struct au1000_private *aup;
203
204 if (!dev) {
205 printk(KERN_ERR "bcm_5201_status error: NULL dev\n");
206 return -1;
207 }
208 aup = (struct au1000_private *) dev->priv;
209
210 mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS);
211 if (mii_data & MII_STAT_LINK) {
212 *link = 1;
213 mii_data = mdio_read(dev, aup->phy_addr, MII_AUX_CNTRL);
214 if (mii_data & MII_AUX_100) {
215 if (mii_data & MII_AUX_FDX) {
216 *speed = IF_PORT_100BASEFX;
217 dev->if_port = IF_PORT_100BASEFX;
218 }
219 else {
220 *speed = IF_PORT_100BASETX;
221 dev->if_port = IF_PORT_100BASETX;
222 }
223 }
224 else {
225 *speed = IF_PORT_10BASET;
226 dev->if_port = IF_PORT_10BASET;
227 }
228
229 }
230 else {
231 *link = 0;
232 *speed = 0;
233 dev->if_port = IF_PORT_UNKNOWN;
234 }
235 return 0;
236 }
237
238 int lsi_80227_init(struct net_device *dev, int phy_addr)
239 {
240 if (au1000_debug > 4)
241 printk("lsi_80227_init\n");
242
243 /* restart auto-negotiation */
244 mdio_write(dev, phy_addr, MII_CONTROL,
245 MII_CNTL_F100 | MII_CNTL_AUTO | MII_CNTL_RST_AUTO); // | MII_CNTL_FDX);
246 mdelay(1);
247
248 /* set up LEDs to correct display */
249 #ifdef CONFIG_MIPS_MTX1
250 mdio_write(dev, phy_addr, 17, 0xff80);
251 #else
252 mdio_write(dev, phy_addr, 17, 0xffc0);
253 #endif
254
255 if (au1000_debug > 4)
256 dump_mii(dev, phy_addr);
257 return 0;
258 }
259
260 int lsi_80227_reset(struct net_device *dev, int phy_addr)
261 {
262 s16 mii_control, timeout;
263
264 if (au1000_debug > 4) {
265 printk("lsi_80227_reset\n");
266 dump_mii(dev, phy_addr);
267 }
268
269 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
270 mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
271 mdelay(1);
272 for (timeout = 100; timeout > 0; --timeout) {
273 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
274 if ((mii_control & MII_CNTL_RESET) == 0)
275 break;
276 mdelay(1);
277 }
278 if (mii_control & MII_CNTL_RESET) {
279 printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
280 return -1;
281 }
282 return 0;
283 }
284
285 int
286 lsi_80227_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
287 {
288 u16 mii_data;
289 struct au1000_private *aup;
290
291 if (!dev) {
292 printk(KERN_ERR "lsi_80227_status error: NULL dev\n");
293 return -1;
294 }
295 aup = (struct au1000_private *) dev->priv;
296
297 mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS);
298 if (mii_data & MII_STAT_LINK) {
299 *link = 1;
300 mii_data = mdio_read(dev, aup->phy_addr, MII_LSI_PHY_STAT);
301 if (mii_data & MII_LSI_PHY_STAT_SPD) {
302 if (mii_data & MII_LSI_PHY_STAT_FDX) {
303 *speed = IF_PORT_100BASEFX;
304 dev->if_port = IF_PORT_100BASEFX;
305 }
306 else {
307 *speed = IF_PORT_100BASETX;
308 dev->if_port = IF_PORT_100BASETX;
309 }
310 }
311 else {
312 *speed = IF_PORT_10BASET;
313 dev->if_port = IF_PORT_10BASET;
314 }
315
316 }
317 else {
318 *link = 0;
319 *speed = 0;
320 dev->if_port = IF_PORT_UNKNOWN;
321 }
322 return 0;
323 }
324
325 int am79c901_init(struct net_device *dev, int phy_addr)
326 {
327 printk("am79c901_init\n");
328 return 0;
329 }
330
331 int am79c901_reset(struct net_device *dev, int phy_addr)
332 {
333 printk("am79c901_reset\n");
334 return 0;
335 }
336
337 int
338 am79c901_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
339 {
340 return 0;
341 }
342
343 int am79c874_init(struct net_device *dev, int phy_addr)
344 {
345 s16 data;
346
347 /* 79c874 has quit resembled bit assignments to BCM5201 */
348 if (au1000_debug > 4)
349 printk("am79c847_init\n");
350
351 /* Stop auto-negotiation */
352 data = mdio_read(dev, phy_addr, MII_CONTROL);
353 mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO);
354
355 /* Set advertisement to 10/100 and Half/Full duplex
356 * (full capabilities) */
357 data = mdio_read(dev, phy_addr, MII_ANADV);
358 data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T;
359 mdio_write(dev, phy_addr, MII_ANADV, data);
360
361 /* Restart auto-negotiation */
362 data = mdio_read(dev, phy_addr, MII_CONTROL);
363 data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO;
364
365 mdio_write(dev, phy_addr, MII_CONTROL, data);
366
367 if (au1000_debug > 4) dump_mii(dev, phy_addr);
368 return 0;
369 }
370
371 int am79c874_reset(struct net_device *dev, int phy_addr)
372 {
373 s16 mii_control, timeout;
374
375 if (au1000_debug > 4)
376 printk("am79c874_reset\n");
377
378 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
379 mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
380 mdelay(1);
381 for (timeout = 100; timeout > 0; --timeout) {
382 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
383 if ((mii_control & MII_CNTL_RESET) == 0)
384 break;
385 mdelay(1);
386 }
387 if (mii_control & MII_CNTL_RESET) {
388 printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
389 return -1;
390 }
391 return 0;
392 }
393
394 int
395 am79c874_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
396 {
397 u16 mii_data;
398 struct au1000_private *aup;
399
400 // printk("am79c874_status\n");
401 if (!dev) {
402 printk(KERN_ERR "am79c874_status error: NULL dev\n");
403 return -1;
404 }
405
406 aup = (struct au1000_private *) dev->priv;
407 mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS);
408
409 if (mii_data & MII_STAT_LINK) {
410 *link = 1;
411 mii_data = mdio_read(dev, aup->phy_addr, MII_AMD_PHY_STAT);
412 if (mii_data & MII_AMD_PHY_STAT_SPD) {
413 if (mii_data & MII_AMD_PHY_STAT_FDX) {
414 *speed = IF_PORT_100BASEFX;
415 dev->if_port = IF_PORT_100BASEFX;
416 }
417 else {
418 *speed = IF_PORT_100BASETX;
419 dev->if_port = IF_PORT_100BASETX;
420 }
421 }
422 else {
423 *speed = IF_PORT_10BASET;
424 dev->if_port = IF_PORT_10BASET;
425 }
426
427 }
428 else {
429 *link = 0;
430 *speed = 0;
431 dev->if_port = IF_PORT_UNKNOWN;
432 }
433 return 0;
434 }
435
436 int lxt971a_init(struct net_device *dev, int phy_addr)
437 {
438 if (au1000_debug > 4)
439 printk("lxt971a_init\n");
440
441 /* restart auto-negotiation */
442 mdio_write(dev, phy_addr, MII_CONTROL,
443 MII_CNTL_F100 | MII_CNTL_AUTO | MII_CNTL_RST_AUTO | MII_CNTL_FDX);
444
445 /* set up LEDs to correct display */
446 mdio_write(dev, phy_addr, 20, 0x0422);
447
448 if (au1000_debug > 4)
449 dump_mii(dev, phy_addr);
450 return 0;
451 }
452
453 int lxt971a_reset(struct net_device *dev, int phy_addr)
454 {
455 s16 mii_control, timeout;
456
457 if (au1000_debug > 4) {
458 printk("lxt971a_reset\n");
459 dump_mii(dev, phy_addr);
460 }
461
462 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
463 mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
464 mdelay(1);
465 for (timeout = 100; timeout > 0; --timeout) {
466 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
467 if ((mii_control & MII_CNTL_RESET) == 0)
468 break;
469 mdelay(1);
470 }
471 if (mii_control & MII_CNTL_RESET) {
472 printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
473 return -1;
474 }
475 return 0;
476 }
477
478 int
479 lxt971a_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
480 {
481 u16 mii_data;
482 struct au1000_private *aup;
483
484 if (!dev) {
485 printk(KERN_ERR "lxt971a_status error: NULL dev\n");
486 return -1;
487 }
488 aup = (struct au1000_private *) dev->priv;
489
490 mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS);
491 if (mii_data & MII_STAT_LINK) {
492 *link = 1;
493 mii_data = mdio_read(dev, aup->phy_addr, MII_INTEL_PHY_STAT);
494 if (mii_data & MII_INTEL_PHY_STAT_SPD) {
495 if (mii_data & MII_INTEL_PHY_STAT_FDX) {
496 *speed = IF_PORT_100BASEFX;
497 dev->if_port = IF_PORT_100BASEFX;
498 }
499 else {
500 *speed = IF_PORT_100BASETX;
501 dev->if_port = IF_PORT_100BASETX;
502 }
503 }
504 else {
505 *speed = IF_PORT_10BASET;
506 dev->if_port = IF_PORT_10BASET;
507 }
508
509 }
510 else {
511 *link = 0;
512 *speed = 0;
513 dev->if_port = IF_PORT_UNKNOWN;
514 }
515 return 0;
516 }
517
518 int ks8995m_init(struct net_device *dev, int phy_addr)
519 {
520 s16 data;
521
522 // printk("ks8995m_init\n");
523 /* Stop auto-negotiation */
524 data = mdio_read(dev, phy_addr, MII_CONTROL);
525 mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO);
526
527 /* Set advertisement to 10/100 and Half/Full duplex
528 * (full capabilities) */
529 data = mdio_read(dev, phy_addr, MII_ANADV);
530 data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T;
531 mdio_write(dev, phy_addr, MII_ANADV, data);
532
533 /* Restart auto-negotiation */
534 data = mdio_read(dev, phy_addr, MII_CONTROL);
535 data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO;
536 mdio_write(dev, phy_addr, MII_CONTROL, data);
537
538 if (au1000_debug > 4) dump_mii(dev, phy_addr);
539
540 return 0;
541 }
542
543 int ks8995m_reset(struct net_device *dev, int phy_addr)
544 {
545 s16 mii_control, timeout;
546
547 // printk("ks8995m_reset\n");
548 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
549 mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
550 mdelay(1);
551 for (timeout = 100; timeout > 0; --timeout) {
552 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
553 if ((mii_control & MII_CNTL_RESET) == 0)
554 break;
555 mdelay(1);
556 }
557 if (mii_control & MII_CNTL_RESET) {
558 printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
559 return -1;
560 }
561 return 0;
562 }
563
564 int ks8995m_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
565 {
566 u16 mii_data;
567 struct au1000_private *aup;
568
569 if (!dev) {
570 printk(KERN_ERR "ks8995m_status error: NULL dev\n");
571 return -1;
572 }
573 aup = (struct au1000_private *) dev->priv;
574
575 mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS);
576 if (mii_data & MII_STAT_LINK) {
577 *link = 1;
578 mii_data = mdio_read(dev, aup->phy_addr, MII_AUX_CNTRL);
579 if (mii_data & MII_AUX_100) {
580 if (mii_data & MII_AUX_FDX) {
581 *speed = IF_PORT_100BASEFX;
582 dev->if_port = IF_PORT_100BASEFX;
583 }
584 else {
585 *speed = IF_PORT_100BASETX;
586 dev->if_port = IF_PORT_100BASETX;
587 }
588 }
589 else {
590 *speed = IF_PORT_10BASET;
591 dev->if_port = IF_PORT_10BASET;
592 }
593
594 }
595 else {
596 *link = 0;
597 *speed = 0;
598 dev->if_port = IF_PORT_UNKNOWN;
599 }
600 return 0;
601 }
602
603 int
604 smsc_83C185_init (struct net_device *dev, int phy_addr)
605 {
606 s16 data;
607
608 if (au1000_debug > 4)
609 printk("smsc_83C185_init\n");
610
611 /* Stop auto-negotiation */
612 data = mdio_read(dev, phy_addr, MII_CONTROL);
613 mdio_write(dev, phy_addr, MII_CONTROL, data & ~MII_CNTL_AUTO);
614
615 /* Set advertisement to 10/100 and Half/Full duplex
616 * (full capabilities) */
617 data = mdio_read(dev, phy_addr, MII_ANADV);
618 data |= MII_NWAY_TX | MII_NWAY_TX_FDX | MII_NWAY_T_FDX | MII_NWAY_T;
619 mdio_write(dev, phy_addr, MII_ANADV, data);
620
621 /* Restart auto-negotiation */
622 data = mdio_read(dev, phy_addr, MII_CONTROL);
623 data |= MII_CNTL_RST_AUTO | MII_CNTL_AUTO;
624
625 mdio_write(dev, phy_addr, MII_CONTROL, data);
626
627 if (au1000_debug > 4) dump_mii(dev, phy_addr);
628 return 0;
629 }
630
631 int
632 smsc_83C185_reset (struct net_device *dev, int phy_addr)
633 {
634 s16 mii_control, timeout;
635
636 if (au1000_debug > 4)
637 printk("smsc_83C185_reset\n");
638
639 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
640 mdio_write(dev, phy_addr, MII_CONTROL, mii_control | MII_CNTL_RESET);
641 mdelay(1);
642 for (timeout = 100; timeout > 0; --timeout) {
643 mii_control = mdio_read(dev, phy_addr, MII_CONTROL);
644 if ((mii_control & MII_CNTL_RESET) == 0)
645 break;
646 mdelay(1);
647 }
648 if (mii_control & MII_CNTL_RESET) {
649 printk(KERN_ERR "%s PHY reset timeout !\n", dev->name);
650 return -1;
651 }
652 return 0;
653 }
654
655 int
656 smsc_83C185_status (struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
657 {
658 u16 mii_data;
659 struct au1000_private *aup;
660
661 if (!dev) {
662 printk(KERN_ERR "smsc_83C185_status error: NULL dev\n");
663 return -1;
664 }
665
666 aup = (struct au1000_private *) dev->priv;
667 mii_data = mdio_read(dev, aup->phy_addr, MII_STATUS);
668
669 if (mii_data & MII_STAT_LINK) {
670 *link = 1;
671 mii_data = mdio_read(dev, aup->phy_addr, 0x1f);
672 if (mii_data & (1<<3)) {
673 if (mii_data & (1<<4)) {
674 *speed = IF_PORT_100BASEFX;
675 dev->if_port = IF_PORT_100BASEFX;
676 }
677 else {
678 *speed = IF_PORT_100BASETX;
679 dev->if_port = IF_PORT_100BASETX;
680 }
681 }
682 else {
683 *speed = IF_PORT_10BASET;
684 dev->if_port = IF_PORT_10BASET;
685 }
686 }
687 else {
688 *link = 0;
689 *speed = 0;
690 dev->if_port = IF_PORT_UNKNOWN;
691 }
692 return 0;
693 }
694
695
696 #ifdef CONFIG_MIPS_BOSPORUS
697 int stub_init(struct net_device *dev, int phy_addr)
698 {
699 //printk("PHY stub_init\n");
700 return 0;
701 }
702
703 int stub_reset(struct net_device *dev, int phy_addr)
704 {
705 //printk("PHY stub_reset\n");
706 return 0;
707 }
708
709 int
710 stub_status(struct net_device *dev, int phy_addr, u16 *link, u16 *speed)
711 {
712 //printk("PHY stub_status\n");
713 *link = 1;
714 /* hmmm, revisit */
715 *speed = IF_PORT_100BASEFX;
716 dev->if_port = IF_PORT_100BASEFX;
717 return 0;
718 }
719 #endif
720
721 struct phy_ops bcm_5201_ops = {
722 bcm_5201_init,
723 bcm_5201_reset,
724 bcm_5201_status,
725 };
726
727 struct phy_ops am79c874_ops = {
728 am79c874_init,
729 am79c874_reset,
730 am79c874_status,
731 };
732
733 struct phy_ops am79c901_ops = {
734 am79c901_init,
735 am79c901_reset,
736 am79c901_status,
737 };
738
739 struct phy_ops lsi_80227_ops = {
740 lsi_80227_init,
741 lsi_80227_reset,
742 lsi_80227_status,
743 };
744
745 struct phy_ops lxt971a_ops = {
746 lxt971a_init,
747 lxt971a_reset,
748 lxt971a_status,
749 };
750
751 struct phy_ops ks8995m_ops = {
752 ks8995m_init,
753 ks8995m_reset,
754 ks8995m_status,
755 };
756
757 struct phy_ops smsc_83C185_ops = {
758 smsc_83C185_init,
759 smsc_83C185_reset,
760 smsc_83C185_status,
761 };
762
763 #ifdef CONFIG_MIPS_BOSPORUS
764 struct phy_ops stub_ops = {
765 stub_init,
766 stub_reset,
767 stub_status,
768 };
769 #endif
770
771 static struct mii_chip_info {
772 const char * name;
773 u16 phy_id0;
774 u16 phy_id1;
775 struct phy_ops *phy_ops;
776 int dual_phy;
777 } mii_chip_table[] = {
778 {"Broadcom BCM5201 10/100 BaseT PHY",0x0040,0x6212, &bcm_5201_ops,0},
779 {"Broadcom BCM5221 10/100 BaseT PHY",0x0040,0x61e4, &bcm_5201_ops,0},
780 {"Broadcom BCM5222 10/100 BaseT PHY",0x0040,0x6322, &bcm_5201_ops,1},
781 {"NS DP83847 PHY", 0x2000, 0x5c30, &bcm_5201_ops ,0},
782 {"AMD 79C901 HomePNA PHY",0x0000,0x35c8, &am79c901_ops,0},
783 {"AMD 79C874 10/100 BaseT PHY",0x0022,0x561b, &am79c874_ops,0},
784 {"LSI 80227 10/100 BaseT PHY",0x0016,0xf840, &lsi_80227_ops,0},
785 {"Intel LXT971A Dual Speed PHY",0x0013,0x78e2, &lxt971a_ops,0},
786 {"Kendin KS8995M 10/100 BaseT PHY",0x0022,0x1450, &ks8995m_ops,0},
787 {"SMSC LAN83C185 10/100 BaseT PHY",0x0007,0xc0a3, &smsc_83C185_ops,0},
788 #ifdef CONFIG_MIPS_BOSPORUS
789 {"Stub", 0x1234, 0x5678, &stub_ops },
790 #endif
791 {0,},
792 };
793
794 static int mdio_read(struct net_device *dev, int phy_id, int reg)
795 {
796 struct au1000_private *aup = (struct au1000_private *) dev->priv;
797 volatile u32 *mii_control_reg;
798 volatile u32 *mii_data_reg;
799 u32 timedout = 20;
800 u32 mii_control;
801
802 #ifdef CONFIG_BCM5222_DUAL_PHY
803 /* First time we probe, it's for the mac0 phy.
804 * Since we haven't determined yet that we have a dual phy,
805 * aup->mii->mii_control_reg won't be setup and we'll
806 * default to the else statement.
807 * By the time we probe for the mac1 phy, the mii_control_reg
808 * will be setup to be the address of the mac0 phy control since
809 * both phys are controlled through mac0.
810 */
811 if (aup->mii && aup->mii->mii_control_reg) {
812 mii_control_reg = aup->mii->mii_control_reg;
813 mii_data_reg = aup->mii->mii_data_reg;
814 }
815 else if (au_macs[0]->mii && au_macs[0]->mii->mii_control_reg) {
816 /* assume both phys are controlled through mac0 */
817 mii_control_reg = au_macs[0]->mii->mii_control_reg;
818 mii_data_reg = au_macs[0]->mii->mii_data_reg;
819 }
820 else
821 #endif
822 {
823 /* default control and data reg addresses */
824 mii_control_reg = &aup->mac->mii_control;
825 mii_data_reg = &aup->mac->mii_data;
826 }
827
828 while (*mii_control_reg & MAC_MII_BUSY) {
829 mdelay(1);
830 if (--timedout == 0) {
831 printk(KERN_ERR "%s: read_MII busy timeout!!\n",
832 dev->name);
833 return -1;
834 }
835 }
836
837 mii_control = MAC_SET_MII_SELECT_REG(reg) |
838 MAC_SET_MII_SELECT_PHY(phy_id) | MAC_MII_READ;
839
840 *mii_control_reg = mii_control;
841
842 timedout = 20;
843 while (*mii_control_reg & MAC_MII_BUSY) {
844 mdelay(1);
845 if (--timedout == 0) {
846 printk(KERN_ERR "%s: mdio_read busy timeout!!\n",
847 dev->name);
848 return -1;
849 }
850 }
851 return (int)*mii_data_reg;
852 }
853
854 static void mdio_write(struct net_device *dev, int phy_id, int reg, u16 value)
855 {
856 struct au1000_private *aup = (struct au1000_private *) dev->priv;
857 volatile u32 *mii_control_reg;
858 volatile u32 *mii_data_reg;
859 u32 timedout = 20;
860 u32 mii_control;
861
862 #ifdef CONFIG_BCM5222_DUAL_PHY
863 if (aup->mii && aup->mii->mii_control_reg) {
864 mii_control_reg = aup->mii->mii_control_reg;
865 mii_data_reg = aup->mii->mii_data_reg;
866 }
867 else if (au_macs[0]->mii && au_macs[0]->mii->mii_control_reg) {
868 /* assume both phys are controlled through mac0 */
869 mii_control_reg = au_macs[0]->mii->mii_control_reg;
870 mii_data_reg = au_macs[0]->mii->mii_data_reg;
871 }
872 else
873 #endif
874 {
875 /* default control and data reg addresses */
876 mii_control_reg = &aup->mac->mii_control;
877 mii_data_reg = &aup->mac->mii_data;
878 }
879
880 while (*mii_control_reg & MAC_MII_BUSY) {
881 mdelay(1);
882 if (--timedout == 0) {
883 printk(KERN_ERR "%s: mdio_write busy timeout!!\n",
884 dev->name);
885 return;
886 }
887 }
888
889 mii_control = MAC_SET_MII_SELECT_REG(reg) |
890 MAC_SET_MII_SELECT_PHY(phy_id) | MAC_MII_WRITE;
891
892 *mii_data_reg = value;
893 *mii_control_reg = mii_control;
894 }
895
896
897 static void dump_mii(struct net_device *dev, int phy_id)
898 {
899 int i, val;
900
901 for (i = 0; i < 7; i++) {
902 if ((val = mdio_read(dev, phy_id, i)) >= 0)
903 printk("%s: MII Reg %d=%x\n", dev->name, i, val);
904 }
905 for (i = 16; i < 25; i++) {
906 if ((val = mdio_read(dev, phy_id, i)) >= 0)
907 printk("%s: MII Reg %d=%x\n", dev->name, i, val);
908 }
909 }
910
911 static int mii_probe (struct net_device * dev)
912 {
913 struct au1000_private *aup = (struct au1000_private *) dev->priv;
914 int phy_addr;
915 #ifdef CONFIG_MIPS_BOSPORUS
916 int phy_found=0;
917 #endif
918
919 /* search for total of 32 possible mii phy addresses */
920 for (phy_addr = 0; phy_addr < 32; phy_addr++) {
921 u16 mii_status;
922 u16 phy_id0, phy_id1;
923 int i;
924
925 #ifdef CONFIG_BCM5222_DUAL_PHY
926 /* Mask the already found phy, try next one */
927 if (au_macs[0]->mii && au_macs[0]->mii->mii_control_reg) {
928 if (au_macs[0]->phy_addr == phy_addr)
929 continue;
930 }
931 #endif
932
933 mii_status = mdio_read(dev, phy_addr, MII_STATUS);
934 if (mii_status == 0xffff || mii_status == 0x0000)
935 /* the mii is not accessable, try next one */
936 continue;
937
938 phy_id0 = mdio_read(dev, phy_addr, MII_PHY_ID0);
939 phy_id1 = mdio_read(dev, phy_addr, MII_PHY_ID1);
940
941 /* search our mii table for the current mii */
942 for (i = 0; mii_chip_table[i].phy_id1; i++) {
943 if (phy_id0 == mii_chip_table[i].phy_id0 &&
944 phy_id1 == mii_chip_table[i].phy_id1) {
945 struct mii_phy * mii_phy = aup->mii;
946
947 printk(KERN_INFO "%s: %s at phy address %d\n",
948 dev->name, mii_chip_table[i].name,
949 phy_addr);
950 #ifdef CONFIG_MIPS_BOSPORUS
951 phy_found = 1;
952 #endif
953 mii_phy->chip_info = mii_chip_table+i;
954 aup->phy_addr = phy_addr;
955 aup->want_autoneg = 1;
956 aup->phy_ops = mii_chip_table[i].phy_ops;
957 aup->phy_ops->phy_init(dev,phy_addr);
958
959 // Check for dual-phy and then store required
960 // values and set indicators. We need to do
961 // this now since mdio_{read,write} need the
962 // control and data register addresses.
963 #ifdef CONFIG_BCM5222_DUAL_PHY
964 if ( mii_chip_table[i].dual_phy) {
965
966 /* assume both phys are controlled
967 * through MAC0. Board specific? */
968
969 /* sanity check */
970 if (!au_macs[0] || !au_macs[0]->mii)
971 return -1;
972 aup->mii->mii_control_reg = (u32 *)
973 &au_macs[0]->mac->mii_control;
974 aup->mii->mii_data_reg = (u32 *)
975 &au_macs[0]->mac->mii_data;
976 }
977 #endif
978 goto found;
979 }
980 }
981 }
982 found:
983
984 #ifdef CONFIG_MIPS_BOSPORUS
985 /* This is a workaround for the Micrel/Kendin 5 port switch
986 The second MAC doesn't see a PHY connected... so we need to
987 trick it into thinking we have one.
988
989 If this kernel is run on another Au1500 development board
990 the stub will be found as well as the actual PHY. However,
991 the last found PHY will be used... usually at Addr 31 (Db1500).
992 */
993 if ( (!phy_found) )
994 {
995 u16 phy_id0, phy_id1;
996 int i;
997
998 phy_id0 = 0x1234;
999 phy_id1 = 0x5678;
1000
1001 /* search our mii table for the current mii */
1002 for (i = 0; mii_chip_table[i].phy_id1; i++) {
1003 if (phy_id0 == mii_chip_table[i].phy_id0 &&
1004 phy_id1 == mii_chip_table[i].phy_id1) {
1005 struct mii_phy * mii_phy;
1006
1007 printk(KERN_INFO "%s: %s at phy address %d\n",
1008 dev->name, mii_chip_table[i].name,
1009 phy_addr);
1010 mii_phy = kmalloc(sizeof(struct mii_phy),
1011 GFP_KERNEL);
1012 if (mii_phy) {
1013 mii_phy->chip_info = mii_chip_table+i;
1014 aup->phy_addr = phy_addr;
1015 mii_phy->next = aup->mii;
1016 aup->phy_ops =
1017 mii_chip_table[i].phy_ops;
1018 aup->mii = mii_phy;
1019 aup->phy_ops->phy_init(dev,phy_addr);
1020 } else {
1021 printk(KERN_ERR "%s: out of memory\n",
1022 dev->name);
1023 return -1;
1024 }
1025 mii_phy->chip_info = mii_chip_table+i;
1026 aup->phy_addr = phy_addr;
1027 aup->phy_ops = mii_chip_table[i].phy_ops;
1028 aup->phy_ops->phy_init(dev,phy_addr);
1029 break;
1030 }
1031 }
1032 }
1033 if (aup->mac_id == 0) {
1034 /* the Bosporus phy responds to addresses 0-5 but
1035 * 5 is the correct one.
1036 */
1037 aup->phy_addr = 5;
1038 }
1039 #endif
1040
1041 if (aup->mii->chip_info == NULL) {
1042 printk(KERN_ERR "%s: Au1x No known MII transceivers found!\n",
1043 dev->name);
1044 return -1;
1045 }
1046
1047 printk(KERN_INFO "%s: Using %s as default\n",
1048 dev->name, aup->mii->chip_info->name);
1049
1050 return 0;
1051 }
1052
1053
1054 /*
1055 * Buffer allocation/deallocation routines. The buffer descriptor returned
1056 * has the virtual and dma address of a buffer suitable for
1057 * both, receive and transmit operations.
1058 */
1059 static db_dest_t *GetFreeDB(struct au1000_private *aup)
1060 {
1061 db_dest_t *pDB;
1062 pDB = aup->pDBfree;
1063
1064 if (pDB) {
1065 aup->pDBfree = pDB->pnext;
1066 }
1067 return pDB;
1068 }
1069
1070 void ReleaseDB(struct au1000_private *aup, db_dest_t *pDB)
1071 {
1072 db_dest_t *pDBfree = aup->pDBfree;
1073 if (pDBfree)
1074 pDBfree->pnext = pDB;
1075 aup->pDBfree = pDB;
1076 }
1077
1078 static void enable_rx_tx(struct net_device *dev)
1079 {
1080 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1081
1082 if (au1000_debug > 4)
1083 printk(KERN_INFO "%s: enable_rx_tx\n", dev->name);
1084
1085 aup->mac->control |= (MAC_RX_ENABLE | MAC_TX_ENABLE);
1086 au_sync_delay(10);
1087 }
1088
1089 static void hard_stop(struct net_device *dev)
1090 {
1091 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1092
1093 if (au1000_debug > 4)
1094 printk(KERN_INFO "%s: hard stop\n", dev->name);
1095
1096 aup->mac->control &= ~(MAC_RX_ENABLE | MAC_TX_ENABLE);
1097 au_sync_delay(10);
1098 }
1099
1100
1101 static void reset_mac(struct net_device *dev)
1102 {
1103 int i;
1104 u32 flags;
1105 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1106
1107 if (au1000_debug > 4)
1108 printk(KERN_INFO "%s: reset mac, aup %x\n",
1109 dev->name, (unsigned)aup);
1110
1111 spin_lock_irqsave(&aup->lock, flags);
1112 if (aup->timer.function == &au1000_timer) {/* check if timer initted */
1113 del_timer(&aup->timer);
1114 }
1115
1116 hard_stop(dev);
1117 #ifdef CONFIG_BCM5222_DUAL_PHY
1118 if (aup->mac_id != 0) {
1119 #endif
1120 /* If BCM5222, we can't leave MAC0 in reset because then
1121 * we can't access the dual phy for ETH1 */
1122 *aup->enable = MAC_EN_CLOCK_ENABLE;
1123 au_sync_delay(2);
1124 *aup->enable = 0;
1125 au_sync_delay(2);
1126 #ifdef CONFIG_BCM5222_DUAL_PHY
1127 }
1128 #endif
1129 aup->tx_full = 0;
1130 for (i = 0; i < NUM_RX_DMA; i++) {
1131 /* reset control bits */
1132 aup->rx_dma_ring[i]->buff_stat &= ~0xf;
1133 }
1134 for (i = 0; i < NUM_TX_DMA; i++) {
1135 /* reset control bits */
1136 aup->tx_dma_ring[i]->buff_stat &= ~0xf;
1137 }
1138 spin_unlock_irqrestore(&aup->lock, flags);
1139 }
1140
1141
1142 /*
1143 * Setup the receive and transmit "rings". These pointers are the addresses
1144 * of the rx and tx MAC DMA registers so they are fixed by the hardware --
1145 * these are not descriptors sitting in memory.
1146 */
1147 static void
1148 setup_hw_rings(struct au1000_private *aup, u32 rx_base, u32 tx_base)
1149 {
1150 int i;
1151
1152 for (i = 0; i < NUM_RX_DMA; i++) {
1153 aup->rx_dma_ring[i] =
1154 (volatile rx_dma_t *) (rx_base + sizeof(rx_dma_t)*i);
1155 }
1156 for (i = 0; i < NUM_TX_DMA; i++) {
1157 aup->tx_dma_ring[i] =
1158 (volatile tx_dma_t *) (tx_base + sizeof(tx_dma_t)*i);
1159 }
1160 }
1161
1162 static struct {
1163 int port;
1164 u32 base_addr;
1165 u32 macen_addr;
1166 int irq;
1167 struct net_device *dev;
1168 } iflist[2];
1169
1170 static int num_ifs;
1171
1172 /*
1173 * Setup the base address and interupt of the Au1xxx ethernet macs
1174 * based on cpu type and whether the interface is enabled in sys_pinfunc
1175 * register. The last interface is enabled if SYS_PF_NI2 (bit 4) is 0.
1176 */
1177 static int __init au1000_init_module(void)
1178 {
1179 struct cpuinfo_mips *c = &current_cpu_data;
1180 int ni = (int)((au_readl(SYS_PINFUNC) & (u32)(SYS_PF_NI2)) >> 4);
1181 struct net_device *dev;
1182 int i, found_one = 0;
1183
1184 switch (c->cputype) {
1185 #ifdef CONFIG_SOC_AU1000
1186 case CPU_AU1000:
1187 num_ifs = 2 - ni;
1188 iflist[0].base_addr = AU1000_ETH0_BASE;
1189 iflist[1].base_addr = AU1000_ETH1_BASE;
1190 iflist[0].macen_addr = AU1000_MAC0_ENABLE;
1191 iflist[1].macen_addr = AU1000_MAC1_ENABLE;
1192 iflist[0].irq = AU1000_MAC0_DMA_INT;
1193 iflist[1].irq = AU1000_MAC1_DMA_INT;
1194 break;
1195 #endif
1196 #ifdef CONFIG_SOC_AU1100
1197 case CPU_AU1100:
1198 num_ifs = 1 - ni;
1199 iflist[0].base_addr = AU1100_ETH0_BASE;
1200 iflist[0].macen_addr = AU1100_MAC0_ENABLE;
1201 iflist[0].irq = AU1100_MAC0_DMA_INT;
1202 break;
1203 #endif
1204 #ifdef CONFIG_SOC_AU1500
1205 case CPU_AU1500:
1206 num_ifs = 2 - ni;
1207 iflist[0].base_addr = AU1500_ETH0_BASE;
1208 iflist[1].base_addr = AU1500_ETH1_BASE;
1209 iflist[0].macen_addr = AU1500_MAC0_ENABLE;
1210 iflist[1].macen_addr = AU1500_MAC1_ENABLE;
1211 iflist[0].irq = AU1500_MAC0_DMA_INT;
1212 iflist[1].irq = AU1500_MAC1_DMA_INT;
1213 break;
1214 #endif
1215 #ifdef CONFIG_SOC_AU1550
1216 case CPU_AU1550:
1217 num_ifs = 2 - ni;
1218 iflist[0].base_addr = AU1550_ETH0_BASE;
1219 iflist[1].base_addr = AU1550_ETH1_BASE;
1220 iflist[0].macen_addr = AU1550_MAC0_ENABLE;
1221 iflist[1].macen_addr = AU1550_MAC1_ENABLE;
1222 iflist[0].irq = AU1550_MAC0_DMA_INT;
1223 iflist[1].irq = AU1550_MAC1_DMA_INT;
1224 break;
1225 #endif
1226 default:
1227 num_ifs = 0;
1228 }
1229 for(i = 0; i < num_ifs; i++) {
1230 dev = au1000_probe(iflist[i].base_addr, iflist[i].irq, i);
1231 iflist[i].dev = dev;
1232 if (dev)
1233 found_one++;
1234 }
1235 if (!found_one)
1236 return -ENODEV;
1237 return 0;
1238 }
1239
1240 static int au1000_setup_aneg(struct net_device *dev, u32 advertise)
1241 {
1242 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1243 u16 ctl, adv;
1244
1245 /* Setup standard advertise */
1246 adv = mdio_read(dev, aup->phy_addr, MII_ADVERTISE);
1247 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
1248 if (advertise & ADVERTISED_10baseT_Half)
1249 adv |= ADVERTISE_10HALF;
1250 if (advertise & ADVERTISED_10baseT_Full)
1251 adv |= ADVERTISE_10FULL;
1252 if (advertise & ADVERTISED_100baseT_Half)
1253 adv |= ADVERTISE_100HALF;
1254 if (advertise & ADVERTISED_100baseT_Full)
1255 adv |= ADVERTISE_100FULL;
1256 mdio_write(dev, aup->phy_addr, MII_ADVERTISE, adv);
1257
1258 /* Start/Restart aneg */
1259 ctl = mdio_read(dev, aup->phy_addr, MII_BMCR);
1260 ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
1261 mdio_write(dev, aup->phy_addr, MII_BMCR, ctl);
1262
1263 return 0;
1264 }
1265
1266 static int au1000_setup_forced(struct net_device *dev, int speed, int fd)
1267 {
1268 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1269 u16 ctl;
1270
1271 ctl = mdio_read(dev, aup->phy_addr, MII_BMCR);
1272 ctl &= ~(BMCR_FULLDPLX | BMCR_SPEED100 | BMCR_ANENABLE);
1273
1274 /* First reset the PHY */
1275 mdio_write(dev, aup->phy_addr, MII_BMCR, ctl | BMCR_RESET);
1276
1277 /* Select speed & duplex */
1278 switch (speed) {
1279 case SPEED_10:
1280 break;
1281 case SPEED_100:
1282 ctl |= BMCR_SPEED100;
1283 break;
1284 case SPEED_1000:
1285 default:
1286 return -EINVAL;
1287 }
1288 if (fd == DUPLEX_FULL)
1289 ctl |= BMCR_FULLDPLX;
1290 mdio_write(dev, aup->phy_addr, MII_BMCR, ctl);
1291
1292 return 0;
1293 }
1294
1295
1296 static void
1297 au1000_start_link(struct net_device *dev, struct ethtool_cmd *cmd)
1298 {
1299 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1300 u32 advertise;
1301 int autoneg;
1302 int forced_speed;
1303 int forced_duplex;
1304
1305 /* Default advertise */
1306 advertise = GENMII_DEFAULT_ADVERTISE;
1307 autoneg = aup->want_autoneg;
1308 forced_speed = SPEED_100;
1309 forced_duplex = DUPLEX_FULL;
1310
1311 /* Setup link parameters */
1312 if (cmd) {
1313 if (cmd->autoneg == AUTONEG_ENABLE) {
1314 advertise = cmd->advertising;
1315 autoneg = 1;
1316 } else {
1317 autoneg = 0;
1318
1319 forced_speed = cmd->speed;
1320 forced_duplex = cmd->duplex;
1321 }
1322 }
1323
1324 /* Configure PHY & start aneg */
1325 aup->want_autoneg = autoneg;
1326 if (autoneg)
1327 au1000_setup_aneg(dev, advertise);
1328 else
1329 au1000_setup_forced(dev, forced_speed, forced_duplex);
1330 mod_timer(&aup->timer, jiffies + HZ);
1331 }
1332
1333 static int au1000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1334 {
1335 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1336 u16 link, speed;
1337
1338 cmd->supported = GENMII_DEFAULT_FEATURES;
1339 cmd->advertising = GENMII_DEFAULT_ADVERTISE;
1340 cmd->port = PORT_MII;
1341 cmd->transceiver = XCVR_EXTERNAL;
1342 cmd->phy_address = aup->phy_addr;
1343 spin_lock_irq(&aup->lock);
1344 cmd->autoneg = aup->want_autoneg;
1345 aup->phy_ops->phy_status(dev, aup->phy_addr, &link, &speed);
1346 if ((speed == IF_PORT_100BASETX) || (speed == IF_PORT_100BASEFX))
1347 cmd->speed = SPEED_100;
1348 else if (speed == IF_PORT_10BASET)
1349 cmd->speed = SPEED_10;
1350 if (link && (dev->if_port == IF_PORT_100BASEFX))
1351 cmd->duplex = DUPLEX_FULL;
1352 else
1353 cmd->duplex = DUPLEX_HALF;
1354 spin_unlock_irq(&aup->lock);
1355 return 0;
1356 }
1357
1358 static int au1000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1359 {
1360 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1361 unsigned long features = GENMII_DEFAULT_FEATURES;
1362
1363 if (!capable(CAP_NET_ADMIN))
1364 return -EPERM;
1365
1366 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
1367 return -EINVAL;
1368 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
1369 return -EINVAL;
1370 if (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL)
1371 return -EINVAL;
1372 if (cmd->autoneg == AUTONEG_DISABLE)
1373 switch (cmd->speed) {
1374 case SPEED_10:
1375 if (cmd->duplex == DUPLEX_HALF &&
1376 (features & SUPPORTED_10baseT_Half) == 0)
1377 return -EINVAL;
1378 if (cmd->duplex == DUPLEX_FULL &&
1379 (features & SUPPORTED_10baseT_Full) == 0)
1380 return -EINVAL;
1381 break;
1382 case SPEED_100:
1383 if (cmd->duplex == DUPLEX_HALF &&
1384 (features & SUPPORTED_100baseT_Half) == 0)
1385 return -EINVAL;
1386 if (cmd->duplex == DUPLEX_FULL &&
1387 (features & SUPPORTED_100baseT_Full) == 0)
1388 return -EINVAL;
1389 break;
1390 default:
1391 return -EINVAL;
1392 }
1393 else if ((features & SUPPORTED_Autoneg) == 0)
1394 return -EINVAL;
1395
1396 spin_lock_irq(&aup->lock);
1397 au1000_start_link(dev, cmd);
1398 spin_unlock_irq(&aup->lock);
1399 return 0;
1400 }
1401
1402 static int au1000_nway_reset(struct net_device *dev)
1403 {
1404 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1405
1406 if (!aup->want_autoneg)
1407 return -EINVAL;
1408 spin_lock_irq(&aup->lock);
1409 au1000_start_link(dev, NULL);
1410 spin_unlock_irq(&aup->lock);
1411 return 0;
1412 }
1413
1414 static void
1415 au1000_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1416 {
1417 struct au1000_private *aup = (struct au1000_private *)dev->priv;
1418
1419 strcpy(info->driver, DRV_NAME);
1420 strcpy(info->version, DRV_VERSION);
1421 info->fw_version[0] = '\0';
1422 sprintf(info->bus_info, "%s %d", DRV_NAME, aup->mac_id);
1423 info->regdump_len = 0;
1424 }
1425
1426 static u32 au1000_get_link(struct net_device *dev)
1427 {
1428 return netif_carrier_ok(dev);
1429 }
1430
1431 static struct ethtool_ops au1000_ethtool_ops = {
1432 .get_settings = au1000_get_settings,
1433 .set_settings = au1000_set_settings,
1434 .get_drvinfo = au1000_get_drvinfo,
1435 .nway_reset = au1000_nway_reset,
1436 .get_link = au1000_get_link
1437 };
1438
1439 static struct net_device *
1440 au1000_probe(u32 ioaddr, int irq, int port_num)
1441 {
1442 static unsigned version_printed = 0;
1443 struct au1000_private *aup = NULL;
1444 struct net_device *dev = NULL;
1445 db_dest_t *pDB, *pDBfree;
1446 char *pmac, *argptr;
1447 char ethaddr[6];
1448 int i, err;
1449
1450 if (!request_mem_region(CPHYSADDR(ioaddr), MAC_IOSIZE, "Au1x00 ENET"))
1451 return NULL;
1452
1453 if (version_printed++ == 0)
1454 printk("%s version %s %s\n", DRV_NAME, DRV_VERSION, DRV_AUTHOR);
1455
1456 dev = alloc_etherdev(sizeof(struct au1000_private));
1457 if (!dev) {
1458 printk (KERN_ERR "au1000 eth: alloc_etherdev failed\n");
1459 return NULL;
1460 }
1461
1462 if ((err = register_netdev(dev))) {
1463 printk(KERN_ERR "Au1x_eth Cannot register net device err %d\n",
1464 err);
1465 free_netdev(dev);
1466 return NULL;
1467 }
1468
1469 printk("%s: Au1x Ethernet found at 0x%x, irq %d\n",
1470 dev->name, ioaddr, irq);
1471
1472 aup = dev->priv;
1473
1474 /* Allocate the data buffers */
1475 /* Snooping works fine with eth on all au1xxx */
1476 aup->vaddr = (u32)dma_alloc_noncoherent(NULL,
1477 MAX_BUF_SIZE * (NUM_TX_BUFFS+NUM_RX_BUFFS),
1478 &aup->dma_addr,
1479 0);
1480 if (!aup->vaddr) {
1481 free_netdev(dev);
1482 release_mem_region(CPHYSADDR(ioaddr), MAC_IOSIZE);
1483 return NULL;
1484 }
1485
1486 /* aup->mac is the base address of the MAC's registers */
1487 aup->mac = (volatile mac_reg_t *)((unsigned long)ioaddr);
1488 /* Setup some variables for quick register address access */
1489 if (ioaddr == iflist[0].base_addr)
1490 {
1491 /* check env variables first */
1492 if (!get_ethernet_addr(ethaddr)) {
1493 memcpy(au1000_mac_addr, ethaddr, sizeof(au1000_mac_addr));
1494 } else {
1495 /* Check command line */
1496 argptr = prom_getcmdline();
1497 if ((pmac = strstr(argptr, "ethaddr=")) == NULL) {
1498 printk(KERN_INFO "%s: No mac address found\n",
1499 dev->name);
1500 /* use the hard coded mac addresses */
1501 } else {
1502 str2eaddr(ethaddr, pmac + strlen("ethaddr="));
1503 memcpy(au1000_mac_addr, ethaddr,
1504 sizeof(au1000_mac_addr));
1505 }
1506 }
1507 aup->enable = (volatile u32 *)
1508 ((unsigned long)iflist[0].macen_addr);
1509 memcpy(dev->dev_addr, au1000_mac_addr, sizeof(au1000_mac_addr));
1510 setup_hw_rings(aup, MAC0_RX_DMA_ADDR, MAC0_TX_DMA_ADDR);
1511 aup->mac_id = 0;
1512 au_macs[0] = aup;
1513 }
1514 else
1515 if (ioaddr == iflist[1].base_addr)
1516 {
1517 aup->enable = (volatile u32 *)
1518 ((unsigned long)iflist[1].macen_addr);
1519 memcpy(dev->dev_addr, au1000_mac_addr, sizeof(au1000_mac_addr));
1520 dev->dev_addr[4] += 0x10;
1521 setup_hw_rings(aup, MAC1_RX_DMA_ADDR, MAC1_TX_DMA_ADDR);
1522 aup->mac_id = 1;
1523 au_macs[1] = aup;
1524 }
1525 else
1526 {
1527 printk(KERN_ERR "%s: bad ioaddr\n", dev->name);
1528 }
1529
1530 /* bring the device out of reset, otherwise probing the mii
1531 * will hang */
1532 *aup->enable = MAC_EN_CLOCK_ENABLE;
1533 au_sync_delay(2);
1534 *aup->enable = MAC_EN_RESET0 | MAC_EN_RESET1 |
1535 MAC_EN_RESET2 | MAC_EN_CLOCK_ENABLE;
1536 au_sync_delay(2);
1537
1538 aup->mii = kmalloc(sizeof(struct mii_phy), GFP_KERNEL);
1539 if (!aup->mii) {
1540 printk(KERN_ERR "%s: out of memory\n", dev->name);
1541 goto err_out;
1542 }
1543 aup->mii->next = NULL;
1544 aup->mii->chip_info = NULL;
1545 aup->mii->status = 0;
1546 aup->mii->mii_control_reg = 0;
1547 aup->mii->mii_data_reg = 0;
1548
1549 if (mii_probe(dev) != 0) {
1550 goto err_out;
1551 }
1552
1553 pDBfree = NULL;
1554 /* setup the data buffer descriptors and attach a buffer to each one */
1555 pDB = aup->db;
1556 for (i = 0; i < (NUM_TX_BUFFS+NUM_RX_BUFFS); i++) {
1557 pDB->pnext = pDBfree;
1558 pDBfree = pDB;
1559 pDB->vaddr = (u32 *)((unsigned)aup->vaddr + MAX_BUF_SIZE*i);
1560 pDB->dma_addr = (dma_addr_t)virt_to_bus(pDB->vaddr);
1561 pDB++;
1562 }
1563 aup->pDBfree = pDBfree;
1564
1565 for (i = 0; i < NUM_RX_DMA; i++) {
1566 pDB = GetFreeDB(aup);
1567 if (!pDB) {
1568 goto err_out;
1569 }
1570 aup->rx_dma_ring[i]->buff_stat = (unsigned)pDB->dma_addr;
1571 aup->rx_db_inuse[i] = pDB;
1572 }
1573 for (i = 0; i < NUM_TX_DMA; i++) {
1574 pDB = GetFreeDB(aup);
1575 if (!pDB) {
1576 goto err_out;
1577 }
1578 aup->tx_dma_ring[i]->buff_stat = (unsigned)pDB->dma_addr;
1579 aup->tx_dma_ring[i]->len = 0;
1580 aup->tx_db_inuse[i] = pDB;
1581 }
1582
1583 spin_lock_init(&aup->lock);
1584 dev->base_addr = ioaddr;
1585 dev->irq = irq;
1586 dev->open = au1000_open;
1587 dev->hard_start_xmit = au1000_tx;
1588 dev->stop = au1000_close;
1589 dev->get_stats = au1000_get_stats;
1590 dev->set_multicast_list = &set_rx_mode;
1591 dev->do_ioctl = &au1000_ioctl;
1592 SET_ETHTOOL_OPS(dev, &au1000_ethtool_ops);
1593 dev->set_config = &au1000_set_config;
1594 dev->tx_timeout = au1000_tx_timeout;
1595 dev->watchdog_timeo = ETH_TX_TIMEOUT;
1596
1597 /*
1598 * The boot code uses the ethernet controller, so reset it to start
1599 * fresh. au1000_init() expects that the device is in reset state.
1600 */
1601 reset_mac(dev);
1602
1603 return dev;
1604
1605 err_out:
1606 /* here we should have a valid dev plus aup-> register addresses
1607 * so we can reset the mac properly.*/
1608 reset_mac(dev);
1609 if (aup->mii)
1610 kfree(aup->mii);
1611 for (i = 0; i < NUM_RX_DMA; i++) {
1612 if (aup->rx_db_inuse[i])
1613 ReleaseDB(aup, aup->rx_db_inuse[i]);
1614 }
1615 for (i = 0; i < NUM_TX_DMA; i++) {
1616 if (aup->tx_db_inuse[i])
1617 ReleaseDB(aup, aup->tx_db_inuse[i]);
1618 }
1619 dma_free_noncoherent(NULL,
1620 MAX_BUF_SIZE * (NUM_TX_BUFFS+NUM_RX_BUFFS),
1621 (void *)aup->vaddr,
1622 aup->dma_addr);
1623 unregister_netdev(dev);
1624 free_netdev(dev);
1625 release_mem_region(CPHYSADDR(ioaddr), MAC_IOSIZE);
1626 return NULL;
1627 }
1628
1629 /*
1630 * Initialize the interface.
1631 *
1632 * When the device powers up, the clocks are disabled and the
1633 * mac is in reset state. When the interface is closed, we
1634 * do the same -- reset the device and disable the clocks to
1635 * conserve power. Thus, whenever au1000_init() is called,
1636 * the device should already be in reset state.
1637 */
1638 static int au1000_init(struct net_device *dev)
1639 {
1640 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1641 u32 flags;
1642 int i;
1643 u32 control;
1644 u16 link, speed;
1645
1646 if (au1000_debug > 4)
1647 printk("%s: au1000_init\n", dev->name);
1648
1649 spin_lock_irqsave(&aup->lock, flags);
1650
1651 /* bring the device out of reset */
1652 *aup->enable = MAC_EN_CLOCK_ENABLE;
1653 au_sync_delay(2);
1654 *aup->enable = MAC_EN_RESET0 | MAC_EN_RESET1 |
1655 MAC_EN_RESET2 | MAC_EN_CLOCK_ENABLE;
1656 au_sync_delay(20);
1657
1658 aup->mac->control = 0;
1659 aup->tx_head = (aup->tx_dma_ring[0]->buff_stat & 0xC) >> 2;
1660 aup->tx_tail = aup->tx_head;
1661 aup->rx_head = (aup->rx_dma_ring[0]->buff_stat & 0xC) >> 2;
1662
1663 aup->mac->mac_addr_high = dev->dev_addr[5]<<8 | dev->dev_addr[4];
1664 aup->mac->mac_addr_low = dev->dev_addr[3]<<24 | dev->dev_addr[2]<<16 |
1665 dev->dev_addr[1]<<8 | dev->dev_addr[0];
1666
1667 for (i = 0; i < NUM_RX_DMA; i++) {
1668 aup->rx_dma_ring[i]->buff_stat |= RX_DMA_ENABLE;
1669 }
1670 au_sync();
1671
1672 aup->phy_ops->phy_status(dev, aup->phy_addr, &link, &speed);
1673 control = MAC_DISABLE_RX_OWN | MAC_RX_ENABLE | MAC_TX_ENABLE;
1674 #ifndef CONFIG_CPU_LITTLE_ENDIAN
1675 control |= MAC_BIG_ENDIAN;
1676 #endif
1677 if (link && (dev->if_port == IF_PORT_100BASEFX)) {
1678 control |= MAC_FULL_DUPLEX;
1679 }
1680
1681 aup->mac->control = control;
1682 aup->mac->vlan1_tag = 0x8100; /* activate vlan support */
1683 au_sync();
1684
1685 spin_unlock_irqrestore(&aup->lock, flags);
1686 return 0;
1687 }
1688
1689 static void au1000_timer(unsigned long data)
1690 {
1691 struct net_device *dev = (struct net_device *)data;
1692 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1693 unsigned char if_port;
1694 u16 link, speed;
1695
1696 if (!dev) {
1697 /* fatal error, don't restart the timer */
1698 printk(KERN_ERR "au1000_timer error: NULL dev\n");
1699 return;
1700 }
1701
1702 if_port = dev->if_port;
1703 if (aup->phy_ops->phy_status(dev, aup->phy_addr, &link, &speed) == 0) {
1704 if (link) {
1705 if (!netif_carrier_ok(dev)) {
1706 netif_carrier_on(dev);
1707 printk(KERN_INFO "%s: link up\n", dev->name);
1708 }
1709 }
1710 else {
1711 if (netif_carrier_ok(dev)) {
1712 netif_carrier_off(dev);
1713 dev->if_port = 0;
1714 printk(KERN_INFO "%s: link down\n", dev->name);
1715 }
1716 }
1717 }
1718
1719 if (link && (dev->if_port != if_port) &&
1720 (dev->if_port != IF_PORT_UNKNOWN)) {
1721 hard_stop(dev);
1722 if (dev->if_port == IF_PORT_100BASEFX) {
1723 printk(KERN_INFO "%s: going to full duplex\n",
1724 dev->name);
1725 aup->mac->control |= MAC_FULL_DUPLEX;
1726 au_sync_delay(1);
1727 }
1728 else {
1729 aup->mac->control &= ~MAC_FULL_DUPLEX;
1730 au_sync_delay(1);
1731 }
1732 enable_rx_tx(dev);
1733 }
1734
1735 aup->timer.expires = RUN_AT((1*HZ));
1736 aup->timer.data = (unsigned long)dev;
1737 aup->timer.function = &au1000_timer; /* timer handler */
1738 add_timer(&aup->timer);
1739
1740 }
1741
1742 static int au1000_open(struct net_device *dev)
1743 {
1744 int retval;
1745 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1746
1747 if (au1000_debug > 4)
1748 printk("%s: open: dev=%p\n", dev->name, dev);
1749
1750 if ((retval = au1000_init(dev))) {
1751 printk(KERN_ERR "%s: error in au1000_init\n", dev->name);
1752 free_irq(dev->irq, dev);
1753 return retval;
1754 }
1755 netif_start_queue(dev);
1756
1757 if ((retval = request_irq(dev->irq, &au1000_interrupt, 0,
1758 dev->name, dev))) {
1759 printk(KERN_ERR "%s: unable to get IRQ %d\n",
1760 dev->name, dev->irq);
1761 return retval;
1762 }
1763
1764 init_timer(&aup->timer); /* used in ioctl() */
1765 aup->timer.expires = RUN_AT((3*HZ));
1766 aup->timer.data = (unsigned long)dev;
1767 aup->timer.function = &au1000_timer; /* timer handler */
1768 add_timer(&aup->timer);
1769
1770 if (au1000_debug > 4)
1771 printk("%s: open: Initialization done.\n", dev->name);
1772
1773 return 0;
1774 }
1775
1776 static int au1000_close(struct net_device *dev)
1777 {
1778 u32 flags;
1779 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1780
1781 if (au1000_debug > 4)
1782 printk("%s: close: dev=%p\n", dev->name, dev);
1783
1784 reset_mac(dev);
1785
1786 spin_lock_irqsave(&aup->lock, flags);
1787
1788 /* stop the device */
1789 netif_stop_queue(dev);
1790
1791 /* disable the interrupt */
1792 free_irq(dev->irq, dev);
1793 spin_unlock_irqrestore(&aup->lock, flags);
1794
1795 return 0;
1796 }
1797
1798 static void __exit au1000_cleanup_module(void)
1799 {
1800 int i, j;
1801 struct net_device *dev;
1802 struct au1000_private *aup;
1803
1804 for (i = 0; i < num_ifs; i++) {
1805 dev = iflist[i].dev;
1806 if (dev) {
1807 aup = (struct au1000_private *) dev->priv;
1808 unregister_netdev(dev);
1809 if (aup->mii)
1810 kfree(aup->mii);
1811 for (j = 0; j < NUM_RX_DMA; j++) {
1812 if (aup->rx_db_inuse[j])
1813 ReleaseDB(aup, aup->rx_db_inuse[j]);
1814 }
1815 for (j = 0; j < NUM_TX_DMA; j++) {
1816 if (aup->tx_db_inuse[j])
1817 ReleaseDB(aup, aup->tx_db_inuse[j]);
1818 }
1819 dma_free_noncoherent(NULL,
1820 MAX_BUF_SIZE * (NUM_TX_BUFFS+NUM_RX_BUFFS),
1821 (void *)aup->vaddr,
1822 aup->dma_addr);
1823 free_netdev(dev);
1824 release_mem_region(CPHYSADDR(iflist[i].base_addr), MAC_IOSIZE);
1825 }
1826 }
1827 }
1828
1829
1830 static inline void
1831 update_tx_stats(struct net_device *dev, u32 status, u32 pkt_len)
1832 {
1833 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1834 struct net_device_stats *ps = &aup->stats;
1835
1836 ps->tx_packets++;
1837 ps->tx_bytes += pkt_len;
1838
1839 if (status & TX_FRAME_ABORTED) {
1840 if (dev->if_port == IF_PORT_100BASEFX) {
1841 if (status & (TX_JAB_TIMEOUT | TX_UNDERRUN)) {
1842 /* any other tx errors are only valid
1843 * in half duplex mode */
1844 ps->tx_errors++;
1845 ps->tx_aborted_errors++;
1846 }
1847 }
1848 else {
1849 ps->tx_errors++;
1850 ps->tx_aborted_errors++;
1851 if (status & (TX_NO_CARRIER | TX_LOSS_CARRIER))
1852 ps->tx_carrier_errors++;
1853 }
1854 }
1855 }
1856
1857
1858 /*
1859 * Called from the interrupt service routine to acknowledge
1860 * the TX DONE bits. This is a must if the irq is setup as
1861 * edge triggered.
1862 */
1863 static void au1000_tx_ack(struct net_device *dev)
1864 {
1865 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1866 volatile tx_dma_t *ptxd;
1867
1868 ptxd = aup->tx_dma_ring[aup->tx_tail];
1869
1870 while (ptxd->buff_stat & TX_T_DONE) {
1871 update_tx_stats(dev, ptxd->status, ptxd->len & 0x3ff);
1872 ptxd->buff_stat &= ~TX_T_DONE;
1873 ptxd->len = 0;
1874 au_sync();
1875
1876 aup->tx_tail = (aup->tx_tail + 1) & (NUM_TX_DMA - 1);
1877 ptxd = aup->tx_dma_ring[aup->tx_tail];
1878
1879 if (aup->tx_full) {
1880 aup->tx_full = 0;
1881 netif_wake_queue(dev);
1882 }
1883 }
1884 }
1885
1886
1887 /*
1888 * Au1000 transmit routine.
1889 */
1890 static int au1000_tx(struct sk_buff *skb, struct net_device *dev)
1891 {
1892 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1893 volatile tx_dma_t *ptxd;
1894 u32 buff_stat;
1895 db_dest_t *pDB;
1896 int i;
1897
1898 if (au1000_debug > 5)
1899 printk("%s: tx: aup %x len=%d, data=%p, head %d\n",
1900 dev->name, (unsigned)aup, skb->len,
1901 skb->data, aup->tx_head);
1902
1903 ptxd = aup->tx_dma_ring[aup->tx_head];
1904 buff_stat = ptxd->buff_stat;
1905 if (buff_stat & TX_DMA_ENABLE) {
1906 /* We've wrapped around and the transmitter is still busy */
1907 netif_stop_queue(dev);
1908 aup->tx_full = 1;
1909 return 1;
1910 }
1911 else if (buff_stat & TX_T_DONE) {
1912 update_tx_stats(dev, ptxd->status, ptxd->len & 0x3ff);
1913 ptxd->len = 0;
1914 }
1915
1916 if (aup->tx_full) {
1917 aup->tx_full = 0;
1918 netif_wake_queue(dev);
1919 }
1920
1921 pDB = aup->tx_db_inuse[aup->tx_head];
1922 memcpy((void *)pDB->vaddr, skb->data, skb->len);
1923 if (skb->len < ETH_ZLEN) {
1924 for (i=skb->len; i<ETH_ZLEN; i++) {
1925 ((char *)pDB->vaddr)[i] = 0;
1926 }
1927 ptxd->len = ETH_ZLEN;
1928 }
1929 else
1930 ptxd->len = skb->len;
1931
1932 ptxd->buff_stat = pDB->dma_addr | TX_DMA_ENABLE;
1933 au_sync();
1934 dev_kfree_skb(skb);
1935 aup->tx_head = (aup->tx_head + 1) & (NUM_TX_DMA - 1);
1936 dev->trans_start = jiffies;
1937 return 0;
1938 }
1939
1940
1941 static inline void update_rx_stats(struct net_device *dev, u32 status)
1942 {
1943 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1944 struct net_device_stats *ps = &aup->stats;
1945
1946 ps->rx_packets++;
1947 if (status & RX_MCAST_FRAME)
1948 ps->multicast++;
1949
1950 if (status & RX_ERROR) {
1951 ps->rx_errors++;
1952 if (status & RX_MISSED_FRAME)
1953 ps->rx_missed_errors++;
1954 if (status & (RX_OVERLEN | RX_OVERLEN | RX_LEN_ERROR))
1955 ps->rx_length_errors++;
1956 if (status & RX_CRC_ERROR)
1957 ps->rx_crc_errors++;
1958 if (status & RX_COLL)
1959 ps->collisions++;
1960 }
1961 else
1962 ps->rx_bytes += status & RX_FRAME_LEN_MASK;
1963
1964 }
1965
1966 /*
1967 * Au1000 receive routine.
1968 */
1969 static int au1000_rx(struct net_device *dev)
1970 {
1971 struct au1000_private *aup = (struct au1000_private *) dev->priv;
1972 struct sk_buff *skb;
1973 volatile rx_dma_t *prxd;
1974 u32 buff_stat, status;
1975 db_dest_t *pDB;
1976 u32 frmlen;
1977
1978 if (au1000_debug > 5)
1979 printk("%s: au1000_rx head %d\n", dev->name, aup->rx_head);
1980
1981 prxd = aup->rx_dma_ring[aup->rx_head];
1982 buff_stat = prxd->buff_stat;
1983 while (buff_stat & RX_T_DONE) {
1984 status = prxd->status;
1985 pDB = aup->rx_db_inuse[aup->rx_head];
1986 update_rx_stats(dev, status);
1987 if (!(status & RX_ERROR)) {
1988
1989 /* good frame */
1990 frmlen = (status & RX_FRAME_LEN_MASK);
1991 frmlen -= 4; /* Remove FCS */
1992 skb = dev_alloc_skb(frmlen + 2);
1993 if (skb == NULL) {
1994 printk(KERN_ERR
1995 "%s: Memory squeeze, dropping packet.\n",
1996 dev->name);
1997 aup->stats.rx_dropped++;
1998 continue;
1999 }
2000 skb->dev = dev;
2001 skb_reserve(skb, 2); /* 16 byte IP header align */
2002 eth_copy_and_sum(skb,
2003 (unsigned char *)pDB->vaddr, frmlen, 0);
2004 skb_put(skb, frmlen);
2005 skb->protocol = eth_type_trans(skb, dev);
2006 netif_rx(skb); /* pass the packet to upper layers */
2007 }
2008 else {
2009 if (au1000_debug > 4) {
2010 if (status & RX_MISSED_FRAME)
2011 printk("rx miss\n");
2012 if (status & RX_WDOG_TIMER)
2013 printk("rx wdog\n");
2014 if (status & RX_RUNT)
2015 printk("rx runt\n");
2016 if (status & RX_OVERLEN)
2017 printk("rx overlen\n");
2018 if (status & RX_COLL)
2019 printk("rx coll\n");
2020 if (status & RX_MII_ERROR)
2021 printk("rx mii error\n");
2022 if (status & RX_CRC_ERROR)
2023 printk("rx crc error\n");
2024 if (status & RX_LEN_ERROR)
2025 printk("rx len error\n");
2026 if (status & RX_U_CNTRL_FRAME)
2027 printk("rx u control frame\n");
2028 if (status & RX_MISSED_FRAME)
2029 printk("rx miss\n");
2030 }
2031 }
2032 prxd->buff_stat = (u32)(pDB->dma_addr | RX_DMA_ENABLE);
2033 aup->rx_head = (aup->rx_head + 1) & (NUM_RX_DMA - 1);
2034 au_sync();
2035
2036 /* next descriptor */
2037 prxd = aup->rx_dma_ring[aup->rx_head];
2038 buff_stat = prxd->buff_stat;
2039 dev->last_rx = jiffies;
2040 }
2041 return 0;
2042 }
2043
2044
2045 /*
2046 * Au1000 interrupt service routine.
2047 */
2048 static irqreturn_t au1000_interrupt(int irq, void *dev_id, struct pt_regs *regs)
2049 {
2050 struct net_device *dev = (struct net_device *) dev_id;
2051
2052 if (dev == NULL) {
2053 printk(KERN_ERR "%s: isr: null dev ptr\n", dev->name);
2054 return IRQ_RETVAL(1);
2055 }
2056
2057 /* Handle RX interrupts first to minimize chance of overrun */
2058
2059 au1000_rx(dev);
2060 au1000_tx_ack(dev);
2061 return IRQ_RETVAL(1);
2062 }
2063
2064
2065 /*
2066 * The Tx ring has been full longer than the watchdog timeout
2067 * value. The transmitter must be hung?
2068 */
2069 static void au1000_tx_timeout(struct net_device *dev)
2070 {
2071 printk(KERN_ERR "%s: au1000_tx_timeout: dev=%p\n", dev->name, dev);
2072 reset_mac(dev);
2073 au1000_init(dev);
2074 dev->trans_start = jiffies;
2075 netif_wake_queue(dev);
2076 }
2077
2078
2079 static unsigned const ethernet_polynomial = 0x04c11db7U;
2080 static inline u32 ether_crc(int length, unsigned char *data)
2081 {
2082 int crc = -1;
2083
2084 while(--length >= 0) {
2085 unsigned char current_octet = *data++;
2086 int bit;
2087 for (bit = 0; bit < 8; bit++, current_octet >>= 1)
2088 crc = (crc << 1) ^
2089 ((crc < 0) ^ (current_octet & 1) ?
2090 ethernet_polynomial : 0);
2091 }
2092 return crc;
2093 }
2094
2095 static void set_rx_mode(struct net_device *dev)
2096 {
2097 struct au1000_private *aup = (struct au1000_private *) dev->priv;
2098
2099 if (au1000_debug > 4)
2100 printk("%s: set_rx_mode: flags=%x\n", dev->name, dev->flags);
2101
2102 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2103 aup->mac->control |= MAC_PROMISCUOUS;
2104 printk(KERN_INFO "%s: Promiscuous mode enabled.\n", dev->name);
2105 } else if ((dev->flags & IFF_ALLMULTI) ||
2106 dev->mc_count > MULTICAST_FILTER_LIMIT) {
2107 aup->mac->control |= MAC_PASS_ALL_MULTI;
2108 aup->mac->control &= ~MAC_PROMISCUOUS;
2109 printk(KERN_INFO "%s: Pass all multicast\n", dev->name);
2110 } else {
2111 int i;
2112 struct dev_mc_list *mclist;
2113 u32 mc_filter[2]; /* Multicast hash filter */
2114
2115 mc_filter[1] = mc_filter[0] = 0;
2116 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2117 i++, mclist = mclist->next) {
2118 set_bit(ether_crc(ETH_ALEN, mclist->dmi_addr)>>26,
2119 (long *)mc_filter);
2120 }
2121 aup->mac->multi_hash_high = mc_filter[1];
2122 aup->mac->multi_hash_low = mc_filter[0];
2123 aup->mac->control &= ~MAC_PROMISCUOUS;
2124 aup->mac->control |= MAC_HASH_MODE;
2125 }
2126 }
2127
2128
2129 static int au1000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2130 {
2131 struct au1000_private *aup = (struct au1000_private *)dev->priv;
2132 u16 *data = (u16 *)&rq->ifr_ifru;
2133
2134 switch(cmd) {
2135 case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */
2136 case SIOCGMIIPHY:
2137 if (!netif_running(dev)) return -EINVAL;
2138 data[0] = aup->phy_addr;
2139 case SIOCDEVPRIVATE+1: /* Read the specified MII register. */
2140 case SIOCGMIIREG:
2141 data[3] = mdio_read(dev, data[0], data[1]);
2142 return 0;
2143 case SIOCDEVPRIVATE+2: /* Write the specified MII register */
2144 case SIOCSMIIREG:
2145 if (!capable(CAP_NET_ADMIN))
2146 return -EPERM;
2147 mdio_write(dev, data[0], data[1],data[2]);
2148 return 0;
2149 default:
2150 return -EOPNOTSUPP;
2151 }
2152
2153 }
2154
2155
2156 static int au1000_set_config(struct net_device *dev, struct ifmap *map)
2157 {
2158 struct au1000_private *aup = (struct au1000_private *) dev->priv;
2159 u16 control;
2160
2161 if (au1000_debug > 4) {
2162 printk("%s: set_config called: dev->if_port %d map->port %x\n",
2163 dev->name, dev->if_port, map->port);
2164 }
2165
2166 switch(map->port){
2167 case IF_PORT_UNKNOWN: /* use auto here */
2168 printk(KERN_INFO "%s: config phy for aneg\n",
2169 dev->name);
2170 dev->if_port = map->port;
2171 /* Link Down: the timer will bring it up */
2172 netif_carrier_off(dev);
2173
2174 /* read current control */
2175 control = mdio_read(dev, aup->phy_addr, MII_CONTROL);
2176 control &= ~(MII_CNTL_FDX | MII_CNTL_F100);
2177
2178 /* enable auto negotiation and reset the negotiation */
2179 mdio_write(dev, aup->phy_addr, MII_CONTROL,
2180 control | MII_CNTL_AUTO |
2181 MII_CNTL_RST_AUTO);
2182
2183 break;
2184
2185 case IF_PORT_10BASET: /* 10BaseT */
2186 printk(KERN_INFO "%s: config phy for 10BaseT\n",
2187 dev->name);
2188 dev->if_port = map->port;
2189
2190 /* Link Down: the timer will bring it up */
2191 netif_carrier_off(dev);
2192
2193 /* set Speed to 10Mbps, Half Duplex */
2194 control = mdio_read(dev, aup->phy_addr, MII_CONTROL);
2195 control &= ~(MII_CNTL_F100 | MII_CNTL_AUTO |
2196 MII_CNTL_FDX);
2197
2198 /* disable auto negotiation and force 10M/HD mode*/
2199 mdio_write(dev, aup->phy_addr, MII_CONTROL, control);
2200 break;
2201
2202 case IF_PORT_100BASET: /* 100BaseT */
2203 case IF_PORT_100BASETX: /* 100BaseTx */
2204 printk(KERN_INFO "%s: config phy for 100BaseTX\n",
2205 dev->name);
2206 dev->if_port = map->port;
2207
2208 /* Link Down: the timer will bring it up */
2209 netif_carrier_off(dev);
2210
2211 /* set Speed to 100Mbps, Half Duplex */
2212 /* disable auto negotiation and enable 100MBit Mode */
2213 control = mdio_read(dev, aup->phy_addr, MII_CONTROL);
2214 control &= ~(MII_CNTL_AUTO | MII_CNTL_FDX);
2215 control |= MII_CNTL_F100;
2216 mdio_write(dev, aup->phy_addr, MII_CONTROL, control);
2217 break;
2218
2219 case IF_PORT_100BASEFX: /* 100BaseFx */
2220 printk(KERN_INFO "%s: config phy for 100BaseFX\n",
2221 dev->name);
2222 dev->if_port = map->port;
2223
2224 /* Link Down: the timer will bring it up */
2225 netif_carrier_off(dev);
2226
2227 /* set Speed to 100Mbps, Full Duplex */
2228 /* disable auto negotiation and enable 100MBit Mode */
2229 control = mdio_read(dev, aup->phy_addr, MII_CONTROL);
2230 control &= ~MII_CNTL_AUTO;
2231 control |= MII_CNTL_F100 | MII_CNTL_FDX;
2232 mdio_write(dev, aup->phy_addr, MII_CONTROL, control);
2233 break;
2234 case IF_PORT_10BASE2: /* 10Base2 */
2235 case IF_PORT_AUI: /* AUI */
2236 /* These Modes are not supported (are they?)*/
2237 printk(KERN_ERR "%s: 10Base2/AUI not supported",
2238 dev->name);
2239 return -EOPNOTSUPP;
2240 break;
2241
2242 default:
2243 printk(KERN_ERR "%s: Invalid media selected",
2244 dev->name);
2245 return -EINVAL;
2246 }
2247 return 0;
2248 }
2249
2250 static struct net_device_stats *au1000_get_stats(struct net_device *dev)
2251 {
2252 struct au1000_private *aup = (struct au1000_private *) dev->priv;
2253
2254 if (au1000_debug > 4)
2255 printk("%s: au1000_get_stats: dev=%p\n", dev->name, dev);
2256
2257 if (netif_device_present(dev)) {
2258 return &aup->stats;
2259 }
2260 return 0;
2261 }
2262
2263 module_init(au1000_init_module);
2264 module_exit(au1000_cleanup_module);
Linux with added FPC-III support