source: src/linux/universal/linux-3.18/drivers/net/ethernet/broadcom/genet/bcmgenet.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 3 months ago

update

File size: 73.0 KB
Line 
1/*
2 * Broadcom GENET (Gigabit Ethernet) controller driver
3 *
4 * Copyright (c) 2014 Broadcom Corporation
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#define pr_fmt(fmt)                             "bcmgenet: " fmt
12
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/sched.h>
16#include <linux/types.h>
17#include <linux/fcntl.h>
18#include <linux/interrupt.h>
19#include <linux/string.h>
20#include <linux/if_ether.h>
21#include <linux/init.h>
22#include <linux/errno.h>
23#include <linux/delay.h>
24#include <linux/platform_device.h>
25#include <linux/dma-mapping.h>
26#include <linux/pm.h>
27#include <linux/clk.h>
28#include <linux/of.h>
29#include <linux/of_address.h>
30#include <linux/of_irq.h>
31#include <linux/of_net.h>
32#include <linux/of_platform.h>
33#include <net/arp.h>
34
35#include <linux/mii.h>
36#include <linux/ethtool.h>
37#include <linux/netdevice.h>
38#include <linux/inetdevice.h>
39#include <linux/etherdevice.h>
40#include <linux/skbuff.h>
41#include <linux/in.h>
42#include <linux/ip.h>
43#include <linux/ipv6.h>
44#include <linux/phy.h>
45
46#include <asm/unaligned.h>
47
48#include "bcmgenet.h"
49
50/* Maximum number of hardware queues, downsized if needed */
51#define GENET_MAX_MQ_CNT        4
52
53/* Default highest priority queue for multi queue support */
54#define GENET_Q0_PRIORITY       0
55
56#define GENET_DEFAULT_BD_CNT    \
57        (TOTAL_DESC - priv->hw_params->tx_queues * priv->hw_params->bds_cnt)
58
59#define RX_BUF_LENGTH           2048
60#define SKB_ALIGNMENT           32
61
62/* Tx/Rx DMA register offset, skip 256 descriptors */
63#define WORDS_PER_BD(p)         (p->hw_params->words_per_bd)
64#define DMA_DESC_SIZE           (WORDS_PER_BD(priv) * sizeof(u32))
65
66#define GENET_TDMA_REG_OFF      (priv->hw_params->tdma_offset + \
67                                TOTAL_DESC * DMA_DESC_SIZE)
68
69#define GENET_RDMA_REG_OFF      (priv->hw_params->rdma_offset + \
70                                TOTAL_DESC * DMA_DESC_SIZE)
71
72static inline void dmadesc_set_length_status(struct bcmgenet_priv *priv,
73                                             void __iomem *d, u32 value)
74{
75        __raw_writel(value, d + DMA_DESC_LENGTH_STATUS);
76}
77
78static inline u32 dmadesc_get_length_status(struct bcmgenet_priv *priv,
79                                            void __iomem *d)
80{
81        return __raw_readl(d + DMA_DESC_LENGTH_STATUS);
82}
83
84static inline void dmadesc_set_addr(struct bcmgenet_priv *priv,
85                                    void __iomem *d,
86                                    dma_addr_t addr)
87{
88        __raw_writel(lower_32_bits(addr), d + DMA_DESC_ADDRESS_LO);
89
90        /* Register writes to GISB bus can take couple hundred nanoseconds
91         * and are done for each packet, save these expensive writes unless
92         * the platform is explicitly configured for 64-bits/LPAE.
93         */
94#ifdef CONFIG_PHYS_ADDR_T_64BIT
95        if (priv->hw_params->flags & GENET_HAS_40BITS)
96                __raw_writel(upper_32_bits(addr), d + DMA_DESC_ADDRESS_HI);
97#endif
98}
99
100/* Combined address + length/status setter */
101static inline void dmadesc_set(struct bcmgenet_priv *priv,
102                               void __iomem *d, dma_addr_t addr, u32 val)
103{
104        dmadesc_set_length_status(priv, d, val);
105        dmadesc_set_addr(priv, d, addr);
106}
107
108static inline dma_addr_t dmadesc_get_addr(struct bcmgenet_priv *priv,
109                                          void __iomem *d)
110{
111        dma_addr_t addr;
112
113        addr = __raw_readl(d + DMA_DESC_ADDRESS_LO);
114
115        /* Register writes to GISB bus can take couple hundred nanoseconds
116         * and are done for each packet, save these expensive writes unless
117         * the platform is explicitly configured for 64-bits/LPAE.
118         */
119#ifdef CONFIG_PHYS_ADDR_T_64BIT
120        if (priv->hw_params->flags & GENET_HAS_40BITS)
121                addr |= (u64)__raw_readl(d + DMA_DESC_ADDRESS_HI) << 32;
122#endif
123        return addr;
124}
125
126#define GENET_VER_FMT   "%1d.%1d EPHY: 0x%04x"
127
128#define GENET_MSG_DEFAULT       (NETIF_MSG_DRV | NETIF_MSG_PROBE | \
129                                NETIF_MSG_LINK)
130
131static inline u32 bcmgenet_rbuf_ctrl_get(struct bcmgenet_priv *priv)
132{
133        if (GENET_IS_V1(priv))
134                return bcmgenet_rbuf_readl(priv, RBUF_FLUSH_CTRL_V1);
135        else
136                return bcmgenet_sys_readl(priv, SYS_RBUF_FLUSH_CTRL);
137}
138
139static inline void bcmgenet_rbuf_ctrl_set(struct bcmgenet_priv *priv, u32 val)
140{
141        if (GENET_IS_V1(priv))
142                bcmgenet_rbuf_writel(priv, val, RBUF_FLUSH_CTRL_V1);
143        else
144                bcmgenet_sys_writel(priv, val, SYS_RBUF_FLUSH_CTRL);
145}
146
147/* These macros are defined to deal with register map change
148 * between GENET1.1 and GENET2. Only those currently being used
149 * by driver are defined.
150 */
151static inline u32 bcmgenet_tbuf_ctrl_get(struct bcmgenet_priv *priv)
152{
153        if (GENET_IS_V1(priv))
154                return bcmgenet_rbuf_readl(priv, TBUF_CTRL_V1);
155        else
156                return __raw_readl(priv->base +
157                                priv->hw_params->tbuf_offset + TBUF_CTRL);
158}
159
160static inline void bcmgenet_tbuf_ctrl_set(struct bcmgenet_priv *priv, u32 val)
161{
162        if (GENET_IS_V1(priv))
163                bcmgenet_rbuf_writel(priv, val, TBUF_CTRL_V1);
164        else
165                __raw_writel(val, priv->base +
166                                priv->hw_params->tbuf_offset + TBUF_CTRL);
167}
168
169static inline u32 bcmgenet_bp_mc_get(struct bcmgenet_priv *priv)
170{
171        if (GENET_IS_V1(priv))
172                return bcmgenet_rbuf_readl(priv, TBUF_BP_MC_V1);
173        else
174                return __raw_readl(priv->base +
175                                priv->hw_params->tbuf_offset + TBUF_BP_MC);
176}
177
178static inline void bcmgenet_bp_mc_set(struct bcmgenet_priv *priv, u32 val)
179{
180        if (GENET_IS_V1(priv))
181                bcmgenet_rbuf_writel(priv, val, TBUF_BP_MC_V1);
182        else
183                __raw_writel(val, priv->base +
184                                priv->hw_params->tbuf_offset + TBUF_BP_MC);
185}
186
187/* RX/TX DMA register accessors */
188enum dma_reg {
189        DMA_RING_CFG = 0,
190        DMA_CTRL,
191        DMA_STATUS,
192        DMA_SCB_BURST_SIZE,
193        DMA_ARB_CTRL,
194        DMA_PRIORITY_0,
195        DMA_PRIORITY_1,
196        DMA_PRIORITY_2,
197};
198
199static const u8 bcmgenet_dma_regs_v3plus[] = {
200        [DMA_RING_CFG]          = 0x00,
201        [DMA_CTRL]              = 0x04,
202        [DMA_STATUS]            = 0x08,
203        [DMA_SCB_BURST_SIZE]    = 0x0C,
204        [DMA_ARB_CTRL]          = 0x2C,
205        [DMA_PRIORITY_0]        = 0x30,
206        [DMA_PRIORITY_1]        = 0x34,
207        [DMA_PRIORITY_2]        = 0x38,
208};
209
210static const u8 bcmgenet_dma_regs_v2[] = {
211        [DMA_RING_CFG]          = 0x00,
212        [DMA_CTRL]              = 0x04,
213        [DMA_STATUS]            = 0x08,
214        [DMA_SCB_BURST_SIZE]    = 0x0C,
215        [DMA_ARB_CTRL]          = 0x30,
216        [DMA_PRIORITY_0]        = 0x34,
217        [DMA_PRIORITY_1]        = 0x38,
218        [DMA_PRIORITY_2]        = 0x3C,
219};
220
221static const u8 bcmgenet_dma_regs_v1[] = {
222        [DMA_CTRL]              = 0x00,
223        [DMA_STATUS]            = 0x04,
224        [DMA_SCB_BURST_SIZE]    = 0x0C,
225        [DMA_ARB_CTRL]          = 0x30,
226        [DMA_PRIORITY_0]        = 0x34,
227        [DMA_PRIORITY_1]        = 0x38,
228        [DMA_PRIORITY_2]        = 0x3C,
229};
230
231/* Set at runtime once bcmgenet version is known */
232static const u8 *bcmgenet_dma_regs;
233
234static inline struct bcmgenet_priv *dev_to_priv(struct device *dev)
235{
236        return netdev_priv(dev_get_drvdata(dev));
237}
238
239static inline u32 bcmgenet_tdma_readl(struct bcmgenet_priv *priv,
240                                      enum dma_reg r)
241{
242        return __raw_readl(priv->base + GENET_TDMA_REG_OFF +
243                        DMA_RINGS_SIZE + bcmgenet_dma_regs[r]);
244}
245
246static inline void bcmgenet_tdma_writel(struct bcmgenet_priv *priv,
247                                        u32 val, enum dma_reg r)
248{
249        __raw_writel(val, priv->base + GENET_TDMA_REG_OFF +
250                        DMA_RINGS_SIZE + bcmgenet_dma_regs[r]);
251}
252
253static inline u32 bcmgenet_rdma_readl(struct bcmgenet_priv *priv,
254                                      enum dma_reg r)
255{
256        return __raw_readl(priv->base + GENET_RDMA_REG_OFF +
257                        DMA_RINGS_SIZE + bcmgenet_dma_regs[r]);
258}
259
260static inline void bcmgenet_rdma_writel(struct bcmgenet_priv *priv,
261                                        u32 val, enum dma_reg r)
262{
263        __raw_writel(val, priv->base + GENET_RDMA_REG_OFF +
264                        DMA_RINGS_SIZE + bcmgenet_dma_regs[r]);
265}
266
267/* RDMA/TDMA ring registers and accessors
268 * we merge the common fields and just prefix with T/D the registers
269 * having different meaning depending on the direction
270 */
271enum dma_ring_reg {
272        TDMA_READ_PTR = 0,
273        RDMA_WRITE_PTR = TDMA_READ_PTR,
274        TDMA_READ_PTR_HI,
275        RDMA_WRITE_PTR_HI = TDMA_READ_PTR_HI,
276        TDMA_CONS_INDEX,
277        RDMA_PROD_INDEX = TDMA_CONS_INDEX,
278        TDMA_PROD_INDEX,
279        RDMA_CONS_INDEX = TDMA_PROD_INDEX,
280        DMA_RING_BUF_SIZE,
281        DMA_START_ADDR,
282        DMA_START_ADDR_HI,
283        DMA_END_ADDR,
284        DMA_END_ADDR_HI,
285        DMA_MBUF_DONE_THRESH,
286        TDMA_FLOW_PERIOD,
287        RDMA_XON_XOFF_THRESH = TDMA_FLOW_PERIOD,
288        TDMA_WRITE_PTR,
289        RDMA_READ_PTR = TDMA_WRITE_PTR,
290        TDMA_WRITE_PTR_HI,
291        RDMA_READ_PTR_HI = TDMA_WRITE_PTR_HI
292};
293
294/* GENET v4 supports 40-bits pointer addressing
295 * for obvious reasons the LO and HI word parts
296 * are contiguous, but this offsets the other
297 * registers.
298 */
299static const u8 genet_dma_ring_regs_v4[] = {
300        [TDMA_READ_PTR]                 = 0x00,
301        [TDMA_READ_PTR_HI]              = 0x04,
302        [TDMA_CONS_INDEX]               = 0x08,
303        [TDMA_PROD_INDEX]               = 0x0C,
304        [DMA_RING_BUF_SIZE]             = 0x10,
305        [DMA_START_ADDR]                = 0x14,
306        [DMA_START_ADDR_HI]             = 0x18,
307        [DMA_END_ADDR]                  = 0x1C,
308        [DMA_END_ADDR_HI]               = 0x20,
309        [DMA_MBUF_DONE_THRESH]          = 0x24,
310        [TDMA_FLOW_PERIOD]              = 0x28,
311        [TDMA_WRITE_PTR]                = 0x2C,
312        [TDMA_WRITE_PTR_HI]             = 0x30,
313};
314
315static const u8 genet_dma_ring_regs_v123[] = {
316        [TDMA_READ_PTR]                 = 0x00,
317        [TDMA_CONS_INDEX]               = 0x04,
318        [TDMA_PROD_INDEX]               = 0x08,
319        [DMA_RING_BUF_SIZE]             = 0x0C,
320        [DMA_START_ADDR]                = 0x10,
321        [DMA_END_ADDR]                  = 0x14,
322        [DMA_MBUF_DONE_THRESH]          = 0x18,
323        [TDMA_FLOW_PERIOD]              = 0x1C,
324        [TDMA_WRITE_PTR]                = 0x20,
325};
326
327/* Set at runtime once GENET version is known */
328static const u8 *genet_dma_ring_regs;
329
330static inline u32 bcmgenet_tdma_ring_readl(struct bcmgenet_priv *priv,
331                                           unsigned int ring,
332                                           enum dma_ring_reg r)
333{
334        return __raw_readl(priv->base + GENET_TDMA_REG_OFF +
335                        (DMA_RING_SIZE * ring) +
336                        genet_dma_ring_regs[r]);
337}
338
339static inline void bcmgenet_tdma_ring_writel(struct bcmgenet_priv *priv,
340                                             unsigned int ring, u32 val,
341                                             enum dma_ring_reg r)
342{
343        __raw_writel(val, priv->base + GENET_TDMA_REG_OFF +
344                        (DMA_RING_SIZE * ring) +
345                        genet_dma_ring_regs[r]);
346}
347
348static inline u32 bcmgenet_rdma_ring_readl(struct bcmgenet_priv *priv,
349                                           unsigned int ring,
350                                           enum dma_ring_reg r)
351{
352        return __raw_readl(priv->base + GENET_RDMA_REG_OFF +
353                        (DMA_RING_SIZE * ring) +
354                        genet_dma_ring_regs[r]);
355}
356
357static inline void bcmgenet_rdma_ring_writel(struct bcmgenet_priv *priv,
358                                             unsigned int ring, u32 val,
359                                             enum dma_ring_reg r)
360{
361        __raw_writel(val, priv->base + GENET_RDMA_REG_OFF +
362                        (DMA_RING_SIZE * ring) +
363                        genet_dma_ring_regs[r]);
364}
365
366static int bcmgenet_get_settings(struct net_device *dev,
367                                 struct ethtool_cmd *cmd)
368{
369        struct bcmgenet_priv *priv = netdev_priv(dev);
370
371        if (!netif_running(dev))
372                return -EINVAL;
373
374        if (!priv->phydev)
375                return -ENODEV;
376
377        return phy_ethtool_gset(priv->phydev, cmd);
378}
379
380static int bcmgenet_set_settings(struct net_device *dev,
381                                 struct ethtool_cmd *cmd)
382{
383        struct bcmgenet_priv *priv = netdev_priv(dev);
384
385        if (!netif_running(dev))
386                return -EINVAL;
387
388        if (!priv->phydev)
389                return -ENODEV;
390
391        return phy_ethtool_sset(priv->phydev, cmd);
392}
393
394static int bcmgenet_set_rx_csum(struct net_device *dev,
395                                netdev_features_t wanted)
396{
397        struct bcmgenet_priv *priv = netdev_priv(dev);
398        u32 rbuf_chk_ctrl;
399        bool rx_csum_en;
400
401        rx_csum_en = !!(wanted & NETIF_F_RXCSUM);
402
403        rbuf_chk_ctrl = bcmgenet_rbuf_readl(priv, RBUF_CHK_CTRL);
404
405        /* enable rx checksumming */
406        if (rx_csum_en)
407                rbuf_chk_ctrl |= RBUF_RXCHK_EN;
408        else
409                rbuf_chk_ctrl &= ~RBUF_RXCHK_EN;
410        priv->desc_rxchk_en = rx_csum_en;
411
412        /* If UniMAC forwards CRC, we need to skip over it to get
413         * a valid CHK bit to be set in the per-packet status word
414        */
415        if (rx_csum_en && priv->crc_fwd_en)
416                rbuf_chk_ctrl |= RBUF_SKIP_FCS;
417        else
418                rbuf_chk_ctrl &= ~RBUF_SKIP_FCS;
419
420        bcmgenet_rbuf_writel(priv, rbuf_chk_ctrl, RBUF_CHK_CTRL);
421
422        return 0;
423}
424
425static int bcmgenet_set_tx_csum(struct net_device *dev,
426                                netdev_features_t wanted)
427{
428        struct bcmgenet_priv *priv = netdev_priv(dev);
429        bool desc_64b_en;
430        u32 tbuf_ctrl, rbuf_ctrl;
431
432        tbuf_ctrl = bcmgenet_tbuf_ctrl_get(priv);
433        rbuf_ctrl = bcmgenet_rbuf_readl(priv, RBUF_CTRL);
434
435        desc_64b_en = !!(wanted & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM));
436
437        /* enable 64 bytes descriptor in both directions (RBUF and TBUF) */
438        if (desc_64b_en) {
439                tbuf_ctrl |= RBUF_64B_EN;
440                rbuf_ctrl |= RBUF_64B_EN;
441        } else {
442                tbuf_ctrl &= ~RBUF_64B_EN;
443                rbuf_ctrl &= ~RBUF_64B_EN;
444        }
445        priv->desc_64b_en = desc_64b_en;
446
447        bcmgenet_tbuf_ctrl_set(priv, tbuf_ctrl);
448        bcmgenet_rbuf_writel(priv, rbuf_ctrl, RBUF_CTRL);
449
450        return 0;
451}
452
453static int bcmgenet_set_features(struct net_device *dev,
454                                 netdev_features_t features)
455{
456        netdev_features_t changed = features ^ dev->features;
457        netdev_features_t wanted = dev->wanted_features;
458        int ret = 0;
459
460        if (changed & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM))
461                ret = bcmgenet_set_tx_csum(dev, wanted);
462        if (changed & (NETIF_F_RXCSUM))
463                ret = bcmgenet_set_rx_csum(dev, wanted);
464
465        return ret;
466}
467
468static u32 bcmgenet_get_msglevel(struct net_device *dev)
469{
470        struct bcmgenet_priv *priv = netdev_priv(dev);
471
472        return priv->msg_enable;
473}
474
475static void bcmgenet_set_msglevel(struct net_device *dev, u32 level)
476{
477        struct bcmgenet_priv *priv = netdev_priv(dev);
478
479        priv->msg_enable = level;
480}
481
482/* standard ethtool support functions. */
483enum bcmgenet_stat_type {
484        BCMGENET_STAT_NETDEV = -1,
485        BCMGENET_STAT_MIB_RX,
486        BCMGENET_STAT_MIB_TX,
487        BCMGENET_STAT_RUNT,
488        BCMGENET_STAT_MISC,
489};
490
491struct bcmgenet_stats {
492        char stat_string[ETH_GSTRING_LEN];
493        int stat_sizeof;
494        int stat_offset;
495        enum bcmgenet_stat_type type;
496        /* reg offset from UMAC base for misc counters */
497        u16 reg_offset;
498};
499
500#define STAT_NETDEV(m) { \
501        .stat_string = __stringify(m), \
502        .stat_sizeof = sizeof(((struct net_device_stats *)0)->m), \
503        .stat_offset = offsetof(struct net_device_stats, m), \
504        .type = BCMGENET_STAT_NETDEV, \
505}
506
507#define STAT_GENET_MIB(str, m, _type) { \
508        .stat_string = str, \
509        .stat_sizeof = sizeof(((struct bcmgenet_priv *)0)->m), \
510        .stat_offset = offsetof(struct bcmgenet_priv, m), \
511        .type = _type, \
512}
513
514#define STAT_GENET_MIB_RX(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_MIB_RX)
515#define STAT_GENET_MIB_TX(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_MIB_TX)
516#define STAT_GENET_RUNT(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_RUNT)
517
518#define STAT_GENET_MISC(str, m, offset) { \
519        .stat_string = str, \
520        .stat_sizeof = sizeof(((struct bcmgenet_priv *)0)->m), \
521        .stat_offset = offsetof(struct bcmgenet_priv, m), \
522        .type = BCMGENET_STAT_MISC, \
523        .reg_offset = offset, \
524}
525
526
527/* There is a 0xC gap between the end of RX and beginning of TX stats and then
528 * between the end of TX stats and the beginning of the RX RUNT
529 */
530#define BCMGENET_STAT_OFFSET    0xc
531
532/* Hardware counters must be kept in sync because the order/offset
533 * is important here (order in structure declaration = order in hardware)
534 */
535static const struct bcmgenet_stats bcmgenet_gstrings_stats[] = {
536        /* general stats */
537        STAT_NETDEV(rx_packets),
538        STAT_NETDEV(tx_packets),
539        STAT_NETDEV(rx_bytes),
540        STAT_NETDEV(tx_bytes),
541        STAT_NETDEV(rx_errors),
542        STAT_NETDEV(tx_errors),
543        STAT_NETDEV(rx_dropped),
544        STAT_NETDEV(tx_dropped),
545        STAT_NETDEV(multicast),
546        /* UniMAC RSV counters */
547        STAT_GENET_MIB_RX("rx_64_octets", mib.rx.pkt_cnt.cnt_64),
548        STAT_GENET_MIB_RX("rx_65_127_oct", mib.rx.pkt_cnt.cnt_127),
549        STAT_GENET_MIB_RX("rx_128_255_oct", mib.rx.pkt_cnt.cnt_255),
550        STAT_GENET_MIB_RX("rx_256_511_oct", mib.rx.pkt_cnt.cnt_511),
551        STAT_GENET_MIB_RX("rx_512_1023_oct", mib.rx.pkt_cnt.cnt_1023),
552        STAT_GENET_MIB_RX("rx_1024_1518_oct", mib.rx.pkt_cnt.cnt_1518),
553        STAT_GENET_MIB_RX("rx_vlan_1519_1522_oct", mib.rx.pkt_cnt.cnt_mgv),
554        STAT_GENET_MIB_RX("rx_1522_2047_oct", mib.rx.pkt_cnt.cnt_2047),
555        STAT_GENET_MIB_RX("rx_2048_4095_oct", mib.rx.pkt_cnt.cnt_4095),
556        STAT_GENET_MIB_RX("rx_4096_9216_oct", mib.rx.pkt_cnt.cnt_9216),
557        STAT_GENET_MIB_RX("rx_pkts", mib.rx.pkt),
558        STAT_GENET_MIB_RX("rx_bytes", mib.rx.bytes),
559        STAT_GENET_MIB_RX("rx_multicast", mib.rx.mca),
560        STAT_GENET_MIB_RX("rx_broadcast", mib.rx.bca),
561        STAT_GENET_MIB_RX("rx_fcs", mib.rx.fcs),
562        STAT_GENET_MIB_RX("rx_control", mib.rx.cf),
563        STAT_GENET_MIB_RX("rx_pause", mib.rx.pf),
564        STAT_GENET_MIB_RX("rx_unknown", mib.rx.uo),
565        STAT_GENET_MIB_RX("rx_align", mib.rx.aln),
566        STAT_GENET_MIB_RX("rx_outrange", mib.rx.flr),
567        STAT_GENET_MIB_RX("rx_code", mib.rx.cde),
568        STAT_GENET_MIB_RX("rx_carrier", mib.rx.fcr),
569        STAT_GENET_MIB_RX("rx_oversize", mib.rx.ovr),
570        STAT_GENET_MIB_RX("rx_jabber", mib.rx.jbr),
571        STAT_GENET_MIB_RX("rx_mtu_err", mib.rx.mtue),
572        STAT_GENET_MIB_RX("rx_good_pkts", mib.rx.pok),
573        STAT_GENET_MIB_RX("rx_unicast", mib.rx.uc),
574        STAT_GENET_MIB_RX("rx_ppp", mib.rx.ppp),
575        STAT_GENET_MIB_RX("rx_crc", mib.rx.rcrc),
576        /* UniMAC TSV counters */
577        STAT_GENET_MIB_TX("tx_64_octets", mib.tx.pkt_cnt.cnt_64),
578        STAT_GENET_MIB_TX("tx_65_127_oct", mib.tx.pkt_cnt.cnt_127),
579        STAT_GENET_MIB_TX("tx_128_255_oct", mib.tx.pkt_cnt.cnt_255),
580        STAT_GENET_MIB_TX("tx_256_511_oct", mib.tx.pkt_cnt.cnt_511),
581        STAT_GENET_MIB_TX("tx_512_1023_oct", mib.tx.pkt_cnt.cnt_1023),
582        STAT_GENET_MIB_TX("tx_1024_1518_oct", mib.tx.pkt_cnt.cnt_1518),
583        STAT_GENET_MIB_TX("tx_vlan_1519_1522_oct", mib.tx.pkt_cnt.cnt_mgv),
584        STAT_GENET_MIB_TX("tx_1522_2047_oct", mib.tx.pkt_cnt.cnt_2047),
585        STAT_GENET_MIB_TX("tx_2048_4095_oct", mib.tx.pkt_cnt.cnt_4095),
586        STAT_GENET_MIB_TX("tx_4096_9216_oct", mib.tx.pkt_cnt.cnt_9216),
587        STAT_GENET_MIB_TX("tx_pkts", mib.tx.pkts),
588        STAT_GENET_MIB_TX("tx_multicast", mib.tx.mca),
589        STAT_GENET_MIB_TX("tx_broadcast", mib.tx.bca),
590        STAT_GENET_MIB_TX("tx_pause", mib.tx.pf),
591        STAT_GENET_MIB_TX("tx_control", mib.tx.cf),
592        STAT_GENET_MIB_TX("tx_fcs_err", mib.tx.fcs),
593        STAT_GENET_MIB_TX("tx_oversize", mib.tx.ovr),
594        STAT_GENET_MIB_TX("tx_defer", mib.tx.drf),
595        STAT_GENET_MIB_TX("tx_excess_defer", mib.tx.edf),
596        STAT_GENET_MIB_TX("tx_single_col", mib.tx.scl),
597        STAT_GENET_MIB_TX("tx_multi_col", mib.tx.mcl),
598        STAT_GENET_MIB_TX("tx_late_col", mib.tx.lcl),
599        STAT_GENET_MIB_TX("tx_excess_col", mib.tx.ecl),
600        STAT_GENET_MIB_TX("tx_frags", mib.tx.frg),
601        STAT_GENET_MIB_TX("tx_total_col", mib.tx.ncl),
602        STAT_GENET_MIB_TX("tx_jabber", mib.tx.jbr),
603        STAT_GENET_MIB_TX("tx_bytes", mib.tx.bytes),
604        STAT_GENET_MIB_TX("tx_good_pkts", mib.tx.pok),
605        STAT_GENET_MIB_TX("tx_unicast", mib.tx.uc),
606        /* UniMAC RUNT counters */
607        STAT_GENET_RUNT("rx_runt_pkts", mib.rx_runt_cnt),
608        STAT_GENET_RUNT("rx_runt_valid_fcs", mib.rx_runt_fcs),
609        STAT_GENET_RUNT("rx_runt_inval_fcs_align", mib.rx_runt_fcs_align),
610        STAT_GENET_RUNT("rx_runt_bytes", mib.rx_runt_bytes),
611        /* Misc UniMAC counters */
612        STAT_GENET_MISC("rbuf_ovflow_cnt", mib.rbuf_ovflow_cnt,
613                        UMAC_RBUF_OVFL_CNT),
614        STAT_GENET_MISC("rbuf_err_cnt", mib.rbuf_err_cnt, UMAC_RBUF_ERR_CNT),
615        STAT_GENET_MISC("mdf_err_cnt", mib.mdf_err_cnt, UMAC_MDF_ERR_CNT),
616};
617
618#define BCMGENET_STATS_LEN      ARRAY_SIZE(bcmgenet_gstrings_stats)
619
620static void bcmgenet_get_drvinfo(struct net_device *dev,
621                                 struct ethtool_drvinfo *info)
622{
623        strlcpy(info->driver, "bcmgenet", sizeof(info->driver));
624        strlcpy(info->version, "v2.0", sizeof(info->version));
625        info->n_stats = BCMGENET_STATS_LEN;
626}
627
628static int bcmgenet_get_sset_count(struct net_device *dev, int string_set)
629{
630        switch (string_set) {
631        case ETH_SS_STATS:
632                return BCMGENET_STATS_LEN;
633        default:
634                return -EOPNOTSUPP;
635        }
636}
637
638static void bcmgenet_get_strings(struct net_device *dev, u32 stringset,
639                                 u8 *data)
640{
641        int i;
642
643        switch (stringset) {
644        case ETH_SS_STATS:
645                for (i = 0; i < BCMGENET_STATS_LEN; i++) {
646                        memcpy(data + i * ETH_GSTRING_LEN,
647                               bcmgenet_gstrings_stats[i].stat_string,
648                               ETH_GSTRING_LEN);
649                }
650                break;
651        }
652}
653
654static void bcmgenet_update_mib_counters(struct bcmgenet_priv *priv)
655{
656        int i, j = 0;
657
658        for (i = 0; i < BCMGENET_STATS_LEN; i++) {
659                const struct bcmgenet_stats *s;
660                u8 offset = 0;
661                u32 val = 0;
662                char *p;
663
664                s = &bcmgenet_gstrings_stats[i];
665                switch (s->type) {
666                case BCMGENET_STAT_NETDEV:
667                        continue;
668                case BCMGENET_STAT_MIB_RX:
669                case BCMGENET_STAT_MIB_TX:
670                case BCMGENET_STAT_RUNT:
671                        if (s->type != BCMGENET_STAT_MIB_RX)
672                                offset = BCMGENET_STAT_OFFSET;
673                        val = bcmgenet_umac_readl(priv,
674                                                  UMAC_MIB_START + j + offset);
675                        break;
676                case BCMGENET_STAT_MISC:
677                        val = bcmgenet_umac_readl(priv, s->reg_offset);
678                        /* clear if overflowed */
679                        if (val == ~0)
680                                bcmgenet_umac_writel(priv, 0, s->reg_offset);
681                        break;
682                }
683
684                j += s->stat_sizeof;
685                p = (char *)priv + s->stat_offset;
686                *(u32 *)p = val;
687        }
688}
689
690static void bcmgenet_get_ethtool_stats(struct net_device *dev,
691                                       struct ethtool_stats *stats,
692                                       u64 *data)
693{
694        struct bcmgenet_priv *priv = netdev_priv(dev);
695        int i;
696
697        if (netif_running(dev))
698                bcmgenet_update_mib_counters(priv);
699
700        for (i = 0; i < BCMGENET_STATS_LEN; i++) {
701                const struct bcmgenet_stats *s;
702                char *p;
703
704                s = &bcmgenet_gstrings_stats[i];
705                if (s->type == BCMGENET_STAT_NETDEV)
706                        p = (char *)&dev->stats;
707                else
708                        p = (char *)priv;
709                p += s->stat_offset;
710                data[i] = *(u32 *)p;
711        }
712}
713
714/* standard ethtool support functions. */
715static struct ethtool_ops bcmgenet_ethtool_ops = {
716        .get_strings            = bcmgenet_get_strings,
717        .get_sset_count         = bcmgenet_get_sset_count,
718        .get_ethtool_stats      = bcmgenet_get_ethtool_stats,
719        .get_settings           = bcmgenet_get_settings,
720        .set_settings           = bcmgenet_set_settings,
721        .get_drvinfo            = bcmgenet_get_drvinfo,
722        .get_link               = ethtool_op_get_link,
723        .get_msglevel           = bcmgenet_get_msglevel,
724        .set_msglevel           = bcmgenet_set_msglevel,
725        .get_wol                = bcmgenet_get_wol,
726        .set_wol                = bcmgenet_set_wol,
727};
728
729/* Power down the unimac, based on mode. */
730static void bcmgenet_power_down(struct bcmgenet_priv *priv,
731                                enum bcmgenet_power_mode mode)
732{
733        u32 reg;
734
735        switch (mode) {
736        case GENET_POWER_CABLE_SENSE:
737                phy_detach(priv->phydev);
738                break;
739
740        case GENET_POWER_WOL_MAGIC:
741                bcmgenet_wol_power_down_cfg(priv, mode);
742                break;
743
744        case GENET_POWER_PASSIVE:
745                /* Power down LED */
746                if (priv->hw_params->flags & GENET_HAS_EXT) {
747                        reg = bcmgenet_ext_readl(priv, EXT_EXT_PWR_MGMT);
748                        reg |= (EXT_PWR_DOWN_PHY |
749                                EXT_PWR_DOWN_DLL | EXT_PWR_DOWN_BIAS);
750                        bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT);
751                }
752                break;
753        default:
754                break;
755        }
756}
757
758static void bcmgenet_power_up(struct bcmgenet_priv *priv,
759                              enum bcmgenet_power_mode mode)
760{
761        u32 reg;
762
763        if (!(priv->hw_params->flags & GENET_HAS_EXT))
764                return;
765
766        reg = bcmgenet_ext_readl(priv, EXT_EXT_PWR_MGMT);
767
768        switch (mode) {
769        case GENET_POWER_PASSIVE:
770                reg &= ~(EXT_PWR_DOWN_DLL | EXT_PWR_DOWN_PHY |
771                                EXT_PWR_DOWN_BIAS);
772                /* fallthrough */
773        case GENET_POWER_CABLE_SENSE:
774                /* enable APD */
775                reg |= EXT_PWR_DN_EN_LD;
776                break;
777        case GENET_POWER_WOL_MAGIC:
778                bcmgenet_wol_power_up_cfg(priv, mode);
779                return;
780        default:
781                break;
782        }
783
784        bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT);
785
786        if (mode == GENET_POWER_PASSIVE)
787                bcmgenet_mii_reset(priv->dev);
788}
789
790/* ioctl handle special commands that are not present in ethtool. */
791static int bcmgenet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
792{
793        struct bcmgenet_priv *priv = netdev_priv(dev);
794        int val = 0;
795
796        if (!netif_running(dev))
797                return -EINVAL;
798
799        switch (cmd) {
800        case SIOCGMIIPHY:
801        case SIOCGMIIREG:
802        case SIOCSMIIREG:
803                if (!priv->phydev)
804                        val = -ENODEV;
805                else
806                        val = phy_mii_ioctl(priv->phydev, rq, cmd);
807                break;
808
809        default:
810                val = -EINVAL;
811                break;
812        }
813
814        return val;
815}
816
817static struct enet_cb *bcmgenet_get_txcb(struct bcmgenet_priv *priv,
818                                         struct bcmgenet_tx_ring *ring)
819{
820        struct enet_cb *tx_cb_ptr;
821
822        tx_cb_ptr = ring->cbs;
823        tx_cb_ptr += ring->write_ptr - ring->cb_ptr;
824        tx_cb_ptr->bd_addr = priv->tx_bds + ring->write_ptr * DMA_DESC_SIZE;
825        /* Advancing local write pointer */
826        if (ring->write_ptr == ring->end_ptr)
827                ring->write_ptr = ring->cb_ptr;
828        else
829                ring->write_ptr++;
830
831        return tx_cb_ptr;
832}
833
834/* Simple helper to free a control block's resources */
835static void bcmgenet_free_cb(struct enet_cb *cb)
836{
837        dev_kfree_skb_any(cb->skb);
838        cb->skb = NULL;
839        dma_unmap_addr_set(cb, dma_addr, 0);
840}
841
842static inline void bcmgenet_tx_ring16_int_disable(struct bcmgenet_priv *priv,
843                                                  struct bcmgenet_tx_ring *ring)
844{
845        bcmgenet_intrl2_0_writel(priv,
846                                 UMAC_IRQ_TXDMA_BDONE | UMAC_IRQ_TXDMA_PDONE,
847                                 INTRL2_CPU_MASK_SET);
848}
849
850static inline void bcmgenet_tx_ring16_int_enable(struct bcmgenet_priv *priv,
851                                                 struct bcmgenet_tx_ring *ring)
852{
853        bcmgenet_intrl2_0_writel(priv,
854                                 UMAC_IRQ_TXDMA_BDONE | UMAC_IRQ_TXDMA_PDONE,
855                                 INTRL2_CPU_MASK_CLEAR);
856}
857
858static inline void bcmgenet_tx_ring_int_enable(struct bcmgenet_priv *priv,
859                                               struct bcmgenet_tx_ring *ring)
860{
861        bcmgenet_intrl2_1_writel(priv, (1 << ring->index),
862                                 INTRL2_CPU_MASK_CLEAR);
863        priv->int1_mask &= ~(1 << ring->index);
864}
865
866static inline void bcmgenet_tx_ring_int_disable(struct bcmgenet_priv *priv,
867                                                struct bcmgenet_tx_ring *ring)
868{
869        bcmgenet_intrl2_1_writel(priv, (1 << ring->index),
870                                 INTRL2_CPU_MASK_SET);
871        priv->int1_mask |= (1 << ring->index);
872}
873
874/* Unlocked version of the reclaim routine */
875static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
876                                          struct bcmgenet_tx_ring *ring)
877{
878        struct bcmgenet_priv *priv = netdev_priv(dev);
879        int last_tx_cn, last_c_index, num_tx_bds;
880        struct enet_cb *tx_cb_ptr;
881        struct netdev_queue *txq;
882        unsigned int pkts_compl = 0;
883        unsigned int bds_compl;
884        unsigned int c_index;
885
886        /* Compute how many buffers are transmitted since last xmit call */
887        c_index = bcmgenet_tdma_ring_readl(priv, ring->index, TDMA_CONS_INDEX);
888        txq = netdev_get_tx_queue(dev, ring->queue);
889
890        last_c_index = ring->c_index;
891        num_tx_bds = ring->size;
892
893        c_index &= (num_tx_bds - 1);
894
895        if (c_index >= last_c_index)
896                last_tx_cn = c_index - last_c_index;
897        else
898                last_tx_cn = num_tx_bds - last_c_index + c_index;
899
900        netif_dbg(priv, tx_done, dev,
901                  "%s ring=%d index=%d last_tx_cn=%d last_index=%d\n",
902                  __func__, ring->index,
903                  c_index, last_tx_cn, last_c_index);
904
905        /* Reclaim transmitted buffers */
906        while (last_tx_cn-- > 0) {
907                tx_cb_ptr = ring->cbs + last_c_index;
908                bds_compl = 0;
909                if (tx_cb_ptr->skb) {
910                        pkts_compl++;
911                        bds_compl = skb_shinfo(tx_cb_ptr->skb)->nr_frags + 1;
912                        dev->stats.tx_bytes += tx_cb_ptr->skb->len;
913                        dma_unmap_single(&dev->dev,
914                                         dma_unmap_addr(tx_cb_ptr, dma_addr),
915                                         dma_unmap_len(tx_cb_ptr, dma_len),
916                                         DMA_TO_DEVICE);
917                        bcmgenet_free_cb(tx_cb_ptr);
918                } else if (dma_unmap_addr(tx_cb_ptr, dma_addr)) {
919                        dev->stats.tx_bytes +=
920                                dma_unmap_len(tx_cb_ptr, dma_len);
921                        dma_unmap_page(&dev->dev,
922                                       dma_unmap_addr(tx_cb_ptr, dma_addr),
923                                       dma_unmap_len(tx_cb_ptr, dma_len),
924                                       DMA_TO_DEVICE);
925                        dma_unmap_addr_set(tx_cb_ptr, dma_addr, 0);
926                }
927                dev->stats.tx_packets++;
928                ring->free_bds += bds_compl;
929
930                last_c_index++;
931                last_c_index &= (num_tx_bds - 1);
932        }
933
934        if (ring->free_bds > (MAX_SKB_FRAGS + 1)) {
935                if (netif_tx_queue_stopped(txq))
936                        netif_tx_wake_queue(txq);
937        }
938
939        ring->c_index = c_index;
940
941        return pkts_compl;
942}
943
944static unsigned int bcmgenet_tx_reclaim(struct net_device *dev,
945                                struct bcmgenet_tx_ring *ring)
946{
947        unsigned int released;
948        unsigned long flags;
949
950        spin_lock_irqsave(&ring->lock, flags);
951        released = __bcmgenet_tx_reclaim(dev, ring);
952        spin_unlock_irqrestore(&ring->lock, flags);
953
954        return released;
955}
956
957static int bcmgenet_tx_poll(struct napi_struct *napi, int budget)
958{
959        struct bcmgenet_tx_ring *ring =
960                container_of(napi, struct bcmgenet_tx_ring, napi);
961        unsigned int work_done = 0;
962
963        work_done = bcmgenet_tx_reclaim(ring->priv->dev, ring);
964
965        if (work_done == 0) {
966                napi_complete(napi);
967                ring->int_enable(ring->priv, ring);
968
969                return 0;
970        }
971
972        return budget;
973}
974
975static void bcmgenet_tx_reclaim_all(struct net_device *dev)
976{
977        struct bcmgenet_priv *priv = netdev_priv(dev);
978        int i;
979
980        if (netif_is_multiqueue(dev)) {
981                for (i = 0; i < priv->hw_params->tx_queues; i++)
982                        bcmgenet_tx_reclaim(dev, &priv->tx_rings[i]);
983        }
984
985        bcmgenet_tx_reclaim(dev, &priv->tx_rings[DESC_INDEX]);
986}
987
988/* Transmits a single SKB (either head of a fragment or a single SKB)
989 * caller must hold priv->lock
990 */
991static int bcmgenet_xmit_single(struct net_device *dev,
992                                struct sk_buff *skb,
993                                u16 dma_desc_flags,
994                                struct bcmgenet_tx_ring *ring)
995{
996        struct bcmgenet_priv *priv = netdev_priv(dev);
997        struct device *kdev = &priv->pdev->dev;
998        struct enet_cb *tx_cb_ptr;
999        unsigned int skb_len;
1000        dma_addr_t mapping;
1001        u32 length_status;
1002        int ret;
1003
1004        tx_cb_ptr = bcmgenet_get_txcb(priv, ring);
1005
1006        if (unlikely(!tx_cb_ptr))
1007                BUG();
1008
1009        tx_cb_ptr->skb = skb;
1010
1011        skb_len = skb_headlen(skb) < ETH_ZLEN ? ETH_ZLEN : skb_headlen(skb);
1012
1013        mapping = dma_map_single(kdev, skb->data, skb_len, DMA_TO_DEVICE);
1014        ret = dma_mapping_error(kdev, mapping);
1015        if (ret) {
1016                netif_err(priv, tx_err, dev, "Tx DMA map failed\n");
1017                dev_kfree_skb(skb);
1018                return ret;
1019        }
1020
1021        dma_unmap_addr_set(tx_cb_ptr, dma_addr, mapping);
1022        dma_unmap_len_set(tx_cb_ptr, dma_len, skb_len);
1023        length_status = (skb_len << DMA_BUFLENGTH_SHIFT) | dma_desc_flags |
1024                        (priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT) |
1025                        DMA_TX_APPEND_CRC;
1026
1027        if (skb->ip_summed == CHECKSUM_PARTIAL)
1028                length_status |= DMA_TX_DO_CSUM;
1029
1030        dmadesc_set(priv, tx_cb_ptr->bd_addr, mapping, length_status);
1031
1032        /* Decrement total BD count and advance our write pointer */
1033        ring->free_bds -= 1;
1034        ring->prod_index += 1;
1035        ring->prod_index &= DMA_P_INDEX_MASK;
1036
1037        return 0;
1038}
1039
1040/* Transmit a SKB fragment */
1041static int bcmgenet_xmit_frag(struct net_device *dev,
1042                              skb_frag_t *frag,
1043                              u16 dma_desc_flags,
1044                              struct bcmgenet_tx_ring *ring)
1045{
1046        struct bcmgenet_priv *priv = netdev_priv(dev);
1047        struct device *kdev = &priv->pdev->dev;
1048        struct enet_cb *tx_cb_ptr;
1049        dma_addr_t mapping;
1050        int ret;
1051
1052        tx_cb_ptr = bcmgenet_get_txcb(priv, ring);
1053
1054        if (unlikely(!tx_cb_ptr))
1055                BUG();
1056        tx_cb_ptr->skb = NULL;
1057
1058        mapping = skb_frag_dma_map(kdev, frag, 0,
1059                                   skb_frag_size(frag), DMA_TO_DEVICE);
1060        ret = dma_mapping_error(kdev, mapping);
1061        if (ret) {
1062                netif_err(priv, tx_err, dev, "%s: Tx DMA map failed\n",
1063                          __func__);
1064                return ret;
1065        }
1066
1067        dma_unmap_addr_set(tx_cb_ptr, dma_addr, mapping);
1068        dma_unmap_len_set(tx_cb_ptr, dma_len, frag->size);
1069
1070        dmadesc_set(priv, tx_cb_ptr->bd_addr, mapping,
1071                    (frag->size << DMA_BUFLENGTH_SHIFT) | dma_desc_flags |
1072                    (priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT));
1073
1074
1075        ring->free_bds -= 1;
1076        ring->prod_index += 1;
1077        ring->prod_index &= DMA_P_INDEX_MASK;
1078
1079        return 0;
1080}
1081
1082/* Reallocate the SKB to put enough headroom in front of it and insert
1083 * the transmit checksum offsets in the descriptors
1084 */
1085static struct sk_buff *bcmgenet_put_tx_csum(struct net_device *dev,
1086                                            struct sk_buff *skb)
1087{
1088        struct status_64 *status = NULL;
1089        struct sk_buff *new_skb;
1090        u16 offset;
1091        u8 ip_proto;
1092        u16 ip_ver;
1093        u32 tx_csum_info;
1094
1095        if (unlikely(skb_headroom(skb) < sizeof(*status))) {
1096                /* If 64 byte status block enabled, must make sure skb has
1097                 * enough headroom for us to insert 64B status block.
1098                 */
1099                new_skb = skb_realloc_headroom(skb, sizeof(*status));
1100                dev_kfree_skb(skb);
1101                if (!new_skb) {
1102                        dev->stats.tx_errors++;
1103                        dev->stats.tx_dropped++;
1104                        return NULL;
1105                }
1106                skb = new_skb;
1107        }
1108
1109        skb_push(skb, sizeof(*status));
1110        status = (struct status_64 *)skb->data;
1111
1112        if (skb->ip_summed  == CHECKSUM_PARTIAL) {
1113                ip_ver = htons(skb->protocol);
1114                switch (ip_ver) {
1115                case ETH_P_IP:
1116                        ip_proto = ip_hdr(skb)->protocol;
1117                        break;
1118                case ETH_P_IPV6:
1119                        ip_proto = ipv6_hdr(skb)->nexthdr;
1120                        break;
1121                default:
1122                        return skb;
1123                }
1124
1125                offset = skb_checksum_start_offset(skb) - sizeof(*status);
1126                tx_csum_info = (offset << STATUS_TX_CSUM_START_SHIFT) |
1127                                (offset + skb->csum_offset);
1128
1129                /* Set the length valid bit for TCP and UDP and just set
1130                 * the special UDP flag for IPv4, else just set to 0.
1131                 */
1132                if (ip_proto == IPPROTO_TCP || ip_proto == IPPROTO_UDP) {
1133                        tx_csum_info |= STATUS_TX_CSUM_LV;
1134                        if (ip_proto == IPPROTO_UDP && ip_ver == ETH_P_IP)
1135                                tx_csum_info |= STATUS_TX_CSUM_PROTO_UDP;
1136                } else {
1137                        tx_csum_info = 0;
1138                }
1139
1140                status->tx_csum_info = tx_csum_info;
1141        }
1142
1143        return skb;
1144}
1145
1146static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
1147{
1148        struct bcmgenet_priv *priv = netdev_priv(dev);
1149        struct bcmgenet_tx_ring *ring = NULL;
1150        struct netdev_queue *txq;
1151        unsigned long flags = 0;
1152        int nr_frags, index;
1153        u16 dma_desc_flags;
1154        int ret;
1155        int i;
1156
1157        index = skb_get_queue_mapping(skb);
1158        /* Mapping strategy:
1159         * queue_mapping = 0, unclassified, packet xmited through ring16
1160         * queue_mapping = 1, goes to ring 0. (highest priority queue
1161         * queue_mapping = 2, goes to ring 1.
1162         * queue_mapping = 3, goes to ring 2.
1163         * queue_mapping = 4, goes to ring 3.
1164         */
1165        if (index == 0)
1166                index = DESC_INDEX;
1167        else
1168                index -= 1;
1169
1170        nr_frags = skb_shinfo(skb)->nr_frags;
1171        ring = &priv->tx_rings[index];
1172        txq = netdev_get_tx_queue(dev, ring->queue);
1173
1174        spin_lock_irqsave(&ring->lock, flags);
1175        if (ring->free_bds <= nr_frags + 1) {
1176                netif_tx_stop_queue(txq);
1177                netdev_err(dev, "%s: tx ring %d full when queue %d awake\n",
1178                           __func__, index, ring->queue);
1179                ret = NETDEV_TX_BUSY;
1180                goto out;
1181        }
1182
1183        if (skb_padto(skb, ETH_ZLEN)) {
1184                ret = NETDEV_TX_OK;
1185                goto out;
1186        }
1187
1188        /* set the SKB transmit checksum */
1189        if (priv->desc_64b_en) {
1190                skb = bcmgenet_put_tx_csum(dev, skb);
1191                if (!skb) {
1192                        ret = NETDEV_TX_OK;
1193                        goto out;
1194                }
1195        }
1196
1197        dma_desc_flags = DMA_SOP;
1198        if (nr_frags == 0)
1199                dma_desc_flags |= DMA_EOP;
1200
1201        /* Transmit single SKB or head of fragment list */
1202        ret = bcmgenet_xmit_single(dev, skb, dma_desc_flags, ring);
1203        if (ret) {
1204                ret = NETDEV_TX_OK;
1205                goto out;
1206        }
1207
1208        /* xmit fragment */
1209        for (i = 0; i < nr_frags; i++) {
1210                ret = bcmgenet_xmit_frag(dev,
1211                                         &skb_shinfo(skb)->frags[i],
1212                                         (i == nr_frags - 1) ? DMA_EOP : 0,
1213                                         ring);
1214                if (ret) {
1215                        ret = NETDEV_TX_OK;
1216                        goto out;
1217                }
1218        }
1219
1220        skb_tx_timestamp(skb);
1221
1222        /* we kept a software copy of how much we should advance the TDMA
1223         * producer index, now write it down to the hardware
1224         */
1225        bcmgenet_tdma_ring_writel(priv, ring->index,
1226                                  ring->prod_index, TDMA_PROD_INDEX);
1227
1228        if (ring->free_bds <= (MAX_SKB_FRAGS + 1))
1229                netif_tx_stop_queue(txq);
1230
1231out:
1232        spin_unlock_irqrestore(&ring->lock, flags);
1233
1234        return ret;
1235}
1236
1237
1238static int bcmgenet_rx_refill(struct bcmgenet_priv *priv, struct enet_cb *cb)
1239{
1240        struct device *kdev = &priv->pdev->dev;
1241        struct sk_buff *skb;
1242        dma_addr_t mapping;
1243        int ret;
1244
1245        skb = netdev_alloc_skb(priv->dev, priv->rx_buf_len + SKB_ALIGNMENT);
1246        if (!skb)
1247                return -ENOMEM;
1248
1249        /* a caller did not release this control block */
1250        WARN_ON(cb->skb != NULL);
1251        cb->skb = skb;
1252        mapping = dma_map_single(kdev, skb->data,
1253                                 priv->rx_buf_len, DMA_FROM_DEVICE);
1254        ret = dma_mapping_error(kdev, mapping);
1255        if (ret) {
1256                bcmgenet_free_cb(cb);
1257                netif_err(priv, rx_err, priv->dev,
1258                          "%s DMA map failed\n", __func__);
1259                return ret;
1260        }
1261
1262        dma_unmap_addr_set(cb, dma_addr, mapping);
1263        /* assign packet, prepare descriptor, and advance pointer */
1264
1265        dmadesc_set_addr(priv, priv->rx_bd_assign_ptr, mapping);
1266
1267        /* turn on the newly assigned BD for DMA to use */
1268        priv->rx_bd_assign_index++;
1269        priv->rx_bd_assign_index &= (priv->num_rx_bds - 1);
1270
1271        priv->rx_bd_assign_ptr = priv->rx_bds +
1272                (priv->rx_bd_assign_index * DMA_DESC_SIZE);
1273
1274        return 0;
1275}
1276
1277/* bcmgenet_desc_rx - descriptor based rx process.
1278 * this could be called from bottom half, or from NAPI polling method.
1279 */
1280static unsigned int bcmgenet_desc_rx(struct bcmgenet_priv *priv,
1281                                     unsigned int budget)
1282{
1283        struct net_device *dev = priv->dev;
1284        struct enet_cb *cb;
1285        struct sk_buff *skb;
1286        u32 dma_length_status;
1287        unsigned long dma_flag;
1288        int len, err;
1289        unsigned int rxpktprocessed = 0, rxpkttoprocess;
1290        unsigned int p_index;
1291        unsigned int chksum_ok = 0;
1292
1293        p_index = bcmgenet_rdma_ring_readl(priv, DESC_INDEX, RDMA_PROD_INDEX);
1294        p_index &= DMA_P_INDEX_MASK;
1295
1296        if (p_index < priv->rx_c_index)
1297                rxpkttoprocess = (DMA_C_INDEX_MASK + 1) -
1298                        priv->rx_c_index + p_index;
1299        else
1300                rxpkttoprocess = p_index - priv->rx_c_index;
1301
1302        netif_dbg(priv, rx_status, dev,
1303                  "RDMA: rxpkttoprocess=%d\n", rxpkttoprocess);
1304
1305        while ((rxpktprocessed < rxpkttoprocess) &&
1306               (rxpktprocessed < budget)) {
1307                cb = &priv->rx_cbs[priv->rx_read_ptr];
1308                skb = cb->skb;
1309
1310                /* We do not have a backing SKB, so we do not have a
1311                 * corresponding DMA mapping for this incoming packet since
1312                 * bcmgenet_rx_refill always either has both skb and mapping or
1313                 * none.
1314                 */
1315                if (unlikely(!skb)) {
1316                        dev->stats.rx_dropped++;
1317                        dev->stats.rx_errors++;
1318                        goto refill;
1319                }
1320
1321                /* Unmap the packet contents such that we can use the
1322                 * RSV from the 64 bytes descriptor when enabled and save
1323                 * a 32-bits register read
1324                 */
1325                dma_unmap_single(&dev->dev, dma_unmap_addr(cb, dma_addr),
1326                                 priv->rx_buf_len, DMA_FROM_DEVICE);
1327
1328                if (!priv->desc_64b_en) {
1329                        dma_length_status =
1330                                dmadesc_get_length_status(priv,
1331                                                          priv->rx_bds +
1332                                                          (priv->rx_read_ptr *
1333                                                           DMA_DESC_SIZE));
1334                } else {
1335                        struct status_64 *status;
1336
1337                        status = (struct status_64 *)skb->data;
1338                        dma_length_status = status->length_status;
1339                }
1340
1341                /* DMA flags and length are still valid no matter how
1342                 * we got the Receive Status Vector (64B RSB or register)
1343                 */
1344                dma_flag = dma_length_status & 0xffff;
1345                len = dma_length_status >> DMA_BUFLENGTH_SHIFT;
1346
1347                netif_dbg(priv, rx_status, dev,
1348                          "%s:p_ind=%d c_ind=%d read_ptr=%d len_stat=0x%08x\n",
1349                          __func__, p_index, priv->rx_c_index,
1350                          priv->rx_read_ptr, dma_length_status);
1351
1352                if (unlikely(!(dma_flag & DMA_EOP) || !(dma_flag & DMA_SOP))) {
1353                        netif_err(priv, rx_status, dev,
1354                                  "dropping fragmented packet!\n");
1355                        dev->stats.rx_dropped++;
1356                        dev->stats.rx_errors++;
1357                        dev_kfree_skb_any(cb->skb);
1358                        cb->skb = NULL;
1359                        goto refill;
1360                }
1361                /* report errors */
1362                if (unlikely(dma_flag & (DMA_RX_CRC_ERROR |
1363                                                DMA_RX_OV |
1364                                                DMA_RX_NO |
1365                                                DMA_RX_LG |
1366                                                DMA_RX_RXER))) {
1367                        netif_err(priv, rx_status, dev, "dma_flag=0x%x\n",
1368                                  (unsigned int)dma_flag);
1369                        if (dma_flag & DMA_RX_CRC_ERROR)
1370                                dev->stats.rx_crc_errors++;
1371                        if (dma_flag & DMA_RX_OV)
1372                                dev->stats.rx_over_errors++;
1373                        if (dma_flag & DMA_RX_NO)
1374                                dev->stats.rx_frame_errors++;
1375                        if (dma_flag & DMA_RX_LG)
1376                                dev->stats.rx_length_errors++;
1377                        dev->stats.rx_dropped++;
1378                        dev->stats.rx_errors++;
1379
1380                        /* discard the packet and advance consumer index.*/
1381                        dev_kfree_skb_any(cb->skb);
1382                        cb->skb = NULL;
1383                        goto refill;
1384                } /* error packet */
1385
1386                chksum_ok = (dma_flag & priv->dma_rx_chk_bit) &&
1387                             priv->desc_rxchk_en;
1388
1389                skb_put(skb, len);
1390                if (priv->desc_64b_en) {
1391                        skb_pull(skb, 64);
1392                        len -= 64;
1393                }
1394
1395                if (likely(chksum_ok))
1396                        skb->ip_summed = CHECKSUM_UNNECESSARY;
1397
1398                /* remove hardware 2bytes added for IP alignment */
1399                skb_pull(skb, 2);
1400                len -= 2;
1401
1402                if (priv->crc_fwd_en) {
1403                        skb_trim(skb, len - ETH_FCS_LEN);
1404                        len -= ETH_FCS_LEN;
1405                }
1406
1407                /*Finish setting up the received SKB and send it to the kernel*/
1408                skb->protocol = eth_type_trans(skb, priv->dev);
1409                dev->stats.rx_packets++;
1410                dev->stats.rx_bytes += len;
1411                if (dma_flag & DMA_RX_MULT)
1412                        dev->stats.multicast++;
1413
1414                /* Notify kernel */
1415                napi_gro_receive(&priv->napi, skb);
1416                cb->skb = NULL;
1417                netif_dbg(priv, rx_status, dev, "pushed up to kernel\n");
1418
1419                /* refill RX path on the current control block */
1420refill:
1421                err = bcmgenet_rx_refill(priv, cb);
1422                if (err)
1423                        netif_err(priv, rx_err, dev, "Rx refill failed\n");
1424
1425                rxpktprocessed++;
1426                priv->rx_read_ptr++;
1427                priv->rx_read_ptr &= (priv->num_rx_bds - 1);
1428        }
1429
1430        return rxpktprocessed;
1431}
1432
1433/* Assign skb to RX DMA descriptor. */
1434static int bcmgenet_alloc_rx_buffers(struct bcmgenet_priv *priv)
1435{
1436        struct enet_cb *cb;
1437        int ret = 0;
1438        int i;
1439
1440        netif_dbg(priv, hw, priv->dev, "%s:\n", __func__);
1441
1442        /* loop here for each buffer needing assign */
1443        for (i = 0; i < priv->num_rx_bds; i++) {
1444                cb = &priv->rx_cbs[priv->rx_bd_assign_index];
1445                if (cb->skb)
1446                        continue;
1447
1448                ret = bcmgenet_rx_refill(priv, cb);
1449                if (ret)
1450                        break;
1451        }
1452
1453        return ret;
1454}
1455
1456static void bcmgenet_free_rx_buffers(struct bcmgenet_priv *priv)
1457{
1458        struct enet_cb *cb;
1459        int i;
1460
1461        for (i = 0; i < priv->num_rx_bds; i++) {
1462                cb = &priv->rx_cbs[i];
1463
1464                if (dma_unmap_addr(cb, dma_addr)) {
1465                        dma_unmap_single(&priv->dev->dev,
1466                                         dma_unmap_addr(cb, dma_addr),
1467                                         priv->rx_buf_len, DMA_FROM_DEVICE);
1468                        dma_unmap_addr_set(cb, dma_addr, 0);
1469                }
1470
1471                if (cb->skb)
1472                        bcmgenet_free_cb(cb);
1473        }
1474}
1475
1476static void umac_enable_set(struct bcmgenet_priv *priv, u32 mask, bool enable)
1477{
1478        u32 reg;
1479
1480        reg = bcmgenet_umac_readl(priv, UMAC_CMD);
1481        if (enable)
1482                reg |= mask;
1483        else
1484                reg &= ~mask;
1485        bcmgenet_umac_writel(priv, reg, UMAC_CMD);
1486
1487        /* UniMAC stops on a packet boundary, wait for a full-size packet
1488         * to be processed
1489         */
1490        if (enable == 0)
1491                usleep_range(1000, 2000);
1492}
1493
1494static int reset_umac(struct bcmgenet_priv *priv)
1495{
1496        struct device *kdev = &priv->pdev->dev;
1497        unsigned int timeout = 0;
1498        u32 reg;
1499
1500        /* 7358a0/7552a0: bad default in RBUF_FLUSH_CTRL.umac_sw_rst */
1501        bcmgenet_rbuf_ctrl_set(priv, 0);
1502        udelay(10);
1503
1504        /* disable MAC while updating its registers */
1505        bcmgenet_umac_writel(priv, 0, UMAC_CMD);
1506
1507        /* issue soft reset, wait for it to complete */
1508        bcmgenet_umac_writel(priv, CMD_SW_RESET, UMAC_CMD);
1509        while (timeout++ < 1000) {
1510                reg = bcmgenet_umac_readl(priv, UMAC_CMD);
1511                if (!(reg & CMD_SW_RESET))
1512                        return 0;
1513
1514                udelay(1);
1515        }
1516
1517        if (timeout == 1000) {
1518                dev_err(kdev,
1519                        "timeout waiting for MAC to come out of reset\n");
1520                return -ETIMEDOUT;
1521        }
1522
1523        return 0;
1524}
1525
1526static void bcmgenet_intr_disable(struct bcmgenet_priv *priv)
1527{
1528        /* Mask all interrupts.*/
1529        bcmgenet_intrl2_0_writel(priv, 0xFFFFFFFF, INTRL2_CPU_MASK_SET);
1530        bcmgenet_intrl2_0_writel(priv, 0xFFFFFFFF, INTRL2_CPU_CLEAR);
1531        bcmgenet_intrl2_0_writel(priv, 0, INTRL2_CPU_MASK_CLEAR);
1532        bcmgenet_intrl2_1_writel(priv, 0xFFFFFFFF, INTRL2_CPU_MASK_SET);
1533        bcmgenet_intrl2_1_writel(priv, 0xFFFFFFFF, INTRL2_CPU_CLEAR);
1534        bcmgenet_intrl2_1_writel(priv, 0, INTRL2_CPU_MASK_CLEAR);
1535}
1536
1537static int init_umac(struct bcmgenet_priv *priv)
1538{
1539        struct device *kdev = &priv->pdev->dev;
1540        int ret;
1541        u32 reg, cpu_mask_clear;
1542        int index;
1543
1544        dev_dbg(&priv->pdev->dev, "bcmgenet: init_umac\n");
1545
1546        ret = reset_umac(priv);
1547        if (ret)
1548                return ret;
1549
1550        bcmgenet_umac_writel(priv, 0, UMAC_CMD);
1551        /* clear tx/rx counter */
1552        bcmgenet_umac_writel(priv,
1553                             MIB_RESET_RX | MIB_RESET_TX | MIB_RESET_RUNT,
1554                             UMAC_MIB_CTRL);
1555        bcmgenet_umac_writel(priv, 0, UMAC_MIB_CTRL);
1556
1557        bcmgenet_umac_writel(priv, ENET_MAX_MTU_SIZE, UMAC_MAX_FRAME_LEN);
1558
1559        /* init rx registers, enable ip header optimization */
1560        reg = bcmgenet_rbuf_readl(priv, RBUF_CTRL);
1561        reg |= RBUF_ALIGN_2B;
1562        bcmgenet_rbuf_writel(priv, reg, RBUF_CTRL);
1563
1564        if (!GENET_IS_V1(priv) && !GENET_IS_V2(priv))
1565                bcmgenet_rbuf_writel(priv, 1, RBUF_TBUF_SIZE_CTRL);
1566
1567        bcmgenet_intr_disable(priv);
1568
1569        cpu_mask_clear = UMAC_IRQ_RXDMA_BDONE | UMAC_IRQ_TXDMA_BDONE;
1570
1571        dev_dbg(kdev, "%s:Enabling RXDMA_BDONE interrupt\n", __func__);
1572
1573        /* Monitor cable plug/unplugged event for internal PHY */
1574        if (phy_is_internal(priv->phydev)) {
1575                cpu_mask_clear |= (UMAC_IRQ_LINK_DOWN | UMAC_IRQ_LINK_UP);
1576        } else if (priv->ext_phy) {
1577                cpu_mask_clear |= (UMAC_IRQ_LINK_DOWN | UMAC_IRQ_LINK_UP);
1578        } else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
1579                reg = bcmgenet_bp_mc_get(priv);
1580                reg |= BIT(priv->hw_params->bp_in_en_shift);
1581
1582                /* bp_mask: back pressure mask */
1583                if (netif_is_multiqueue(priv->dev))
1584                        reg |= priv->hw_params->bp_in_mask;
1585                else
1586                        reg &= ~priv->hw_params->bp_in_mask;
1587                bcmgenet_bp_mc_set(priv, reg);
1588        }
1589
1590        /* Enable MDIO interrupts on GENET v3+ */
1591        if (priv->hw_params->flags & GENET_HAS_MDIO_INTR)
1592                cpu_mask_clear |= UMAC_IRQ_MDIO_DONE | UMAC_IRQ_MDIO_ERROR;
1593
1594        bcmgenet_intrl2_0_writel(priv, cpu_mask_clear, INTRL2_CPU_MASK_CLEAR);
1595
1596        for (index = 0; index < priv->hw_params->tx_queues; index++)
1597                bcmgenet_intrl2_1_writel(priv, (1 << index),
1598                                         INTRL2_CPU_MASK_CLEAR);
1599
1600        /* Enable rx/tx engine.*/
1601        dev_dbg(kdev, "done init umac\n");
1602
1603        return 0;
1604}
1605
1606/* Initialize all house-keeping variables for a TX ring, along
1607 * with corresponding hardware registers
1608 */
1609static void bcmgenet_init_tx_ring(struct bcmgenet_priv *priv,
1610                                  unsigned int index, unsigned int size,
1611                                  unsigned int write_ptr, unsigned int end_ptr)
1612{
1613        struct bcmgenet_tx_ring *ring = &priv->tx_rings[index];
1614        u32 words_per_bd = WORDS_PER_BD(priv);
1615        u32 flow_period_val = 0;
1616        unsigned int first_bd;
1617
1618        spin_lock_init(&ring->lock);
1619        ring->priv = priv;
1620        netif_napi_add(priv->dev, &ring->napi, bcmgenet_tx_poll, 64);
1621        ring->index = index;
1622        if (index == DESC_INDEX) {
1623                ring->queue = 0;
1624                ring->int_enable = bcmgenet_tx_ring16_int_enable;
1625                ring->int_disable = bcmgenet_tx_ring16_int_disable;
1626        } else {
1627                ring->queue = index + 1;
1628                ring->int_enable = bcmgenet_tx_ring_int_enable;
1629                ring->int_disable = bcmgenet_tx_ring_int_disable;
1630        }
1631        ring->cbs = priv->tx_cbs + write_ptr;
1632        ring->size = size;
1633        ring->c_index = 0;
1634        ring->free_bds = size;
1635        ring->write_ptr = write_ptr;
1636        ring->cb_ptr = write_ptr;
1637        ring->end_ptr = end_ptr - 1;
1638        ring->prod_index = 0;
1639
1640        /* Set flow period for ring != 16 */
1641        if (index != DESC_INDEX)
1642                flow_period_val = ENET_MAX_MTU_SIZE << 16;
1643
1644        bcmgenet_tdma_ring_writel(priv, index, 0, TDMA_PROD_INDEX);
1645        bcmgenet_tdma_ring_writel(priv, index, 0, TDMA_CONS_INDEX);
1646        bcmgenet_tdma_ring_writel(priv, index, 1, DMA_MBUF_DONE_THRESH);
1647        /* Disable rate control for now */
1648        bcmgenet_tdma_ring_writel(priv, index, flow_period_val,
1649                                  TDMA_FLOW_PERIOD);
1650        /* Unclassified traffic goes to ring 16 */
1651        bcmgenet_tdma_ring_writel(priv, index,
1652                                  ((size << DMA_RING_SIZE_SHIFT) |
1653                                   RX_BUF_LENGTH), DMA_RING_BUF_SIZE);
1654
1655        first_bd = write_ptr;
1656
1657        /* Set start and end address, read and write pointers */
1658        bcmgenet_tdma_ring_writel(priv, index, first_bd * words_per_bd,
1659                                  DMA_START_ADDR);
1660        bcmgenet_tdma_ring_writel(priv, index, first_bd * words_per_bd,
1661                                  TDMA_READ_PTR);
1662        bcmgenet_tdma_ring_writel(priv, index, first_bd,
1663                                  TDMA_WRITE_PTR);
1664        bcmgenet_tdma_ring_writel(priv, index, end_ptr * words_per_bd - 1,
1665                                  DMA_END_ADDR);
1666
1667        napi_enable(&ring->napi);
1668}
1669
1670static void bcmgenet_fini_tx_ring(struct bcmgenet_priv *priv,
1671                                  unsigned int index)
1672{
1673        struct bcmgenet_tx_ring *ring = &priv->tx_rings[index];
1674
1675        napi_disable(&ring->napi);
1676        netif_napi_del(&ring->napi);
1677}
1678
1679/* Initialize a RDMA ring */
1680static int bcmgenet_init_rx_ring(struct bcmgenet_priv *priv,
1681                                 unsigned int index, unsigned int size)
1682{
1683        u32 words_per_bd = WORDS_PER_BD(priv);
1684        int ret;
1685
1686        priv->num_rx_bds = TOTAL_DESC;
1687        priv->rx_bds = priv->base + priv->hw_params->rdma_offset;
1688        priv->rx_bd_assign_ptr = priv->rx_bds;
1689        priv->rx_bd_assign_index = 0;
1690        priv->rx_c_index = 0;
1691        priv->rx_read_ptr = 0;
1692        priv->rx_cbs = kcalloc(priv->num_rx_bds, sizeof(struct enet_cb),
1693                               GFP_KERNEL);
1694        if (!priv->rx_cbs)
1695                return -ENOMEM;
1696
1697        ret = bcmgenet_alloc_rx_buffers(priv);
1698        if (ret) {
1699                kfree(priv->rx_cbs);
1700                return ret;
1701        }
1702
1703        bcmgenet_rdma_ring_writel(priv, index, 0, RDMA_WRITE_PTR);
1704        bcmgenet_rdma_ring_writel(priv, index, 0, RDMA_PROD_INDEX);
1705        bcmgenet_rdma_ring_writel(priv, index, 0, RDMA_CONS_INDEX);
1706        bcmgenet_rdma_ring_writel(priv, index,
1707                                  ((size << DMA_RING_SIZE_SHIFT) |
1708                                   RX_BUF_LENGTH), DMA_RING_BUF_SIZE);
1709        bcmgenet_rdma_ring_writel(priv, index, 0, DMA_START_ADDR);
1710        bcmgenet_rdma_ring_writel(priv, index,
1711                                  words_per_bd * size - 1, DMA_END_ADDR);
1712        bcmgenet_rdma_ring_writel(priv, index,
1713                                  (DMA_FC_THRESH_LO <<
1714                                   DMA_XOFF_THRESHOLD_SHIFT) |
1715                                   DMA_FC_THRESH_HI, RDMA_XON_XOFF_THRESH);
1716        bcmgenet_rdma_ring_writel(priv, index, 0, RDMA_READ_PTR);
1717
1718        return ret;
1719}
1720
1721/* init multi xmit queues, only available for GENET2+
1722 * the queue is partitioned as follows:
1723 *
1724 * queue 0 - 3 is priority based, each one has 32 descriptors,
1725 * with queue 0 being the highest priority queue.
1726 *
1727 * queue 16 is the default tx queue with GENET_DEFAULT_BD_CNT
1728 * descriptors: 256 - (number of tx queues * bds per queues) = 128
1729 * descriptors.
1730 *
1731 * The transmit control block pool is then partitioned as following:
1732 * - tx_cbs[0...127] are for queue 16
1733 * - tx_ring_cbs[0] points to tx_cbs[128..159]
1734 * - tx_ring_cbs[1] points to tx_cbs[160..191]
1735 * - tx_ring_cbs[2] points to tx_cbs[192..223]
1736 * - tx_ring_cbs[3] points to tx_cbs[224..255]
1737 */
1738static void bcmgenet_init_multiq(struct net_device *dev)
1739{
1740        struct bcmgenet_priv *priv = netdev_priv(dev);
1741        unsigned int i, dma_enable;
1742        u32 reg, dma_ctrl, ring_cfg = 0;
1743        u32 dma_priority[3] = {0, 0, 0};
1744
1745        if (!netif_is_multiqueue(dev)) {
1746                netdev_warn(dev, "called with non multi queue aware HW\n");
1747                return;
1748        }
1749
1750        dma_ctrl = bcmgenet_tdma_readl(priv, DMA_CTRL);
1751        dma_enable = dma_ctrl & DMA_EN;
1752        dma_ctrl &= ~DMA_EN;
1753        bcmgenet_tdma_writel(priv, dma_ctrl, DMA_CTRL);
1754
1755        /* Enable strict priority arbiter mode */
1756        bcmgenet_tdma_writel(priv, DMA_ARBITER_SP, DMA_ARB_CTRL);
1757
1758        for (i = 0; i < priv->hw_params->tx_queues; i++) {
1759                /* first 64 tx_cbs are reserved for default tx queue
1760                 * (ring 16)
1761                 */
1762                bcmgenet_init_tx_ring(priv, i, priv->hw_params->bds_cnt,
1763                                      i * priv->hw_params->bds_cnt,
1764                                      (i + 1) * priv->hw_params->bds_cnt);
1765
1766                /* Configure ring as descriptor ring and setup priority */
1767                ring_cfg |= 1 << i;
1768                dma_ctrl |= 1 << (i + DMA_RING_BUF_EN_SHIFT);
1769
1770                dma_priority[DMA_PRIO_REG_INDEX(i)] |=
1771                        ((GENET_Q0_PRIORITY + i) << DMA_PRIO_REG_SHIFT(i));
1772        }
1773
1774        /* Set ring 16 priority and program the hardware registers */
1775        dma_priority[DMA_PRIO_REG_INDEX(DESC_INDEX)] |=
1776                ((GENET_Q0_PRIORITY + priv->hw_params->tx_queues) <<
1777                 DMA_PRIO_REG_SHIFT(DESC_INDEX));
1778        bcmgenet_tdma_writel(priv, dma_priority[0], DMA_PRIORITY_0);
1779        bcmgenet_tdma_writel(priv, dma_priority[1], DMA_PRIORITY_1);
1780        bcmgenet_tdma_writel(priv, dma_priority[2], DMA_PRIORITY_2);
1781
1782        /* Enable rings */
1783        reg = bcmgenet_tdma_readl(priv, DMA_RING_CFG);
1784        reg |= ring_cfg;
1785        bcmgenet_tdma_writel(priv, reg, DMA_RING_CFG);
1786
1787        /* Configure ring as descriptor ring and re-enable DMA if enabled */
1788        reg = bcmgenet_tdma_readl(priv, DMA_CTRL);
1789        reg |= dma_ctrl;
1790        if (dma_enable)
1791                reg |= DMA_EN;
1792        bcmgenet_tdma_writel(priv, reg, DMA_CTRL);
1793}
1794
1795static int bcmgenet_dma_teardown(struct bcmgenet_priv *priv)
1796{
1797        int ret = 0;
1798        int timeout = 0;
1799        u32 reg;
1800
1801        /* Disable TDMA to stop add more frames in TX DMA */
1802        reg = bcmgenet_tdma_readl(priv, DMA_CTRL);
1803        reg &= ~DMA_EN;
1804        bcmgenet_tdma_writel(priv, reg, DMA_CTRL);
1805
1806        /* Check TDMA status register to confirm TDMA is disabled */
1807        while (timeout++ < DMA_TIMEOUT_VAL) {
1808                reg = bcmgenet_tdma_readl(priv, DMA_STATUS);
1809                if (reg & DMA_DISABLED)
1810                        break;
1811
1812                udelay(1);
1813        }
1814
1815        if (timeout == DMA_TIMEOUT_VAL) {
1816                netdev_warn(priv->dev, "Timed out while disabling TX DMA\n");
1817                ret = -ETIMEDOUT;
1818        }
1819
1820        /* Wait 10ms for packet drain in both tx and rx dma */
1821        usleep_range(10000, 20000);
1822
1823        /* Disable RDMA */
1824        reg = bcmgenet_rdma_readl(priv, DMA_CTRL);
1825        reg &= ~DMA_EN;
1826        bcmgenet_rdma_writel(priv, reg, DMA_CTRL);
1827
1828        timeout = 0;
1829        /* Check RDMA status register to confirm RDMA is disabled */
1830        while (timeout++ < DMA_TIMEOUT_VAL) {
1831                reg = bcmgenet_rdma_readl(priv, DMA_STATUS);
1832                if (reg & DMA_DISABLED)
1833                        break;
1834
1835                udelay(1);
1836        }
1837
1838        if (timeout == DMA_TIMEOUT_VAL) {
1839                netdev_warn(priv->dev, "Timed out while disabling RX DMA\n");
1840                ret = -ETIMEDOUT;
1841        }
1842
1843        return ret;
1844}
1845
1846static void __bcmgenet_fini_dma(struct bcmgenet_priv *priv)
1847{
1848        int i;
1849
1850        /* disable DMA */
1851        bcmgenet_dma_teardown(priv);
1852
1853        for (i = 0; i < priv->num_tx_bds; i++) {
1854                if (priv->tx_cbs[i].skb != NULL) {
1855                        dev_kfree_skb(priv->tx_cbs[i].skb);
1856                        priv->tx_cbs[i].skb = NULL;
1857                }
1858        }
1859
1860        bcmgenet_free_rx_buffers(priv);
1861        kfree(priv->rx_cbs);
1862        kfree(priv->tx_cbs);
1863}
1864
1865static void bcmgenet_fini_dma(struct bcmgenet_priv *priv)
1866{
1867        int i;
1868
1869        bcmgenet_fini_tx_ring(priv, DESC_INDEX);
1870
1871        for (i = 0; i < priv->hw_params->tx_queues; i++)
1872                bcmgenet_fini_tx_ring(priv, i);
1873
1874        __bcmgenet_fini_dma(priv);
1875}
1876
1877/* init_edma: Initialize DMA control register */
1878static int bcmgenet_init_dma(struct bcmgenet_priv *priv)
1879{
1880        int ret;
1881
1882        netif_dbg(priv, hw, priv->dev, "bcmgenet: init_edma\n");
1883
1884        /* by default, enable ring 16 (descriptor based) */
1885        ret = bcmgenet_init_rx_ring(priv, DESC_INDEX, TOTAL_DESC);
1886        if (ret) {
1887                netdev_err(priv->dev, "failed to initialize RX ring\n");
1888                return ret;
1889        }
1890
1891        /* init rDma */
1892        bcmgenet_rdma_writel(priv, DMA_MAX_BURST_LENGTH, DMA_SCB_BURST_SIZE);
1893
1894        /* Init tDma */
1895        bcmgenet_tdma_writel(priv, DMA_MAX_BURST_LENGTH, DMA_SCB_BURST_SIZE);
1896
1897        /* Initialize common TX ring structures */
1898        priv->tx_bds = priv->base + priv->hw_params->tdma_offset;
1899        priv->num_tx_bds = TOTAL_DESC;
1900        priv->tx_cbs = kcalloc(priv->num_tx_bds, sizeof(struct enet_cb),
1901                               GFP_KERNEL);
1902        if (!priv->tx_cbs) {
1903                __bcmgenet_fini_dma(priv);
1904                return -ENOMEM;
1905        }
1906
1907        /* initialize multi xmit queue */
1908        bcmgenet_init_multiq(priv->dev);
1909
1910        /* initialize special ring 16 */
1911        bcmgenet_init_tx_ring(priv, DESC_INDEX, GENET_DEFAULT_BD_CNT,
1912                              priv->hw_params->tx_queues *
1913                              priv->hw_params->bds_cnt,
1914                              TOTAL_DESC);
1915
1916        return 0;
1917}
1918
1919/* NAPI polling method*/
1920static int bcmgenet_poll(struct napi_struct *napi, int budget)
1921{
1922        struct bcmgenet_priv *priv = container_of(napi,
1923                        struct bcmgenet_priv, napi);
1924        unsigned int work_done;
1925
1926        work_done = bcmgenet_desc_rx(priv, budget);
1927
1928        /* Advancing our consumer index*/
1929        priv->rx_c_index += work_done;
1930        priv->rx_c_index &= DMA_C_INDEX_MASK;
1931        bcmgenet_rdma_ring_writel(priv, DESC_INDEX,
1932                                  priv->rx_c_index, RDMA_CONS_INDEX);
1933        if (work_done < budget) {
1934                napi_complete(napi);
1935                bcmgenet_intrl2_0_writel(priv, UMAC_IRQ_RXDMA_BDONE,
1936                                         INTRL2_CPU_MASK_CLEAR);
1937        }
1938
1939        return work_done;
1940}
1941
1942/* Interrupt bottom half */
1943static void bcmgenet_irq_task(struct work_struct *work)
1944{
1945        struct bcmgenet_priv *priv = container_of(
1946                        work, struct bcmgenet_priv, bcmgenet_irq_work);
1947
1948        netif_dbg(priv, intr, priv->dev, "%s\n", __func__);
1949
1950        if (priv->irq0_stat & UMAC_IRQ_MPD_R) {
1951                priv->irq0_stat &= ~UMAC_IRQ_MPD_R;
1952                netif_dbg(priv, wol, priv->dev,
1953                          "magic packet detected, waking up\n");
1954                bcmgenet_power_up(priv, GENET_POWER_WOL_MAGIC);
1955        }
1956
1957        /* Link UP/DOWN event */
1958        if ((priv->hw_params->flags & GENET_HAS_MDIO_INTR) &&
1959            (priv->irq0_stat & (UMAC_IRQ_LINK_UP|UMAC_IRQ_LINK_DOWN))) {
1960                phy_mac_interrupt(priv->phydev,
1961                                  priv->irq0_stat & UMAC_IRQ_LINK_UP);
1962                priv->irq0_stat &= ~(UMAC_IRQ_LINK_UP|UMAC_IRQ_LINK_DOWN);
1963        }
1964}
1965
1966/* bcmgenet_isr1: interrupt handler for ring buffer. */
1967static irqreturn_t bcmgenet_isr1(int irq, void *dev_id)
1968{
1969        struct bcmgenet_priv *priv = dev_id;
1970        struct bcmgenet_tx_ring *ring;
1971        unsigned int index;
1972
1973        /* Save irq status for bottom-half processing. */
1974        priv->irq1_stat =
1975                bcmgenet_intrl2_1_readl(priv, INTRL2_CPU_STAT) &
1976                ~bcmgenet_intrl2_1_readl(priv, INTRL2_CPU_MASK_STATUS);
1977        /* clear interrupts */
1978        bcmgenet_intrl2_1_writel(priv, priv->irq1_stat, INTRL2_CPU_CLEAR);
1979
1980        netif_dbg(priv, intr, priv->dev,
1981                  "%s: IRQ=0x%x\n", __func__, priv->irq1_stat);
1982
1983        /* Check the MBDONE interrupts.
1984         * packet is done, reclaim descriptors
1985         */
1986        for (index = 0; index < priv->hw_params->tx_queues; index++) {
1987                if (!(priv->irq1_stat & BIT(index)))
1988                        continue;
1989
1990                ring = &priv->tx_rings[index];
1991
1992                if (likely(napi_schedule_prep(&ring->napi))) {
1993                        ring->int_disable(priv, ring);
1994                        __napi_schedule(&ring->napi);
1995                }
1996        }
1997
1998        return IRQ_HANDLED;
1999}
2000
2001/* bcmgenet_isr0: Handle various interrupts. */
2002static irqreturn_t bcmgenet_isr0(int irq, void *dev_id)
2003{
2004        struct bcmgenet_priv *priv = dev_id;
2005
2006        /* Save irq status for bottom-half processing. */
2007        priv->irq0_stat =
2008                bcmgenet_intrl2_0_readl(priv, INTRL2_CPU_STAT) &
2009                ~bcmgenet_intrl2_0_readl(priv, INTRL2_CPU_MASK_STATUS);
2010        /* clear interrupts */
2011        bcmgenet_intrl2_0_writel(priv, priv->irq0_stat, INTRL2_CPU_CLEAR);
2012
2013        netif_dbg(priv, intr, priv->dev,
2014                  "IRQ=0x%x\n", priv->irq0_stat);
2015
2016        if (priv->irq0_stat & (UMAC_IRQ_RXDMA_BDONE | UMAC_IRQ_RXDMA_PDONE)) {
2017                /* We use NAPI(software interrupt throttling, if
2018                 * Rx Descriptor throttling is not used.
2019                 * Disable interrupt, will be enabled in the poll method.
2020                 */
2021                if (likely(napi_schedule_prep(&priv->napi))) {
2022                        bcmgenet_intrl2_0_writel(priv, UMAC_IRQ_RXDMA_BDONE,
2023                                                 INTRL2_CPU_MASK_SET);
2024                        __napi_schedule(&priv->napi);
2025                }
2026        }
2027        if (priv->irq0_stat &
2028                        (UMAC_IRQ_TXDMA_BDONE | UMAC_IRQ_TXDMA_PDONE)) {
2029                struct bcmgenet_tx_ring *ring = &priv->tx_rings[DESC_INDEX];
2030
2031                if (likely(napi_schedule_prep(&ring->napi))) {
2032                        ring->int_disable(priv, ring);
2033                        __napi_schedule(&ring->napi);
2034                }
2035        }
2036        if (priv->irq0_stat & (UMAC_IRQ_PHY_DET_R |
2037                                UMAC_IRQ_PHY_DET_F |
2038                                UMAC_IRQ_LINK_UP |
2039                                UMAC_IRQ_LINK_DOWN |
2040                                UMAC_IRQ_HFB_SM |
2041                                UMAC_IRQ_HFB_MM |
2042                                UMAC_IRQ_MPD_R)) {
2043                /* all other interested interrupts handled in bottom half */
2044                schedule_work(&priv->bcmgenet_irq_work);
2045        }
2046
2047        if ((priv->hw_params->flags & GENET_HAS_MDIO_INTR) &&
2048            priv->irq0_stat & (UMAC_IRQ_MDIO_DONE | UMAC_IRQ_MDIO_ERROR)) {
2049                priv->irq0_stat &= ~(UMAC_IRQ_MDIO_DONE | UMAC_IRQ_MDIO_ERROR);
2050                wake_up(&priv->wq);
2051        }
2052
2053        return IRQ_HANDLED;
2054}
2055
2056static irqreturn_t bcmgenet_wol_isr(int irq, void *dev_id)
2057{
2058        struct bcmgenet_priv *priv = dev_id;
2059
2060        pm_wakeup_event(&priv->pdev->dev, 0);
2061
2062        return IRQ_HANDLED;
2063}
2064
2065static void bcmgenet_umac_reset(struct bcmgenet_priv *priv)
2066{
2067        u32 reg;
2068
2069        reg = bcmgenet_rbuf_ctrl_get(priv);
2070        reg |= BIT(1);
2071        bcmgenet_rbuf_ctrl_set(priv, reg);
2072        udelay(10);
2073
2074        reg &= ~BIT(1);
2075        bcmgenet_rbuf_ctrl_set(priv, reg);
2076        udelay(10);
2077}
2078
2079static void bcmgenet_set_hw_addr(struct bcmgenet_priv *priv,
2080                                 unsigned char *addr)
2081{
2082        bcmgenet_umac_writel(priv, (addr[0] << 24) | (addr[1] << 16) |
2083                        (addr[2] << 8) | addr[3], UMAC_MAC0);
2084        bcmgenet_umac_writel(priv, (addr[4] << 8) | addr[5], UMAC_MAC1);
2085}
2086
2087/* Returns a reusable dma control register value */
2088static u32 bcmgenet_dma_disable(struct bcmgenet_priv *priv)
2089{
2090        u32 reg;
2091        u32 dma_ctrl;
2092
2093        /* disable DMA */
2094        dma_ctrl = 1 << (DESC_INDEX + DMA_RING_BUF_EN_SHIFT) | DMA_EN;
2095        reg = bcmgenet_tdma_readl(priv, DMA_CTRL);
2096        reg &= ~dma_ctrl;
2097        bcmgenet_tdma_writel(priv, reg, DMA_CTRL);
2098
2099        reg = bcmgenet_rdma_readl(priv, DMA_CTRL);
2100        reg &= ~dma_ctrl;
2101        bcmgenet_rdma_writel(priv, reg, DMA_CTRL);
2102
2103        bcmgenet_umac_writel(priv, 1, UMAC_TX_FLUSH);
2104        udelay(10);
2105        bcmgenet_umac_writel(priv, 0, UMAC_TX_FLUSH);
2106
2107        return dma_ctrl;
2108}
2109
2110static void bcmgenet_enable_dma(struct bcmgenet_priv *priv, u32 dma_ctrl)
2111{
2112        u32 reg;
2113
2114        reg = bcmgenet_rdma_readl(priv, DMA_CTRL);
2115        reg |= dma_ctrl;
2116        bcmgenet_rdma_writel(priv, reg, DMA_CTRL);
2117
2118        reg = bcmgenet_tdma_readl(priv, DMA_CTRL);
2119        reg |= dma_ctrl;
2120        bcmgenet_tdma_writel(priv, reg, DMA_CTRL);
2121}
2122
2123static void bcmgenet_netif_start(struct net_device *dev)
2124{
2125        struct bcmgenet_priv *priv = netdev_priv(dev);
2126
2127        /* Start the network engine */
2128        napi_enable(&priv->napi);
2129
2130        umac_enable_set(priv, CMD_TX_EN | CMD_RX_EN, true);
2131
2132        if (phy_is_internal(priv->phydev))
2133                bcmgenet_power_up(priv, GENET_POWER_PASSIVE);
2134
2135        netif_tx_start_all_queues(dev);
2136
2137        phy_start(priv->phydev);
2138}
2139
2140static int bcmgenet_open(struct net_device *dev)
2141{
2142        struct bcmgenet_priv *priv = netdev_priv(dev);
2143        unsigned long dma_ctrl;
2144        u32 reg;
2145        int ret;
2146
2147        netif_dbg(priv, ifup, dev, "bcmgenet_open\n");
2148
2149        /* Turn on the clock */
2150        if (!IS_ERR(priv->clk))
2151                clk_prepare_enable(priv->clk);
2152
2153        /* take MAC out of reset */
2154        bcmgenet_umac_reset(priv);
2155
2156        ret = init_umac(priv);
2157        if (ret)
2158                goto err_clk_disable;
2159
2160        /* disable ethernet MAC while updating its registers */
2161        umac_enable_set(priv, CMD_TX_EN | CMD_RX_EN, false);
2162
2163        /* Make sure we reflect the value of CRC_CMD_FWD */
2164        reg = bcmgenet_umac_readl(priv, UMAC_CMD);
2165        priv->crc_fwd_en = !!(reg & CMD_CRC_FWD);
2166
2167        bcmgenet_set_hw_addr(priv, dev->dev_addr);
2168
2169        if (phy_is_internal(priv->phydev)) {
2170                reg = bcmgenet_ext_readl(priv, EXT_EXT_PWR_MGMT);
2171                reg |= EXT_ENERGY_DET_MASK;
2172                bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT);
2173        }
2174
2175        /* Disable RX/TX DMA and flush TX queues */
2176        dma_ctrl = bcmgenet_dma_disable(priv);
2177
2178        /* Reinitialize TDMA and RDMA and SW housekeeping */
2179        ret = bcmgenet_init_dma(priv);
2180        if (ret) {
2181                netdev_err(dev, "failed to initialize DMA\n");
2182                goto err_fini_dma;
2183        }
2184
2185        /* Always enable ring 16 - descriptor ring */
2186        bcmgenet_enable_dma(priv, dma_ctrl);
2187
2188        ret = request_irq(priv->irq0, bcmgenet_isr0, IRQF_SHARED,
2189                          dev->name, priv);
2190        if (ret < 0) {
2191                netdev_err(dev, "can't request IRQ %d\n", priv->irq0);
2192                goto err_fini_dma;
2193        }
2194
2195        ret = request_irq(priv->irq1, bcmgenet_isr1, IRQF_SHARED,
2196                          dev->name, priv);
2197        if (ret < 0) {
2198                netdev_err(dev, "can't request IRQ %d\n", priv->irq1);
2199                goto err_irq0;
2200        }
2201
2202        /* Re-configure the port multiplexer towards the PHY device */
2203        bcmgenet_mii_config(priv->dev, false);
2204
2205        phy_connect_direct(dev, priv->phydev, bcmgenet_mii_setup,
2206                           priv->phy_interface);
2207
2208        bcmgenet_netif_start(dev);
2209
2210        return 0;
2211
2212err_irq0:
2213        free_irq(priv->irq0, dev);
2214err_fini_dma:
2215        bcmgenet_fini_dma(priv);
2216err_clk_disable:
2217        if (!IS_ERR(priv->clk))
2218                clk_disable_unprepare(priv->clk);
2219        return ret;
2220}
2221
2222static void bcmgenet_netif_stop(struct net_device *dev)
2223{
2224        struct bcmgenet_priv *priv = netdev_priv(dev);
2225
2226        netif_tx_stop_all_queues(dev);
2227        napi_disable(&priv->napi);
2228        phy_stop(priv->phydev);
2229
2230        bcmgenet_intr_disable(priv);
2231
2232        /* Wait for pending work items to complete. Since interrupts are
2233         * disabled no new work will be scheduled.
2234         */
2235        cancel_work_sync(&priv->bcmgenet_irq_work);
2236
2237        priv->old_link = -1;
2238        priv->old_speed = -1;
2239        priv->old_duplex = -1;
2240        priv->old_pause = -1;
2241}
2242
2243static int bcmgenet_close(struct net_device *dev)
2244{
2245        struct bcmgenet_priv *priv = netdev_priv(dev);
2246        int ret;
2247
2248        netif_dbg(priv, ifdown, dev, "bcmgenet_close\n");
2249
2250        bcmgenet_netif_stop(dev);
2251
2252        /* Really kill the PHY state machine and disconnect from it */
2253        phy_disconnect(priv->phydev);
2254
2255        /* Disable MAC receive */
2256        umac_enable_set(priv, CMD_RX_EN, false);
2257
2258        ret = bcmgenet_dma_teardown(priv);
2259        if (ret)
2260                return ret;
2261
2262        /* Disable MAC transmit. TX DMA disabled have to done before this */
2263        umac_enable_set(priv, CMD_TX_EN, false);
2264
2265        /* tx reclaim */
2266        bcmgenet_tx_reclaim_all(dev);
2267        bcmgenet_fini_dma(priv);
2268
2269        free_irq(priv->irq0, priv);
2270        free_irq(priv->irq1, priv);
2271
2272        if (phy_is_internal(priv->phydev))
2273                bcmgenet_power_down(priv, GENET_POWER_PASSIVE);
2274
2275        if (!IS_ERR(priv->clk))
2276                clk_disable_unprepare(priv->clk);
2277
2278        return 0;
2279}
2280
2281static void bcmgenet_timeout(struct net_device *dev)
2282{
2283        struct bcmgenet_priv *priv = netdev_priv(dev);
2284
2285        netif_dbg(priv, tx_err, dev, "bcmgenet_timeout\n");
2286
2287        dev->trans_start = jiffies;
2288
2289        dev->stats.tx_errors++;
2290
2291        netif_tx_wake_all_queues(dev);
2292}
2293
2294#define MAX_MC_COUNT    16
2295
2296static inline void bcmgenet_set_mdf_addr(struct bcmgenet_priv *priv,
2297                                         unsigned char *addr,
2298                                         int *i,
2299                                         int *mc)
2300{
2301        u32 reg;
2302
2303        bcmgenet_umac_writel(priv, addr[0] << 8 | addr[1],
2304                             UMAC_MDF_ADDR + (*i * 4));
2305        bcmgenet_umac_writel(priv, addr[2] << 24 | addr[3] << 16 |
2306                             addr[4] << 8 | addr[5],
2307                             UMAC_MDF_ADDR + ((*i + 1) * 4));
2308        reg = bcmgenet_umac_readl(priv, UMAC_MDF_CTRL);
2309        reg |= (1 << (MAX_MC_COUNT - *mc));
2310        bcmgenet_umac_writel(priv, reg, UMAC_MDF_CTRL);
2311        *i += 2;
2312        (*mc)++;
2313}
2314
2315static void bcmgenet_set_rx_mode(struct net_device *dev)
2316{
2317        struct bcmgenet_priv *priv = netdev_priv(dev);
2318        struct netdev_hw_addr *ha;
2319        int i, mc;
2320        u32 reg;
2321
2322        netif_dbg(priv, hw, dev, "%s: %08X\n", __func__, dev->flags);
2323
2324        /* Promiscuous mode */
2325        reg = bcmgenet_umac_readl(priv, UMAC_CMD);
2326        if (dev->flags & IFF_PROMISC) {
2327                reg |= CMD_PROMISC;
2328                bcmgenet_umac_writel(priv, reg, UMAC_CMD);
2329                bcmgenet_umac_writel(priv, 0, UMAC_MDF_CTRL);
2330                return;
2331        } else {
2332                reg &= ~CMD_PROMISC;
2333                bcmgenet_umac_writel(priv, reg, UMAC_CMD);
2334        }
2335
2336        /* UniMac doesn't support ALLMULTI */
2337        if (dev->flags & IFF_ALLMULTI) {
2338                netdev_warn(dev, "ALLMULTI is not supported\n");
2339                return;
2340        }
2341
2342        /* update MDF filter */
2343        i = 0;
2344        mc = 0;
2345        /* Broadcast */
2346        bcmgenet_set_mdf_addr(priv, dev->broadcast, &i, &mc);
2347        /* my own address.*/
2348        bcmgenet_set_mdf_addr(priv, dev->dev_addr, &i, &mc);
2349        /* Unicast list*/
2350        if (netdev_uc_count(dev) > (MAX_MC_COUNT - mc))
2351                return;
2352
2353        if (!netdev_uc_empty(dev))
2354                netdev_for_each_uc_addr(ha, dev)
2355                        bcmgenet_set_mdf_addr(priv, ha->addr, &i, &mc);
2356        /* Multicast */
2357        if (netdev_mc_empty(dev) || netdev_mc_count(dev) >= (MAX_MC_COUNT - mc))
2358                return;
2359
2360        netdev_for_each_mc_addr(ha, dev)
2361                bcmgenet_set_mdf_addr(priv, ha->addr, &i, &mc);
2362}
2363
2364/* Set the hardware MAC address. */
2365static int bcmgenet_set_mac_addr(struct net_device *dev, void *p)
2366{
2367        struct sockaddr *addr = p;
2368
2369        /* Setting the MAC address at the hardware level is not possible
2370         * without disabling the UniMAC RX/TX enable bits.
2371         */
2372        if (netif_running(dev))
2373                return -EBUSY;
2374
2375        ether_addr_copy(dev->dev_addr, addr->sa_data);
2376
2377        return 0;
2378}
2379
2380static const struct net_device_ops bcmgenet_netdev_ops = {
2381        .ndo_open               = bcmgenet_open,
2382        .ndo_stop               = bcmgenet_close,
2383        .ndo_start_xmit         = bcmgenet_xmit,
2384        .ndo_tx_timeout         = bcmgenet_timeout,
2385        .ndo_set_rx_mode        = bcmgenet_set_rx_mode,
2386        .ndo_set_mac_address    = bcmgenet_set_mac_addr,
2387        .ndo_do_ioctl           = bcmgenet_ioctl,
2388        .ndo_set_features       = bcmgenet_set_features,
2389};
2390
2391/* Array of GENET hardware parameters/characteristics */
2392static struct bcmgenet_hw_params bcmgenet_hw_params[] = {
2393        [GENET_V1] = {
2394                .tx_queues = 0,
2395                .rx_queues = 0,
2396                .bds_cnt = 0,
2397                .bp_in_en_shift = 16,
2398                .bp_in_mask = 0xffff,
2399                .hfb_filter_cnt = 16,
2400                .qtag_mask = 0x1F,
2401                .hfb_offset = 0x1000,
2402                .rdma_offset = 0x2000,
2403                .tdma_offset = 0x3000,
2404                .words_per_bd = 2,
2405        },
2406        [GENET_V2] = {
2407                .tx_queues = 4,
2408                .rx_queues = 4,
2409                .bds_cnt = 32,
2410                .bp_in_en_shift = 16,
2411                .bp_in_mask = 0xffff,
2412                .hfb_filter_cnt = 16,
2413                .qtag_mask = 0x1F,
2414                .tbuf_offset = 0x0600,
2415                .hfb_offset = 0x1000,
2416                .hfb_reg_offset = 0x2000,
2417                .rdma_offset = 0x3000,
2418                .tdma_offset = 0x4000,
2419                .words_per_bd = 2,
2420                .flags = GENET_HAS_EXT,
2421        },
2422        [GENET_V3] = {
2423                .tx_queues = 4,
2424                .rx_queues = 4,
2425                .bds_cnt = 32,
2426                .bp_in_en_shift = 17,
2427                .bp_in_mask = 0x1ffff,
2428                .hfb_filter_cnt = 48,
2429                .qtag_mask = 0x3F,
2430                .tbuf_offset = 0x0600,
2431                .hfb_offset = 0x8000,
2432                .hfb_reg_offset = 0xfc00,
2433                .rdma_offset = 0x10000,
2434                .tdma_offset = 0x11000,
2435                .words_per_bd = 2,
2436                .flags = GENET_HAS_EXT | GENET_HAS_MDIO_INTR,
2437        },
2438        [GENET_V4] = {
2439                .tx_queues = 4,
2440                .rx_queues = 4,
2441                .bds_cnt = 32,
2442                .bp_in_en_shift = 17,
2443                .bp_in_mask = 0x1ffff,
2444                .hfb_filter_cnt = 48,
2445                .qtag_mask = 0x3F,
2446                .tbuf_offset = 0x0600,
2447                .hfb_offset = 0x8000,
2448                .hfb_reg_offset = 0xfc00,
2449                .rdma_offset = 0x2000,
2450                .tdma_offset = 0x4000,
2451                .words_per_bd = 3,
2452                .flags = GENET_HAS_40BITS | GENET_HAS_EXT | GENET_HAS_MDIO_INTR,
2453        },
2454};
2455
2456/* Infer hardware parameters from the detected GENET version */
2457static void bcmgenet_set_hw_params(struct bcmgenet_priv *priv)
2458{
2459        struct bcmgenet_hw_params *params;
2460        u32 reg;
2461        u8 major;
2462
2463        if (GENET_IS_V4(priv)) {
2464                bcmgenet_dma_regs = bcmgenet_dma_regs_v3plus;
2465                genet_dma_ring_regs = genet_dma_ring_regs_v4;
2466                priv->dma_rx_chk_bit = DMA_RX_CHK_V3PLUS;
2467                priv->version = GENET_V4;
2468        } else if (GENET_IS_V3(priv)) {
2469                bcmgenet_dma_regs = bcmgenet_dma_regs_v3plus;
2470                genet_dma_ring_regs = genet_dma_ring_regs_v123;
2471                priv->dma_rx_chk_bit = DMA_RX_CHK_V3PLUS;
2472                priv->version = GENET_V3;
2473        } else if (GENET_IS_V2(priv)) {
2474                bcmgenet_dma_regs = bcmgenet_dma_regs_v2;
2475                genet_dma_ring_regs = genet_dma_ring_regs_v123;
2476                priv->dma_rx_chk_bit = DMA_RX_CHK_V12;
2477                priv->version = GENET_V2;
2478        } else if (GENET_IS_V1(priv)) {
2479                bcmgenet_dma_regs = bcmgenet_dma_regs_v1;
2480                genet_dma_ring_regs = genet_dma_ring_regs_v123;
2481                priv->dma_rx_chk_bit = DMA_RX_CHK_V12;
2482                priv->version = GENET_V1;
2483        }
2484
2485        /* enum genet_version starts at 1 */
2486        priv->hw_params = &bcmgenet_hw_params[priv->version];
2487        params = priv->hw_params;
2488
2489        /* Read GENET HW version */
2490        reg = bcmgenet_sys_readl(priv, SYS_REV_CTRL);
2491        major = (reg >> 24 & 0x0f);
2492        if (major == 5)
2493                major = 4;
2494        else if (major == 0)
2495                major = 1;
2496        if (major != priv->version) {
2497                dev_err(&priv->pdev->dev,
2498                        "GENET version mismatch, got: %d, configured for: %d\n",
2499                        major, priv->version);
2500        }
2501
2502        /* Print the GENET core version */
2503        dev_info(&priv->pdev->dev, "GENET " GENET_VER_FMT,
2504                 major, (reg >> 16) & 0x0f, reg & 0xffff);
2505
2506        /* Store the integrated PHY revision for the MDIO probing function
2507         * to pass this information to the PHY driver. The PHY driver expects
2508         * to find the PHY major revision in bits 15:8 while the GENET register
2509         * stores that information in bits 7:0, account for that.
2510         */
2511        priv->gphy_rev = (reg & 0xffff) << 8;
2512
2513#ifdef CONFIG_PHYS_ADDR_T_64BIT
2514        if (!(params->flags & GENET_HAS_40BITS))
2515                pr_warn("GENET does not support 40-bits PA\n");
2516#endif
2517
2518        pr_debug("Configuration for version: %d\n"
2519                "TXq: %1d, RXq: %1d, BDs: %1d\n"
2520                "BP << en: %2d, BP msk: 0x%05x\n"
2521                "HFB count: %2d, QTAQ msk: 0x%05x\n"
2522                "TBUF: 0x%04x, HFB: 0x%04x, HFBreg: 0x%04x\n"
2523                "RDMA: 0x%05x, TDMA: 0x%05x\n"
2524                "Words/BD: %d\n",
2525                priv->version,
2526                params->tx_queues, params->rx_queues, params->bds_cnt,
2527                params->bp_in_en_shift, params->bp_in_mask,
2528                params->hfb_filter_cnt, params->qtag_mask,
2529                params->tbuf_offset, params->hfb_offset,
2530                params->hfb_reg_offset,
2531                params->rdma_offset, params->tdma_offset,
2532                params->words_per_bd);
2533}
2534
2535static const struct of_device_id bcmgenet_match[] = {
2536        { .compatible = "brcm,genet-v1", .data = (void *)GENET_V1 },
2537        { .compatible = "brcm,genet-v2", .data = (void *)GENET_V2 },
2538        { .compatible = "brcm,genet-v3", .data = (void *)GENET_V3 },
2539        { .compatible = "brcm,genet-v4", .data = (void *)GENET_V4 },
2540        { },
2541};
2542
2543static int bcmgenet_probe(struct platform_device *pdev)
2544{
2545        struct device_node *dn = pdev->dev.of_node;
2546        const struct of_device_id *of_id;
2547        struct bcmgenet_priv *priv;
2548        struct net_device *dev;
2549        const void *macaddr;
2550        struct resource *r;
2551        int err = -EIO;
2552
2553        /* Up to GENET_MAX_MQ_CNT + 1 TX queues and a single RX queue */
2554        dev = alloc_etherdev_mqs(sizeof(*priv), GENET_MAX_MQ_CNT + 1, 1);
2555        if (!dev) {
2556                dev_err(&pdev->dev, "can't allocate net device\n");
2557                return -ENOMEM;
2558        }
2559
2560        of_id = of_match_node(bcmgenet_match, dn);
2561        if (!of_id)
2562                return -EINVAL;
2563
2564        priv = netdev_priv(dev);
2565        priv->irq0 = platform_get_irq(pdev, 0);
2566        priv->irq1 = platform_get_irq(pdev, 1);
2567        priv->wol_irq = platform_get_irq(pdev, 2);
2568        if (!priv->irq0 || !priv->irq1) {
2569                dev_err(&pdev->dev, "can't find IRQs\n");
2570                err = -EINVAL;
2571                goto err;
2572        }
2573
2574        macaddr = of_get_mac_address(dn);
2575        if (!macaddr) {
2576                dev_err(&pdev->dev, "can't find MAC address\n");
2577                err = -EINVAL;
2578                goto err;
2579        }
2580
2581        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2582        priv->base = devm_ioremap_resource(&pdev->dev, r);
2583        if (IS_ERR(priv->base)) {
2584                err = PTR_ERR(priv->base);
2585                goto err;
2586        }
2587
2588        SET_NETDEV_DEV(dev, &pdev->dev);
2589        dev_set_drvdata(&pdev->dev, dev);
2590        ether_addr_copy(dev->dev_addr, macaddr);
2591        dev->watchdog_timeo = 2 * HZ;
2592        dev->ethtool_ops = &bcmgenet_ethtool_ops;
2593        dev->netdev_ops = &bcmgenet_netdev_ops;
2594        netif_napi_add(dev, &priv->napi, bcmgenet_poll, 64);
2595
2596        priv->msg_enable = netif_msg_init(-1, GENET_MSG_DEFAULT);
2597
2598        /* Set hardware features */
2599        dev->hw_features |= NETIF_F_SG | NETIF_F_IP_CSUM |
2600                NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM;
2601
2602        /* Request the WOL interrupt and advertise suspend if available */
2603        priv->wol_irq_disabled = true;
2604        err = devm_request_irq(&pdev->dev, priv->wol_irq, bcmgenet_wol_isr, 0,
2605                               dev->name, priv);
2606        if (!err)
2607                device_set_wakeup_capable(&pdev->dev, 1);
2608
2609        /* Set the needed headroom to account for any possible
2610         * features enabling/disabling at runtime
2611         */
2612        dev->needed_headroom += 64;
2613
2614        netdev_boot_setup_check(dev);
2615
2616        priv->dev = dev;
2617        priv->pdev = pdev;
2618        priv->version = (enum bcmgenet_version)of_id->data;
2619
2620        priv->clk = devm_clk_get(&priv->pdev->dev, "enet");
2621        if (IS_ERR(priv->clk))
2622                dev_warn(&priv->pdev->dev, "failed to get enet clock\n");
2623
2624        if (!IS_ERR(priv->clk))
2625                clk_prepare_enable(priv->clk);
2626
2627        bcmgenet_set_hw_params(priv);
2628
2629        /* Mii wait queue */
2630        init_waitqueue_head(&priv->wq);
2631        /* Always use RX_BUF_LENGTH (2KB) buffer for all chips */
2632        priv->rx_buf_len = RX_BUF_LENGTH;
2633        INIT_WORK(&priv->bcmgenet_irq_work, bcmgenet_irq_task);
2634
2635        priv->clk_wol = devm_clk_get(&priv->pdev->dev, "enet-wol");
2636        if (IS_ERR(priv->clk_wol))
2637                dev_warn(&priv->pdev->dev, "failed to get enet-wol clock\n");
2638
2639        err = reset_umac(priv);
2640        if (err)
2641                goto err_clk_disable;
2642
2643        err = bcmgenet_mii_init(dev);
2644        if (err)
2645                goto err_clk_disable;
2646
2647        /* setup number of real queues  + 1 (GENET_V1 has 0 hardware queues
2648         * just the ring 16 descriptor based TX
2649         */
2650        netif_set_real_num_tx_queues(priv->dev, priv->hw_params->tx_queues + 1);
2651        netif_set_real_num_rx_queues(priv->dev, priv->hw_params->rx_queues + 1);
2652
2653        /* libphy will determine the link state */
2654        netif_carrier_off(dev);
2655
2656        /* Turn off the main clock, WOL clock is handled separately */
2657        if (!IS_ERR(priv->clk))
2658                clk_disable_unprepare(priv->clk);
2659
2660        err = register_netdev(dev);
2661        if (err)
2662                goto err;
2663
2664        return err;
2665
2666err_clk_disable:
2667        if (!IS_ERR(priv->clk))
2668                clk_disable_unprepare(priv->clk);
2669err:
2670        free_netdev(dev);
2671        return err;
2672}
2673
2674static int bcmgenet_remove(struct platform_device *pdev)
2675{
2676        struct bcmgenet_priv *priv = dev_to_priv(&pdev->dev);
2677
2678        dev_set_drvdata(&pdev->dev, NULL);
2679        unregister_netdev(priv->dev);
2680        bcmgenet_mii_exit(priv->dev);
2681        free_netdev(priv->dev);
2682
2683        return 0;
2684}
2685
2686#ifdef CONFIG_PM_SLEEP
2687static int bcmgenet_suspend(struct device *d)
2688{
2689        struct net_device *dev = dev_get_drvdata(d);
2690        struct bcmgenet_priv *priv = netdev_priv(dev);
2691        int ret;
2692
2693        if (!netif_running(dev))
2694                return 0;
2695
2696        bcmgenet_netif_stop(dev);
2697
2698        if (!device_may_wakeup(d))
2699                phy_suspend(priv->phydev);
2700
2701        netif_device_detach(dev);
2702
2703        /* Disable MAC receive */
2704        umac_enable_set(priv, CMD_RX_EN, false);
2705
2706        ret = bcmgenet_dma_teardown(priv);
2707        if (ret)
2708                return ret;
2709
2710        /* Disable MAC transmit. TX DMA disabled have to done before this */
2711        umac_enable_set(priv, CMD_TX_EN, false);
2712
2713        /* tx reclaim */
2714        bcmgenet_tx_reclaim_all(dev);
2715        bcmgenet_fini_dma(priv);
2716
2717        /* Prepare the device for Wake-on-LAN and switch to the slow clock */
2718        if (device_may_wakeup(d) && priv->wolopts) {
2719                bcmgenet_power_down(priv, GENET_POWER_WOL_MAGIC);
2720                clk_prepare_enable(priv->clk_wol);
2721        }
2722
2723        /* Turn off the clocks */
2724        clk_disable_unprepare(priv->clk);
2725
2726        return 0;
2727}
2728
2729static int bcmgenet_resume(struct device *d)
2730{
2731        struct net_device *dev = dev_get_drvdata(d);
2732        struct bcmgenet_priv *priv = netdev_priv(dev);
2733        unsigned long dma_ctrl;
2734        int ret;
2735        u32 reg;
2736
2737        if (!netif_running(dev))
2738                return 0;
2739
2740        /* Turn on the clock */
2741        ret = clk_prepare_enable(priv->clk);
2742        if (ret)
2743                return ret;
2744
2745        bcmgenet_umac_reset(priv);
2746
2747        ret = init_umac(priv);
2748        if (ret)
2749                goto out_clk_disable;
2750
2751        /* From WOL-enabled suspend, switch to regular clock */
2752        if (priv->wolopts)
2753                clk_disable_unprepare(priv->clk_wol);
2754
2755        phy_init_hw(priv->phydev);
2756        /* Speed settings must be restored */
2757        bcmgenet_mii_config(priv->dev, false);
2758
2759        /* disable ethernet MAC while updating its registers */
2760        umac_enable_set(priv, CMD_TX_EN | CMD_RX_EN, false);
2761
2762        bcmgenet_set_hw_addr(priv, dev->dev_addr);
2763
2764        if (phy_is_internal(priv->phydev)) {
2765                reg = bcmgenet_ext_readl(priv, EXT_EXT_PWR_MGMT);
2766                reg |= EXT_ENERGY_DET_MASK;
2767                bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT);
2768        }
2769
2770        if (priv->wolopts)
2771                bcmgenet_power_up(priv, GENET_POWER_WOL_MAGIC);
2772
2773        /* Disable RX/TX DMA and flush TX queues */
2774        dma_ctrl = bcmgenet_dma_disable(priv);
2775
2776        /* Reinitialize TDMA and RDMA and SW housekeeping */
2777        ret = bcmgenet_init_dma(priv);
2778        if (ret) {
2779                netdev_err(dev, "failed to initialize DMA\n");
2780                goto out_clk_disable;
2781        }
2782
2783        /* Always enable ring 16 - descriptor ring */
2784        bcmgenet_enable_dma(priv, dma_ctrl);
2785
2786        netif_device_attach(dev);
2787
2788        if (!device_may_wakeup(d))
2789                phy_resume(priv->phydev);
2790
2791        bcmgenet_netif_start(dev);
2792
2793        return 0;
2794
2795out_clk_disable:
2796        clk_disable_unprepare(priv->clk);
2797        return ret;
2798}
2799#endif /* CONFIG_PM_SLEEP */
2800
2801static SIMPLE_DEV_PM_OPS(bcmgenet_pm_ops, bcmgenet_suspend, bcmgenet_resume);
2802
2803static struct platform_driver bcmgenet_driver = {
2804        .probe  = bcmgenet_probe,
2805        .remove = bcmgenet_remove,
2806        .driver = {
2807                .name   = "bcmgenet",
2808                .owner  = THIS_MODULE,
2809                .of_match_table = bcmgenet_match,
2810                .pm     = &bcmgenet_pm_ops,
2811        },
2812};
2813module_platform_driver(bcmgenet_driver);
2814
2815MODULE_AUTHOR("Broadcom Corporation");
2816MODULE_DESCRIPTION("Broadcom GENET Ethernet controller driver");
2817MODULE_ALIAS("platform:bcmgenet");
2818MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.