?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / net / ibm_emac / ibm_emac_core.c
blobffeafb28f782036dff1255ce92fff70efbae68fb
1 /*
2 * drivers/net/ibm_emac/ibm_emac_core.c
3 *
4 * Driver for PowerPC 4xx on-chip ethernet controller.
5 *
6 * Copyright (c) 2004, 2005 Zultys Technologies.
7 * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
8 *
9 * Based on original work by
10 * Matt Porter <mporter@kernel.crashing.org>
11 * (c) 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
12 * Armin Kuster <akuster@mvista.com>
13 * Johnnie Peters <jpeters@mvista.com>
14 *
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the
17 * Free Software Foundation; either version 2 of the License, or (at your
18 * option) any later version.
19 *
20 */
21
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/string.h>
26 #include <linux/errno.h>
27 #include <linux/interrupt.h>
28 #include <linux/delay.h>
29 #include <linux/init.h>
30 #include <linux/types.h>
31 #include <linux/pci.h>
32 #include <linux/netdevice.h>
33 #include <linux/etherdevice.h>
34 #include <linux/skbuff.h>
35 #include <linux/crc32.h>
36 #include <linux/ethtool.h>
37 #include <linux/mii.h>
38 #include <linux/bitops.h>
39
40 #include <asm/processor.h>
41 #include <asm/io.h>
42 #include <asm/dma.h>
43 #include <asm/uaccess.h>
44 #include <asm/ocp.h>
45
46 #include "ibm_emac_core.h"
47 #include "ibm_emac_debug.h"
48
49 /*
50 * Lack of dma_unmap_???? calls is intentional.
51 *
52 * API-correct usage requires additional support state information to be
53 * maintained for every RX and TX buffer descriptor (BD). Unfortunately, due to
54 * EMAC design (e.g. TX buffer passed from network stack can be split into
55 * several BDs, dma_map_single/dma_map_page can be used to map particular BD),
56 * maintaining such information will add additional overhead.
57 * Current DMA API implementation for 4xx processors only ensures cache coherency
58 * and dma_unmap_???? routines are empty and are likely to stay this way.
59 * I decided to omit dma_unmap_??? calls because I don't want to add additional
60 * complexity just for the sake of following some abstract API, when it doesn't
61 * add any real benefit to the driver. I understand that this decision maybe
62 * controversial, but I really tried to make code API-correct and efficient
63 * at the same time and didn't come up with code I liked :(. --ebs
64 */
65
66 #define DRV_NAME "emac"
67 #define DRV_VERSION "3.54"
68 #define DRV_DESC "PPC 4xx OCP EMAC driver"
69
70 MODULE_DESCRIPTION(DRV_DESC);
71 MODULE_AUTHOR
72 ("Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>");
73 MODULE_LICENSE("GPL");
74
75 /* minimum number of free TX descriptors required to wake up TX process */
76 #define EMAC_TX_WAKEUP_THRESH (NUM_TX_BUFF / 4)
77
78 /* If packet size is less than this number, we allocate small skb and copy packet
79 * contents into it instead of just sending original big skb up
80 */
81 #define EMAC_RX_COPY_THRESH CONFIG_IBM_EMAC_RX_COPY_THRESHOLD
82
83 /* Since multiple EMACs share MDIO lines in various ways, we need
84 * to avoid re-using the same PHY ID in cases where the arch didn't
85 * setup precise phy_map entries
86 */
87 static u32 busy_phy_map;
88
89 #if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX) && \
90 (defined(CONFIG_405EP) || defined(CONFIG_440EP) || defined(CONFIG_440GR))
91 /* 405EP has "EMAC to PHY Control Register" (CPC0_EPCTL) which can help us
92 * with PHY RX clock problem.
93 * 440EP/440GR has more sane SDR0_MFR register implementation than 440GX, which
94 * also allows controlling each EMAC clock
95 */
96 static inline void EMAC_RX_CLK_TX(int idx)
97 {
98 unsigned long flags;
99 local_irq_save(flags);
100
101 #if defined(CONFIG_405EP)
102 mtdcr(0xf3, mfdcr(0xf3) | (1 << idx));
103 #else /* CONFIG_440EP || CONFIG_440GR */
104 SDR_WRITE(DCRN_SDR_MFR, SDR_READ(DCRN_SDR_MFR) | (0x08000000 >> idx));
105 #endif
106
107 local_irq_restore(flags);
108 }
109
110 static inline void EMAC_RX_CLK_DEFAULT(int idx)
111 {
112 unsigned long flags;
113 local_irq_save(flags);
114
115 #if defined(CONFIG_405EP)
116 mtdcr(0xf3, mfdcr(0xf3) & ~(1 << idx));
117 #else /* CONFIG_440EP */
118 SDR_WRITE(DCRN_SDR_MFR, SDR_READ(DCRN_SDR_MFR) & ~(0x08000000 >> idx));
119 #endif
120
121 local_irq_restore(flags);
122 }
123 #else
124 #define EMAC_RX_CLK_TX(idx) ((void)0)
125 #define EMAC_RX_CLK_DEFAULT(idx) ((void)0)
126 #endif
127
128 #if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX) && defined(CONFIG_440GX)
129 /* We can switch Ethernet clock to the internal source through SDR0_MFR[ECS],
130 * unfortunately this is less flexible than 440EP case, because it's a global
131 * setting for all EMACs, therefore we do this clock trick only during probe.
132 */
133 #define EMAC_CLK_INTERNAL SDR_WRITE(DCRN_SDR_MFR, \
134 SDR_READ(DCRN_SDR_MFR) | 0x08000000)
135 #define EMAC_CLK_EXTERNAL SDR_WRITE(DCRN_SDR_MFR, \
136 SDR_READ(DCRN_SDR_MFR) & ~0x08000000)
137 #else
138 #define EMAC_CLK_INTERNAL ((void)0)
139 #define EMAC_CLK_EXTERNAL ((void)0)
140 #endif
141
142 /* I don't want to litter system log with timeout errors
143 * when we have brain-damaged PHY.
144 */
145 static inline void emac_report_timeout_error(struct ocp_enet_private *dev,
146 const char *error)
147 {
148 #if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX)
149 DBG("%d: %s" NL, dev->def->index, error);
150 #else
151 if (net_ratelimit())
152 printk(KERN_ERR "emac%d: %s\n", dev->def->index, error);
153 #endif
154 }
155
156 /* PHY polling intervals */
157 #define PHY_POLL_LINK_ON HZ
158 #define PHY_POLL_LINK_OFF (HZ / 5)
159
160 /* Graceful stop timeouts in us.
161 * We should allow up to 1 frame time (full-duplex, ignoring collisions)
162 */
163 #define STOP_TIMEOUT_10 1230
164 #define STOP_TIMEOUT_100 124
165 #define STOP_TIMEOUT_1000 13
166 #define STOP_TIMEOUT_1000_JUMBO 73
167
168 /* Please, keep in sync with struct ibm_emac_stats/ibm_emac_error_stats */
169 static const char emac_stats_keys[EMAC_ETHTOOL_STATS_COUNT][ETH_GSTRING_LEN] = {
170 "rx_packets", "rx_bytes", "tx_packets", "tx_bytes", "rx_packets_csum",
171 "tx_packets_csum", "tx_undo", "rx_dropped_stack", "rx_dropped_oom",
172 "rx_dropped_error", "rx_dropped_resize", "rx_dropped_mtu",
173 "rx_stopped", "rx_bd_errors", "rx_bd_overrun", "rx_bd_bad_packet",
174 "rx_bd_runt_packet", "rx_bd_short_event", "rx_bd_alignment_error",
175 "rx_bd_bad_fcs", "rx_bd_packet_too_long", "rx_bd_out_of_range",
176 "rx_bd_in_range", "rx_parity", "rx_fifo_overrun", "rx_overrun",
177 "rx_bad_packet", "rx_runt_packet", "rx_short_event",
178 "rx_alignment_error", "rx_bad_fcs", "rx_packet_too_long",
179 "rx_out_of_range", "rx_in_range", "tx_dropped", "tx_bd_errors",
180 "tx_bd_bad_fcs", "tx_bd_carrier_loss", "tx_bd_excessive_deferral",
181 "tx_bd_excessive_collisions", "tx_bd_late_collision",
182 "tx_bd_multple_collisions", "tx_bd_single_collision",
183 "tx_bd_underrun", "tx_bd_sqe", "tx_parity", "tx_underrun", "tx_sqe",
184 "tx_errors"
185 };
186
187 static irqreturn_t emac_irq(int irq, void *dev_instance);
188 static void emac_clean_tx_ring(struct ocp_enet_private *dev);
189
190 static inline int emac_phy_supports_gige(int phy_mode)
191 {
192 return phy_mode == PHY_MODE_GMII ||
193 phy_mode == PHY_MODE_RGMII ||
194 phy_mode == PHY_MODE_TBI ||
195 phy_mode == PHY_MODE_RTBI;
196 }
197
198 static inline int emac_phy_gpcs(int phy_mode)
199 {
200 return phy_mode == PHY_MODE_TBI ||
201 phy_mode == PHY_MODE_RTBI;
202 }
203
204 static inline void emac_tx_enable(struct ocp_enet_private *dev)
205 {
206 struct emac_regs __iomem *p = dev->emacp;
207 unsigned long flags;
208 u32 r;
209
210 local_irq_save(flags);
211
212 DBG("%d: tx_enable" NL, dev->def->index);
213
214 r = in_be32(&p->mr0);
215 if (!(r & EMAC_MR0_TXE))
216 out_be32(&p->mr0, r | EMAC_MR0_TXE);
217 local_irq_restore(flags);
218 }
219
220 static void emac_tx_disable(struct ocp_enet_private *dev)
221 {
222 struct emac_regs __iomem *p = dev->emacp;
223 unsigned long flags;
224 u32 r;
225
226 local_irq_save(flags);
227
228 DBG("%d: tx_disable" NL, dev->def->index);
229
230 r = in_be32(&p->mr0);
231 if (r & EMAC_MR0_TXE) {
232 int n = dev->stop_timeout;
233 out_be32(&p->mr0, r & ~EMAC_MR0_TXE);
234 while (!(in_be32(&p->mr0) & EMAC_MR0_TXI) && n) {
235 udelay(1);
236 --n;
237 }
238 if (unlikely(!n))
239 emac_report_timeout_error(dev, "TX disable timeout");
240 }
241 local_irq_restore(flags);
242 }
243
244 static void emac_rx_enable(struct ocp_enet_private *dev)
245 {
246 struct emac_regs __iomem *p = dev->emacp;
247 unsigned long flags;
248 u32 r;
249
250 local_irq_save(flags);
251 if (unlikely(dev->commac.rx_stopped))
252 goto out;
253
254 DBG("%d: rx_enable" NL, dev->def->index);
255
256 r = in_be32(&p->mr0);
257 if (!(r & EMAC_MR0_RXE)) {
258 if (unlikely(!(r & EMAC_MR0_RXI))) {
259 /* Wait if previous async disable is still in progress */
260 int n = dev->stop_timeout;
261 while (!(r = in_be32(&p->mr0) & EMAC_MR0_RXI) && n) {
262 udelay(1);
263 --n;
264 }
265 if (unlikely(!n))
266 emac_report_timeout_error(dev,
267 "RX disable timeout");
268 }
269 out_be32(&p->mr0, r | EMAC_MR0_RXE);
270 }
271 out:
272 local_irq_restore(flags);
273 }
274
275 static void emac_rx_disable(struct ocp_enet_private *dev)
276 {
277 struct emac_regs __iomem *p = dev->emacp;
278 unsigned long flags;
279 u32 r;
280
281 local_irq_save(flags);
282
283 DBG("%d: rx_disable" NL, dev->def->index);
284
285 r = in_be32(&p->mr0);
286 if (r & EMAC_MR0_RXE) {
287 int n = dev->stop_timeout;
288 out_be32(&p->mr0, r & ~EMAC_MR0_RXE);
289 while (!(in_be32(&p->mr0) & EMAC_MR0_RXI) && n) {
290 udelay(1);
291 --n;
292 }
293 if (unlikely(!n))
294 emac_report_timeout_error(dev, "RX disable timeout");
295 }
296 local_irq_restore(flags);
297 }
298
299 static inline void emac_rx_disable_async(struct ocp_enet_private *dev)
300 {
301 struct emac_regs __iomem *p = dev->emacp;
302 unsigned long flags;
303 u32 r;
304
305 local_irq_save(flags);
306
307 DBG("%d: rx_disable_async" NL, dev->def->index);
308
309 r = in_be32(&p->mr0);
310 if (r & EMAC_MR0_RXE)
311 out_be32(&p->mr0, r & ~EMAC_MR0_RXE);
312 local_irq_restore(flags);
313 }
314
315 static int emac_reset(struct ocp_enet_private *dev)
316 {
317 struct emac_regs __iomem *p = dev->emacp;
318 unsigned long flags;
319 int n = 20;
320
321 DBG("%d: reset" NL, dev->def->index);
322
323 local_irq_save(flags);
324
325 if (!dev->reset_failed) {
326 /* 40x erratum suggests stopping RX channel before reset,
327 * we stop TX as well
328 */
329 emac_rx_disable(dev);
330 emac_tx_disable(dev);
331 }
332
333 out_be32(&p->mr0, EMAC_MR0_SRST);
334 while ((in_be32(&p->mr0) & EMAC_MR0_SRST) && n)
335 --n;
336 local_irq_restore(flags);
337
338 if (n) {
339 dev->reset_failed = 0;
340 return 0;
341 } else {
342 emac_report_timeout_error(dev, "reset timeout");
343 dev->reset_failed = 1;
344 return -ETIMEDOUT;
345 }
346 }
347
348 static void emac_hash_mc(struct ocp_enet_private *dev)
349 {
350 struct emac_regs __iomem *p = dev->emacp;
351 u16 gaht[4] = { 0 };
352 struct dev_mc_list *dmi;
353
354 DBG("%d: hash_mc %d" NL, dev->def->index, dev->ndev->mc_count);
355
356 for (dmi = dev->ndev->mc_list; dmi; dmi = dmi->next) {
357 int bit;
358 DBG2("%d: mc %02x:%02x:%02x:%02x:%02x:%02x" NL,
359 dev->def->index,
360 dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2],
361 dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5]);
362
363 bit = 63 - (ether_crc(ETH_ALEN, dmi->dmi_addr) >> 26);
364 gaht[bit >> 4] |= 0x8000 >> (bit & 0x0f);
365 }
366 out_be32(&p->gaht1, gaht[0]);
367 out_be32(&p->gaht2, gaht[1]);
368 out_be32(&p->gaht3, gaht[2]);
369 out_be32(&p->gaht4, gaht[3]);
370 }
371
372 static inline u32 emac_iff2rmr(struct net_device *ndev)
373 {
374 u32 r = EMAC_RMR_SP | EMAC_RMR_SFCS | EMAC_RMR_IAE | EMAC_RMR_BAE |
375 EMAC_RMR_BASE;
376
377 if (ndev->flags & IFF_PROMISC)
378 r |= EMAC_RMR_PME;
379 else if (ndev->flags & IFF_ALLMULTI || ndev->mc_count > 32)
380 r |= EMAC_RMR_PMME;
381 else if (ndev->mc_count > 0)
382 r |= EMAC_RMR_MAE;
383
384 return r;
385 }
386
387 static inline int emac_opb_mhz(void)
388 {
389 return (ocp_sys_info.opb_bus_freq + 500000) / 1000000;
390 }
391
392 /* BHs disabled */
393 static int emac_configure(struct ocp_enet_private *dev)
394 {
395 struct emac_regs __iomem *p = dev->emacp;
396 struct net_device *ndev = dev->ndev;
397 int gige;
398 u32 r;
399
400 DBG("%d: configure" NL, dev->def->index);
401
402 if (emac_reset(dev) < 0)
403 return -ETIMEDOUT;
404
405 tah_reset(dev->tah_dev);
406
407 /* Mode register */
408 r = EMAC_MR1_BASE(emac_opb_mhz()) | EMAC_MR1_VLE | EMAC_MR1_IST;
409 if (dev->phy.duplex == DUPLEX_FULL)
410 r |= EMAC_MR1_FDE | EMAC_MR1_MWSW_001;
411 dev->stop_timeout = STOP_TIMEOUT_10;
412 switch (dev->phy.speed) {
413 case SPEED_1000:
414 if (emac_phy_gpcs(dev->phy.mode)) {
415 r |= EMAC_MR1_MF_1000GPCS |
416 EMAC_MR1_MF_IPPA(dev->phy.address);
417
418 /* Put some arbitrary OUI, Manuf & Rev IDs so we can
419 * identify this GPCS PHY later.
420 */
421 out_be32(&p->ipcr, 0xdeadbeef);
422 } else
423 r |= EMAC_MR1_MF_1000;
424 r |= EMAC_MR1_RFS_16K;
425 gige = 1;
426
427 if (dev->ndev->mtu > ETH_DATA_LEN) {
428 r |= EMAC_MR1_JPSM;
429 dev->stop_timeout = STOP_TIMEOUT_1000_JUMBO;
430 } else
431 dev->stop_timeout = STOP_TIMEOUT_1000;
432 break;
433 case SPEED_100:
434 r |= EMAC_MR1_MF_100;
435 dev->stop_timeout = STOP_TIMEOUT_100;
436 /* Fall through */
437 default:
438 r |= EMAC_MR1_RFS_4K;
439 gige = 0;
440 break;
441 }
442
443 if (dev->rgmii_dev)
444 rgmii_set_speed(dev->rgmii_dev, dev->rgmii_input,
445 dev->phy.speed);
446 else
447 zmii_set_speed(dev->zmii_dev, dev->zmii_input, dev->phy.speed);
448
449 #if !defined(CONFIG_40x)
450 /* on 40x erratum forces us to NOT use integrated flow control,
451 * let's hope it works on 44x ;)
452 */
453 if (dev->phy.duplex == DUPLEX_FULL) {
454 if (dev->phy.pause)
455 r |= EMAC_MR1_EIFC | EMAC_MR1_APP;
456 else if (dev->phy.asym_pause)
457 r |= EMAC_MR1_APP;
458 }
459 #endif
460 out_be32(&p->mr1, r);
461
462 /* Set individual MAC address */
463 out_be32(&p->iahr, (ndev->dev_addr[0] << 8) | ndev->dev_addr[1]);
464 out_be32(&p->ialr, (ndev->dev_addr[2] << 24) |
465 (ndev->dev_addr[3] << 16) | (ndev->dev_addr[4] << 8) |
466 ndev->dev_addr[5]);
467
468 /* VLAN Tag Protocol ID */
469 out_be32(&p->vtpid, 0x8100);
470
471 /* Receive mode register */
472 r = emac_iff2rmr(ndev);
473 if (r & EMAC_RMR_MAE)
474 emac_hash_mc(dev);
475 out_be32(&p->rmr, r);
476
477 /* FIFOs thresholds */
478 r = EMAC_TMR1((EMAC_MAL_BURST_SIZE / EMAC_FIFO_ENTRY_SIZE) + 1,
479 EMAC_TX_FIFO_SIZE / 2 / EMAC_FIFO_ENTRY_SIZE);
480 out_be32(&p->tmr1, r);
481 out_be32(&p->trtr, EMAC_TRTR(EMAC_TX_FIFO_SIZE / 2));
482
483 /* PAUSE frame is sent when RX FIFO reaches its high-water mark,
484 there should be still enough space in FIFO to allow the our link
485 partner time to process this frame and also time to send PAUSE
486 frame itself.
487
488 Here is the worst case scenario for the RX FIFO "headroom"
489 (from "The Switch Book") (100Mbps, without preamble, inter-frame gap):
490
491 1) One maximum-length frame on TX 1522 bytes
492 2) One PAUSE frame time 64 bytes
493 3) PAUSE frame decode time allowance 64 bytes
494 4) One maximum-length frame on RX 1522 bytes
495 5) Round-trip propagation delay of the link (100Mb) 15 bytes
496 ----------
497 3187 bytes
498
499 I chose to set high-water mark to RX_FIFO_SIZE / 4 (1024 bytes)
500 low-water mark to RX_FIFO_SIZE / 8 (512 bytes)
501 */
502 r = EMAC_RWMR(EMAC_RX_FIFO_SIZE(gige) / 8 / EMAC_FIFO_ENTRY_SIZE,
503 EMAC_RX_FIFO_SIZE(gige) / 4 / EMAC_FIFO_ENTRY_SIZE);
504 out_be32(&p->rwmr, r);
505
506 /* Set PAUSE timer to the maximum */
507 out_be32(&p->ptr, 0xffff);
508
509 /* IRQ sources */
510 out_be32(&p->iser, EMAC_ISR_TXPE | EMAC_ISR_RXPE | /* EMAC_ISR_TXUE |
511 EMAC_ISR_RXOE | */ EMAC_ISR_OVR | EMAC_ISR_BP | EMAC_ISR_SE |
512 EMAC_ISR_ALE | EMAC_ISR_BFCS | EMAC_ISR_PTLE | EMAC_ISR_ORE |
513 EMAC_ISR_IRE | EMAC_ISR_TE);
514
515 /* We need to take GPCS PHY out of isolate mode after EMAC reset */
516 if (emac_phy_gpcs(dev->phy.mode))
517 mii_reset_phy(&dev->phy);
518
519 return 0;
520 }
521
522 /* BHs disabled */
523 static void emac_reinitialize(struct ocp_enet_private *dev)
524 {
525 DBG("%d: reinitialize" NL, dev->def->index);
526
527 if (!emac_configure(dev)) {
528 emac_tx_enable(dev);
529 emac_rx_enable(dev);
530 }
531 }
532
533 /* BHs disabled */
534 static void emac_full_tx_reset(struct net_device *ndev)
535 {
536 struct ocp_enet_private *dev = ndev->priv;
537 struct ocp_func_emac_data *emacdata = dev->def->additions;
538
539 DBG("%d: full_tx_reset" NL, dev->def->index);
540
541 emac_tx_disable(dev);
542 mal_disable_tx_channel(dev->mal, emacdata->mal_tx_chan);
543 emac_clean_tx_ring(dev);
544 dev->tx_cnt = dev->tx_slot = dev->ack_slot = 0;
545
546 emac_configure(dev);
547
548 mal_enable_tx_channel(dev->mal, emacdata->mal_tx_chan);
549 emac_tx_enable(dev);
550 emac_rx_enable(dev);
551
552 netif_wake_queue(ndev);
553 }
554
555 static int __emac_mdio_read(struct ocp_enet_private *dev, u8 id, u8 reg)
556 {
557 struct emac_regs __iomem *p = dev->emacp;
558 u32 r;
559 int n;
560
561 DBG2("%d: mdio_read(%02x,%02x)" NL, dev->def->index, id, reg);
562
563 /* Enable proper MDIO port */
564 zmii_enable_mdio(dev->zmii_dev, dev->zmii_input);
565
566 /* Wait for management interface to become idle */
567 n = 10;
568 while (!emac_phy_done(in_be32(&p->stacr))) {
569 udelay(1);
570 if (!--n)
571 goto to;
572 }
573
574 /* Issue read command */
575 out_be32(&p->stacr,
576 EMAC_STACR_BASE(emac_opb_mhz()) | EMAC_STACR_STAC_READ |
577 (reg & EMAC_STACR_PRA_MASK)
578 | ((id & EMAC_STACR_PCDA_MASK) << EMAC_STACR_PCDA_SHIFT)
579 | EMAC_STACR_START);
580
581 /* Wait for read to complete */
582 n = 100;
583 while (!emac_phy_done(r = in_be32(&p->stacr))) {
584 udelay(1);
585 if (!--n)
586 goto to;
587 }
588
589 if (unlikely(r & EMAC_STACR_PHYE)) {
590 DBG("%d: mdio_read(%02x, %02x) failed" NL, dev->def->index,
591 id, reg);
592 return -EREMOTEIO;
593 }
594
595 r = ((r >> EMAC_STACR_PHYD_SHIFT) & EMAC_STACR_PHYD_MASK);
596 DBG2("%d: mdio_read -> %04x" NL, dev->def->index, r);
597 return r;
598 to:
599 DBG("%d: MII management interface timeout (read)" NL, dev->def->index);
600 return -ETIMEDOUT;
601 }
602
603 static void __emac_mdio_write(struct ocp_enet_private *dev, u8 id, u8 reg,
604 u16 val)
605 {
606 struct emac_regs __iomem *p = dev->emacp;
607 int n;
608
609 DBG2("%d: mdio_write(%02x,%02x,%04x)" NL, dev->def->index, id, reg,
610 val);
611
612 /* Enable proper MDIO port */
613 zmii_enable_mdio(dev->zmii_dev, dev->zmii_input);
614
615 /* Wait for management interface to be idle */
616 n = 10;
617 while (!emac_phy_done(in_be32(&p->stacr))) {
618 udelay(1);
619 if (!--n)
620 goto to;
621 }
622
623 /* Issue write command */
624 out_be32(&p->stacr,
625 EMAC_STACR_BASE(emac_opb_mhz()) | EMAC_STACR_STAC_WRITE |
626 (reg & EMAC_STACR_PRA_MASK) |
627 ((id & EMAC_STACR_PCDA_MASK) << EMAC_STACR_PCDA_SHIFT) |
628 (val << EMAC_STACR_PHYD_SHIFT) | EMAC_STACR_START);
629
630 /* Wait for write to complete */
631 n = 100;
632 while (!emac_phy_done(in_be32(&p->stacr))) {
633 udelay(1);
634 if (!--n)
635 goto to;
636 }
637 return;
638 to:
639 DBG("%d: MII management interface timeout (write)" NL, dev->def->index);
640 }
641
642 static int emac_mdio_read(struct net_device *ndev, int id, int reg)
643 {
644 struct ocp_enet_private *dev = ndev->priv;
645 int res;
646
647 local_bh_disable();
648 res = __emac_mdio_read(dev->mdio_dev ? dev->mdio_dev : dev, (u8) id,
649 (u8) reg);
650 local_bh_enable();
651 return res;
652 }
653
654 static void emac_mdio_write(struct net_device *ndev, int id, int reg, int val)
655 {
656 struct ocp_enet_private *dev = ndev->priv;
657
658 local_bh_disable();
659 __emac_mdio_write(dev->mdio_dev ? dev->mdio_dev : dev, (u8) id,
660 (u8) reg, (u16) val);
661 local_bh_enable();
662 }
663
664 /* BHs disabled */
665 static void emac_set_multicast_list(struct net_device *ndev)
666 {
667 struct ocp_enet_private *dev = ndev->priv;
668 struct emac_regs __iomem *p = dev->emacp;
669 u32 rmr = emac_iff2rmr(ndev);
670
671 DBG("%d: multicast %08x" NL, dev->def->index, rmr);
672 BUG_ON(!netif_running(dev->ndev));
673
674 /* I decided to relax register access rules here to avoid
675 * full EMAC reset.
676 *
677 * There is a real problem with EMAC4 core if we use MWSW_001 bit
678 * in MR1 register and do a full EMAC reset.
679 * One TX BD status update is delayed and, after EMAC reset, it
680 * never happens, resulting in TX hung (it'll be recovered by TX
681 * timeout handler eventually, but this is just gross).
682 * So we either have to do full TX reset or try to cheat here :)
683 *
684 * The only required change is to RX mode register, so I *think* all
685 * we need is just to stop RX channel. This seems to work on all
686 * tested SoCs. --ebs
687 */
688 emac_rx_disable(dev);
689 if (rmr & EMAC_RMR_MAE)
690 emac_hash_mc(dev);
691 out_be32(&p->rmr, rmr);
692 emac_rx_enable(dev);
693 }
694
695 /* BHs disabled */
696 static int emac_resize_rx_ring(struct ocp_enet_private *dev, int new_mtu)
697 {
698 struct ocp_func_emac_data *emacdata = dev->def->additions;
699 int rx_sync_size = emac_rx_sync_size(new_mtu);
700 int rx_skb_size = emac_rx_skb_size(new_mtu);
701 int i, ret = 0;
702
703 emac_rx_disable(dev);
704 mal_disable_rx_channel(dev->mal, emacdata->mal_rx_chan);
705
706 if (dev->rx_sg_skb) {
707 ++dev->estats.rx_dropped_resize;
708 dev_kfree_skb(dev->rx_sg_skb);
709 dev->rx_sg_skb = NULL;
710 }
711
712 /* Make a first pass over RX ring and mark BDs ready, dropping
713 * non-processed packets on the way. We need this as a separate pass
714 * to simplify error recovery in the case of allocation failure later.
715 */
716 for (i = 0; i < NUM_RX_BUFF; ++i) {
717 if (dev->rx_desc[i].ctrl & MAL_RX_CTRL_FIRST)
718 ++dev->estats.rx_dropped_resize;
719
720 dev->rx_desc[i].data_len = 0;
721 dev->rx_desc[i].ctrl = MAL_RX_CTRL_EMPTY |
722 (i == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
723 }
724
725 /* Reallocate RX ring only if bigger skb buffers are required */
726 if (rx_skb_size <= dev->rx_skb_size)
727 goto skip;
728
729 /* Second pass, allocate new skbs */
730 for (i = 0; i < NUM_RX_BUFF; ++i) {
731 struct sk_buff *skb = alloc_skb(rx_skb_size, GFP_ATOMIC);
732 if (!skb) {
733 ret = -ENOMEM;
734 goto oom;
735 }
736
737 BUG_ON(!dev->rx_skb[i]);
738 dev_kfree_skb(dev->rx_skb[i]);
739
740 skb_reserve(skb, EMAC_RX_SKB_HEADROOM + 2);
741 dev->rx_desc[i].data_ptr =
742 dma_map_single(dev->ldev, skb->data - 2, rx_sync_size,
743 DMA_FROM_DEVICE) + 2;
744 dev->rx_skb[i] = skb;
745 }
746 skip:
747 /* Check if we need to change "Jumbo" bit in MR1 */
748 if ((new_mtu > ETH_DATA_LEN) ^ (dev->ndev->mtu > ETH_DATA_LEN)) {
749 /* This is to prevent starting RX channel in emac_rx_enable() */
750 dev->commac.rx_stopped = 1;
751
752 dev->ndev->mtu = new_mtu;
753 emac_full_tx_reset(dev->ndev);
754 }
755
756 mal_set_rcbs(dev->mal, emacdata->mal_rx_chan, emac_rx_size(new_mtu));
757 oom:
758 /* Restart RX */
759 dev->commac.rx_stopped = dev->rx_slot = 0;
760 mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
761 emac_rx_enable(dev);
762
763 return ret;
764 }
765
766 /* Process ctx, rtnl_lock semaphore */
767 static int emac_change_mtu(struct net_device *ndev, int new_mtu)
768 {
769 struct ocp_enet_private *dev = ndev->priv;
770 int ret = 0;
771
772 if (new_mtu < EMAC_MIN_MTU || new_mtu > EMAC_MAX_MTU)
773 return -EINVAL;
774
775 DBG("%d: change_mtu(%d)" NL, dev->def->index, new_mtu);
776
777 local_bh_disable();
778 if (netif_running(ndev)) {
779 /* Check if we really need to reinitalize RX ring */
780 if (emac_rx_skb_size(ndev->mtu) != emac_rx_skb_size(new_mtu))
781 ret = emac_resize_rx_ring(dev, new_mtu);
782 }
783
784 if (!ret) {
785 ndev->mtu = new_mtu;
786 dev->rx_skb_size = emac_rx_skb_size(new_mtu);
787 dev->rx_sync_size = emac_rx_sync_size(new_mtu);
788 }
789 local_bh_enable();
790
791 return ret;
792 }
793
794 static void emac_clean_tx_ring(struct ocp_enet_private *dev)
795 {
796 int i;
797 for (i = 0; i < NUM_TX_BUFF; ++i) {
798 if (dev->tx_skb[i]) {
799 dev_kfree_skb(dev->tx_skb[i]);
800 dev->tx_skb[i] = NULL;
801 if (dev->tx_desc[i].ctrl & MAL_TX_CTRL_READY)
802 ++dev->estats.tx_dropped;
803 }
804 dev->tx_desc[i].ctrl = 0;
805 dev->tx_desc[i].data_ptr = 0;
806 }
807 }
808
809 static void emac_clean_rx_ring(struct ocp_enet_private *dev)
810 {
811 int i;
812 for (i = 0; i < NUM_RX_BUFF; ++i)
813 if (dev->rx_skb[i]) {
814 dev->rx_desc[i].ctrl = 0;
815 dev_kfree_skb(dev->rx_skb[i]);
816 dev->rx_skb[i] = NULL;
817 dev->rx_desc[i].data_ptr = 0;
818 }
819
820 if (dev->rx_sg_skb) {
821 dev_kfree_skb(dev->rx_sg_skb);
822 dev->rx_sg_skb = NULL;
823 }
824 }
825
826 static inline int emac_alloc_rx_skb(struct ocp_enet_private *dev, int slot,
827 gfp_t flags)
828 {
829 struct sk_buff *skb = alloc_skb(dev->rx_skb_size, flags);
830 if (unlikely(!skb))
831 return -ENOMEM;
832
833 dev->rx_skb[slot] = skb;
834 dev->rx_desc[slot].data_len = 0;
835
836 skb_reserve(skb, EMAC_RX_SKB_HEADROOM + 2);
837 dev->rx_desc[slot].data_ptr =
838 dma_map_single(dev->ldev, skb->data - 2, dev->rx_sync_size,
839 DMA_FROM_DEVICE) + 2;
840 barrier();
841 dev->rx_desc[slot].ctrl = MAL_RX_CTRL_EMPTY |
842 (slot == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
843
844 return 0;
845 }
846
847 static void emac_print_link_status(struct ocp_enet_private *dev)
848 {
849 if (netif_carrier_ok(dev->ndev))
850 printk(KERN_INFO "%s: link is up, %d %s%s\n",
851 dev->ndev->name, dev->phy.speed,
852 dev->phy.duplex == DUPLEX_FULL ? "FDX" : "HDX",
853 dev->phy.pause ? ", pause enabled" :
854 dev->phy.asym_pause ? ", assymetric pause enabled" : "");
855 else
856 printk(KERN_INFO "%s: link is down\n", dev->ndev->name);
857 }
858
859 /* Process ctx, rtnl_lock semaphore */
860 static int emac_open(struct net_device *ndev)
861 {
862 struct ocp_enet_private *dev = ndev->priv;
863 struct ocp_func_emac_data *emacdata = dev->def->additions;
864 int err, i;
865
866 DBG("%d: open" NL, dev->def->index);
867
868 /* Setup error IRQ handler */
869 err = request_irq(dev->def->irq, emac_irq, 0, "EMAC", dev);
870 if (err) {
871 printk(KERN_ERR "%s: failed to request IRQ %d\n",
872 ndev->name, dev->def->irq);
873 return err;
874 }
875
876 /* Allocate RX ring */
877 for (i = 0; i < NUM_RX_BUFF; ++i)
878 if (emac_alloc_rx_skb(dev, i, GFP_KERNEL)) {
879 printk(KERN_ERR "%s: failed to allocate RX ring\n",
880 ndev->name);
881 goto oom;
882 }
883
884 local_bh_disable();
885 dev->tx_cnt = dev->tx_slot = dev->ack_slot = dev->rx_slot =
886 dev->commac.rx_stopped = 0;
887 dev->rx_sg_skb = NULL;
888
889 if (dev->phy.address >= 0) {
890 int link_poll_interval;
891 if (dev->phy.def->ops->poll_link(&dev->phy)) {
892 dev->phy.def->ops->read_link(&dev->phy);
893 EMAC_RX_CLK_DEFAULT(dev->def->index);
894 netif_carrier_on(dev->ndev);
895 link_poll_interval = PHY_POLL_LINK_ON;
896 } else {
897 EMAC_RX_CLK_TX(dev->def->index);
898 netif_carrier_off(dev->ndev);
899 link_poll_interval = PHY_POLL_LINK_OFF;
900 }
901 mod_timer(&dev->link_timer, jiffies + link_poll_interval);
902 emac_print_link_status(dev);
903 } else
904 netif_carrier_on(dev->ndev);
905
906 emac_configure(dev);
907 mal_poll_add(dev->mal, &dev->commac);
908 mal_enable_tx_channel(dev->mal, emacdata->mal_tx_chan);
909 mal_set_rcbs(dev->mal, emacdata->mal_rx_chan, emac_rx_size(ndev->mtu));
910 mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
911 emac_tx_enable(dev);
912 emac_rx_enable(dev);
913 netif_start_queue(ndev);
914 local_bh_enable();
915
916 return 0;
917 oom:
918 emac_clean_rx_ring(dev);
919 free_irq(dev->def->irq, dev);
920 return -ENOMEM;
921 }
922
923 /* BHs disabled */
924 static int emac_link_differs(struct ocp_enet_private *dev)
925 {
926 u32 r = in_be32(&dev->emacp->mr1);
927
928 int duplex = r & EMAC_MR1_FDE ? DUPLEX_FULL : DUPLEX_HALF;
929 int speed, pause, asym_pause;
930
931 if (r & (EMAC_MR1_MF_1000 | EMAC_MR1_MF_1000GPCS))
932 speed = SPEED_1000;
933 else if (r & EMAC_MR1_MF_100)
934 speed = SPEED_100;
935 else
936 speed = SPEED_10;
937
938 switch (r & (EMAC_MR1_EIFC | EMAC_MR1_APP)) {
939 case (EMAC_MR1_EIFC | EMAC_MR1_APP):
940 pause = 1;
941 asym_pause = 0;
942 break;
943 case EMAC_MR1_APP:
944 pause = 0;
945 asym_pause = 1;
946 break;
947 default:
948 pause = asym_pause = 0;
949 }
950 return speed != dev->phy.speed || duplex != dev->phy.duplex ||
951 pause != dev->phy.pause || asym_pause != dev->phy.asym_pause;
952 }
953
954 /* BHs disabled */
955 static void emac_link_timer(unsigned long data)
956 {
957 struct ocp_enet_private *dev = (struct ocp_enet_private *)data;
958 int link_poll_interval;
959
960 DBG2("%d: link timer" NL, dev->def->index);
961
962 if (dev->phy.def->ops->poll_link(&dev->phy)) {
963 if (!netif_carrier_ok(dev->ndev)) {
964 EMAC_RX_CLK_DEFAULT(dev->def->index);
965
966 /* Get new link parameters */
967 dev->phy.def->ops->read_link(&dev->phy);
968
969 if (dev->tah_dev || emac_link_differs(dev))
970 emac_full_tx_reset(dev->ndev);
971
972 netif_carrier_on(dev->ndev);
973 emac_print_link_status(dev);
974 }
975 link_poll_interval = PHY_POLL_LINK_ON;
976 } else {
977 if (netif_carrier_ok(dev->ndev)) {
978 EMAC_RX_CLK_TX(dev->def->index);
979 #if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX)
980 emac_reinitialize(dev);
981 #endif
982 netif_carrier_off(dev->ndev);
983 emac_print_link_status(dev);
984 }
985
986 /* Retry reset if the previous attempt failed.
987 * This is needed mostly for CONFIG_IBM_EMAC_PHY_RX_CLK_FIX
988 * case, but I left it here because it shouldn't trigger for
989 * sane PHYs anyway.
990 */
991 if (unlikely(dev->reset_failed))
992 emac_reinitialize(dev);
993
994 link_poll_interval = PHY_POLL_LINK_OFF;
995 }
996 mod_timer(&dev->link_timer, jiffies + link_poll_interval);
997 }
998
999 /* BHs disabled */
1000 static void emac_force_link_update(struct ocp_enet_private *dev)
1001 {
1002 netif_carrier_off(dev->ndev);
1003 if (timer_pending(&dev->link_timer))
1004 mod_timer(&dev->link_timer, jiffies + PHY_POLL_LINK_OFF);
1005 }
1006
1007 /* Process ctx, rtnl_lock semaphore */
1008 static int emac_close(struct net_device *ndev)
1009 {
1010 struct ocp_enet_private *dev = ndev->priv;
1011 struct ocp_func_emac_data *emacdata = dev->def->additions;
1012
1013 DBG("%d: close" NL, dev->def->index);
1014
1015 local_bh_disable();
1016
1017 if (dev->phy.address >= 0)
1018 del_timer_sync(&dev->link_timer);
1019
1020 netif_stop_queue(ndev);
1021 emac_rx_disable(dev);
1022 emac_tx_disable(dev);
1023 mal_disable_rx_channel(dev->mal, emacdata->mal_rx_chan);
1024 mal_disable_tx_channel(dev->mal, emacdata->mal_tx_chan);
1025 mal_poll_del(dev->mal, &dev->commac);
1026 local_bh_enable();
1027
1028 emac_clean_tx_ring(dev);
1029 emac_clean_rx_ring(dev);
1030 free_irq(dev->def->irq, dev);
1031
1032 return 0;
1033 }
1034
1035 static inline u16 emac_tx_csum(struct ocp_enet_private *dev,
1036 struct sk_buff *skb)
1037 {
1038 #if defined(CONFIG_IBM_EMAC_TAH)
1039 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1040 ++dev->stats.tx_packets_csum;
1041 return EMAC_TX_CTRL_TAH_CSUM;
1042 }
1043 #endif
1044 return 0;
1045 }
1046
1047 static inline int emac_xmit_finish(struct ocp_enet_private *dev, int len)
1048 {
1049 struct emac_regs __iomem *p = dev->emacp;
1050 struct net_device *ndev = dev->ndev;
1051
1052 /* Send the packet out */
1053 out_be32(&p->tmr0, EMAC_TMR0_XMIT);
1054
1055 if (unlikely(++dev->tx_cnt == NUM_TX_BUFF)) {
1056 netif_stop_queue(ndev);
1057 DBG2("%d: stopped TX queue" NL, dev->def->index);
1058 }
1059
1060 ndev->trans_start = jiffies;
1061 ++dev->stats.tx_packets;
1062 dev->stats.tx_bytes += len;
1063
1064 return 0;
1065 }
1066
1067 /* BHs disabled */
1068 static int emac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1069 {
1070 struct ocp_enet_private *dev = ndev->priv;
1071 unsigned int len = skb->len;
1072 int slot;
1073
1074 u16 ctrl = EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP | MAL_TX_CTRL_READY |
1075 MAL_TX_CTRL_LAST | emac_tx_csum(dev, skb);
1076
1077 slot = dev->tx_slot++;
1078 if (dev->tx_slot == NUM_TX_BUFF) {
1079 dev->tx_slot = 0;
1080 ctrl |= MAL_TX_CTRL_WRAP;
1081 }
1082
1083 DBG2("%d: xmit(%u) %d" NL, dev->def->index, len, slot);
1084
1085 dev->tx_skb[slot] = skb;
1086 dev->tx_desc[slot].data_ptr = dma_map_single(dev->ldev, skb->data, len,
1087 DMA_TO_DEVICE);
1088 dev->tx_desc[slot].data_len = (u16) len;
1089 barrier();
1090 dev->tx_desc[slot].ctrl = ctrl;
1091
1092 return emac_xmit_finish(dev, len);
1093 }
1094
1095 #if defined(CONFIG_IBM_EMAC_TAH)
1096 static inline int emac_xmit_split(struct ocp_enet_private *dev, int slot,
1097 u32 pd, int len, int last, u16 base_ctrl)
1098 {
1099 while (1) {
1100 u16 ctrl = base_ctrl;
1101 int chunk = min(len, MAL_MAX_TX_SIZE);
1102 len -= chunk;
1103
1104 slot = (slot + 1) % NUM_TX_BUFF;
1105
1106 if (last && !len)
1107 ctrl |= MAL_TX_CTRL_LAST;
1108 if (slot == NUM_TX_BUFF - 1)
1109 ctrl |= MAL_TX_CTRL_WRAP;
1110
1111 dev->tx_skb[slot] = NULL;
1112 dev->tx_desc[slot].data_ptr = pd;
1113 dev->tx_desc[slot].data_len = (u16) chunk;
1114 dev->tx_desc[slot].ctrl = ctrl;
1115 ++dev->tx_cnt;
1116
1117 if (!len)
1118 break;
1119
1120 pd += chunk;
1121 }
1122 return slot;
1123 }
1124
1125 /* BHs disabled (SG version for TAH equipped EMACs) */
1126 static int emac_start_xmit_sg(struct sk_buff *skb, struct net_device *ndev)
1127 {
1128 struct ocp_enet_private *dev = ndev->priv;
1129 int nr_frags = skb_shinfo(skb)->nr_frags;
1130 int len = skb->len, chunk;
1131 int slot, i;
1132 u16 ctrl;
1133 u32 pd;
1134
1135 /* This is common "fast" path */
1136 if (likely(!nr_frags && len <= MAL_MAX_TX_SIZE))
1137 return emac_start_xmit(skb, ndev);
1138
1139 len -= skb->data_len;
1140
1141 /* Note, this is only an *estimation*, we can still run out of empty
1142 * slots because of the additional fragmentation into
1143 * MAL_MAX_TX_SIZE-sized chunks
1144 */
1145 if (unlikely(dev->tx_cnt + nr_frags + mal_tx_chunks(len) > NUM_TX_BUFF))
1146 goto stop_queue;
1147
1148 ctrl = EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP | MAL_TX_CTRL_READY |
1149 emac_tx_csum(dev, skb);
1150 slot = dev->tx_slot;
1151
1152 /* skb data */
1153 dev->tx_skb[slot] = NULL;
1154 chunk = min(len, MAL_MAX_TX_SIZE);
1155 dev->tx_desc[slot].data_ptr = pd =
1156 dma_map_single(dev->ldev, skb->data, len, DMA_TO_DEVICE);
1157 dev->tx_desc[slot].data_len = (u16) chunk;
1158 len -= chunk;
1159 if (unlikely(len))
1160 slot = emac_xmit_split(dev, slot, pd + chunk, len, !nr_frags,
1161 ctrl);
1162 /* skb fragments */
1163 for (i = 0; i < nr_frags; ++i) {
1164 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
1165 len = frag->size;
1166
1167 if (unlikely(dev->tx_cnt + mal_tx_chunks(len) >= NUM_TX_BUFF))
1168 goto undo_frame;
1169
1170 pd = dma_map_page(dev->ldev, frag->page, frag->page_offset, len,
1171 DMA_TO_DEVICE);
1172
1173 slot = emac_xmit_split(dev, slot, pd, len, i == nr_frags - 1,
1174 ctrl);
1175 }
1176
1177 DBG2("%d: xmit_sg(%u) %d - %d" NL, dev->def->index, skb->len,
1178 dev->tx_slot, slot);
1179
1180 /* Attach skb to the last slot so we don't release it too early */
1181 dev->tx_skb[slot] = skb;
1182
1183 /* Send the packet out */
1184 if (dev->tx_slot == NUM_TX_BUFF - 1)
1185 ctrl |= MAL_TX_CTRL_WRAP;
1186 barrier();
1187 dev->tx_desc[dev->tx_slot].ctrl = ctrl;
1188 dev->tx_slot = (slot + 1) % NUM_TX_BUFF;
1189
1190 return emac_xmit_finish(dev, skb->len);
1191
1192 undo_frame:
1193 /* Well, too bad. Our previous estimation was overly optimistic.
1194 * Undo everything.
1195 */
1196 while (slot != dev->tx_slot) {
1197 dev->tx_desc[slot].ctrl = 0;
1198 --dev->tx_cnt;
1199 if (--slot < 0)
1200 slot = NUM_TX_BUFF - 1;
1201 }
1202 ++dev->estats.tx_undo;
1203
1204 stop_queue:
1205 netif_stop_queue(ndev);
1206 DBG2("%d: stopped TX queue" NL, dev->def->index);
1207 return 1;
1208 }
1209 #else
1210 # define emac_start_xmit_sg emac_start_xmit
1211 #endif /* !defined(CONFIG_IBM_EMAC_TAH) */
1212
1213 /* BHs disabled */
1214 static void emac_parse_tx_error(struct ocp_enet_private *dev, u16 ctrl)
1215 {
1216 struct ibm_emac_error_stats *st = &dev->estats;
1217 DBG("%d: BD TX error %04x" NL, dev->def->index, ctrl);
1218
1219 ++st->tx_bd_errors;
1220 if (ctrl & EMAC_TX_ST_BFCS)
1221 ++st->tx_bd_bad_fcs;
1222 if (ctrl & EMAC_TX_ST_LCS)
1223 ++st->tx_bd_carrier_loss;
1224 if (ctrl & EMAC_TX_ST_ED)
1225 ++st->tx_bd_excessive_deferral;
1226 if (ctrl & EMAC_TX_ST_EC)
1227 ++st->tx_bd_excessive_collisions;
1228 if (ctrl & EMAC_TX_ST_LC)
1229 ++st->tx_bd_late_collision;
1230 if (ctrl & EMAC_TX_ST_MC)
1231 ++st->tx_bd_multple_collisions;
1232 if (ctrl & EMAC_TX_ST_SC)
1233 ++st->tx_bd_single_collision;
1234 if (ctrl & EMAC_TX_ST_UR)
1235 ++st->tx_bd_underrun;
1236 if (ctrl & EMAC_TX_ST_SQE)
1237 ++st->tx_bd_sqe;
1238 }
1239
1240 static void emac_poll_tx(void *param)
1241 {
1242 struct ocp_enet_private *dev = param;
1243 DBG2("%d: poll_tx, %d %d" NL, dev->def->index, dev->tx_cnt,
1244 dev->ack_slot);
1245
1246 if (dev->tx_cnt) {
1247 u16 ctrl;
1248 int slot = dev->ack_slot, n = 0;
1249 again:
1250 ctrl = dev->tx_desc[slot].ctrl;
1251 if (!(ctrl & MAL_TX_CTRL_READY)) {
1252 struct sk_buff *skb = dev->tx_skb[slot];
1253 ++n;
1254
1255 if (skb) {
1256 dev_kfree_skb(skb);
1257 dev->tx_skb[slot] = NULL;
1258 }
1259 slot = (slot + 1) % NUM_TX_BUFF;
1260
1261 if (unlikely(EMAC_IS_BAD_TX(ctrl)))
1262 emac_parse_tx_error(dev, ctrl);
1263
1264 if (--dev->tx_cnt)
1265 goto again;
1266 }
1267 if (n) {
1268 dev->ack_slot = slot;
1269 if (netif_queue_stopped(dev->ndev) &&
1270 dev->tx_cnt < EMAC_TX_WAKEUP_THRESH)
1271 netif_wake_queue(dev->ndev);
1272
1273 DBG2("%d: tx %d pkts" NL, dev->def->index, n);
1274 }
1275 }
1276 }
1277
1278 static inline void emac_recycle_rx_skb(struct ocp_enet_private *dev, int slot,
1279 int len)
1280 {
1281 struct sk_buff *skb = dev->rx_skb[slot];
1282 DBG2("%d: recycle %d %d" NL, dev->def->index, slot, len);
1283
1284 if (len)
1285 dma_map_single(dev->ldev, skb->data - 2,
1286 EMAC_DMA_ALIGN(len + 2), DMA_FROM_DEVICE);
1287
1288 dev->rx_desc[slot].data_len = 0;
1289 barrier();
1290 dev->rx_desc[slot].ctrl = MAL_RX_CTRL_EMPTY |
1291 (slot == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
1292 }
1293
1294 static void emac_parse_rx_error(struct ocp_enet_private *dev, u16 ctrl)
1295 {
1296 struct ibm_emac_error_stats *st = &dev->estats;
1297 DBG("%d: BD RX error %04x" NL, dev->def->index, ctrl);
1298
1299 ++st->rx_bd_errors;
1300 if (ctrl & EMAC_RX_ST_OE)
1301 ++st->rx_bd_overrun;
1302 if (ctrl & EMAC_RX_ST_BP)
1303 ++st->rx_bd_bad_packet;
1304 if (ctrl & EMAC_RX_ST_RP)
1305 ++st->rx_bd_runt_packet;
1306 if (ctrl & EMAC_RX_ST_SE)
1307 ++st->rx_bd_short_event;
1308 if (ctrl & EMAC_RX_ST_AE)
1309 ++st->rx_bd_alignment_error;
1310 if (ctrl & EMAC_RX_ST_BFCS)
1311 ++st->rx_bd_bad_fcs;
1312 if (ctrl & EMAC_RX_ST_PTL)
1313 ++st->rx_bd_packet_too_long;
1314 if (ctrl & EMAC_RX_ST_ORE)
1315 ++st->rx_bd_out_of_range;
1316 if (ctrl & EMAC_RX_ST_IRE)
1317 ++st->rx_bd_in_range;
1318 }
1319
1320 static inline void emac_rx_csum(struct ocp_enet_private *dev,
1321 struct sk_buff *skb, u16 ctrl)
1322 {
1323 #if defined(CONFIG_IBM_EMAC_TAH)
1324 if (!ctrl && dev->tah_dev) {
1325 skb->ip_summed = CHECKSUM_UNNECESSARY;
1326 ++dev->stats.rx_packets_csum;
1327 }
1328 #endif
1329 }
1330
1331 static inline int emac_rx_sg_append(struct ocp_enet_private *dev, int slot)
1332 {
1333 if (likely(dev->rx_sg_skb != NULL)) {
1334 int len = dev->rx_desc[slot].data_len;
1335 int tot_len = dev->rx_sg_skb->len + len;
1336
1337 if (unlikely(tot_len + 2 > dev->rx_skb_size)) {
1338 ++dev->estats.rx_dropped_mtu;
1339 dev_kfree_skb(dev->rx_sg_skb);
1340 dev->rx_sg_skb = NULL;
1341 } else {
1342 cacheable_memcpy(dev->rx_sg_skb->tail,
1343 dev->rx_skb[slot]->data, len);
1344 skb_put(dev->rx_sg_skb, len);
1345 emac_recycle_rx_skb(dev, slot, len);
1346 return 0;
1347 }
1348 }
1349 emac_recycle_rx_skb(dev, slot, 0);
1350 return -1;
1351 }
1352
1353 /* BHs disabled */
1354 static int emac_poll_rx(void *param, int budget)
1355 {
1356 struct ocp_enet_private *dev = param;
1357 int slot = dev->rx_slot, received = 0;
1358
1359 DBG2("%d: poll_rx(%d)" NL, dev->def->index, budget);
1360
1361 again:
1362 while (budget > 0) {
1363 int len;
1364 struct sk_buff *skb;
1365 u16 ctrl = dev->rx_desc[slot].ctrl;
1366
1367 if (ctrl & MAL_RX_CTRL_EMPTY)
1368 break;
1369
1370 skb = dev->rx_skb[slot];
1371 barrier();
1372 len = dev->rx_desc[slot].data_len;
1373
1374 if (unlikely(!MAL_IS_SINGLE_RX(ctrl)))
1375 goto sg;
1376
1377 ctrl &= EMAC_BAD_RX_MASK;
1378 if (unlikely(ctrl && ctrl != EMAC_RX_TAH_BAD_CSUM)) {
1379 emac_parse_rx_error(dev, ctrl);
1380 ++dev->estats.rx_dropped_error;
1381 emac_recycle_rx_skb(dev, slot, 0);
1382 len = 0;
1383 goto next;
1384 }
1385
1386 if (len && len < EMAC_RX_COPY_THRESH) {
1387 struct sk_buff *copy_skb =
1388 alloc_skb(len + EMAC_RX_SKB_HEADROOM + 2, GFP_ATOMIC);
1389 if (unlikely(!copy_skb))
1390 goto oom;
1391
1392 skb_reserve(copy_skb, EMAC_RX_SKB_HEADROOM + 2);
1393 cacheable_memcpy(copy_skb->data - 2, skb->data - 2,
1394 len + 2);
1395 emac_recycle_rx_skb(dev, slot, len);
1396 skb = copy_skb;
1397 } else if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC)))
1398 goto oom;
1399
1400 skb_put(skb, len);
1401 push_packet:
1402 skb->dev = dev->ndev;
1403 skb->protocol = eth_type_trans(skb, dev->ndev);
1404 emac_rx_csum(dev, skb, ctrl);
1405
1406 if (unlikely(netif_receive_skb(skb) == NET_RX_DROP))
1407 ++dev->estats.rx_dropped_stack;
1408 next:
1409 ++dev->stats.rx_packets;
1410 skip:
1411 dev->stats.rx_bytes += len;
1412 slot = (slot + 1) % NUM_RX_BUFF;
1413 --budget;
1414 ++received;
1415 continue;
1416 sg:
1417 if (ctrl & MAL_RX_CTRL_FIRST) {
1418 BUG_ON(dev->rx_sg_skb);
1419 if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC))) {
1420 DBG("%d: rx OOM %d" NL, dev->def->index, slot);
1421 ++dev->estats.rx_dropped_oom;
1422 emac_recycle_rx_skb(dev, slot, 0);
1423 } else {
1424 dev->rx_sg_skb = skb;
1425 skb_put(skb, len);
1426 }
1427 } else if (!emac_rx_sg_append(dev, slot) &&
1428 (ctrl & MAL_RX_CTRL_LAST)) {
1429
1430 skb = dev->rx_sg_skb;
1431 dev->rx_sg_skb = NULL;
1432
1433 ctrl &= EMAC_BAD_RX_MASK;
1434 if (unlikely(ctrl && ctrl != EMAC_RX_TAH_BAD_CSUM)) {
1435 emac_parse_rx_error(dev, ctrl);
1436 ++dev->estats.rx_dropped_error;
1437 dev_kfree_skb(skb);
1438 len = 0;
1439 } else
1440 goto push_packet;
1441 }
1442 goto skip;
1443 oom:
1444 DBG("%d: rx OOM %d" NL, dev->def->index, slot);
1445 /* Drop the packet and recycle skb */
1446 ++dev->estats.rx_dropped_oom;
1447 emac_recycle_rx_skb(dev, slot, 0);
1448 goto next;
1449 }
1450
1451 if (received) {
1452 DBG2("%d: rx %d BDs" NL, dev->def->index, received);
1453 dev->rx_slot = slot;
1454 }
1455
1456 if (unlikely(budget && dev->commac.rx_stopped)) {
1457 struct ocp_func_emac_data *emacdata = dev->def->additions;
1458
1459 barrier();
1460 if (!(dev->rx_desc[slot].ctrl & MAL_RX_CTRL_EMPTY)) {
1461 DBG2("%d: rx restart" NL, dev->def->index);
1462 received = 0;
1463 goto again;
1464 }
1465
1466 if (dev->rx_sg_skb) {
1467 DBG2("%d: dropping partial rx packet" NL,
1468 dev->def->index);
1469 ++dev->estats.rx_dropped_error;
1470 dev_kfree_skb(dev->rx_sg_skb);
1471 dev->rx_sg_skb = NULL;
1472 }
1473
1474 dev->commac.rx_stopped = 0;
1475 mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
1476 emac_rx_enable(dev);
1477 dev->rx_slot = 0;
1478 }
1479 return received;
1480 }
1481
1482 /* BHs disabled */
1483 static int emac_peek_rx(void *param)
1484 {
1485 struct ocp_enet_private *dev = param;
1486 return !(dev->rx_desc[dev->rx_slot].ctrl & MAL_RX_CTRL_EMPTY);
1487 }
1488
1489 /* BHs disabled */
1490 static int emac_peek_rx_sg(void *param)
1491 {
1492 struct ocp_enet_private *dev = param;
1493 int slot = dev->rx_slot;
1494 while (1) {
1495 u16 ctrl = dev->rx_desc[slot].ctrl;
1496 if (ctrl & MAL_RX_CTRL_EMPTY)
1497 return 0;
1498 else if (ctrl & MAL_RX_CTRL_LAST)
1499 return 1;
1500
1501 slot = (slot + 1) % NUM_RX_BUFF;
1502
1503 /* I'm just being paranoid here :) */
1504 if (unlikely(slot == dev->rx_slot))
1505 return 0;
1506 }
1507 }
1508
1509 /* Hard IRQ */
1510 static void emac_rxde(void *param)
1511 {
1512 struct ocp_enet_private *dev = param;
1513 ++dev->estats.rx_stopped;
1514 emac_rx_disable_async(dev);
1515 }
1516
1517 /* Hard IRQ */
1518 static irqreturn_t emac_irq(int irq, void *dev_instance)
1519 {
1520 struct ocp_enet_private *dev = dev_instance;
1521 struct emac_regs __iomem *p = dev->emacp;
1522 struct ibm_emac_error_stats *st = &dev->estats;
1523
1524 u32 isr = in_be32(&p->isr);
1525 out_be32(&p->isr, isr);
1526
1527 DBG("%d: isr = %08x" NL, dev->def->index, isr);
1528
1529 if (isr & EMAC_ISR_TXPE)
1530 ++st->tx_parity;
1531 if (isr & EMAC_ISR_RXPE)
1532 ++st->rx_parity;
1533 if (isr & EMAC_ISR_TXUE)
1534 ++st->tx_underrun;
1535 if (isr & EMAC_ISR_RXOE)
1536 ++st->rx_fifo_overrun;
1537 if (isr & EMAC_ISR_OVR)
1538 ++st->rx_overrun;
1539 if (isr & EMAC_ISR_BP)
1540 ++st->rx_bad_packet;
1541 if (isr & EMAC_ISR_RP)
1542 ++st->rx_runt_packet;
1543 if (isr & EMAC_ISR_SE)
1544 ++st->rx_short_event;
1545 if (isr & EMAC_ISR_ALE)
1546 ++st->rx_alignment_error;
1547 if (isr & EMAC_ISR_BFCS)
1548 ++st->rx_bad_fcs;
1549 if (isr & EMAC_ISR_PTLE)
1550 ++st->rx_packet_too_long;
1551 if (isr & EMAC_ISR_ORE)
1552 ++st->rx_out_of_range;
1553 if (isr & EMAC_ISR_IRE)
1554 ++st->rx_in_range;
1555 if (isr & EMAC_ISR_SQE)
1556 ++st->tx_sqe;
1557 if (isr & EMAC_ISR_TE)
1558 ++st->tx_errors;
1559
1560 return IRQ_HANDLED;
1561 }
1562
1563 static struct net_device_stats *emac_stats(struct net_device *ndev)
1564 {
1565 struct ocp_enet_private *dev = ndev->priv;
1566 struct ibm_emac_stats *st = &dev->stats;
1567 struct ibm_emac_error_stats *est = &dev->estats;
1568 struct net_device_stats *nst = &dev->nstats;
1569
1570 DBG2("%d: stats" NL, dev->def->index);
1571
1572 /* Compute "legacy" statistics */
1573 local_irq_disable();
1574 nst->rx_packets = (unsigned long)st->rx_packets;
1575 nst->rx_bytes = (unsigned long)st->rx_bytes;
1576 nst->tx_packets = (unsigned long)st->tx_packets;
1577 nst->tx_bytes = (unsigned long)st->tx_bytes;
1578 nst->rx_dropped = (unsigned long)(est->rx_dropped_oom +
1579 est->rx_dropped_error +
1580 est->rx_dropped_resize +
1581 est->rx_dropped_mtu);
1582 nst->tx_dropped = (unsigned long)est->tx_dropped;
1583
1584 nst->rx_errors = (unsigned long)est->rx_bd_errors;
1585 nst->rx_fifo_errors = (unsigned long)(est->rx_bd_overrun +
1586 est->rx_fifo_overrun +
1587 est->rx_overrun);
1588 nst->rx_frame_errors = (unsigned long)(est->rx_bd_alignment_error +
1589 est->rx_alignment_error);
1590 nst->rx_crc_errors = (unsigned long)(est->rx_bd_bad_fcs +
1591 est->rx_bad_fcs);
1592 nst->rx_length_errors = (unsigned long)(est->rx_bd_runt_packet +
1593 est->rx_bd_short_event +
1594 est->rx_bd_packet_too_long +
1595 est->rx_bd_out_of_range +
1596 est->rx_bd_in_range +
1597 est->rx_runt_packet +
1598 est->rx_short_event +
1599 est->rx_packet_too_long +
1600 est->rx_out_of_range +
1601 est->rx_in_range);
1602
1603 nst->tx_errors = (unsigned long)(est->tx_bd_errors + est->tx_errors);
1604 nst->tx_fifo_errors = (unsigned long)(est->tx_bd_underrun +
1605 est->tx_underrun);
1606 nst->tx_carrier_errors = (unsigned long)est->tx_bd_carrier_loss;
1607 nst->collisions = (unsigned long)(est->tx_bd_excessive_deferral +
1608 est->tx_bd_excessive_collisions +
1609 est->tx_bd_late_collision +
1610 est->tx_bd_multple_collisions);
1611 local_irq_enable();
1612 return nst;
1613 }
1614
1615 static void emac_remove(struct ocp_device *ocpdev)
1616 {
1617 struct ocp_enet_private *dev = ocp_get_drvdata(ocpdev);
1618
1619 DBG("%d: remove" NL, dev->def->index);
1620
1621 ocp_set_drvdata(ocpdev, NULL);
1622 unregister_netdev(dev->ndev);
1623
1624 tah_fini(dev->tah_dev);
1625 rgmii_fini(dev->rgmii_dev, dev->rgmii_input);
1626 zmii_fini(dev->zmii_dev, dev->zmii_input);
1627
1628 emac_dbg_register(dev->def->index, NULL);
1629
1630 mal_unregister_commac(dev->mal, &dev->commac);
1631 iounmap(dev->emacp);
1632 kfree(dev->ndev);
1633 }
1634
1635 static struct mal_commac_ops emac_commac_ops = {
1636 .poll_tx = &emac_poll_tx,
1637 .poll_rx = &emac_poll_rx,
1638 .peek_rx = &emac_peek_rx,
1639 .rxde = &emac_rxde,
1640 };
1641
1642 static struct mal_commac_ops emac_commac_sg_ops = {
1643 .poll_tx = &emac_poll_tx,
1644 .poll_rx = &emac_poll_rx,
1645 .peek_rx = &emac_peek_rx_sg,
1646 .rxde = &emac_rxde,
1647 };
1648
1649 /* Ethtool support */
1650 static int emac_ethtool_get_settings(struct net_device *ndev,
1651 struct ethtool_cmd *cmd)
1652 {
1653 struct ocp_enet_private *dev = ndev->priv;
1654
1655 cmd->supported = dev->phy.features;
1656 cmd->port = PORT_MII;
1657 cmd->phy_address = dev->phy.address;
1658 cmd->transceiver =
1659 dev->phy.address >= 0 ? XCVR_EXTERNAL : XCVR_INTERNAL;
1660
1661 local_bh_disable();
1662 cmd->advertising = dev->phy.advertising;
1663 cmd->autoneg = dev->phy.autoneg;
1664 cmd->speed = dev->phy.speed;
1665 cmd->duplex = dev->phy.duplex;
1666 local_bh_enable();
1667
1668 return 0;
1669 }
1670
1671 static int emac_ethtool_set_settings(struct net_device *ndev,
1672 struct ethtool_cmd *cmd)
1673 {
1674 struct ocp_enet_private *dev = ndev->priv;
1675 u32 f = dev->phy.features;
1676
1677 DBG("%d: set_settings(%d, %d, %d, 0x%08x)" NL, dev->def->index,
1678 cmd->autoneg, cmd->speed, cmd->duplex, cmd->advertising);
1679
1680 /* Basic sanity checks */
1681 if (dev->phy.address < 0)
1682 return -EOPNOTSUPP;
1683 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
1684 return -EINVAL;
1685 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
1686 return -EINVAL;
1687 if (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL)
1688 return -EINVAL;
1689
1690 if (cmd->autoneg == AUTONEG_DISABLE) {
1691 switch (cmd->speed) {
1692 case SPEED_10:
1693 if (cmd->duplex == DUPLEX_HALF
1694 && !(f & SUPPORTED_10baseT_Half))
1695 return -EINVAL;
1696 if (cmd->duplex == DUPLEX_FULL
1697 && !(f & SUPPORTED_10baseT_Full))
1698 return -EINVAL;
1699 break;
1700 case SPEED_100:
1701 if (cmd->duplex == DUPLEX_HALF
1702 && !(f & SUPPORTED_100baseT_Half))
1703 return -EINVAL;
1704 if (cmd->duplex == DUPLEX_FULL
1705 && !(f & SUPPORTED_100baseT_Full))
1706 return -EINVAL;
1707 break;
1708 case SPEED_1000:
1709 if (cmd->duplex == DUPLEX_HALF
1710 && !(f & SUPPORTED_1000baseT_Half))
1711 return -EINVAL;
1712 if (cmd->duplex == DUPLEX_FULL
1713 && !(f & SUPPORTED_1000baseT_Full))
1714 return -EINVAL;
1715 break;
1716 default:
1717 return -EINVAL;
1718 }
1719
1720 local_bh_disable();
1721 dev->phy.def->ops->setup_forced(&dev->phy, cmd->speed,
1722 cmd->duplex);
1723
1724 } else {
1725 if (!(f & SUPPORTED_Autoneg))
1726 return -EINVAL;
1727
1728 local_bh_disable();
1729 dev->phy.def->ops->setup_aneg(&dev->phy,
1730 (cmd->advertising & f) |
1731 (dev->phy.advertising &
1732 (ADVERTISED_Pause |
1733 ADVERTISED_Asym_Pause)));
1734 }
1735 emac_force_link_update(dev);
1736 local_bh_enable();
1737
1738 return 0;
1739 }
1740
1741 static void emac_ethtool_get_ringparam(struct net_device *ndev,
1742 struct ethtool_ringparam *rp)
1743 {
1744 rp->rx_max_pending = rp->rx_pending = NUM_RX_BUFF;
1745 rp->tx_max_pending = rp->tx_pending = NUM_TX_BUFF;
1746 }
1747
1748 static void emac_ethtool_get_pauseparam(struct net_device *ndev,
1749 struct ethtool_pauseparam *pp)
1750 {
1751 struct ocp_enet_private *dev = ndev->priv;
1752
1753 local_bh_disable();
1754 if ((dev->phy.features & SUPPORTED_Autoneg) &&
1755 (dev->phy.advertising & (ADVERTISED_Pause | ADVERTISED_Asym_Pause)))
1756 pp->autoneg = 1;
1757
1758 if (dev->phy.duplex == DUPLEX_FULL) {
1759 if (dev->phy.pause)
1760 pp->rx_pause = pp->tx_pause = 1;
1761 else if (dev->phy.asym_pause)
1762 pp->tx_pause = 1;
1763 }
1764 local_bh_enable();
1765 }
1766
1767 static u32 emac_ethtool_get_rx_csum(struct net_device *ndev)
1768 {
1769 struct ocp_enet_private *dev = ndev->priv;
1770 return dev->tah_dev != 0;
1771 }
1772
1773 static int emac_get_regs_len(struct ocp_enet_private *dev)
1774 {
1775 return sizeof(struct emac_ethtool_regs_subhdr) + EMAC_ETHTOOL_REGS_SIZE;
1776 }
1777
1778 static int emac_ethtool_get_regs_len(struct net_device *ndev)
1779 {
1780 struct ocp_enet_private *dev = ndev->priv;
1781 return sizeof(struct emac_ethtool_regs_hdr) +
1782 emac_get_regs_len(dev) + mal_get_regs_len(dev->mal) +
1783 zmii_get_regs_len(dev->zmii_dev) +
1784 rgmii_get_regs_len(dev->rgmii_dev) +
1785 tah_get_regs_len(dev->tah_dev);
1786 }
1787
1788 static void *emac_dump_regs(struct ocp_enet_private *dev, void *buf)
1789 {
1790 struct emac_ethtool_regs_subhdr *hdr = buf;
1791
1792 hdr->version = EMAC_ETHTOOL_REGS_VER;
1793 hdr->index = dev->def->index;
1794 memcpy_fromio(hdr + 1, dev->emacp, EMAC_ETHTOOL_REGS_SIZE);
1795 return ((void *)(hdr + 1) + EMAC_ETHTOOL_REGS_SIZE);
1796 }
1797
1798 static void emac_ethtool_get_regs(struct net_device *ndev,
1799 struct ethtool_regs *regs, void *buf)
1800 {
1801 struct ocp_enet_private *dev = ndev->priv;
1802 struct emac_ethtool_regs_hdr *hdr = buf;
1803
1804 hdr->components = 0;
1805 buf = hdr + 1;
1806
1807 local_irq_disable();
1808 buf = mal_dump_regs(dev->mal, buf);
1809 buf = emac_dump_regs(dev, buf);
1810 if (dev->zmii_dev) {
1811 hdr->components |= EMAC_ETHTOOL_REGS_ZMII;
1812 buf = zmii_dump_regs(dev->zmii_dev, buf);
1813 }
1814 if (dev->rgmii_dev) {
1815 hdr->components |= EMAC_ETHTOOL_REGS_RGMII;
1816 buf = rgmii_dump_regs(dev->rgmii_dev, buf);
1817 }
1818 if (dev->tah_dev) {
1819 hdr->components |= EMAC_ETHTOOL_REGS_TAH;
1820 buf = tah_dump_regs(dev->tah_dev, buf);
1821 }
1822 local_irq_enable();
1823 }
1824
1825 static int emac_ethtool_nway_reset(struct net_device *ndev)
1826 {
1827 struct ocp_enet_private *dev = ndev->priv;
1828 int res = 0;
1829
1830 DBG("%d: nway_reset" NL, dev->def->index);
1831
1832 if (dev->phy.address < 0)
1833 return -EOPNOTSUPP;
1834
1835 local_bh_disable();
1836 if (!dev->phy.autoneg) {
1837 res = -EINVAL;
1838 goto out;
1839 }
1840
1841 dev->phy.def->ops->setup_aneg(&dev->phy, dev->phy.advertising);
1842 emac_force_link_update(dev);
1843
1844 out:
1845 local_bh_enable();
1846 return res;
1847 }
1848
1849 static int emac_ethtool_get_stats_count(struct net_device *ndev)
1850 {
1851 return EMAC_ETHTOOL_STATS_COUNT;
1852 }
1853
1854 static void emac_ethtool_get_strings(struct net_device *ndev, u32 stringset,
1855 u8 * buf)
1856 {
1857 if (stringset == ETH_SS_STATS)
1858 memcpy(buf, &emac_stats_keys, sizeof(emac_stats_keys));
1859 }
1860
1861 static void emac_ethtool_get_ethtool_stats(struct net_device *ndev,
1862 struct ethtool_stats *estats,
1863 u64 * tmp_stats)
1864 {
1865 struct ocp_enet_private *dev = ndev->priv;
1866 local_irq_disable();
1867 memcpy(tmp_stats, &dev->stats, sizeof(dev->stats));
1868 tmp_stats += sizeof(dev->stats) / sizeof(u64);
1869 memcpy(tmp_stats, &dev->estats, sizeof(dev->estats));
1870 local_irq_enable();
1871 }
1872
1873 static void emac_ethtool_get_drvinfo(struct net_device *ndev,
1874 struct ethtool_drvinfo *info)
1875 {
1876 struct ocp_enet_private *dev = ndev->priv;
1877
1878 strcpy(info->driver, "ibm_emac");
1879 strcpy(info->version, DRV_VERSION);
1880 info->fw_version[0] = '\0';
1881 sprintf(info->bus_info, "PPC 4xx EMAC %d", dev->def->index);
1882 info->n_stats = emac_ethtool_get_stats_count(ndev);
1883 info->regdump_len = emac_ethtool_get_regs_len(ndev);
1884 }
1885
1886 static const struct ethtool_ops emac_ethtool_ops = {
1887 .get_settings = emac_ethtool_get_settings,
1888 .set_settings = emac_ethtool_set_settings,
1889 .get_drvinfo = emac_ethtool_get_drvinfo,
1890
1891 .get_regs_len = emac_ethtool_get_regs_len,
1892 .get_regs = emac_ethtool_get_regs,
1893
1894 .nway_reset = emac_ethtool_nway_reset,
1895
1896 .get_ringparam = emac_ethtool_get_ringparam,
1897 .get_pauseparam = emac_ethtool_get_pauseparam,
1898
1899 .get_rx_csum = emac_ethtool_get_rx_csum,
1900
1901 .get_strings = emac_ethtool_get_strings,
1902 .get_stats_count = emac_ethtool_get_stats_count,
1903 .get_ethtool_stats = emac_ethtool_get_ethtool_stats,
1904
1905 .get_link = ethtool_op_get_link,
1906 .get_tx_csum = ethtool_op_get_tx_csum,
1907 .get_sg = ethtool_op_get_sg,
1908 };
1909
1910 static int emac_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
1911 {
1912 struct ocp_enet_private *dev = ndev->priv;
1913 uint16_t *data = (uint16_t *) & rq->ifr_ifru;
1914
1915 DBG("%d: ioctl %08x" NL, dev->def->index, cmd);
1916
1917 if (dev->phy.address < 0)
1918 return -EOPNOTSUPP;
1919
1920 switch (cmd) {
1921 case SIOCGMIIPHY:
1922 case SIOCDEVPRIVATE:
1923 data[0] = dev->phy.address;
1924 /* Fall through */
1925 case SIOCGMIIREG:
1926 case SIOCDEVPRIVATE + 1:
1927 data[3] = emac_mdio_read(ndev, dev->phy.address, data[1]);
1928 return 0;
1929
1930 case SIOCSMIIREG:
1931 case SIOCDEVPRIVATE + 2:
1932 if (!capable(CAP_NET_ADMIN))
1933 return -EPERM;
1934 emac_mdio_write(ndev, dev->phy.address, data[1], data[2]);
1935 return 0;
1936 default:
1937 return -EOPNOTSUPP;
1938 }
1939 }
1940
1941 static int __init emac_probe(struct ocp_device *ocpdev)
1942 {
1943 struct ocp_func_emac_data *emacdata = ocpdev->def->additions;
1944 struct net_device *ndev;
1945 struct ocp_device *maldev;
1946 struct ocp_enet_private *dev;
1947 int err, i;
1948
1949 DBG("%d: probe" NL, ocpdev->def->index);
1950
1951 if (!emacdata) {
1952 printk(KERN_ERR "emac%d: Missing additional data!\n",
1953 ocpdev->def->index);
1954 return -ENODEV;
1955 }
1956
1957 /* Allocate our net_device structure */
1958 ndev = alloc_etherdev(sizeof(struct ocp_enet_private));
1959 if (!ndev) {
1960 printk(KERN_ERR "emac%d: could not allocate ethernet device!\n",
1961 ocpdev->def->index);
1962 return -ENOMEM;
1963 }
1964 dev = ndev->priv;
1965 dev->ndev = ndev;
1966 dev->ldev = &ocpdev->dev;
1967 dev->def = ocpdev->def;
1968 SET_MODULE_OWNER(ndev);
1969
1970 /* Find MAL device we are connected to */
1971 maldev =
1972 ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_MAL, emacdata->mal_idx);
1973 if (!maldev) {
1974 printk(KERN_ERR "emac%d: unknown mal%d device!\n",
1975 dev->def->index, emacdata->mal_idx);
1976 err = -ENODEV;
1977 goto out;
1978 }
1979 dev->mal = ocp_get_drvdata(maldev);
1980 if (!dev->mal) {
1981 printk(KERN_ERR "emac%d: mal%d hasn't been initialized yet!\n",
1982 dev->def->index, emacdata->mal_idx);
1983 err = -ENODEV;
1984 goto out;
1985 }
1986
1987 /* Register with MAL */
1988 dev->commac.ops = &emac_commac_ops;
1989 dev->commac.dev = dev;
1990 dev->commac.tx_chan_mask = MAL_CHAN_MASK(emacdata->mal_tx_chan);
1991 dev->commac.rx_chan_mask = MAL_CHAN_MASK(emacdata->mal_rx_chan);
1992 err = mal_register_commac(dev->mal, &dev->commac);
1993 if (err) {
1994 printk(KERN_ERR "emac%d: failed to register with mal%d!\n",
1995 dev->def->index, emacdata->mal_idx);
1996 goto out;
1997 }
1998 dev->rx_skb_size = emac_rx_skb_size(ndev->mtu);
1999 dev->rx_sync_size = emac_rx_sync_size(ndev->mtu);
2000
2001 /* Get pointers to BD rings */
2002 dev->tx_desc =
2003 dev->mal->bd_virt + mal_tx_bd_offset(dev->mal,
2004 emacdata->mal_tx_chan);
2005 dev->rx_desc =
2006 dev->mal->bd_virt + mal_rx_bd_offset(dev->mal,
2007 emacdata->mal_rx_chan);
2008
2009 DBG("%d: tx_desc %p" NL, ocpdev->def->index, dev->tx_desc);
2010 DBG("%d: rx_desc %p" NL, ocpdev->def->index, dev->rx_desc);
2011
2012 /* Clean rings */
2013 memset(dev->tx_desc, 0, NUM_TX_BUFF * sizeof(struct mal_descriptor));
2014 memset(dev->rx_desc, 0, NUM_RX_BUFF * sizeof(struct mal_descriptor));
2015
2016 /* If we depend on another EMAC for MDIO, check whether it was probed already */
2017 if (emacdata->mdio_idx >= 0 && emacdata->mdio_idx != ocpdev->def->index) {
2018 struct ocp_device *mdiodev =
2019 ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_EMAC,
2020 emacdata->mdio_idx);
2021 if (!mdiodev) {
2022 printk(KERN_ERR "emac%d: unknown emac%d device!\n",
2023 dev->def->index, emacdata->mdio_idx);
2024 err = -ENODEV;
2025 goto out2;
2026 }
2027 dev->mdio_dev = ocp_get_drvdata(mdiodev);
2028 if (!dev->mdio_dev) {
2029 printk(KERN_ERR
2030 "emac%d: emac%d hasn't been initialized yet!\n",
2031 dev->def->index, emacdata->mdio_idx);
2032 err = -ENODEV;
2033 goto out2;
2034 }
2035 }
2036
2037 /* Attach to ZMII, if needed */
2038 if ((err = zmii_attach(dev)) != 0)
2039 goto out2;
2040
2041 /* Attach to RGMII, if needed */
2042 if ((err = rgmii_attach(dev)) != 0)
2043 goto out3;
2044
2045 /* Attach to TAH, if needed */
2046 if ((err = tah_attach(dev)) != 0)
2047 goto out4;
2048
2049 /* Map EMAC regs */
2050 dev->emacp = ioremap(dev->def->paddr, sizeof(struct emac_regs));
2051 if (!dev->emacp) {
2052 printk(KERN_ERR "emac%d: could not ioremap device registers!\n",
2053 dev->def->index);
2054 err = -ENOMEM;
2055 goto out5;
2056 }
2057
2058 /* Fill in MAC address */
2059 for (i = 0; i < 6; ++i)
2060 ndev->dev_addr[i] = emacdata->mac_addr[i];
2061
2062 /* Set some link defaults before we can find out real parameters */
2063 dev->phy.speed = SPEED_100;
2064 dev->phy.duplex = DUPLEX_FULL;
2065 dev->phy.autoneg = AUTONEG_DISABLE;
2066 dev->phy.pause = dev->phy.asym_pause = 0;
2067 dev->stop_timeout = STOP_TIMEOUT_100;
2068 init_timer(&dev->link_timer);
2069 dev->link_timer.function = emac_link_timer;
2070 dev->link_timer.data = (unsigned long)dev;
2071
2072 /* Find PHY if any */
2073 dev->phy.dev = ndev;
2074 dev->phy.mode = emacdata->phy_mode;
2075 if (emacdata->phy_map != 0xffffffff) {
2076 u32 phy_map = emacdata->phy_map | busy_phy_map;
2077 u32 adv;
2078
2079 DBG("%d: PHY maps %08x %08x" NL, dev->def->index,
2080 emacdata->phy_map, busy_phy_map);
2081
2082 EMAC_RX_CLK_TX(dev->def->index);
2083
2084 dev->phy.mdio_read = emac_mdio_read;
2085 dev->phy.mdio_write = emac_mdio_write;
2086
2087 /* Configure EMAC with defaults so we can at least use MDIO
2088 * This is needed mostly for 440GX
2089 */
2090 if (emac_phy_gpcs(dev->phy.mode)) {
2091 /* XXX
2092 * Make GPCS PHY address equal to EMAC index.
2093 * We probably should take into account busy_phy_map
2094 * and/or phy_map here.
2095 */
2096 dev->phy.address = dev->def->index;
2097 }
2098
2099 emac_configure(dev);
2100
2101 for (i = 0; i < 0x20; phy_map >>= 1, ++i)
2102 if (!(phy_map & 1)) {
2103 int r;
2104 busy_phy_map |= 1 << i;
2105
2106 /* Quick check if there is a PHY at the address */
2107 r = emac_mdio_read(dev->ndev, i, MII_BMCR);
2108 if (r == 0xffff || r < 0)
2109 continue;
2110 if (!mii_phy_probe(&dev->phy, i))
2111 break;
2112 }
2113 if (i == 0x20) {
2114 printk(KERN_WARNING "emac%d: can't find PHY!\n",
2115 dev->def->index);
2116 goto out6;
2117 }
2118
2119 /* Init PHY */
2120 if (dev->phy.def->ops->init)
2121 dev->phy.def->ops->init(&dev->phy);
2122
2123 /* Disable any PHY features not supported by the platform */
2124 dev->phy.def->features &= ~emacdata->phy_feat_exc;
2125
2126 /* Setup initial link parameters */
2127 if (dev->phy.features & SUPPORTED_Autoneg) {
2128 adv = dev->phy.features;
2129 #if !defined(CONFIG_40x)
2130 adv |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
2131 #endif
2132 /* Restart autonegotiation */
2133 dev->phy.def->ops->setup_aneg(&dev->phy, adv);
2134 } else {
2135 u32 f = dev->phy.def->features;
2136 int speed = SPEED_10, fd = DUPLEX_HALF;
2137
2138 /* Select highest supported speed/duplex */
2139 if (f & SUPPORTED_1000baseT_Full) {
2140 speed = SPEED_1000;
2141 fd = DUPLEX_FULL;
2142 } else if (f & SUPPORTED_1000baseT_Half)
2143 speed = SPEED_1000;
2144 else if (f & SUPPORTED_100baseT_Full) {
2145 speed = SPEED_100;
2146 fd = DUPLEX_FULL;
2147 } else if (f & SUPPORTED_100baseT_Half)
2148 speed = SPEED_100;
2149 else if (f & SUPPORTED_10baseT_Full)
2150 fd = DUPLEX_FULL;
2151
2152 /* Force link parameters */
2153 dev->phy.def->ops->setup_forced(&dev->phy, speed, fd);
2154 }
2155 } else {
2156 emac_reset(dev);
2157
2158 /* PHY-less configuration.
2159 * XXX I probably should move these settings to emacdata
2160 */
2161 dev->phy.address = -1;
2162 dev->phy.features = SUPPORTED_100baseT_Full | SUPPORTED_MII;
2163 dev->phy.pause = 1;
2164 }
2165
2166 /* Fill in the driver function table */
2167 ndev->open = &emac_open;
2168 if (dev->tah_dev) {
2169 ndev->hard_start_xmit = &emac_start_xmit_sg;
2170 ndev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
2171 } else
2172 ndev->hard_start_xmit = &emac_start_xmit;
2173 ndev->tx_timeout = &emac_full_tx_reset;
2174 ndev->watchdog_timeo = 5 * HZ;
2175 ndev->stop = &emac_close;
2176 ndev->get_stats = &emac_stats;
2177 ndev->set_multicast_list = &emac_set_multicast_list;
2178 ndev->do_ioctl = &emac_ioctl;
2179 if (emac_phy_supports_gige(emacdata->phy_mode)) {
2180 ndev->change_mtu = &emac_change_mtu;
2181 dev->commac.ops = &emac_commac_sg_ops;
2182 }
2183 SET_ETHTOOL_OPS(ndev, &emac_ethtool_ops);
2184
2185 netif_carrier_off(ndev);
2186 netif_stop_queue(ndev);
2187
2188 err = register_netdev(ndev);
2189 if (err) {
2190 printk(KERN_ERR "emac%d: failed to register net device (%d)!\n",
2191 dev->def->index, err);
2192 goto out6;
2193 }
2194
2195 ocp_set_drvdata(ocpdev, dev);
2196
2197 printk("%s: emac%d, MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
2198 ndev->name, dev->def->index,
2199 ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
2200 ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
2201
2202 if (dev->phy.address >= 0)
2203 printk("%s: found %s PHY (0x%02x)\n", ndev->name,
2204 dev->phy.def->name, dev->phy.address);
2205
2206 emac_dbg_register(dev->def->index, dev);
2207
2208 return 0;
2209 out6:
2210 iounmap(dev->emacp);
2211 out5:
2212 tah_fini(dev->tah_dev);
2213 out4:
2214 rgmii_fini(dev->rgmii_dev, dev->rgmii_input);
2215 out3:
2216 zmii_fini(dev->zmii_dev, dev->zmii_input);
2217 out2:
2218 mal_unregister_commac(dev->mal, &dev->commac);
2219 out:
2220 kfree(ndev);
2221 return err;
2222 }
2223
2224 static struct ocp_device_id emac_ids[] = {
2225 { .vendor = OCP_VENDOR_IBM, .function = OCP_FUNC_EMAC },
2226 { .vendor = OCP_VENDOR_INVALID}
2227 };
2228
2229 static struct ocp_driver emac_driver = {
2230 .name = "emac",
2231 .id_table = emac_ids,
2232 .probe = emac_probe,
2233 .remove = emac_remove,
2234 };
2235
2236 static int __init emac_init(void)
2237 {
2238 printk(KERN_INFO DRV_DESC ", version " DRV_VERSION "\n");
2239
2240 DBG(": init" NL);
2241
2242 if (mal_init())
2243 return -ENODEV;
2244
2245 EMAC_CLK_INTERNAL;
2246 if (ocp_register_driver(&emac_driver)) {
2247 EMAC_CLK_EXTERNAL;
2248 ocp_unregister_driver(&emac_driver);
2249 mal_exit();
2250 return -ENODEV;
2251 }
2252 EMAC_CLK_EXTERNAL;
2253
2254 emac_init_debug();
2255 return 0;
2256 }
2257
2258 static void __exit emac_exit(void)
2259 {
2260 DBG(": exit" NL);
2261 ocp_unregister_driver(&emac_driver);
2262 mal_exit();
2263 emac_fini_debug();
2264 }
2265
2266 module_init(emac_init);
2267 module_exit(emac_exit);
Linux with added FPC-III support