drivers/net/ethernet/freescale/fec_main.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
   4  * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
   5  *
   6  * Right now, I am very wasteful with the buffers.  I allocate memory
   7  * pages and then divide them into 2K frame buffers.  This way I know I
   8  * have buffers large enough to hold one frame within one buffer descriptor.
   9  * Once I get this working, I will use 64 or 128 byte CPM buffers, which
  10  * will be much more memory efficient and will easily handle lots of
  11  * small packets.
  12  *
  13  * Much better multiple PHY support by Magnus Damm.
  14  * Copyright (c) 2000 Ericsson Radio Systems AB.
  15  *
  16  * Support for FEC controller of ColdFire processors.
  17  * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
  18  *
  19  * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
  20  * Copyright (c) 2004-2006 Macq Electronique SA.
  21  *
  22  * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/string.h>
  28 #include <linux/pm_runtime.h>
  29 #include <linux/ptrace.h>
  30 #include <linux/errno.h>
  31 #include <linux/ioport.h>
  32 #include <linux/slab.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/delay.h>
  35 #include <linux/netdevice.h>
  36 #include <linux/etherdevice.h>
  37 #include <linux/skbuff.h>
  38 #include <linux/in.h>
  39 #include <linux/ip.h>
  40 #include <net/ip.h>
  41 #include <net/tso.h>
  42 #include <linux/tcp.h>
  43 #include <linux/udp.h>
  44 #include <linux/icmp.h>
  45 #include <linux/spinlock.h>
  46 #include <linux/workqueue.h>
  47 #include <linux/bitops.h>
  48 #include <linux/io.h>
  49 #include <linux/irq.h>
  50 #include <linux/clk.h>
  51 #include <linux/crc32.h>
  52 #include <linux/platform_device.h>
  53 #include <linux/mdio.h>
  54 #include <linux/phy.h>
  55 #include <linux/fec.h>
  56 #include <linux/of.h>
  57 #include <linux/of_device.h>
  58 #include <linux/of_gpio.h>
  59 #include <linux/of_mdio.h>
  60 #include <linux/of_net.h>
  61 #include <linux/regulator/consumer.h>
  62 #include <linux/if_vlan.h>
  63 #include <linux/pinctrl/consumer.h>
  64 #include <linux/prefetch.h>
  65 #include <linux/mfd/syscon.h>
  66 #include <linux/regmap.h>
  67 #include <soc/imx/cpuidle.h>
  68
  69 #include <asm/cacheflush.h>
  70
  71 #include "fec.h"
  72
  73 static void set_multicast_list(struct net_device *ndev);
  74 static void fec_enet_itr_coal_init(struct net_device *ndev);
  75
  76 #define DRIVER_NAME     "fec"
  77
  78 /* Pause frame feild and FIFO threshold */
  79 #define FEC_ENET_FCE    (1 << 5)
  80 #define FEC_ENET_RSEM_V 0x84
  81 #define FEC_ENET_RSFL_V 16
  82 #define FEC_ENET_RAEM_V 0x8
  83 #define FEC_ENET_RAFL_V 0x8
  84 #define FEC_ENET_OPD_V  0xFFF0
  85 #define FEC_MDIO_PM_TIMEOUT  100 /* ms */
  86
  87 struct fec_devinfo {
  88         u32 quirks;
  89 };
  90
  91 static const struct fec_devinfo fec_imx25_info = {
  92         .quirks = FEC_QUIRK_USE_GASKET | FEC_QUIRK_MIB_CLEAR |
  93                   FEC_QUIRK_HAS_FRREG,
  94 };
  95
  96 static const struct fec_devinfo fec_imx27_info = {
  97         .quirks = FEC_QUIRK_MIB_CLEAR | FEC_QUIRK_HAS_FRREG,
  98 };
  99
 100 static const struct fec_devinfo fec_imx28_info = {
 101         .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME |
 102                   FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC |
 103                   FEC_QUIRK_HAS_FRREG,
 104 };
 105
 106 static const struct fec_devinfo fec_imx6q_info = {
 107         .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
 108                   FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
 109                   FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358 |
 110                   FEC_QUIRK_HAS_RACC,
 111 };
 112
 113 static const struct fec_devinfo fec_mvf600_info = {
 114         .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_RACC,
 115 };
 116
 117 static const struct fec_devinfo fec_imx6x_info = {
 118         .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
 119                   FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
 120                   FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB |
 121                   FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE |
 122                   FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE,
 123 };
 124
 125 static const struct fec_devinfo fec_imx6ul_info = {
 126         .quirks = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
 127                   FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
 128                   FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR007885 |
 129                   FEC_QUIRK_BUG_CAPTURE | FEC_QUIRK_HAS_RACC |
 130                   FEC_QUIRK_HAS_COALESCE,
 131 };
 132
 133 static struct platform_device_id fec_devtype[] = {
 134         {
 135                 /* keep it for coldfire */
 136                 .name = DRIVER_NAME,
 137                 .driver_data = 0,
 138         }, {
 139                 .name = "imx25-fec",
 140                 .driver_data = (kernel_ulong_t)&fec_imx25_info,
 141         }, {
 142                 .name = "imx27-fec",
 143                 .driver_data = (kernel_ulong_t)&fec_imx27_info,
 144         }, {
 145                 .name = "imx28-fec",
 146                 .driver_data = (kernel_ulong_t)&fec_imx28_info,
 147         }, {
 148                 .name = "imx6q-fec",
 149                 .driver_data = (kernel_ulong_t)&fec_imx6q_info,
 150         }, {
 151                 .name = "mvf600-fec",
 152                 .driver_data = (kernel_ulong_t)&fec_mvf600_info,
 153         }, {
 154                 .name = "imx6sx-fec",
 155                 .driver_data = (kernel_ulong_t)&fec_imx6x_info,
 156         }, {
 157                 .name = "imx6ul-fec",
 158                 .driver_data = (kernel_ulong_t)&fec_imx6ul_info,
 159         }, {
 160                 /* sentinel */
 161         }
 162 };
 163 MODULE_DEVICE_TABLE(platform, fec_devtype);
 164
 165 enum imx_fec_type {
 166         IMX25_FEC = 1,  /* runs on i.mx25/50/53 */
 167         IMX27_FEC,      /* runs on i.mx27/35/51 */
 168         IMX28_FEC,
 169         IMX6Q_FEC,
 170         MVF600_FEC,
 171         IMX6SX_FEC,
 172         IMX6UL_FEC,
 173 };
 174
 175 static const struct of_device_id fec_dt_ids[] = {
 176         { .compatible = "fsl,imx25-fec", .data = &fec_devtype[IMX25_FEC], },
 177         { .compatible = "fsl,imx27-fec", .data = &fec_devtype[IMX27_FEC], },
 178         { .compatible = "fsl,imx28-fec", .data = &fec_devtype[IMX28_FEC], },
 179         { .compatible = "fsl,imx6q-fec", .data = &fec_devtype[IMX6Q_FEC], },
 180         { .compatible = "fsl,mvf600-fec", .data = &fec_devtype[MVF600_FEC], },
 181         { .compatible = "fsl,imx6sx-fec", .data = &fec_devtype[IMX6SX_FEC], },
 182         { .compatible = "fsl,imx6ul-fec", .data = &fec_devtype[IMX6UL_FEC], },
 183         { /* sentinel */ }
 184 };
 185 MODULE_DEVICE_TABLE(of, fec_dt_ids);
 186
 187 static unsigned char macaddr[ETH_ALEN];
 188 module_param_array(macaddr, byte, NULL, 0);
 189 MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 190
 191 #if defined(CONFIG_M5272)
 192 /*
 193  * Some hardware gets it MAC address out of local flash memory.
 194  * if this is non-zero then assume it is the address to get MAC from.
 195  */
 196 #if defined(CONFIG_NETtel)
 197 #define FEC_FLASHMAC    0xf0006006
 198 #elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
 199 #define FEC_FLASHMAC    0xf0006000
 200 #elif defined(CONFIG_CANCam)
 201 #define FEC_FLASHMAC    0xf0020000
 202 #elif defined (CONFIG_M5272C3)
 203 #define FEC_FLASHMAC    (0xffe04000 + 4)
 204 #elif defined(CONFIG_MOD5272)
 205 #define FEC_FLASHMAC    0xffc0406b
 206 #else
 207 #define FEC_FLASHMAC    0
 208 #endif
 209 #endif /* CONFIG_M5272 */
 210
 211 /* The FEC stores dest/src/type/vlan, data, and checksum for receive packets.
 212  *
 213  * 2048 byte skbufs are allocated. However, alignment requirements
 214  * varies between FEC variants. Worst case is 64, so round down by 64.
 215  */
 216 #define PKT_MAXBUF_SIZE         (round_down(2048 - 64, 64))
 217 #define PKT_MINBUF_SIZE         64
 218
 219 /* FEC receive acceleration */
 220 #define FEC_RACC_IPDIS          (1 << 1)
 221 #define FEC_RACC_PRODIS         (1 << 2)
 222 #define FEC_RACC_SHIFT16        BIT(7)
 223 #define FEC_RACC_OPTIONS        (FEC_RACC_IPDIS | FEC_RACC_PRODIS)
 224
 225 /* MIB Control Register */
 226 #define FEC_MIB_CTRLSTAT_DISABLE        BIT(31)
 227
 228 /*
 229  * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
 230  * size bits. Other FEC hardware does not, so we need to take that into
 231  * account when setting it.
 232  */
 233 #if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
 234     defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM) || \
 235     defined(CONFIG_ARM64)
 236 #define OPT_FRAME_SIZE  (PKT_MAXBUF_SIZE << 16)
 237 #else
 238 #define OPT_FRAME_SIZE  0
 239 #endif
 240
 241 /* FEC MII MMFR bits definition */
 242 #define FEC_MMFR_ST             (1 << 30)
 243 #define FEC_MMFR_ST_C45         (0)
 244 #define FEC_MMFR_OP_READ        (2 << 28)
 245 #define FEC_MMFR_OP_READ_C45    (3 << 28)
 246 #define FEC_MMFR_OP_WRITE       (1 << 28)
 247 #define FEC_MMFR_OP_ADDR_WRITE  (0)
 248 #define FEC_MMFR_PA(v)          ((v & 0x1f) << 23)
 249 #define FEC_MMFR_RA(v)          ((v & 0x1f) << 18)
 250 #define FEC_MMFR_TA             (2 << 16)
 251 #define FEC_MMFR_DATA(v)        (v & 0xffff)
 252 /* FEC ECR bits definition */
 253 #define FEC_ECR_MAGICEN         (1 << 2)
 254 #define FEC_ECR_SLEEP           (1 << 3)
 255
 256 #define FEC_MII_TIMEOUT         30000 /* us */
 257
 258 /* Transmitter timeout */
 259 #define TX_TIMEOUT (2 * HZ)
 260
 261 #define FEC_PAUSE_FLAG_AUTONEG  0x1
 262 #define FEC_PAUSE_FLAG_ENABLE   0x2
 263 #define FEC_WOL_HAS_MAGIC_PACKET        (0x1 << 0)
 264 #define FEC_WOL_FLAG_ENABLE             (0x1 << 1)
 265 #define FEC_WOL_FLAG_SLEEP_ON           (0x1 << 2)
 266
 267 #define COPYBREAK_DEFAULT       256
 268
 269 /* Max number of allowed TCP segments for software TSO */
 270 #define FEC_MAX_TSO_SEGS        100
 271 #define FEC_MAX_SKB_DESCS       (FEC_MAX_TSO_SEGS * 2 + MAX_SKB_FRAGS)
 272
 273 #define IS_TSO_HEADER(txq, addr) \
 274         ((addr >= txq->tso_hdrs_dma) && \
 275         (addr < txq->tso_hdrs_dma + txq->bd.ring_size * TSO_HEADER_SIZE))
 276
 277 static int mii_cnt;
 278
 279 static struct bufdesc *fec_enet_get_nextdesc(struct bufdesc *bdp,
 280                                              struct bufdesc_prop *bd)
 281 {
 282         return (bdp >= bd->last) ? bd->base
 283                         : (struct bufdesc *)(((void *)bdp) + bd->dsize);
 284 }
 285
 286 static struct bufdesc *fec_enet_get_prevdesc(struct bufdesc *bdp,
 287                                              struct bufdesc_prop *bd)
 288 {
 289         return (bdp <= bd->base) ? bd->last
 290                         : (struct bufdesc *)(((void *)bdp) - bd->dsize);
 291 }
 292
 293 static int fec_enet_get_bd_index(struct bufdesc *bdp,
 294                                  struct bufdesc_prop *bd)
 295 {
 296         return ((const char *)bdp - (const char *)bd->base) >> bd->dsize_log2;
 297 }
 298
 299 static int fec_enet_get_free_txdesc_num(struct fec_enet_priv_tx_q *txq)
 300 {
 301         int entries;
 302
 303         entries = (((const char *)txq->dirty_tx -
 304                         (const char *)txq->bd.cur) >> txq->bd.dsize_log2) - 1;
 305
 306         return entries >= 0 ? entries : entries + txq->bd.ring_size;
 307 }
 308
 309 static void swap_buffer(void *bufaddr, int len)
 310 {
 311         int i;
 312         unsigned int *buf = bufaddr;
 313
 314         for (i = 0; i < len; i += 4, buf++)
 315                 swab32s(buf);
 316 }
 317
 318 static void swap_buffer2(void *dst_buf, void *src_buf, int len)
 319 {
 320         int i;
 321         unsigned int *src = src_buf;
 322         unsigned int *dst = dst_buf;
 323
 324         for (i = 0; i < len; i += 4, src++, dst++)
 325                 *dst = swab32p(src);
 326 }
 327
 328 static void fec_dump(struct net_device *ndev)
 329 {
 330         struct fec_enet_private *fep = netdev_priv(ndev);
 331         struct bufdesc *bdp;
 332         struct fec_enet_priv_tx_q *txq;
 333         int index = 0;
 334
 335         netdev_info(ndev, "TX ring dump\n");
 336         pr_info("Nr     SC     addr       len  SKB\n");
 337
 338         txq = fep->tx_queue[0];
 339         bdp = txq->bd.base;
 340
 341         do {
 342                 pr_info("%3u %c%c 0x%04x 0x%08x %4u %p\n",
 343                         index,
 344                         bdp == txq->bd.cur ? 'S' : ' ',
 345                         bdp == txq->dirty_tx ? 'H' : ' ',
 346                         fec16_to_cpu(bdp->cbd_sc),
 347                         fec32_to_cpu(bdp->cbd_bufaddr),
 348                         fec16_to_cpu(bdp->cbd_datlen),
 349                         txq->tx_skbuff[index]);
 350                 bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
 351                 index++;
 352         } while (bdp != txq->bd.base);
 353 }
 354
 355 static inline bool is_ipv4_pkt(struct sk_buff *skb)
 356 {
 357         return skb->protocol == htons(ETH_P_IP) && ip_hdr(skb)->version == 4;
 358 }
 359
 360 static int
 361 fec_enet_clear_csum(struct sk_buff *skb, struct net_device *ndev)
 362 {
 363         /* Only run for packets requiring a checksum. */
 364         if (skb->ip_summed != CHECKSUM_PARTIAL)
 365                 return 0;
 366
 367         if (unlikely(skb_cow_head(skb, 0)))
 368                 return -1;
 369
 370         if (is_ipv4_pkt(skb))
 371                 ip_hdr(skb)->check = 0;
 372         *(__sum16 *)(skb->head + skb->csum_start + skb->csum_offset) = 0;
 373
 374         return 0;
 375 }
 376
 377 static struct bufdesc *
 378 fec_enet_txq_submit_frag_skb(struct fec_enet_priv_tx_q *txq,
 379                              struct sk_buff *skb,
 380                              struct net_device *ndev)
 381 {
 382         struct fec_enet_private *fep = netdev_priv(ndev);
 383         struct bufdesc *bdp = txq->bd.cur;
 384         struct bufdesc_ex *ebdp;
 385         int nr_frags = skb_shinfo(skb)->nr_frags;
 386         int frag, frag_len;
 387         unsigned short status;
 388         unsigned int estatus = 0;
 389         skb_frag_t *this_frag;
 390         unsigned int index;
 391         void *bufaddr;
 392         dma_addr_t addr;
 393         int i;
 394
 395         for (frag = 0; frag < nr_frags; frag++) {
 396                 this_frag = &skb_shinfo(skb)->frags[frag];
 397                 bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
 398                 ebdp = (struct bufdesc_ex *)bdp;
 399
 400                 status = fec16_to_cpu(bdp->cbd_sc);
 401                 status &= ~BD_ENET_TX_STATS;
 402                 status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
 403                 frag_len = skb_frag_size(&skb_shinfo(skb)->frags[frag]);
 404
 405                 /* Handle the last BD specially */
 406                 if (frag == nr_frags - 1) {
 407                         status |= (BD_ENET_TX_INTR | BD_ENET_TX_LAST);
 408                         if (fep->bufdesc_ex) {
 409                                 estatus |= BD_ENET_TX_INT;
 410                                 if (unlikely(skb_shinfo(skb)->tx_flags &
 411                                         SKBTX_HW_TSTAMP && fep->hwts_tx_en))
 412                                         estatus |= BD_ENET_TX_TS;
 413                         }
 414                 }
 415
 416                 if (fep->bufdesc_ex) {
 417                         if (fep->quirks & FEC_QUIRK_HAS_AVB)
 418                                 estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
 419                         if (skb->ip_summed == CHECKSUM_PARTIAL)
 420                                 estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
 421                         ebdp->cbd_bdu = 0;
 422                         ebdp->cbd_esc = cpu_to_fec32(estatus);
 423                 }
 424
 425                 bufaddr = skb_frag_address(this_frag);
 426
 427                 index = fec_enet_get_bd_index(bdp, &txq->bd);
 428                 if (((unsigned long) bufaddr) & fep->tx_align ||
 429                         fep->quirks & FEC_QUIRK_SWAP_FRAME) {
 430                         memcpy(txq->tx_bounce[index], bufaddr, frag_len);
 431                         bufaddr = txq->tx_bounce[index];
 432
 433                         if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
 434                                 swap_buffer(bufaddr, frag_len);
 435                 }
 436
 437                 addr = dma_map_single(&fep->pdev->dev, bufaddr, frag_len,
 438                                       DMA_TO_DEVICE);
 439                 if (dma_mapping_error(&fep->pdev->dev, addr)) {
 440                         if (net_ratelimit())
 441                                 netdev_err(ndev, "Tx DMA memory map failed\n");
 442                         goto dma_mapping_error;
 443                 }
 444
 445                 bdp->cbd_bufaddr = cpu_to_fec32(addr);
 446                 bdp->cbd_datlen = cpu_to_fec16(frag_len);
 447                 /* Make sure the updates to rest of the descriptor are
 448                  * performed before transferring ownership.
 449                  */
 450                 wmb();
 451                 bdp->cbd_sc = cpu_to_fec16(status);
 452         }
 453
 454         return bdp;
 455 dma_mapping_error:
 456         bdp = txq->bd.cur;
 457         for (i = 0; i < frag; i++) {
 458                 bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
 459                 dma_unmap_single(&fep->pdev->dev, fec32_to_cpu(bdp->cbd_bufaddr),
 460                                  fec16_to_cpu(bdp->cbd_datlen), DMA_TO_DEVICE);
 461         }
 462         return ERR_PTR(-ENOMEM);
 463 }
 464
 465 static int fec_enet_txq_submit_skb(struct fec_enet_priv_tx_q *txq,
 466                                    struct sk_buff *skb, struct net_device *ndev)
 467 {
 468         struct fec_enet_private *fep = netdev_priv(ndev);
 469         int nr_frags = skb_shinfo(skb)->nr_frags;
 470         struct bufdesc *bdp, *last_bdp;
 471         void *bufaddr;
 472         dma_addr_t addr;
 473         unsigned short status;
 474         unsigned short buflen;
 475         unsigned int estatus = 0;
 476         unsigned int index;
 477         int entries_free;
 478
 479         entries_free = fec_enet_get_free_txdesc_num(txq);
 480         if (entries_free < MAX_SKB_FRAGS + 1) {
 481                 dev_kfree_skb_any(skb);
 482                 if (net_ratelimit())
 483                         netdev_err(ndev, "NOT enough BD for SG!\n");
 484                 return NETDEV_TX_OK;
 485         }
 486
 487         /* Protocol checksum off-load for TCP and UDP. */
 488         if (fec_enet_clear_csum(skb, ndev)) {
 489                 dev_kfree_skb_any(skb);
 490                 return NETDEV_TX_OK;
 491         }
 492
 493         /* Fill in a Tx ring entry */
 494         bdp = txq->bd.cur;
 495         last_bdp = bdp;
 496         status = fec16_to_cpu(bdp->cbd_sc);
 497         status &= ~BD_ENET_TX_STATS;
 498
 499         /* Set buffer length and buffer pointer */
 500         bufaddr = skb->data;
 501         buflen = skb_headlen(skb);
 502
 503         index = fec_enet_get_bd_index(bdp, &txq->bd);
 504         if (((unsigned long) bufaddr) & fep->tx_align ||
 505                 fep->quirks & FEC_QUIRK_SWAP_FRAME) {
 506                 memcpy(txq->tx_bounce[index], skb->data, buflen);
 507                 bufaddr = txq->tx_bounce[index];
 508
 509                 if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
 510                         swap_buffer(bufaddr, buflen);
 511         }
 512
 513         /* Push the data cache so the CPM does not get stale memory data. */
 514         addr = dma_map_single(&fep->pdev->dev, bufaddr, buflen, DMA_TO_DEVICE);
 515         if (dma_mapping_error(&fep->pdev->dev, addr)) {
 516                 dev_kfree_skb_any(skb);
 517                 if (net_ratelimit())
 518                         netdev_err(ndev, "Tx DMA memory map failed\n");
 519                 return NETDEV_TX_OK;
 520         }
 521
 522         if (nr_frags) {
 523                 last_bdp = fec_enet_txq_submit_frag_skb(txq, skb, ndev);
 524                 if (IS_ERR(last_bdp)) {
 525                         dma_unmap_single(&fep->pdev->dev, addr,
 526                                          buflen, DMA_TO_DEVICE);
 527                         dev_kfree_skb_any(skb);
 528                         return NETDEV_TX_OK;
 529                 }
 530         } else {
 531                 status |= (BD_ENET_TX_INTR | BD_ENET_TX_LAST);
 532                 if (fep->bufdesc_ex) {
 533                         estatus = BD_ENET_TX_INT;
 534                         if (unlikely(skb_shinfo(skb)->tx_flags &
 535                                 SKBTX_HW_TSTAMP && fep->hwts_tx_en))
 536                                 estatus |= BD_ENET_TX_TS;
 537                 }
 538         }
 539         bdp->cbd_bufaddr = cpu_to_fec32(addr);
 540         bdp->cbd_datlen = cpu_to_fec16(buflen);
 541
 542         if (fep->bufdesc_ex) {
 543
 544                 struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
 545
 546                 if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
 547                         fep->hwts_tx_en))
 548                         skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
 549
 550                 if (fep->quirks & FEC_QUIRK_HAS_AVB)
 551                         estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
 552
 553                 if (skb->ip_summed == CHECKSUM_PARTIAL)
 554                         estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
 555
 556                 ebdp->cbd_bdu = 0;
 557                 ebdp->cbd_esc = cpu_to_fec32(estatus);
 558         }
 559
 560         index = fec_enet_get_bd_index(last_bdp, &txq->bd);
 561         /* Save skb pointer */
 562         txq->tx_skbuff[index] = skb;
 563
 564         /* Make sure the updates to rest of the descriptor are performed before
 565          * transferring ownership.
 566          */
 567         wmb();
 568
 569         /* Send it on its way.  Tell FEC it's ready, interrupt when done,
 570          * it's the last BD of the frame, and to put the CRC on the end.
 571          */
 572         status |= (BD_ENET_TX_READY | BD_ENET_TX_TC);
 573         bdp->cbd_sc = cpu_to_fec16(status);
 574
 575         /* If this was the last BD in the ring, start at the beginning again. */
 576         bdp = fec_enet_get_nextdesc(last_bdp, &txq->bd);
 577
 578         skb_tx_timestamp(skb);
 579
 580         /* Make sure the update to bdp and tx_skbuff are performed before
 581          * txq->bd.cur.
 582          */
 583         wmb();
 584         txq->bd.cur = bdp;
 585
 586         /* Trigger transmission start */
 587         writel(0, txq->bd.reg_desc_active);
 588
 589         return 0;
 590 }
 591
 592 static int
 593 fec_enet_txq_put_data_tso(struct fec_enet_priv_tx_q *txq, struct sk_buff *skb,
 594                           struct net_device *ndev,
 595                           struct bufdesc *bdp, int index, char *data,
 596                           int size, bool last_tcp, bool is_last)
 597 {
 598         struct fec_enet_private *fep = netdev_priv(ndev);
 599         struct bufdesc_ex *ebdp = container_of(bdp, struct bufdesc_ex, desc);
 600         unsigned short status;
 601         unsigned int estatus = 0;
 602         dma_addr_t addr;
 603
 604         status = fec16_to_cpu(bdp->cbd_sc);
 605         status &= ~BD_ENET_TX_STATS;
 606
 607         status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
 608
 609         if (((unsigned long) data) & fep->tx_align ||
 610                 fep->quirks & FEC_QUIRK_SWAP_FRAME) {
 611                 memcpy(txq->tx_bounce[index], data, size);
 612                 data = txq->tx_bounce[index];
 613
 614                 if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
 615                         swap_buffer(data, size);
 616         }
 617
 618         addr = dma_map_single(&fep->pdev->dev, data, size, DMA_TO_DEVICE);
 619         if (dma_mapping_error(&fep->pdev->dev, addr)) {
 620                 dev_kfree_skb_any(skb);
 621                 if (net_ratelimit())
 622                         netdev_err(ndev, "Tx DMA memory map failed\n");
 623                 return NETDEV_TX_BUSY;
 624         }
 625
 626         bdp->cbd_datlen = cpu_to_fec16(size);
 627         bdp->cbd_bufaddr = cpu_to_fec32(addr);
 628
 629         if (fep->bufdesc_ex) {
 630                 if (fep->quirks & FEC_QUIRK_HAS_AVB)
 631                         estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
 632                 if (skb->ip_summed == CHECKSUM_PARTIAL)
 633                         estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
 634                 ebdp->cbd_bdu = 0;
 635                 ebdp->cbd_esc = cpu_to_fec32(estatus);
 636         }
 637
 638         /* Handle the last BD specially */
 639         if (last_tcp)
 640                 status |= (BD_ENET_TX_LAST | BD_ENET_TX_TC);
 641         if (is_last) {
 642                 status |= BD_ENET_TX_INTR;
 643                 if (fep->bufdesc_ex)
 644                         ebdp->cbd_esc |= cpu_to_fec32(BD_ENET_TX_INT);
 645         }
 646
 647         bdp->cbd_sc = cpu_to_fec16(status);
 648
 649         return 0;
 650 }
 651
 652 static int
 653 fec_enet_txq_put_hdr_tso(struct fec_enet_priv_tx_q *txq,
 654                          struct sk_buff *skb, struct net_device *ndev,
 655                          struct bufdesc *bdp, int index)
 656 {
 657         struct fec_enet_private *fep = netdev_priv(ndev);
 658         int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
 659         struct bufdesc_ex *ebdp = container_of(bdp, struct bufdesc_ex, desc);
 660         void *bufaddr;
 661         unsigned long dmabuf;
 662         unsigned short status;
 663         unsigned int estatus = 0;
 664
 665         status = fec16_to_cpu(bdp->cbd_sc);
 666         status &= ~BD_ENET_TX_STATS;
 667         status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
 668
 669         bufaddr = txq->tso_hdrs + index * TSO_HEADER_SIZE;
 670         dmabuf = txq->tso_hdrs_dma + index * TSO_HEADER_SIZE;
 671         if (((unsigned long)bufaddr) & fep->tx_align ||
 672                 fep->quirks & FEC_QUIRK_SWAP_FRAME) {
 673                 memcpy(txq->tx_bounce[index], skb->data, hdr_len);
 674                 bufaddr = txq->tx_bounce[index];
 675
 676                 if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
 677                         swap_buffer(bufaddr, hdr_len);
 678
 679                 dmabuf = dma_map_single(&fep->pdev->dev, bufaddr,
 680                                         hdr_len, DMA_TO_DEVICE);
 681                 if (dma_mapping_error(&fep->pdev->dev, dmabuf)) {
 682                         dev_kfree_skb_any(skb);
 683                         if (net_ratelimit())
 684                                 netdev_err(ndev, "Tx DMA memory map failed\n");
 685                         return NETDEV_TX_BUSY;
 686                 }
 687         }
 688
 689         bdp->cbd_bufaddr = cpu_to_fec32(dmabuf);
 690         bdp->cbd_datlen = cpu_to_fec16(hdr_len);
 691
 692         if (fep->bufdesc_ex) {
 693                 if (fep->quirks & FEC_QUIRK_HAS_AVB)
 694                         estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
 695                 if (skb->ip_summed == CHECKSUM_PARTIAL)
 696                         estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
 697                 ebdp->cbd_bdu = 0;
 698                 ebdp->cbd_esc = cpu_to_fec32(estatus);
 699         }
 700
 701         bdp->cbd_sc = cpu_to_fec16(status);
 702
 703         return 0;
 704 }
 705
 706 static int fec_enet_txq_submit_tso(struct fec_enet_priv_tx_q *txq,
 707                                    struct sk_buff *skb,
 708                                    struct net_device *ndev)
 709 {
 710         struct fec_enet_private *fep = netdev_priv(ndev);
 711         int hdr_len, total_len, data_left;
 712         struct bufdesc *bdp = txq->bd.cur;
 713         struct tso_t tso;
 714         unsigned int index = 0;
 715         int ret;
 716
 717         if (tso_count_descs(skb) >= fec_enet_get_free_txdesc_num(txq)) {
 718                 dev_kfree_skb_any(skb);
 719                 if (net_ratelimit())
 720                         netdev_err(ndev, "NOT enough BD for TSO!\n");
 721                 return NETDEV_TX_OK;
 722         }
 723
 724         /* Protocol checksum off-load for TCP and UDP. */
 725         if (fec_enet_clear_csum(skb, ndev)) {
 726                 dev_kfree_skb_any(skb);
 727                 return NETDEV_TX_OK;
 728         }
 729
 730         /* Initialize the TSO handler, and prepare the first payload */
 731         hdr_len = tso_start(skb, &tso);
 732
 733         total_len = skb->len - hdr_len;
 734         while (total_len > 0) {
 735                 char *hdr;
 736
 737                 index = fec_enet_get_bd_index(bdp, &txq->bd);
 738                 data_left = min_t(int, skb_shinfo(skb)->gso_size, total_len);
 739                 total_len -= data_left;
 740
 741                 /* prepare packet headers: MAC + IP + TCP */
 742                 hdr = txq->tso_hdrs + index * TSO_HEADER_SIZE;
 743                 tso_build_hdr(skb, hdr, &tso, data_left, total_len == 0);
 744                 ret = fec_enet_txq_put_hdr_tso(txq, skb, ndev, bdp, index);
 745                 if (ret)
 746                         goto err_release;
 747
 748                 while (data_left > 0) {
 749                         int size;
 750
 751                         size = min_t(int, tso.size, data_left);
 752                         bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
 753                         index = fec_enet_get_bd_index(bdp, &txq->bd);
 754                         ret = fec_enet_txq_put_data_tso(txq, skb, ndev,
 755                                                         bdp, index,
 756                                                         tso.data, size,
 757                                                         size == data_left,
 758                                                         total_len == 0);
 759                         if (ret)
 760                                 goto err_release;
 761
 762                         data_left -= size;
 763                         tso_build_data(skb, &tso, size);
 764                 }
 765
 766                 bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
 767         }
 768
 769         /* Save skb pointer */
 770         txq->tx_skbuff[index] = skb;
 771
 772         skb_tx_timestamp(skb);
 773         txq->bd.cur = bdp;
 774
 775         /* Trigger transmission start */
 776         if (!(fep->quirks & FEC_QUIRK_ERR007885) ||
 777             !readl(txq->bd.reg_desc_active) ||
 778             !readl(txq->bd.reg_desc_active) ||
 779             !readl(txq->bd.reg_desc_active) ||
 780             !readl(txq->bd.reg_desc_active))
 781                 writel(0, txq->bd.reg_desc_active);
 782
 783         return 0;
 784
 785 err_release:
 786         /* TODO: Release all used data descriptors for TSO */
 787         return ret;
 788 }
 789
 790 static netdev_tx_t
 791 fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 792 {
 793         struct fec_enet_private *fep = netdev_priv(ndev);
 794         int entries_free;
 795         unsigned short queue;
 796         struct fec_enet_priv_tx_q *txq;
 797         struct netdev_queue *nq;
 798         int ret;
 799
 800         queue = skb_get_queue_mapping(skb);
 801         txq = fep->tx_queue[queue];
 802         nq = netdev_get_tx_queue(ndev, queue);
 803
 804         if (skb_is_gso(skb))
 805                 ret = fec_enet_txq_submit_tso(txq, skb, ndev);
 806         else
 807                 ret = fec_enet_txq_submit_skb(txq, skb, ndev);
 808         if (ret)
 809                 return ret;
 810
 811         entries_free = fec_enet_get_free_txdesc_num(txq);
 812         if (entries_free <= txq->tx_stop_threshold)
 813                 netif_tx_stop_queue(nq);
 814
 815         return NETDEV_TX_OK;
 816 }
 817
 818 /* Init RX & TX buffer descriptors
 819  */
 820 static void fec_enet_bd_init(struct net_device *dev)
 821 {
 822         struct fec_enet_private *fep = netdev_priv(dev);
 823         struct fec_enet_priv_tx_q *txq;
 824         struct fec_enet_priv_rx_q *rxq;
 825         struct bufdesc *bdp;
 826         unsigned int i;
 827         unsigned int q;
 828
 829         for (q = 0; q < fep->num_rx_queues; q++) {
 830                 /* Initialize the receive buffer descriptors. */
 831                 rxq = fep->rx_queue[q];
 832                 bdp = rxq->bd.base;
 833
 834                 for (i = 0; i < rxq->bd.ring_size; i++) {
 835
 836                         /* Initialize the BD for every fragment in the page. */
 837                         if (bdp->cbd_bufaddr)
 838                                 bdp->cbd_sc = cpu_to_fec16(BD_ENET_RX_EMPTY);
 839                         else
 840                                 bdp->cbd_sc = cpu_to_fec16(0);
 841                         bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
 842                 }
 843
 844                 /* Set the last buffer to wrap */
 845                 bdp = fec_enet_get_prevdesc(bdp, &rxq->bd);
 846                 bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
 847
 848                 rxq->bd.cur = rxq->bd.base;
 849         }
 850
 851         for (q = 0; q < fep->num_tx_queues; q++) {
 852                 /* ...and the same for transmit */
 853                 txq = fep->tx_queue[q];
 854                 bdp = txq->bd.base;
 855                 txq->bd.cur = bdp;
 856
 857                 for (i = 0; i < txq->bd.ring_size; i++) {
 858                         /* Initialize the BD for every fragment in the page. */
 859                         bdp->cbd_sc = cpu_to_fec16(0);
 860                         if (bdp->cbd_bufaddr &&
 861                             !IS_TSO_HEADER(txq, fec32_to_cpu(bdp->cbd_bufaddr)))
 862                                 dma_unmap_single(&fep->pdev->dev,
 863                                                  fec32_to_cpu(bdp->cbd_bufaddr),
 864                                                  fec16_to_cpu(bdp->cbd_datlen),
 865                                                  DMA_TO_DEVICE);
 866                         if (txq->tx_skbuff[i]) {
 867                                 dev_kfree_skb_any(txq->tx_skbuff[i]);
 868                                 txq->tx_skbuff[i] = NULL;
 869                         }
 870                         bdp->cbd_bufaddr = cpu_to_fec32(0);
 871                         bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
 872                 }
 873
 874                 /* Set the last buffer to wrap */
 875                 bdp = fec_enet_get_prevdesc(bdp, &txq->bd);
 876                 bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
 877                 txq->dirty_tx = bdp;
 878         }
 879 }
 880
 881 static void fec_enet_active_rxring(struct net_device *ndev)
 882 {
 883         struct fec_enet_private *fep = netdev_priv(ndev);
 884         int i;
 885
 886         for (i = 0; i < fep->num_rx_queues; i++)
 887                 writel(0, fep->rx_queue[i]->bd.reg_desc_active);
 888 }
 889
 890 static void fec_enet_enable_ring(struct net_device *ndev)
 891 {
 892         struct fec_enet_private *fep = netdev_priv(ndev);
 893         struct fec_enet_priv_tx_q *txq;
 894         struct fec_enet_priv_rx_q *rxq;
 895         int i;
 896
 897         for (i = 0; i < fep->num_rx_queues; i++) {
 898                 rxq = fep->rx_queue[i];
 899                 writel(rxq->bd.dma, fep->hwp + FEC_R_DES_START(i));
 900                 writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_R_BUFF_SIZE(i));
 901
 902                 /* enable DMA1/2 */
 903                 if (i)
 904                         writel(RCMR_MATCHEN | RCMR_CMP(i),
 905                                fep->hwp + FEC_RCMR(i));
 906         }
 907
 908         for (i = 0; i < fep->num_tx_queues; i++) {
 909                 txq = fep->tx_queue[i];
 910                 writel(txq->bd.dma, fep->hwp + FEC_X_DES_START(i));
 911
 912                 /* enable DMA1/2 */
 913                 if (i)
 914                         writel(DMA_CLASS_EN | IDLE_SLOPE(i),
 915                                fep->hwp + FEC_DMA_CFG(i));
 916         }
 917 }
 918
 919 static void fec_enet_reset_skb(struct net_device *ndev)
 920 {
 921         struct fec_enet_private *fep = netdev_priv(ndev);
 922         struct fec_enet_priv_tx_q *txq;
 923         int i, j;
 924
 925         for (i = 0; i < fep->num_tx_queues; i++) {
 926                 txq = fep->tx_queue[i];
 927
 928                 for (j = 0; j < txq->bd.ring_size; j++) {
 929                         if (txq->tx_skbuff[j]) {
 930                                 dev_kfree_skb_any(txq->tx_skbuff[j]);
 931                                 txq->tx_skbuff[j] = NULL;
 932                         }
 933                 }
 934         }
 935 }
 936
 937 /*
 938  * This function is called to start or restart the FEC during a link
 939  * change, transmit timeout, or to reconfigure the FEC.  The network
 940  * packet processing for this device must be stopped before this call.
 941  */
 942 static void
 943 fec_restart(struct net_device *ndev)
 944 {
 945         struct fec_enet_private *fep = netdev_priv(ndev);
 946         u32 val;
 947         u32 temp_mac[2];
 948         u32 rcntl = OPT_FRAME_SIZE | 0x04;
 949         u32 ecntl = 0x2; /* ETHEREN */
 950
 951         /* Whack a reset.  We should wait for this.
 952          * For i.MX6SX SOC, enet use AXI bus, we use disable MAC
 953          * instead of reset MAC itself.
 954          */
 955         if (fep->quirks & FEC_QUIRK_HAS_AVB) {
 956                 writel(0, fep->hwp + FEC_ECNTRL);
 957         } else {
 958                 writel(1, fep->hwp + FEC_ECNTRL);
 959                 udelay(10);
 960         }
 961
 962         /*
 963          * enet-mac reset will reset mac address registers too,
 964          * so need to reconfigure it.
 965          */
 966         memcpy(&temp_mac, ndev->dev_addr, ETH_ALEN);
 967         writel((__force u32)cpu_to_be32(temp_mac[0]),
 968                fep->hwp + FEC_ADDR_LOW);
 969         writel((__force u32)cpu_to_be32(temp_mac[1]),
 970                fep->hwp + FEC_ADDR_HIGH);
 971
 972         /* Clear any outstanding interrupt, except MDIO. */
 973         writel((0xffffffff & ~FEC_ENET_MII), fep->hwp + FEC_IEVENT);
 974
 975         fec_enet_bd_init(ndev);
 976
 977         fec_enet_enable_ring(ndev);
 978
 979         /* Reset tx SKB buffers. */
 980         fec_enet_reset_skb(ndev);
 981
 982         /* Enable MII mode */
 983         if (fep->full_duplex == DUPLEX_FULL) {
 984                 /* FD enable */
 985                 writel(0x04, fep->hwp + FEC_X_CNTRL);
 986         } else {
 987                 /* No Rcv on Xmit */
 988                 rcntl |= 0x02;
 989                 writel(0x0, fep->hwp + FEC_X_CNTRL);
 990         }
 991
 992         /* Set MII speed */
 993         writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
 994
 995 #if !defined(CONFIG_M5272)
 996         if (fep->quirks & FEC_QUIRK_HAS_RACC) {
 997                 val = readl(fep->hwp + FEC_RACC);
 998                 /* align IP header */
 999                 val |= FEC_RACC_SHIFT16;
1000                 if (fep->csum_flags & FLAG_RX_CSUM_ENABLED)
1001                         /* set RX checksum */
1002                         val |= FEC_RACC_OPTIONS;
1003                 else
1004                         val &= ~FEC_RACC_OPTIONS;
1005                 writel(val, fep->hwp + FEC_RACC);
1006                 writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_FTRL);
1007         }
1008 #endif
1009
1010         /*
1011          * The phy interface and speed need to get configured
1012          * differently on enet-mac.
1013          */
1014         if (fep->quirks & FEC_QUIRK_ENET_MAC) {
1015                 /* Enable flow control and length check */
1016                 rcntl |= 0x40000000 | 0x00000020;
1017
1018                 /* RGMII, RMII or MII */
1019                 if (fep->phy_interface == PHY_INTERFACE_MODE_RGMII ||
1020                     fep->phy_interface == PHY_INTERFACE_MODE_RGMII_ID ||
1021                     fep->phy_interface == PHY_INTERFACE_MODE_RGMII_RXID ||
1022                     fep->phy_interface == PHY_INTERFACE_MODE_RGMII_TXID)
1023                         rcntl |= (1 << 6);
1024                 else if (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
1025                         rcntl |= (1 << 8);
1026                 else
1027                         rcntl &= ~(1 << 8);
1028
1029                 /* 1G, 100M or 10M */
1030                 if (ndev->phydev) {
1031                         if (ndev->phydev->speed == SPEED_1000)
1032                                 ecntl |= (1 << 5);
1033                         else if (ndev->phydev->speed == SPEED_100)
1034                                 rcntl &= ~(1 << 9);
1035                         else
1036                                 rcntl |= (1 << 9);
1037                 }
1038         } else {
1039 #ifdef FEC_MIIGSK_ENR
1040                 if (fep->quirks & FEC_QUIRK_USE_GASKET) {
1041                         u32 cfgr;
1042                         /* disable the gasket and wait */
1043                         writel(0, fep->hwp + FEC_MIIGSK_ENR);
1044                         while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
1045                                 udelay(1);
1046
1047                         /*
1048                          * configure the gasket:
1049                          *   RMII, 50 MHz, no loopback, no echo
1050                          *   MII, 25 MHz, no loopback, no echo
1051                          */
1052                         cfgr = (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
1053                                 ? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII;
1054                         if (ndev->phydev && ndev->phydev->speed == SPEED_10)
1055                                 cfgr |= BM_MIIGSK_CFGR_FRCONT_10M;
1056                         writel(cfgr, fep->hwp + FEC_MIIGSK_CFGR);
1057
1058                         /* re-enable the gasket */
1059                         writel(2, fep->hwp + FEC_MIIGSK_ENR);
1060                 }
1061 #endif
1062         }
1063
1064 #if !defined(CONFIG_M5272)
1065         /* enable pause frame*/
1066         if ((fep->pause_flag & FEC_PAUSE_FLAG_ENABLE) ||
1067             ((fep->pause_flag & FEC_PAUSE_FLAG_AUTONEG) &&
1068              ndev->phydev && ndev->phydev->pause)) {
1069                 rcntl |= FEC_ENET_FCE;
1070
1071                 /* set FIFO threshold parameter to reduce overrun */
1072                 writel(FEC_ENET_RSEM_V, fep->hwp + FEC_R_FIFO_RSEM);
1073                 writel(FEC_ENET_RSFL_V, fep->hwp + FEC_R_FIFO_RSFL);
1074                 writel(FEC_ENET_RAEM_V, fep->hwp + FEC_R_FIFO_RAEM);
1075                 writel(FEC_ENET_RAFL_V, fep->hwp + FEC_R_FIFO_RAFL);
1076
1077                 /* OPD */
1078                 writel(FEC_ENET_OPD_V, fep->hwp + FEC_OPD);
1079         } else {
1080                 rcntl &= ~FEC_ENET_FCE;
1081         }
1082 #endif /* !defined(CONFIG_M5272) */
1083
1084         writel(rcntl, fep->hwp + FEC_R_CNTRL);
1085
1086         /* Setup multicast filter. */
1087         set_multicast_list(ndev);
1088 #ifndef CONFIG_M5272
1089         writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
1090         writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
1091 #endif
1092
1093         if (fep->quirks & FEC_QUIRK_ENET_MAC) {
1094                 /* enable ENET endian swap */
1095                 ecntl |= (1 << 8);
1096                 /* enable ENET store and forward mode */
1097                 writel(1 << 8, fep->hwp + FEC_X_WMRK);
1098         }
1099
1100         if (fep->bufdesc_ex)
1101                 ecntl |= (1 << 4);
1102
1103 #ifndef CONFIG_M5272
1104         /* Enable the MIB statistic event counters */
1105         writel(0 << 31, fep->hwp + FEC_MIB_CTRLSTAT);
1106 #endif
1107
1108         /* And last, enable the transmit and receive processing */
1109         writel(ecntl, fep->hwp + FEC_ECNTRL);
1110         fec_enet_active_rxring(ndev);
1111
1112         if (fep->bufdesc_ex)
1113                 fec_ptp_start_cyclecounter(ndev);
1114
1115         /* Enable interrupts we wish to service */
1116         if (fep->link)
1117                 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
1118         else
1119                 writel(0, fep->hwp + FEC_IMASK);
1120
1121         /* Init the interrupt coalescing */
1122         fec_enet_itr_coal_init(ndev);
1123
1124 }
1125
1126 static void fec_enet_stop_mode(struct fec_enet_private *fep, bool enabled)
1127 {
1128         struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
1129         struct fec_stop_mode_gpr *stop_gpr = &fep->stop_gpr;
1130
1131         if (stop_gpr->gpr) {
1132                 if (enabled)
1133                         regmap_update_bits(stop_gpr->gpr, stop_gpr->reg,
1134                                            BIT(stop_gpr->bit),
1135                                            BIT(stop_gpr->bit));
1136                 else
1137                         regmap_update_bits(stop_gpr->gpr, stop_gpr->reg,
1138                                            BIT(stop_gpr->bit), 0);
1139         } else if (pdata && pdata->sleep_mode_enable) {
1140                 pdata->sleep_mode_enable(enabled);
1141         }
1142 }
1143
1144 static void
1145 fec_stop(struct net_device *ndev)
1146 {
1147         struct fec_enet_private *fep = netdev_priv(ndev);
1148         u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
1149         u32 val;
1150
1151         /* We cannot expect a graceful transmit stop without link !!! */
1152         if (fep->link) {
1153                 writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
1154                 udelay(10);
1155                 if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
1156                         netdev_err(ndev, "Graceful transmit stop did not complete!\n");
1157         }
1158
1159         /* Whack a reset.  We should wait for this.
1160          * For i.MX6SX SOC, enet use AXI bus, we use disable MAC
1161          * instead of reset MAC itself.
1162          */
1163         if (!(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) {
1164                 if (fep->quirks & FEC_QUIRK_HAS_AVB) {
1165                         writel(0, fep->hwp + FEC_ECNTRL);
1166                 } else {
1167                         writel(1, fep->hwp + FEC_ECNTRL);
1168                         udelay(10);
1169                 }
1170                 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
1171         } else {
1172                 writel(FEC_DEFAULT_IMASK | FEC_ENET_WAKEUP, fep->hwp + FEC_IMASK);
1173                 val = readl(fep->hwp + FEC_ECNTRL);
1174                 val |= (FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
1175                 writel(val, fep->hwp + FEC_ECNTRL);
1176                 fec_enet_stop_mode(fep, true);
1177         }
1178         writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
1179
1180         /* We have to keep ENET enabled to have MII interrupt stay working */
1181         if (fep->quirks & FEC_QUIRK_ENET_MAC &&
1182                 !(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) {
1183                 writel(2, fep->hwp + FEC_ECNTRL);
1184                 writel(rmii_mode, fep->hwp + FEC_R_CNTRL);
1185         }
1186 }
1187
1188
1189 static void
1190 fec_timeout(struct net_device *ndev, unsigned int txqueue)
1191 {
1192         struct fec_enet_private *fep = netdev_priv(ndev);
1193
1194         fec_dump(ndev);
1195
1196         ndev->stats.tx_errors++;
1197
1198         schedule_work(&fep->tx_timeout_work);
1199 }
1200
1201 static void fec_enet_timeout_work(struct work_struct *work)
1202 {
1203         struct fec_enet_private *fep =
1204                 container_of(work, struct fec_enet_private, tx_timeout_work);
1205         struct net_device *ndev = fep->netdev;
1206
1207         rtnl_lock();
1208         if (netif_device_present(ndev) || netif_running(ndev)) {
1209                 napi_disable(&fep->napi);
1210                 netif_tx_lock_bh(ndev);
1211                 fec_restart(ndev);
1212                 netif_tx_wake_all_queues(ndev);
1213                 netif_tx_unlock_bh(ndev);
1214                 napi_enable(&fep->napi);
1215         }
1216         rtnl_unlock();
1217 }
1218
1219 static void
1220 fec_enet_hwtstamp(struct fec_enet_private *fep, unsigned ts,
1221         struct skb_shared_hwtstamps *hwtstamps)
1222 {
1223         unsigned long flags;
1224         u64 ns;
1225
1226         spin_lock_irqsave(&fep->tmreg_lock, flags);
1227         ns = timecounter_cyc2time(&fep->tc, ts);
1228         spin_unlock_irqrestore(&fep->tmreg_lock, flags);
1229
1230         memset(hwtstamps, 0, sizeof(*hwtstamps));
1231         hwtstamps->hwtstamp = ns_to_ktime(ns);
1232 }
1233
1234 static void
1235 fec_enet_tx_queue(struct net_device *ndev, u16 queue_id)
1236 {
1237         struct  fec_enet_private *fep;
1238         struct bufdesc *bdp;
1239         unsigned short status;
1240         struct  sk_buff *skb;
1241         struct fec_enet_priv_tx_q *txq;
1242         struct netdev_queue *nq;
1243         int     index = 0;
1244         int     entries_free;
1245
1246         fep = netdev_priv(ndev);
1247
1248         txq = fep->tx_queue[queue_id];
1249         /* get next bdp of dirty_tx */
1250         nq = netdev_get_tx_queue(ndev, queue_id);
1251         bdp = txq->dirty_tx;
1252
1253         /* get next bdp of dirty_tx */
1254         bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
1255
1256         while (bdp != READ_ONCE(txq->bd.cur)) {
1257                 /* Order the load of bd.cur and cbd_sc */
1258                 rmb();
1259                 status = fec16_to_cpu(READ_ONCE(bdp->cbd_sc));
1260                 if (status & BD_ENET_TX_READY)
1261                         break;
1262
1263                 index = fec_enet_get_bd_index(bdp, &txq->bd);
1264
1265                 skb = txq->tx_skbuff[index];
1266                 txq->tx_skbuff[index] = NULL;
1267                 if (!IS_TSO_HEADER(txq, fec32_to_cpu(bdp->cbd_bufaddr)))
1268                         dma_unmap_single(&fep->pdev->dev,
1269                                          fec32_to_cpu(bdp->cbd_bufaddr),
1270                                          fec16_to_cpu(bdp->cbd_datlen),
1271                                          DMA_TO_DEVICE);
1272                 bdp->cbd_bufaddr = cpu_to_fec32(0);
1273                 if (!skb)
1274                         goto skb_done;
1275
1276                 /* Check for errors. */
1277                 if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
1278                                    BD_ENET_TX_RL | BD_ENET_TX_UN |
1279                                    BD_ENET_TX_CSL)) {
1280                         ndev->stats.tx_errors++;
1281                         if (status & BD_ENET_TX_HB)  /* No heartbeat */
1282                                 ndev->stats.tx_heartbeat_errors++;
1283                         if (status & BD_ENET_TX_LC)  /* Late collision */
1284                                 ndev->stats.tx_window_errors++;
1285                         if (status & BD_ENET_TX_RL)  /* Retrans limit */
1286                                 ndev->stats.tx_aborted_errors++;
1287                         if (status & BD_ENET_TX_UN)  /* Underrun */
1288                                 ndev->stats.tx_fifo_errors++;
1289                         if (status & BD_ENET_TX_CSL) /* Carrier lost */
1290                                 ndev->stats.tx_carrier_errors++;
1291                 } else {
1292                         ndev->stats.tx_packets++;
1293                         ndev->stats.tx_bytes += skb->len;
1294                 }
1295
1296                 if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS) &&
1297                         fep->bufdesc_ex) {
1298                         struct skb_shared_hwtstamps shhwtstamps;
1299                         struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
1300
1301                         fec_enet_hwtstamp(fep, fec32_to_cpu(ebdp->ts), &shhwtstamps);
1302                         skb_tstamp_tx(skb, &shhwtstamps);
1303                 }
1304
1305                 /* Deferred means some collisions occurred during transmit,
1306                  * but we eventually sent the packet OK.
1307                  */
1308                 if (status & BD_ENET_TX_DEF)
1309                         ndev->stats.collisions++;
1310
1311                 /* Free the sk buffer associated with this last transmit */
1312                 dev_kfree_skb_any(skb);
1313 skb_done:
1314                 /* Make sure the update to bdp and tx_skbuff are performed
1315                  * before dirty_tx
1316                  */
1317                 wmb();
1318                 txq->dirty_tx = bdp;
1319
1320                 /* Update pointer to next buffer descriptor to be transmitted */
1321                 bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
1322
1323                 /* Since we have freed up a buffer, the ring is no longer full
1324                  */
1325                 if (netif_tx_queue_stopped(nq)) {
1326                         entries_free = fec_enet_get_free_txdesc_num(txq);
1327                         if (entries_free >= txq->tx_wake_threshold)
1328                                 netif_tx_wake_queue(nq);
1329                 }
1330         }
1331
1332         /* ERR006358: Keep the transmitter going */
1333         if (bdp != txq->bd.cur &&
1334             readl(txq->bd.reg_desc_active) == 0)
1335                 writel(0, txq->bd.reg_desc_active);
1336 }
1337
1338 static void fec_enet_tx(struct net_device *ndev)
1339 {
1340         struct fec_enet_private *fep = netdev_priv(ndev);
1341         int i;
1342
1343         /* Make sure that AVB queues are processed first. */
1344         for (i = fep->num_tx_queues - 1; i >= 0; i--)
1345                 fec_enet_tx_queue(ndev, i);
1346 }
1347
1348 static int
1349 fec_enet_new_rxbdp(struct net_device *ndev, struct bufdesc *bdp, struct sk_buff *skb)
1350 {
1351         struct  fec_enet_private *fep = netdev_priv(ndev);
1352         int off;
1353
1354         off = ((unsigned long)skb->data) & fep->rx_align;
1355         if (off)
1356                 skb_reserve(skb, fep->rx_align + 1 - off);
1357
1358         bdp->cbd_bufaddr = cpu_to_fec32(dma_map_single(&fep->pdev->dev, skb->data, FEC_ENET_RX_FRSIZE - fep->rx_align, DMA_FROM_DEVICE));
1359         if (dma_mapping_error(&fep->pdev->dev, fec32_to_cpu(bdp->cbd_bufaddr))) {
1360                 if (net_ratelimit())
1361                         netdev_err(ndev, "Rx DMA memory map failed\n");
1362                 return -ENOMEM;
1363         }
1364
1365         return 0;
1366 }
1367
1368 static bool fec_enet_copybreak(struct net_device *ndev, struct sk_buff **skb,
1369                                struct bufdesc *bdp, u32 length, bool swap)
1370 {
1371         struct  fec_enet_private *fep = netdev_priv(ndev);
1372         struct sk_buff *new_skb;
1373
1374         if (length > fep->rx_copybreak)
1375                 return false;
1376
1377         new_skb = netdev_alloc_skb(ndev, length);
1378         if (!new_skb)
1379                 return false;
1380
1381         dma_sync_single_for_cpu(&fep->pdev->dev,
1382                                 fec32_to_cpu(bdp->cbd_bufaddr),
1383                                 FEC_ENET_RX_FRSIZE - fep->rx_align,
1384                                 DMA_FROM_DEVICE);
1385         if (!swap)
1386                 memcpy(new_skb->data, (*skb)->data, length);
1387         else
1388                 swap_buffer2(new_skb->data, (*skb)->data, length);
1389         *skb = new_skb;
1390
1391         return true;
1392 }
1393
1394 /* During a receive, the bd_rx.cur points to the current incoming buffer.
1395  * When we update through the ring, if the next incoming buffer has
1396  * not been given to the system, we just set the empty indicator,
1397  * effectively tossing the packet.
1398  */
1399 static int
1400 fec_enet_rx_queue(struct net_device *ndev, int budget, u16 queue_id)
1401 {
1402         struct fec_enet_private *fep = netdev_priv(ndev);
1403         struct fec_enet_priv_rx_q *rxq;
1404         struct bufdesc *bdp;
1405         unsigned short status;
1406         struct  sk_buff *skb_new = NULL;
1407         struct  sk_buff *skb;
1408         ushort  pkt_len;
1409         __u8 *data;
1410         int     pkt_received = 0;
1411         struct  bufdesc_ex *ebdp = NULL;
1412         bool    vlan_packet_rcvd = false;
1413         u16     vlan_tag;
1414         int     index = 0;
1415         bool    is_copybreak;
1416         bool    need_swap = fep->quirks & FEC_QUIRK_SWAP_FRAME;
1417
1418 #ifdef CONFIG_M532x
1419         flush_cache_all();
1420 #endif
1421         rxq = fep->rx_queue[queue_id];
1422
1423         /* First, grab all of the stats for the incoming packet.
1424          * These get messed up if we get called due to a busy condition.
1425          */
1426         bdp = rxq->bd.cur;
1427
1428         while (!((status = fec16_to_cpu(bdp->cbd_sc)) & BD_ENET_RX_EMPTY)) {
1429
1430                 if (pkt_received >= budget)
1431                         break;
1432                 pkt_received++;
1433
1434                 writel(FEC_ENET_RXF, fep->hwp + FEC_IEVENT);
1435
1436                 /* Check for errors. */
1437                 status ^= BD_ENET_RX_LAST;
1438                 if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
1439                            BD_ENET_RX_CR | BD_ENET_RX_OV | BD_ENET_RX_LAST |
1440                            BD_ENET_RX_CL)) {
1441                         ndev->stats.rx_errors++;
1442                         if (status & BD_ENET_RX_OV) {
1443                                 /* FIFO overrun */
1444                                 ndev->stats.rx_fifo_errors++;
1445                                 goto rx_processing_done;
1446                         }
1447                         if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH
1448                                                 | BD_ENET_RX_LAST)) {
1449                                 /* Frame too long or too short. */
1450                                 ndev->stats.rx_length_errors++;
1451                                 if (status & BD_ENET_RX_LAST)
1452                                         netdev_err(ndev, "rcv is not +last\n");
1453                         }
1454                         if (status & BD_ENET_RX_CR)     /* CRC Error */
1455                                 ndev->stats.rx_crc_errors++;
1456                         /* Report late collisions as a frame error. */
1457                         if (status & (BD_ENET_RX_NO | BD_ENET_RX_CL))
1458                                 ndev->stats.rx_frame_errors++;
1459                         goto rx_processing_done;
1460                 }
1461
1462                 /* Process the incoming frame. */
1463                 ndev->stats.rx_packets++;
1464                 pkt_len = fec16_to_cpu(bdp->cbd_datlen);
1465                 ndev->stats.rx_bytes += pkt_len;
1466
1467                 index = fec_enet_get_bd_index(bdp, &rxq->bd);
1468                 skb = rxq->rx_skbuff[index];
1469
1470                 /* The packet length includes FCS, but we don't want to
1471                  * include that when passing upstream as it messes up
1472                  * bridging applications.
1473                  */
1474                 is_copybreak = fec_enet_copybreak(ndev, &skb, bdp, pkt_len - 4,
1475                                                   need_swap);
1476                 if (!is_copybreak) {
1477                         skb_new = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
1478                         if (unlikely(!skb_new)) {
1479                                 ndev->stats.rx_dropped++;
1480                                 goto rx_processing_done;
1481                         }
1482                         dma_unmap_single(&fep->pdev->dev,
1483                                          fec32_to_cpu(bdp->cbd_bufaddr),
1484                                          FEC_ENET_RX_FRSIZE - fep->rx_align,
1485                                          DMA_FROM_DEVICE);
1486                 }
1487
1488                 prefetch(skb->data - NET_IP_ALIGN);
1489                 skb_put(skb, pkt_len - 4);
1490                 data = skb->data;
1491
1492                 if (!is_copybreak && need_swap)
1493                         swap_buffer(data, pkt_len);
1494
1495 #if !defined(CONFIG_M5272)
1496                 if (fep->quirks & FEC_QUIRK_HAS_RACC)
1497                         data = skb_pull_inline(skb, 2);
1498 #endif
1499
1500                 /* Extract the enhanced buffer descriptor */
1501                 ebdp = NULL;
1502                 if (fep->bufdesc_ex)
1503                         ebdp = (struct bufdesc_ex *)bdp;
1504
1505                 /* If this is a VLAN packet remove the VLAN Tag */
1506                 vlan_packet_rcvd = false;
1507                 if ((ndev->features & NETIF_F_HW_VLAN_CTAG_RX) &&
1508                     fep->bufdesc_ex &&
1509                     (ebdp->cbd_esc & cpu_to_fec32(BD_ENET_RX_VLAN))) {
1510                         /* Push and remove the vlan tag */
1511                         struct vlan_hdr *vlan_header =
1512                                         (struct vlan_hdr *) (data + ETH_HLEN);
1513                         vlan_tag = ntohs(vlan_header->h_vlan_TCI);
1514
1515                         vlan_packet_rcvd = true;
1516
1517                         memmove(skb->data + VLAN_HLEN, data, ETH_ALEN * 2);
1518                         skb_pull(skb, VLAN_HLEN);
1519                 }
1520
1521                 skb->protocol = eth_type_trans(skb, ndev);
1522
1523                 /* Get receive timestamp from the skb */
1524                 if (fep->hwts_rx_en && fep->bufdesc_ex)
1525                         fec_enet_hwtstamp(fep, fec32_to_cpu(ebdp->ts),
1526                                           skb_hwtstamps(skb));
1527
1528                 if (fep->bufdesc_ex &&
1529                     (fep->csum_flags & FLAG_RX_CSUM_ENABLED)) {
1530                         if (!(ebdp->cbd_esc & cpu_to_fec32(FLAG_RX_CSUM_ERROR))) {
1531                                 /* don't check it */
1532                                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1533                         } else {
1534                                 skb_checksum_none_assert(skb);
1535                         }
1536                 }
1537
1538                 /* Handle received VLAN packets */
1539                 if (vlan_packet_rcvd)
1540                         __vlan_hwaccel_put_tag(skb,
1541                                                htons(ETH_P_8021Q),
1542                                                vlan_tag);
1543
1544                 skb_record_rx_queue(skb, queue_id);
1545                 napi_gro_receive(&fep->napi, skb);
1546
1547                 if (is_copybreak) {
1548                         dma_sync_single_for_device(&fep->pdev->dev,
1549                                                    fec32_to_cpu(bdp->cbd_bufaddr),
1550                                                    FEC_ENET_RX_FRSIZE - fep->rx_align,
1551                                                    DMA_FROM_DEVICE);
1552                 } else {
1553                         rxq->rx_skbuff[index] = skb_new;
1554                         fec_enet_new_rxbdp(ndev, bdp, skb_new);
1555                 }
1556
1557 rx_processing_done:
1558                 /* Clear the status flags for this buffer */
1559                 status &= ~BD_ENET_RX_STATS;
1560
1561                 /* Mark the buffer empty */
1562                 status |= BD_ENET_RX_EMPTY;
1563
1564                 if (fep->bufdesc_ex) {
1565                         struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
1566
1567                         ebdp->cbd_esc = cpu_to_fec32(BD_ENET_RX_INT);
1568                         ebdp->cbd_prot = 0;
1569                         ebdp->cbd_bdu = 0;
1570                 }
1571                 /* Make sure the updates to rest of the descriptor are
1572                  * performed before transferring ownership.
1573                  */
1574                 wmb();
1575                 bdp->cbd_sc = cpu_to_fec16(status);
1576
1577                 /* Update BD pointer to next entry */
1578                 bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
1579
1580                 /* Doing this here will keep the FEC running while we process
1581                  * incoming frames.  On a heavily loaded network, we should be
1582                  * able to keep up at the expense of system resources.
1583                  */
1584                 writel(0, rxq->bd.reg_desc_active);
1585         }
1586         rxq->bd.cur = bdp;
1587         return pkt_received;
1588 }
1589
1590 static int fec_enet_rx(struct net_device *ndev, int budget)
1591 {
1592         struct fec_enet_private *fep = netdev_priv(ndev);
1593         int i, done = 0;
1594
1595         /* Make sure that AVB queues are processed first. */
1596         for (i = fep->num_rx_queues - 1; i >= 0; i--)
1597                 done += fec_enet_rx_queue(ndev, budget - done, i);
1598
1599         return done;
1600 }
1601
1602 static bool fec_enet_collect_events(struct fec_enet_private *fep)
1603 {
1604         uint int_events;
1605
1606         int_events = readl(fep->hwp + FEC_IEVENT);
1607
1608         /* Don't clear MDIO events, we poll for those */
1609         int_events &= ~FEC_ENET_MII;
1610
1611         writel(int_events, fep->hwp + FEC_IEVENT);
1612
1613         return int_events != 0;
1614 }
1615
1616 static irqreturn_t
1617 fec_enet_interrupt(int irq, void *dev_id)
1618 {
1619         struct net_device *ndev = dev_id;
1620         struct fec_enet_private *fep = netdev_priv(ndev);
1621         irqreturn_t ret = IRQ_NONE;
1622
1623         if (fec_enet_collect_events(fep) && fep->link) {
1624                 ret = IRQ_HANDLED;
1625
1626                 if (napi_schedule_prep(&fep->napi)) {
1627                         /* Disable interrupts */
1628                         writel(0, fep->hwp + FEC_IMASK);
1629                         __napi_schedule(&fep->napi);
1630                 }
1631         }
1632
1633         return ret;
1634 }
1635
1636 static int fec_enet_rx_napi(struct napi_struct *napi, int budget)
1637 {
1638         struct net_device *ndev = napi->dev;
1639         struct fec_enet_private *fep = netdev_priv(ndev);
1640         int done = 0;
1641
1642         do {
1643                 done += fec_enet_rx(ndev, budget - done);
1644                 fec_enet_tx(ndev);
1645         } while ((done < budget) && fec_enet_collect_events(fep));
1646
1647         if (done < budget) {
1648                 napi_complete_done(napi, done);
1649                 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
1650         }
1651
1652         return done;
1653 }
1654
1655 /* ------------------------------------------------------------------------- */
1656 static void fec_get_mac(struct net_device *ndev)
1657 {
1658         struct fec_enet_private *fep = netdev_priv(ndev);
1659         struct fec_platform_data *pdata = dev_get_platdata(&fep->pdev->dev);
1660         unsigned char *iap, tmpaddr[ETH_ALEN];
1661
1662         /*
1663          * try to get mac address in following order:
1664          *
1665          * 1) module parameter via kernel command line in form
1666          *    fec.macaddr=0x00,0x04,0x9f,0x01,0x30,0xe0
1667          */
1668         iap = macaddr;
1669
1670         /*
1671          * 2) from device tree data
1672          */
1673         if (!is_valid_ether_addr(iap)) {
1674                 struct device_node *np = fep->pdev->dev.of_node;
1675                 if (np) {
1676                         const char *mac = of_get_mac_address(np);
1677                         if (!IS_ERR(mac))
1678                                 iap = (unsigned char *) mac;
1679                 }
1680         }
1681
1682         /*
1683          * 3) from flash or fuse (via platform data)
1684          */
1685         if (!is_valid_ether_addr(iap)) {
1686 #ifdef CONFIG_M5272
1687                 if (FEC_FLASHMAC)
1688                         iap = (unsigned char *)FEC_FLASHMAC;
1689 #else
1690                 if (pdata)
1691                         iap = (unsigned char *)&pdata->mac;
1692 #endif
1693         }
1694
1695         /*
1696          * 4) FEC mac registers set by bootloader
1697          */
1698         if (!is_valid_ether_addr(iap)) {
1699                 *((__be32 *) &tmpaddr[0]) =
1700                         cpu_to_be32(readl(fep->hwp + FEC_ADDR_LOW));
1701                 *((__be16 *) &tmpaddr[4]) =
1702                         cpu_to_be16(readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
1703                 iap = &tmpaddr[0];
1704         }
1705
1706         /*
1707          * 5) random mac address
1708          */
1709         if (!is_valid_ether_addr(iap)) {
1710                 /* Report it and use a random ethernet address instead */
1711                 dev_err(&fep->pdev->dev, "Invalid MAC address: %pM\n", iap);
1712                 eth_hw_addr_random(ndev);
1713                 dev_info(&fep->pdev->dev, "Using random MAC address: %pM\n",
1714                          ndev->dev_addr);
1715                 return;
1716         }
1717
1718         memcpy(ndev->dev_addr, iap, ETH_ALEN);
1719
1720         /* Adjust MAC if using macaddr */
1721         if (iap == macaddr)
1722                  ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->dev_id;
1723 }
1724
1725 /* ------------------------------------------------------------------------- */
1726
1727 /*
1728  * Phy section
1729  */
1730 static void fec_enet_adjust_link(struct net_device *ndev)
1731 {
1732         struct fec_enet_private *fep = netdev_priv(ndev);
1733         struct phy_device *phy_dev = ndev->phydev;
1734         int status_change = 0;
1735
1736         /*
1737          * If the netdev is down, or is going down, we're not interested
1738          * in link state events, so just mark our idea of the link as down
1739          * and ignore the event.
1740          */
1741         if (!netif_running(ndev) || !netif_device_present(ndev)) {
1742                 fep->link = 0;
1743         } else if (phy_dev->link) {
1744                 if (!fep->link) {
1745                         fep->link = phy_dev->link;
1746                         status_change = 1;
1747                 }
1748
1749                 if (fep->full_duplex != phy_dev->duplex) {
1750                         fep->full_duplex = phy_dev->duplex;
1751                         status_change = 1;
1752                 }
1753
1754                 if (phy_dev->speed != fep->speed) {
1755                         fep->speed = phy_dev->speed;
1756                         status_change = 1;
1757                 }
1758
1759                 /* if any of the above changed restart the FEC */
1760                 if (status_change) {
1761                         napi_disable(&fep->napi);
1762                         netif_tx_lock_bh(ndev);
1763                         fec_restart(ndev);
1764                         netif_tx_wake_all_queues(ndev);
1765                         netif_tx_unlock_bh(ndev);
1766                         napi_enable(&fep->napi);
1767                 }
1768         } else {
1769                 if (fep->link) {
1770                         napi_disable(&fep->napi);
1771                         netif_tx_lock_bh(ndev);
1772                         fec_stop(ndev);
1773                         netif_tx_unlock_bh(ndev);
1774                         napi_enable(&fep->napi);
1775                         fep->link = phy_dev->link;
1776                         status_change = 1;
1777                 }
1778         }
1779
1780         if (status_change)
1781                 phy_print_status(phy_dev);
1782 }
1783
1784 static int fec_enet_mdio_wait(struct fec_enet_private *fep)
1785 {
1786         uint ievent;
1787         int ret;
1788
1789         ret = readl_poll_timeout_atomic(fep->hwp + FEC_IEVENT, ievent,
1790                                         ievent & FEC_ENET_MII, 2, 30000);
1791
1792         if (!ret)
1793                 writel(FEC_ENET_MII, fep->hwp + FEC_IEVENT);
1794
1795         return ret;
1796 }
1797
1798 static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
1799 {
1800         struct fec_enet_private *fep = bus->priv;
1801         struct device *dev = &fep->pdev->dev;
1802         int ret = 0, frame_start, frame_addr, frame_op;
1803         bool is_c45 = !!(regnum & MII_ADDR_C45);
1804
1805         ret = pm_runtime_get_sync(dev);
1806         if (ret < 0)
1807                 return ret;
1808
1809         if (is_c45) {
1810                 frame_start = FEC_MMFR_ST_C45;
1811
1812                 /* write address */
1813                 frame_addr = (regnum >> 16);
1814                 writel(frame_start | FEC_MMFR_OP_ADDR_WRITE |
1815                        FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
1816                        FEC_MMFR_TA | (regnum & 0xFFFF),
1817                        fep->hwp + FEC_MII_DATA);
1818
1819                 /* wait for end of transfer */
1820                 ret = fec_enet_mdio_wait(fep);
1821                 if (ret) {
1822                         netdev_err(fep->netdev, "MDIO address write timeout\n");
1823                         goto out;
1824                 }
1825
1826                 frame_op = FEC_MMFR_OP_READ_C45;
1827
1828         } else {
1829                 /* C22 read */
1830                 frame_op = FEC_MMFR_OP_READ;
1831                 frame_start = FEC_MMFR_ST;
1832                 frame_addr = regnum;
1833         }
1834
1835         /* start a read op */
1836         writel(frame_start | frame_op |
1837                 FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
1838                 FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);
1839
1840         /* wait for end of transfer */
1841         ret = fec_enet_mdio_wait(fep);
1842         if (ret) {
1843                 netdev_err(fep->netdev, "MDIO read timeout\n");
1844                 goto out;
1845         }
1846
1847         ret = FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
1848
1849 out:
1850         pm_runtime_mark_last_busy(dev);
1851         pm_runtime_put_autosuspend(dev);
1852
1853         return ret;
1854 }
1855
1856 static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
1857                            u16 value)
1858 {
1859         struct fec_enet_private *fep = bus->priv;
1860         struct device *dev = &fep->pdev->dev;
1861         int ret, frame_start, frame_addr;
1862         bool is_c45 = !!(regnum & MII_ADDR_C45);
1863
1864         ret = pm_runtime_get_sync(dev);
1865         if (ret < 0)
1866                 return ret;
1867         else
1868                 ret = 0;
1869
1870         if (is_c45) {
1871                 frame_start = FEC_MMFR_ST_C45;
1872
1873                 /* write address */
1874                 frame_addr = (regnum >> 16);
1875                 writel(frame_start | FEC_MMFR_OP_ADDR_WRITE |
1876                        FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
1877                        FEC_MMFR_TA | (regnum & 0xFFFF),
1878                        fep->hwp + FEC_MII_DATA);
1879
1880                 /* wait for end of transfer */
1881                 ret = fec_enet_mdio_wait(fep);
1882                 if (ret) {
1883                         netdev_err(fep->netdev, "MDIO address write timeout\n");
1884                         goto out;
1885                 }
1886         } else {
1887                 /* C22 write */
1888                 frame_start = FEC_MMFR_ST;
1889                 frame_addr = regnum;
1890         }
1891
1892         /* start a write op */
1893         writel(frame_start | FEC_MMFR_OP_WRITE |
1894                 FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
1895                 FEC_MMFR_TA | FEC_MMFR_DATA(value),
1896                 fep->hwp + FEC_MII_DATA);
1897
1898         /* wait for end of transfer */
1899         ret = fec_enet_mdio_wait(fep);
1900         if (ret)
1901                 netdev_err(fep->netdev, "MDIO write timeout\n");
1902
1903 out:
1904         pm_runtime_mark_last_busy(dev);
1905         pm_runtime_put_autosuspend(dev);
1906
1907         return ret;
1908 }
1909
1910 static int fec_enet_clk_enable(struct net_device *ndev, bool enable)
1911 {
1912         struct fec_enet_private *fep = netdev_priv(ndev);
1913         int ret;
1914
1915         if (enable) {
1916                 ret = clk_prepare_enable(fep->clk_enet_out);
1917                 if (ret)
1918                         return ret;
1919
1920                 if (fep->clk_ptp) {
1921                         mutex_lock(&fep->ptp_clk_mutex);
1922                         ret = clk_prepare_enable(fep->clk_ptp);
1923                         if (ret) {
1924                                 mutex_unlock(&fep->ptp_clk_mutex);
1925                                 goto failed_clk_ptp;
1926                         } else {
1927                                 fep->ptp_clk_on = true;
1928                         }
1929                         mutex_unlock(&fep->ptp_clk_mutex);
1930                 }
1931
1932                 ret = clk_prepare_enable(fep->clk_ref);
1933                 if (ret)
1934                         goto failed_clk_ref;
1935
1936                 phy_reset_after_clk_enable(ndev->phydev);
1937         } else {
1938                 clk_disable_unprepare(fep->clk_enet_out);
1939                 if (fep->clk_ptp) {
1940                         mutex_lock(&fep->ptp_clk_mutex);
1941                         clk_disable_unprepare(fep->clk_ptp);
1942                         fep->ptp_clk_on = false;
1943                         mutex_unlock(&fep->ptp_clk_mutex);
1944                 }
1945                 clk_disable_unprepare(fep->clk_ref);
1946         }
1947
1948         return 0;
1949
1950 failed_clk_ref:
1951         if (fep->clk_ptp) {
1952                 mutex_lock(&fep->ptp_clk_mutex);
1953                 clk_disable_unprepare(fep->clk_ptp);
1954                 fep->ptp_clk_on = false;
1955                 mutex_unlock(&fep->ptp_clk_mutex);
1956         }
1957 failed_clk_ptp:
1958         if (fep->clk_enet_out)
1959                 clk_disable_unprepare(fep->clk_enet_out);
1960
1961         return ret;
1962 }
1963
1964 static int fec_enet_mii_probe(struct net_device *ndev)
1965 {
1966         struct fec_enet_private *fep = netdev_priv(ndev);
1967         struct phy_device *phy_dev = NULL;
1968         char mdio_bus_id[MII_BUS_ID_SIZE];
1969         char phy_name[MII_BUS_ID_SIZE + 3];
1970         int phy_id;
1971         int dev_id = fep->dev_id;
1972
1973         if (fep->phy_node) {
1974                 phy_dev = of_phy_connect(ndev, fep->phy_node,
1975                                          &fec_enet_adjust_link, 0,
1976                                          fep->phy_interface);
1977                 if (!phy_dev) {
1978                         netdev_err(ndev, "Unable to connect to phy\n");
1979                         return -ENODEV;
1980                 }
1981         } else {
1982                 /* check for attached phy */
1983                 for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
1984                         if (!mdiobus_is_registered_device(fep->mii_bus, phy_id))
1985                                 continue;
1986                         if (dev_id--)
1987                                 continue;
1988                         strlcpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
1989                         break;
1990                 }
1991
1992                 if (phy_id >= PHY_MAX_ADDR) {
1993                         netdev_info(ndev, "no PHY, assuming direct connection to switch\n");
1994                         strlcpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
1995                         phy_id = 0;
1996                 }
1997
1998                 snprintf(phy_name, sizeof(phy_name),
1999                          PHY_ID_FMT, mdio_bus_id, phy_id);
2000                 phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link,
2001                                       fep->phy_interface);
2002         }
2003
2004         if (IS_ERR(phy_dev)) {
2005                 netdev_err(ndev, "could not attach to PHY\n");
2006                 return PTR_ERR(phy_dev);
2007         }
2008
2009         /* mask with MAC supported features */
2010         if (fep->quirks & FEC_QUIRK_HAS_GBIT) {
2011                 phy_set_max_speed(phy_dev, 1000);
2012                 phy_remove_link_mode(phy_dev,
2013                                      ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2014 #if !defined(CONFIG_M5272)
2015                 phy_support_sym_pause(phy_dev);
2016 #endif
2017         }
2018         else
2019                 phy_set_max_speed(phy_dev, 100);
2020
2021         fep->link = 0;
2022         fep->full_duplex = 0;
2023
2024         phy_attached_info(phy_dev);
2025
2026         return 0;
2027 }
2028
2029 static int fec_enet_mii_init(struct platform_device *pdev)
2030 {
2031         static struct mii_bus *fec0_mii_bus;
2032         struct net_device *ndev = platform_get_drvdata(pdev);
2033         struct fec_enet_private *fep = netdev_priv(ndev);
2034         bool suppress_preamble = false;
2035         struct device_node *node;
2036         int err = -ENXIO;
2037         u32 mii_speed, holdtime;
2038         u32 bus_freq;
2039
2040         /*
2041          * The i.MX28 dual fec interfaces are not equal.
2042          * Here are the differences:
2043          *
2044          *  - fec0 supports MII & RMII modes while fec1 only supports RMII
2045          *  - fec0 acts as the 1588 time master while fec1 is slave
2046          *  - external phys can only be configured by fec0
2047          *
2048          * That is to say fec1 can not work independently. It only works
2049          * when fec0 is working. The reason behind this design is that the
2050          * second interface is added primarily for Switch mode.
2051          *
2052          * Because of the last point above, both phys are attached on fec0
2053          * mdio interface in board design, and need to be configured by
2054          * fec0 mii_bus.
2055          */
2056         if ((fep->quirks & FEC_QUIRK_SINGLE_MDIO) && fep->dev_id > 0) {
2057                 /* fec1 uses fec0 mii_bus */
2058                 if (mii_cnt && fec0_mii_bus) {
2059                         fep->mii_bus = fec0_mii_bus;
2060                         mii_cnt++;
2061                         return 0;
2062                 }
2063                 return -ENOENT;
2064         }
2065
2066         bus_freq = 2500000; /* 2.5MHz by default */
2067         node = of_get_child_by_name(pdev->dev.of_node, "mdio");
2068         if (node) {
2069                 of_property_read_u32(node, "clock-frequency", &bus_freq);
2070                 suppress_preamble = of_property_read_bool(node,
2071                                                           "suppress-preamble");
2072         }
2073
2074         /*
2075          * Set MII speed (= clk_get_rate() / 2 * phy_speed)
2076          *
2077          * The formula for FEC MDC is 'ref_freq / (MII_SPEED x 2)' while
2078          * for ENET-MAC is 'ref_freq / ((MII_SPEED + 1) x 2)'.  The i.MX28
2079          * Reference Manual has an error on this, and gets fixed on i.MX6Q
2080          * document.
2081          */
2082         mii_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), bus_freq * 2);
2083         if (fep->quirks & FEC_QUIRK_ENET_MAC)
2084                 mii_speed--;
2085         if (mii_speed > 63) {
2086                 dev_err(&pdev->dev,
2087                         "fec clock (%lu) too fast to get right mii speed\n",
2088                         clk_get_rate(fep->clk_ipg));
2089                 err = -EINVAL;
2090                 goto err_out;
2091         }
2092
2093         /*
2094          * The i.MX28 and i.MX6 types have another filed in the MSCR (aka
2095          * MII_SPEED) register that defines the MDIO output hold time. Earlier
2096          * versions are RAZ there, so just ignore the difference and write the
2097          * register always.
2098          * The minimal hold time according to IEE802.3 (clause 22) is 10 ns.
2099          * HOLDTIME + 1 is the number of clk cycles the fec is holding the
2100          * output.
2101          * The HOLDTIME bitfield takes values between 0 and 7 (inclusive).
2102          * Given that ceil(clkrate / 5000000) <= 64, the calculation for
2103          * holdtime cannot result in a value greater than 3.
2104          */
2105         holdtime = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), 100000000) - 1;
2106
2107         fep->phy_speed = mii_speed << 1 | holdtime << 8;
2108
2109         if (suppress_preamble)
2110                 fep->phy_speed |= BIT(7);
2111
2112         /* Clear MMFR to avoid to generate MII event by writing MSCR.
2113          * MII event generation condition:
2114          * - writing MSCR:
2115          *      - mmfr[31:0]_not_zero & mscr[7:0]_is_zero &
2116          *        mscr_reg_data_in[7:0] != 0
2117          * - writing MMFR:
2118          *      - mscr[7:0]_not_zero
2119          */
2120         writel(0, fep->hwp + FEC_MII_DATA);
2121
2122         writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
2123
2124         /* Clear any pending transaction complete indication */
2125         writel(FEC_ENET_MII, fep->hwp + FEC_IEVENT);
2126
2127         fep->mii_bus = mdiobus_alloc();
2128         if (fep->mii_bus == NULL) {
2129                 err = -ENOMEM;
2130                 goto err_out;
2131         }
2132
2133         fep->mii_bus->name = "fec_enet_mii_bus";
2134         fep->mii_bus->read = fec_enet_mdio_read;
2135         fep->mii_bus->write = fec_enet_mdio_write;
2136         snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
2137                 pdev->name, fep->dev_id + 1);
2138         fep->mii_bus->priv = fep;
2139         fep->mii_bus->parent = &pdev->dev;
2140
2141         err = of_mdiobus_register(fep->mii_bus, node);
2142         of_node_put(node);
2143         if (err)
2144                 goto err_out_free_mdiobus;
2145
2146         mii_cnt++;
2147
2148         /* save fec0 mii_bus */
2149         if (fep->quirks & FEC_QUIRK_SINGLE_MDIO)
2150                 fec0_mii_bus = fep->mii_bus;
2151
2152         return 0;
2153
2154 err_out_free_mdiobus:
2155         mdiobus_free(fep->mii_bus);
2156 err_out:
2157         return err;
2158 }
2159
2160 static void fec_enet_mii_remove(struct fec_enet_private *fep)
2161 {
2162         if (--mii_cnt == 0) {
2163                 mdiobus_unregister(fep->mii_bus);
2164                 mdiobus_free(fep->mii_bus);
2165         }
2166 }
2167
2168 static void fec_enet_get_drvinfo(struct net_device *ndev,
2169                                  struct ethtool_drvinfo *info)
2170 {
2171         struct fec_enet_private *fep = netdev_priv(ndev);
2172
2173         strlcpy(info->driver, fep->pdev->dev.driver->name,
2174                 sizeof(info->driver));
2175         strlcpy(info->bus_info, dev_name(&ndev->dev), sizeof(info->bus_info));
2176 }
2177
2178 static int fec_enet_get_regs_len(struct net_device *ndev)
2179 {
2180         struct fec_enet_private *fep = netdev_priv(ndev);
2181         struct resource *r;
2182         int s = 0;
2183
2184         r = platform_get_resource(fep->pdev, IORESOURCE_MEM, 0);
2185         if (r)
2186                 s = resource_size(r);
2187
2188         return s;
2189 }
2190
2191 /* List of registers that can be safety be read to dump them with ethtool */
2192 #if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
2193         defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM) || \
2194         defined(CONFIG_ARM64) || defined(CONFIG_COMPILE_TEST)
2195 static __u32 fec_enet_register_version = 2;
2196 static u32 fec_enet_register_offset[] = {
2197         FEC_IEVENT, FEC_IMASK, FEC_R_DES_ACTIVE_0, FEC_X_DES_ACTIVE_0,
2198         FEC_ECNTRL, FEC_MII_DATA, FEC_MII_SPEED, FEC_MIB_CTRLSTAT, FEC_R_CNTRL,
2199         FEC_X_CNTRL, FEC_ADDR_LOW, FEC_ADDR_HIGH, FEC_OPD, FEC_TXIC0, FEC_TXIC1,
2200         FEC_TXIC2, FEC_RXIC0, FEC_RXIC1, FEC_RXIC2, FEC_HASH_TABLE_HIGH,
2201         FEC_HASH_TABLE_LOW, FEC_GRP_HASH_TABLE_HIGH, FEC_GRP_HASH_TABLE_LOW,
2202         FEC_X_WMRK, FEC_R_BOUND, FEC_R_FSTART, FEC_R_DES_START_1,
2203         FEC_X_DES_START_1, FEC_R_BUFF_SIZE_1, FEC_R_DES_START_2,
2204         FEC_X_DES_START_2, FEC_R_BUFF_SIZE_2, FEC_R_DES_START_0,
2205         FEC_X_DES_START_0, FEC_R_BUFF_SIZE_0, FEC_R_FIFO_RSFL, FEC_R_FIFO_RSEM,
2206         FEC_R_FIFO_RAEM, FEC_R_FIFO_RAFL, FEC_RACC, FEC_RCMR_1, FEC_RCMR_2,
2207         FEC_DMA_CFG_1, FEC_DMA_CFG_2, FEC_R_DES_ACTIVE_1, FEC_X_DES_ACTIVE_1,
2208         FEC_R_DES_ACTIVE_2, FEC_X_DES_ACTIVE_2, FEC_QOS_SCHEME,
2209         RMON_T_DROP, RMON_T_PACKETS, RMON_T_BC_PKT, RMON_T_MC_PKT,
2210         RMON_T_CRC_ALIGN, RMON_T_UNDERSIZE, RMON_T_OVERSIZE, RMON_T_FRAG,
2211         RMON_T_JAB, RMON_T_COL, RMON_T_P64, RMON_T_P65TO127, RMON_T_P128TO255,
2212         RMON_T_P256TO511, RMON_T_P512TO1023, RMON_T_P1024TO2047,
2213         RMON_T_P_GTE2048, RMON_T_OCTETS,
2214         IEEE_T_DROP, IEEE_T_FRAME_OK, IEEE_T_1COL, IEEE_T_MCOL, IEEE_T_DEF,
2215         IEEE_T_LCOL, IEEE_T_EXCOL, IEEE_T_MACERR, IEEE_T_CSERR, IEEE_T_SQE,
2216         IEEE_T_FDXFC, IEEE_T_OCTETS_OK,
2217         RMON_R_PACKETS, RMON_R_BC_PKT, RMON_R_MC_PKT, RMON_R_CRC_ALIGN,
2218         RMON_R_UNDERSIZE, RMON_R_OVERSIZE, RMON_R_FRAG, RMON_R_JAB,
2219         RMON_R_RESVD_O, RMON_R_P64, RMON_R_P65TO127, RMON_R_P128TO255,
2220         RMON_R_P256TO511, RMON_R_P512TO1023, RMON_R_P1024TO2047,
2221         RMON_R_P_GTE2048, RMON_R_OCTETS,
2222         IEEE_R_DROP, IEEE_R_FRAME_OK, IEEE_R_CRC, IEEE_R_ALIGN, IEEE_R_MACERR,
2223         IEEE_R_FDXFC, IEEE_R_OCTETS_OK
2224 };
2225 #else
2226 static __u32 fec_enet_register_version = 1;
2227 static u32 fec_enet_register_offset[] = {
2228         FEC_ECNTRL, FEC_IEVENT, FEC_IMASK, FEC_IVEC, FEC_R_DES_ACTIVE_0,
2229         FEC_R_DES_ACTIVE_1, FEC_R_DES_ACTIVE_2, FEC_X_DES_ACTIVE_0,
2230         FEC_X_DES_ACTIVE_1, FEC_X_DES_ACTIVE_2, FEC_MII_DATA, FEC_MII_SPEED,
2231         FEC_R_BOUND, FEC_R_FSTART, FEC_X_WMRK, FEC_X_FSTART, FEC_R_CNTRL,
2232         FEC_MAX_FRM_LEN, FEC_X_CNTRL, FEC_ADDR_LOW, FEC_ADDR_HIGH,
2233         FEC_GRP_HASH_TABLE_HIGH, FEC_GRP_HASH_TABLE_LOW, FEC_R_DES_START_0,
2234         FEC_R_DES_START_1, FEC_R_DES_START_2, FEC_X_DES_START_0,
2235         FEC_X_DES_START_1, FEC_X_DES_START_2, FEC_R_BUFF_SIZE_0,
2236         FEC_R_BUFF_SIZE_1, FEC_R_BUFF_SIZE_2
2237 };
2238 #endif
2239
2240 static void fec_enet_get_regs(struct net_device *ndev,
2241                               struct ethtool_regs *regs, void *regbuf)
2242 {
2243         struct fec_enet_private *fep = netdev_priv(ndev);
2244         u32 __iomem *theregs = (u32 __iomem *)fep->hwp;
2245         struct device *dev = &fep->pdev->dev;
2246         u32 *buf = (u32 *)regbuf;
2247         u32 i, off;
2248         int ret;
2249
2250         ret = pm_runtime_get_sync(dev);
2251         if (ret < 0)
2252                 return;
2253
2254         regs->version = fec_enet_register_version;
2255
2256         memset(buf, 0, regs->len);
2257
2258         for (i = 0; i < ARRAY_SIZE(fec_enet_register_offset); i++) {
2259                 off = fec_enet_register_offset[i];
2260
2261                 if ((off == FEC_R_BOUND || off == FEC_R_FSTART) &&
2262                     !(fep->quirks & FEC_QUIRK_HAS_FRREG))
2263                         continue;
2264
2265                 off >>= 2;
2266                 buf[off] = readl(&theregs[off]);
2267         }
2268
2269         pm_runtime_mark_last_busy(dev);
2270         pm_runtime_put_autosuspend(dev);
2271 }
2272
2273 static int fec_enet_get_ts_info(struct net_device *ndev,
2274                                 struct ethtool_ts_info *info)
2275 {
2276         struct fec_enet_private *fep = netdev_priv(ndev);
2277
2278         if (fep->bufdesc_ex) {
2279
2280                 info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
2281                                         SOF_TIMESTAMPING_RX_SOFTWARE |
2282                                         SOF_TIMESTAMPING_SOFTWARE |
2283                                         SOF_TIMESTAMPING_TX_HARDWARE |
2284                                         SOF_TIMESTAMPING_RX_HARDWARE |
2285                                         SOF_TIMESTAMPING_RAW_HARDWARE;
2286                 if (fep->ptp_clock)
2287                         info->phc_index = ptp_clock_index(fep->ptp_clock);
2288                 else
2289                         info->phc_index = -1;
2290
2291                 info->tx_types = (1 << HWTSTAMP_TX_OFF) |
2292                                  (1 << HWTSTAMP_TX_ON);
2293
2294                 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
2295                                    (1 << HWTSTAMP_FILTER_ALL);
2296                 return 0;
2297         } else {
2298                 return ethtool_op_get_ts_info(ndev, info);
2299         }
2300 }
2301
2302 #if !defined(CONFIG_M5272)
2303
2304 static void fec_enet_get_pauseparam(struct net_device *ndev,
2305                                     struct ethtool_pauseparam *pause)
2306 {
2307         struct fec_enet_private *fep = netdev_priv(ndev);
2308
2309         pause->autoneg = (fep->pause_flag & FEC_PAUSE_FLAG_AUTONEG) != 0;
2310         pause->tx_pause = (fep->pause_flag & FEC_PAUSE_FLAG_ENABLE) != 0;
2311         pause->rx_pause = pause->tx_pause;
2312 }
2313
2314 static int fec_enet_set_pauseparam(struct net_device *ndev,
2315                                    struct ethtool_pauseparam *pause)
2316 {
2317         struct fec_enet_private *fep = netdev_priv(ndev);
2318
2319         if (!ndev->phydev)
2320                 return -ENODEV;
2321
2322         if (pause->tx_pause != pause->rx_pause) {
2323                 netdev_info(ndev,
2324                         "hardware only support enable/disable both tx and rx");
2325                 return -EINVAL;
2326         }
2327
2328         fep->pause_flag = 0;
2329
2330         /* tx pause must be same as rx pause */
2331         fep->pause_flag |= pause->rx_pause ? FEC_PAUSE_FLAG_ENABLE : 0;
2332         fep->pause_flag |= pause->autoneg ? FEC_PAUSE_FLAG_AUTONEG : 0;
2333
2334         phy_set_sym_pause(ndev->phydev, pause->rx_pause, pause->tx_pause,
2335                           pause->autoneg);
2336
2337         if (pause->autoneg) {
2338                 if (netif_running(ndev))
2339                         fec_stop(ndev);
2340                 phy_start_aneg(ndev->phydev);
2341         }
2342         if (netif_running(ndev)) {
2343                 napi_disable(&fep->napi);
2344                 netif_tx_lock_bh(ndev);
2345                 fec_restart(ndev);
2346                 netif_tx_wake_all_queues(ndev);
2347                 netif_tx_unlock_bh(ndev);
2348                 napi_enable(&fep->napi);
2349         }
2350
2351         return 0;
2352 }
2353
2354 static const struct fec_stat {
2355         char name[ETH_GSTRING_LEN];
2356         u16 offset;
2357 } fec_stats[] = {
2358         /* RMON TX */
2359         { "tx_dropped", RMON_T_DROP },
2360         { "tx_packets", RMON_T_PACKETS },
2361         { "tx_broadcast", RMON_T_BC_PKT },
2362         { "tx_multicast", RMON_T_MC_PKT },
2363         { "tx_crc_errors", RMON_T_CRC_ALIGN },
2364         { "tx_undersize", RMON_T_UNDERSIZE },
2365         { "tx_oversize", RMON_T_OVERSIZE },
2366         { "tx_fragment", RMON_T_FRAG },
2367         { "tx_jabber", RMON_T_JAB },
2368         { "tx_collision", RMON_T_COL },
2369         { "tx_64byte", RMON_T_P64 },
2370         { "tx_65to127byte", RMON_T_P65TO127 },
2371         { "tx_128to255byte", RMON_T_P128TO255 },
2372         { "tx_256to511byte", RMON_T_P256TO511 },
2373         { "tx_512to1023byte", RMON_T_P512TO1023 },
2374         { "tx_1024to2047byte", RMON_T_P1024TO2047 },
2375         { "tx_GTE2048byte", RMON_T_P_GTE2048 },
2376         { "tx_octets", RMON_T_OCTETS },
2377
2378         /* IEEE TX */
2379         { "IEEE_tx_drop", IEEE_T_DROP },
2380         { "IEEE_tx_frame_ok", IEEE_T_FRAME_OK },
2381         { "IEEE_tx_1col", IEEE_T_1COL },
2382         { "IEEE_tx_mcol", IEEE_T_MCOL },
2383         { "IEEE_tx_def", IEEE_T_DEF },
2384         { "IEEE_tx_lcol", IEEE_T_LCOL },
2385         { "IEEE_tx_excol", IEEE_T_EXCOL },
2386         { "IEEE_tx_macerr", IEEE_T_MACERR },
2387         { "IEEE_tx_cserr", IEEE_T_CSERR },
2388         { "IEEE_tx_sqe", IEEE_T_SQE },
2389         { "IEEE_tx_fdxfc", IEEE_T_FDXFC },
2390         { "IEEE_tx_octets_ok", IEEE_T_OCTETS_OK },
2391
2392         /* RMON RX */
2393         { "rx_packets", RMON_R_PACKETS },
2394         { "rx_broadcast", RMON_R_BC_PKT },
2395         { "rx_multicast", RMON_R_MC_PKT },
2396         { "rx_crc_errors", RMON_R_CRC_ALIGN },
2397         { "rx_undersize", RMON_R_UNDERSIZE },
2398         { "rx_oversize", RMON_R_OVERSIZE },
2399         { "rx_fragment", RMON_R_FRAG },
2400         { "rx_jabber", RMON_R_JAB },
2401         { "rx_64byte", RMON_R_P64 },
2402         { "rx_65to127byte", RMON_R_P65TO127 },
2403         { "rx_128to255byte", RMON_R_P128TO255 },
2404         { "rx_256to511byte", RMON_R_P256TO511 },
2405         { "rx_512to1023byte", RMON_R_P512TO1023 },
2406         { "rx_1024to2047byte", RMON_R_P1024TO2047 },
2407         { "rx_GTE2048byte", RMON_R_P_GTE2048 },
2408         { "rx_octets", RMON_R_OCTETS },
2409
2410         /* IEEE RX */
2411         { "IEEE_rx_drop", IEEE_R_DROP },
2412         { "IEEE_rx_frame_ok", IEEE_R_FRAME_OK },
2413         { "IEEE_rx_crc", IEEE_R_CRC },
2414         { "IEEE_rx_align", IEEE_R_ALIGN },
2415         { "IEEE_rx_macerr", IEEE_R_MACERR },
2416         { "IEEE_rx_fdxfc", IEEE_R_FDXFC },
2417         { "IEEE_rx_octets_ok", IEEE_R_OCTETS_OK },
2418 };
2419
2420 #define FEC_STATS_SIZE          (ARRAY_SIZE(fec_stats) * sizeof(u64))
2421
2422 static void fec_enet_update_ethtool_stats(struct net_device *dev)
2423 {
2424         struct fec_enet_private *fep = netdev_priv(dev);
2425         int i;
2426
2427         for (i = 0; i < ARRAY_SIZE(fec_stats); i++)
2428                 fep->ethtool_stats[i] = readl(fep->hwp + fec_stats[i].offset);
2429 }
2430
2431 static void fec_enet_get_ethtool_stats(struct net_device *dev,
2432                                        struct ethtool_stats *stats, u64 *data)
2433 {
2434         struct fec_enet_private *fep = netdev_priv(dev);
2435
2436         if (netif_running(dev))
2437                 fec_enet_update_ethtool_stats(dev);
2438
2439         memcpy(data, fep->ethtool_stats, FEC_STATS_SIZE);
2440 }
2441
2442 static void fec_enet_get_strings(struct net_device *netdev,
2443         u32 stringset, u8 *data)
2444 {
2445         int i;
2446         switch (stringset) {
2447         case ETH_SS_STATS:
2448                 for (i = 0; i < ARRAY_SIZE(fec_stats); i++)
2449                         memcpy(data + i * ETH_GSTRING_LEN,
2450                                 fec_stats[i].name, ETH_GSTRING_LEN);
2451                 break;
2452         }
2453 }
2454
2455 static int fec_enet_get_sset_count(struct net_device *dev, int sset)
2456 {
2457         switch (sset) {
2458         case ETH_SS_STATS:
2459                 return ARRAY_SIZE(fec_stats);
2460         default:
2461                 return -EOPNOTSUPP;
2462         }
2463 }
2464
2465 static void fec_enet_clear_ethtool_stats(struct net_device *dev)
2466 {
2467         struct fec_enet_private *fep = netdev_priv(dev);
2468         int i;
2469
2470         /* Disable MIB statistics counters */
2471         writel(FEC_MIB_CTRLSTAT_DISABLE, fep->hwp + FEC_MIB_CTRLSTAT);
2472
2473         for (i = 0; i < ARRAY_SIZE(fec_stats); i++)
2474                 writel(0, fep->hwp + fec_stats[i].offset);
2475
2476         /* Don't disable MIB statistics counters */
2477         writel(0, fep->hwp + FEC_MIB_CTRLSTAT);
2478 }
2479
2480 #else   /* !defined(CONFIG_M5272) */
2481 #define FEC_STATS_SIZE  0
2482 static inline void fec_enet_update_ethtool_stats(struct net_device *dev)
2483 {
2484 }
2485
2486 static inline void fec_enet_clear_ethtool_stats(struct net_device *dev)
2487 {
2488 }
2489 #endif /* !defined(CONFIG_M5272) */
2490
2491 /* ITR clock source is enet system clock (clk_ahb).
2492  * TCTT unit is cycle_ns * 64 cycle
2493  * So, the ICTT value = X us / (cycle_ns * 64)
2494  */
2495 static int fec_enet_us_to_itr_clock(struct net_device *ndev, int us)
2496 {
2497         struct fec_enet_private *fep = netdev_priv(ndev);
2498
2499         return us * (fep->itr_clk_rate / 64000) / 1000;
2500 }
2501
2502 /* Set threshold for interrupt coalescing */
2503 static void fec_enet_itr_coal_set(struct net_device *ndev)
2504 {
2505         struct fec_enet_private *fep = netdev_priv(ndev);
2506         int rx_itr, tx_itr;
2507
2508         /* Must be greater than zero to avoid unpredictable behavior */
2509         if (!fep->rx_time_itr || !fep->rx_pkts_itr ||
2510             !fep->tx_time_itr || !fep->tx_pkts_itr)
2511                 return;
2512
2513         /* Select enet system clock as Interrupt Coalescing
2514          * timer Clock Source
2515          */
2516         rx_itr = FEC_ITR_CLK_SEL;
2517         tx_itr = FEC_ITR_CLK_SEL;
2518
2519         /* set ICFT and ICTT */
2520         rx_itr |= FEC_ITR_ICFT(fep->rx_pkts_itr);
2521         rx_itr |= FEC_ITR_ICTT(fec_enet_us_to_itr_clock(ndev, fep->rx_time_itr));
2522         tx_itr |= FEC_ITR_ICFT(fep->tx_pkts_itr);
2523         tx_itr |= FEC_ITR_ICTT(fec_enet_us_to_itr_clock(ndev, fep->tx_time_itr));
2524
2525         rx_itr |= FEC_ITR_EN;
2526         tx_itr |= FEC_ITR_EN;
2527
2528         writel(tx_itr, fep->hwp + FEC_TXIC0);
2529         writel(rx_itr, fep->hwp + FEC_RXIC0);
2530         if (fep->quirks & FEC_QUIRK_HAS_AVB) {
2531                 writel(tx_itr, fep->hwp + FEC_TXIC1);
2532                 writel(rx_itr, fep->hwp + FEC_RXIC1);
2533                 writel(tx_itr, fep->hwp + FEC_TXIC2);
2534                 writel(rx_itr, fep->hwp + FEC_RXIC2);
2535         }
2536 }
2537
2538 static int
2539 fec_enet_get_coalesce(struct net_device *ndev, struct ethtool_coalesce *ec)
2540 {
2541         struct fec_enet_private *fep = netdev_priv(ndev);
2542
2543         if (!(fep->quirks & FEC_QUIRK_HAS_COALESCE))
2544                 return -EOPNOTSUPP;
2545
2546         ec->rx_coalesce_usecs = fep->rx_time_itr;
2547         ec->rx_max_coalesced_frames = fep->rx_pkts_itr;
2548
2549         ec->tx_coalesce_usecs = fep->tx_time_itr;
2550         ec->tx_max_coalesced_frames = fep->tx_pkts_itr;
2551
2552         return 0;
2553 }
2554
2555 static int
2556 fec_enet_set_coalesce(struct net_device *ndev, struct ethtool_coalesce *ec)
2557 {
2558         struct fec_enet_private *fep = netdev_priv(ndev);
2559         struct device *dev = &fep->pdev->dev;
2560         unsigned int cycle;
2561
2562         if (!(fep->quirks & FEC_QUIRK_HAS_COALESCE))
2563                 return -EOPNOTSUPP;
2564
2565         if (ec->rx_max_coalesced_frames > 255) {
2566                 dev_err(dev, "Rx coalesced frames exceed hardware limitation\n");
2567                 return -EINVAL;
2568         }
2569
2570         if (ec->tx_max_coalesced_frames > 255) {
2571                 dev_err(dev, "Tx coalesced frame exceed hardware limitation\n");
2572                 return -EINVAL;
2573         }
2574
2575         cycle = fec_enet_us_to_itr_clock(ndev, ec->rx_coalesce_usecs);
2576         if (cycle > 0xFFFF) {
2577                 dev_err(dev, "Rx coalesced usec exceed hardware limitation\n");
2578                 return -EINVAL;
2579         }
2580
2581         cycle = fec_enet_us_to_itr_clock(ndev, ec->tx_coalesce_usecs);
2582         if (cycle > 0xFFFF) {
2583                 dev_err(dev, "Tx coalesced usec exceed hardware limitation\n");
2584                 return -EINVAL;
2585         }
2586
2587         fep->rx_time_itr = ec->rx_coalesce_usecs;
2588         fep->rx_pkts_itr = ec->rx_max_coalesced_frames;
2589
2590         fep->tx_time_itr = ec->tx_coalesce_usecs;
2591         fep->tx_pkts_itr = ec->tx_max_coalesced_frames;
2592
2593         fec_enet_itr_coal_set(ndev);
2594
2595         return 0;
2596 }
2597
2598 static void fec_enet_itr_coal_init(struct net_device *ndev)
2599 {
2600         struct ethtool_coalesce ec;
2601
2602         ec.rx_coalesce_usecs = FEC_ITR_ICTT_DEFAULT;
2603         ec.rx_max_coalesced_frames = FEC_ITR_ICFT_DEFAULT;
2604
2605         ec.tx_coalesce_usecs = FEC_ITR_ICTT_DEFAULT;
2606         ec.tx_max_coalesced_frames = FEC_ITR_ICFT_DEFAULT;
2607
2608         fec_enet_set_coalesce(ndev, &ec);
2609 }
2610
2611 static int fec_enet_get_tunable(struct net_device *netdev,
2612                                 const struct ethtool_tunable *tuna,
2613                                 void *data)
2614 {
2615         struct fec_enet_private *fep = netdev_priv(netdev);
2616         int ret = 0;
2617
2618         switch (tuna->id) {
2619         case ETHTOOL_RX_COPYBREAK:
2620                 *(u32 *)data = fep->rx_copybreak;
2621                 break;
2622         default:
2623                 ret = -EINVAL;
2624                 break;
2625         }
2626
2627         return ret;
2628 }
2629
2630 static int fec_enet_set_tunable(struct net_device *netdev,
2631                                 const struct ethtool_tunable *tuna,
2632                                 const void *data)
2633 {
2634         struct fec_enet_private *fep = netdev_priv(netdev);
2635         int ret = 0;
2636
2637         switch (tuna->id) {
2638         case ETHTOOL_RX_COPYBREAK:
2639                 fep->rx_copybreak = *(u32 *)data;
2640                 break;
2641         default:
2642                 ret = -EINVAL;
2643                 break;
2644         }
2645
2646         return ret;
2647 }
2648
2649 static void
2650 fec_enet_get_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
2651 {
2652         struct fec_enet_private *fep = netdev_priv(ndev);
2653
2654         if (fep->wol_flag & FEC_WOL_HAS_MAGIC_PACKET) {
2655                 wol->supported = WAKE_MAGIC;
2656                 wol->wolopts = fep->wol_flag & FEC_WOL_FLAG_ENABLE ? WAKE_MAGIC : 0;
2657         } else {
2658                 wol->supported = wol->wolopts = 0;
2659         }
2660 }
2661
2662 static int
2663 fec_enet_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
2664 {
2665         struct fec_enet_private *fep = netdev_priv(ndev);
2666
2667         if (!(fep->wol_flag & FEC_WOL_HAS_MAGIC_PACKET))
2668                 return -EINVAL;
2669
2670         if (wol->wolopts & ~WAKE_MAGIC)
2671                 return -EINVAL;
2672
2673         device_set_wakeup_enable(&ndev->dev, wol->wolopts & WAKE_MAGIC);
2674         if (device_may_wakeup(&ndev->dev)) {
2675                 fep->wol_flag |= FEC_WOL_FLAG_ENABLE;
2676                 if (fep->irq[0] > 0)
2677                         enable_irq_wake(fep->irq[0]);
2678         } else {
2679                 fep->wol_flag &= (~FEC_WOL_FLAG_ENABLE);
2680                 if (fep->irq[0] > 0)
2681                         disable_irq_wake(fep->irq[0]);
2682         }
2683
2684         return 0;
2685 }
2686
2687 static const struct ethtool_ops fec_enet_ethtool_ops = {
2688         .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
2689                                      ETHTOOL_COALESCE_MAX_FRAMES,
2690         .get_drvinfo            = fec_enet_get_drvinfo,
2691         .get_regs_len           = fec_enet_get_regs_len,
2692         .get_regs               = fec_enet_get_regs,
2693         .nway_reset             = phy_ethtool_nway_reset,
2694         .get_link               = ethtool_op_get_link,
2695         .get_coalesce           = fec_enet_get_coalesce,
2696         .set_coalesce           = fec_enet_set_coalesce,
2697 #ifndef CONFIG_M5272
2698         .get_pauseparam         = fec_enet_get_pauseparam,
2699         .set_pauseparam         = fec_enet_set_pauseparam,
2700         .get_strings            = fec_enet_get_strings,
2701         .get_ethtool_stats      = fec_enet_get_ethtool_stats,
2702         .get_sset_count         = fec_enet_get_sset_count,
2703 #endif
2704         .get_ts_info            = fec_enet_get_ts_info,
2705         .get_tunable            = fec_enet_get_tunable,
2706         .set_tunable            = fec_enet_set_tunable,
2707         .get_wol                = fec_enet_get_wol,
2708         .set_wol                = fec_enet_set_wol,
2709         .get_link_ksettings     = phy_ethtool_get_link_ksettings,
2710         .set_link_ksettings     = phy_ethtool_set_link_ksettings,
2711 };
2712
2713 static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
2714 {
2715         struct fec_enet_private *fep = netdev_priv(ndev);
2716         struct phy_device *phydev = ndev->phydev;
2717
2718         if (!netif_running(ndev))
2719                 return -EINVAL;
2720
2721         if (!phydev)
2722                 return -ENODEV;
2723
2724         if (fep->bufdesc_ex) {
2725                 if (cmd == SIOCSHWTSTAMP)
2726                         return fec_ptp_set(ndev, rq);
2727                 if (cmd == SIOCGHWTSTAMP)
2728                         return fec_ptp_get(ndev, rq);
2729         }
2730
2731         return phy_mii_ioctl(phydev, rq, cmd);
2732 }
2733
2734 static void fec_enet_free_buffers(struct net_device *ndev)
2735 {
2736         struct fec_enet_private *fep = netdev_priv(ndev);
2737         unsigned int i;
2738         struct sk_buff *skb;
2739         struct bufdesc  *bdp;
2740         struct fec_enet_priv_tx_q *txq;
2741         struct fec_enet_priv_rx_q *rxq;
2742         unsigned int q;
2743
2744         for (q = 0; q < fep->num_rx_queues; q++) {
2745                 rxq = fep->rx_queue[q];
2746                 bdp = rxq->bd.base;
2747                 for (i = 0; i < rxq->bd.ring_size; i++) {
2748                         skb = rxq->rx_skbuff[i];
2749                         rxq->rx_skbuff[i] = NULL;
2750                         if (skb) {
2751                                 dma_unmap_single(&fep->pdev->dev,
2752                                                  fec32_to_cpu(bdp->cbd_bufaddr),
2753                                                  FEC_ENET_RX_FRSIZE - fep->rx_align,
2754                                                  DMA_FROM_DEVICE);
2755                                 dev_kfree_skb(skb);
2756                         }
2757                         bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
2758                 }
2759         }
2760
2761         for (q = 0; q < fep->num_tx_queues; q++) {
2762                 txq = fep->tx_queue[q];
2763                 for (i = 0; i < txq->bd.ring_size; i++) {
2764                         kfree(txq->tx_bounce[i]);
2765                         txq->tx_bounce[i] = NULL;
2766                         skb = txq->tx_skbuff[i];
2767                         txq->tx_skbuff[i] = NULL;
2768                         dev_kfree_skb(skb);
2769                 }
2770         }
2771 }
2772
2773 static void fec_enet_free_queue(struct net_device *ndev)
2774 {
2775         struct fec_enet_private *fep = netdev_priv(ndev);
2776         int i;
2777         struct fec_enet_priv_tx_q *txq;
2778
2779         for (i = 0; i < fep->num_tx_queues; i++)
2780                 if (fep->tx_queue[i] && fep->tx_queue[i]->tso_hdrs) {
2781                         txq = fep->tx_queue[i];
2782                         dma_free_coherent(&fep->pdev->dev,
2783                                           txq->bd.ring_size * TSO_HEADER_SIZE,
2784                                           txq->tso_hdrs,
2785                                           txq->tso_hdrs_dma);
2786                 }
2787
2788         for (i = 0; i < fep->num_rx_queues; i++)
2789                 kfree(fep->rx_queue[i]);
2790         for (i = 0; i < fep->num_tx_queues; i++)
2791                 kfree(fep->tx_queue[i]);
2792 }
2793
2794 static int fec_enet_alloc_queue(struct net_device *ndev)
2795 {
2796         struct fec_enet_private *fep = netdev_priv(ndev);
2797         int i;
2798         int ret = 0;
2799         struct fec_enet_priv_tx_q *txq;
2800
2801         for (i = 0; i < fep->num_tx_queues; i++) {
2802                 txq = kzalloc(sizeof(*txq), GFP_KERNEL);
2803                 if (!txq) {
2804                         ret = -ENOMEM;
2805                         goto alloc_failed;
2806                 }
2807
2808                 fep->tx_queue[i] = txq;
2809                 txq->bd.ring_size = TX_RING_SIZE;
2810                 fep->total_tx_ring_size += fep->tx_queue[i]->bd.ring_size;
2811
2812                 txq->tx_stop_threshold = FEC_MAX_SKB_DESCS;
2813                 txq->tx_wake_threshold =
2814                         (txq->bd.ring_size - txq->tx_stop_threshold) / 2;
2815
2816                 txq->tso_hdrs = dma_alloc_coherent(&fep->pdev->dev,
2817                                         txq->bd.ring_size * TSO_HEADER_SIZE,
2818                                         &txq->tso_hdrs_dma,
2819                                         GFP_KERNEL);
2820                 if (!txq->tso_hdrs) {
2821                         ret = -ENOMEM;
2822                         goto alloc_failed;
2823                 }
2824         }
2825
2826         for (i = 0; i < fep->num_rx_queues; i++) {
2827                 fep->rx_queue[i] = kzalloc(sizeof(*fep->rx_queue[i]),
2828                                            GFP_KERNEL);
2829                 if (!fep->rx_queue[i]) {
2830                         ret = -ENOMEM;
2831                         goto alloc_failed;
2832                 }
2833
2834                 fep->rx_queue[i]->bd.ring_size = RX_RING_SIZE;
2835                 fep->total_rx_ring_size += fep->rx_queue[i]->bd.ring_size;
2836         }
2837         return ret;
2838
2839 alloc_failed:
2840         fec_enet_free_queue(ndev);
2841         return ret;
2842 }
2843
2844 static int
2845 fec_enet_alloc_rxq_buffers(struct net_device *ndev, unsigned int queue)
2846 {
2847         struct fec_enet_private *fep = netdev_priv(ndev);
2848         unsigned int i;
2849         struct sk_buff *skb;
2850         struct bufdesc  *bdp;
2851         struct fec_enet_priv_rx_q *rxq;
2852
2853         rxq = fep->rx_queue[queue];
2854         bdp = rxq->bd.base;
2855         for (i = 0; i < rxq->bd.ring_size; i++) {
2856                 skb = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
2857                 if (!skb)
2858                         goto err_alloc;
2859
2860                 if (fec_enet_new_rxbdp(ndev, bdp, skb)) {
2861                         dev_kfree_skb(skb);
2862                         goto err_alloc;
2863                 }
2864
2865                 rxq->rx_skbuff[i] = skb;
2866                 bdp->cbd_sc = cpu_to_fec16(BD_ENET_RX_EMPTY);
2867
2868                 if (fep->bufdesc_ex) {
2869                         struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
2870                         ebdp->cbd_esc = cpu_to_fec32(BD_ENET_RX_INT);
2871                 }
2872
2873                 bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
2874         }
2875
2876         /* Set the last buffer to wrap. */
2877         bdp = fec_enet_get_prevdesc(bdp, &rxq->bd);
2878         bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
2879         return 0;
2880
2881  err_alloc:
2882         fec_enet_free_buffers(ndev);
2883         return -ENOMEM;
2884 }
2885
2886 static int
2887 fec_enet_alloc_txq_buffers(struct net_device *ndev, unsigned int queue)
2888 {
2889         struct fec_enet_private *fep = netdev_priv(ndev);
2890         unsigned int i;
2891         struct bufdesc  *bdp;
2892         struct fec_enet_priv_tx_q *txq;
2893
2894         txq = fep->tx_queue[queue];
2895         bdp = txq->bd.base;
2896         for (i = 0; i < txq->bd.ring_size; i++) {
2897                 txq->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
2898                 if (!txq->tx_bounce[i])
2899                         goto err_alloc;
2900
2901                 bdp->cbd_sc = cpu_to_fec16(0);
2902                 bdp->cbd_bufaddr = cpu_to_fec32(0);
2903
2904                 if (fep->bufdesc_ex) {
2905                         struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
2906                         ebdp->cbd_esc = cpu_to_fec32(BD_ENET_TX_INT);
2907                 }
2908
2909                 bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
2910         }
2911
2912         /* Set the last buffer to wrap. */
2913         bdp = fec_enet_get_prevdesc(bdp, &txq->bd);
2914         bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
2915
2916         return 0;
2917
2918  err_alloc:
2919         fec_enet_free_buffers(ndev);
2920         return -ENOMEM;
2921 }
2922
2923 static int fec_enet_alloc_buffers(struct net_device *ndev)
2924 {
2925         struct fec_enet_private *fep = netdev_priv(ndev);
2926         unsigned int i;
2927
2928         for (i = 0; i < fep->num_rx_queues; i++)
2929                 if (fec_enet_alloc_rxq_buffers(ndev, i))
2930                         return -ENOMEM;
2931
2932         for (i = 0; i < fep->num_tx_queues; i++)
2933                 if (fec_enet_alloc_txq_buffers(ndev, i))
2934                         return -ENOMEM;
2935         return 0;
2936 }
2937
2938 static int
2939 fec_enet_open(struct net_device *ndev)
2940 {
2941         struct fec_enet_private *fep = netdev_priv(ndev);
2942         int ret;
2943         bool reset_again;
2944
2945         ret = pm_runtime_get_sync(&fep->pdev->dev);
2946         if (ret < 0)
2947                 return ret;
2948
2949         pinctrl_pm_select_default_state(&fep->pdev->dev);
2950         ret = fec_enet_clk_enable(ndev, true);
2951         if (ret)
2952                 goto clk_enable;
2953
2954         /* During the first fec_enet_open call the PHY isn't probed at this
2955          * point. Therefore the phy_reset_after_clk_enable() call within
2956          * fec_enet_clk_enable() fails. As we need this reset in order to be
2957          * sure the PHY is working correctly we check if we need to reset again
2958          * later when the PHY is probed
2959          */
2960         if (ndev->phydev && ndev->phydev->drv)
2961                 reset_again = false;
2962         else
2963                 reset_again = true;
2964
2965         /* I should reset the ring buffers here, but I don't yet know
2966          * a simple way to do that.
2967          */
2968
2969         ret = fec_enet_alloc_buffers(ndev);
2970         if (ret)
2971                 goto err_enet_alloc;
2972
2973         /* Init MAC prior to mii bus probe */
2974         fec_restart(ndev);
2975
2976         /* Probe and connect to PHY when open the interface */
2977         ret = fec_enet_mii_probe(ndev);
2978         if (ret)
2979                 goto err_enet_mii_probe;
2980
2981         /* Call phy_reset_after_clk_enable() again if it failed during
2982          * phy_reset_after_clk_enable() before because the PHY wasn't probed.
2983          */
2984         if (reset_again)
2985                 phy_reset_after_clk_enable(ndev->phydev);
2986
2987         if (fep->quirks & FEC_QUIRK_ERR006687)
2988                 imx6q_cpuidle_fec_irqs_used();
2989
2990         napi_enable(&fep->napi);
2991         phy_start(ndev->phydev);
2992         netif_tx_start_all_queues(ndev);
2993
2994         device_set_wakeup_enable(&ndev->dev, fep->wol_flag &
2995                                  FEC_WOL_FLAG_ENABLE);
2996
2997         return 0;
2998
2999 err_enet_mii_probe:
3000         fec_enet_free_buffers(ndev);
3001 err_enet_alloc:
3002         fec_enet_clk_enable(ndev, false);
3003 clk_enable:
3004         pm_runtime_mark_last_busy(&fep->pdev->dev);
3005         pm_runtime_put_autosuspend(&fep->pdev->dev);
3006         pinctrl_pm_select_sleep_state(&fep->pdev->dev);
3007         return ret;
3008 }
3009
3010 static int
3011 fec_enet_close(struct net_device *ndev)
3012 {
3013         struct fec_enet_private *fep = netdev_priv(ndev);
3014
3015         phy_stop(ndev->phydev);
3016
3017         if (netif_device_present(ndev)) {
3018                 napi_disable(&fep->napi);
3019                 netif_tx_disable(ndev);
3020                 fec_stop(ndev);
3021         }
3022
3023         phy_disconnect(ndev->phydev);
3024
3025         if (fep->quirks & FEC_QUIRK_ERR006687)
3026                 imx6q_cpuidle_fec_irqs_unused();
3027
3028         fec_enet_update_ethtool_stats(ndev);
3029
3030         fec_enet_clk_enable(ndev, false);
3031         pinctrl_pm_select_sleep_state(&fep->pdev->dev);
3032         pm_runtime_mark_last_busy(&fep->pdev->dev);
3033         pm_runtime_put_autosuspend(&fep->pdev->dev);
3034
3035         fec_enet_free_buffers(ndev);
3036
3037         return 0;
3038 }
3039
3040 /* Set or clear the multicast filter for this adaptor.
3041  * Skeleton taken from sunlance driver.
3042  * The CPM Ethernet implementation allows Multicast as well as individual
3043  * MAC address filtering.  Some of the drivers check to make sure it is
3044  * a group multicast address, and discard those that are not.  I guess I
3045  * will do the same for now, but just remove the test if you want
3046  * individual filtering as well (do the upper net layers want or support
3047  * this kind of feature?).
3048  */
3049
3050 #define FEC_HASH_BITS   6               /* #bits in hash */
3051
3052 static void set_multicast_list(struct net_device *ndev)
3053 {
3054         struct fec_enet_private *fep = netdev_priv(ndev);
3055         struct netdev_hw_addr *ha;
3056         unsigned int crc, tmp;
3057         unsigned char hash;
3058         unsigned int hash_high = 0, hash_low = 0;
3059
3060         if (ndev->flags & IFF_PROMISC) {
3061                 tmp = readl(fep->hwp + FEC_R_CNTRL);
3062                 tmp |= 0x8;
3063                 writel(tmp, fep->hwp + FEC_R_CNTRL);
3064                 return;
3065         }
3066
3067         tmp = readl(fep->hwp + FEC_R_CNTRL);
3068         tmp &= ~0x8;
3069         writel(tmp, fep->hwp + FEC_R_CNTRL);
3070
3071         if (ndev->flags & IFF_ALLMULTI) {
3072                 /* Catch all multicast addresses, so set the
3073                  * filter to all 1's
3074                  */
3075                 writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
3076                 writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
3077
3078                 return;
3079         }
3080
3081         /* Add the addresses in hash register */
3082         netdev_for_each_mc_addr(ha, ndev) {
3083                 /* calculate crc32 value of mac address */
3084                 crc = ether_crc_le(ndev->addr_len, ha->addr);
3085
3086                 /* only upper 6 bits (FEC_HASH_BITS) are used
3087                  * which point to specific bit in the hash registers
3088                  */
3089                 hash = (crc >> (32 - FEC_HASH_BITS)) & 0x3f;
3090
3091                 if (hash > 31)
3092                         hash_high |= 1 << (hash - 32);
3093                 else
3094                         hash_low |= 1 << hash;
3095         }
3096
3097         writel(hash_high, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
3098         writel(hash_low, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
3099 }
3100
3101 /* Set a MAC change in hardware. */
3102 static int
3103 fec_set_mac_address(struct net_device *ndev, void *p)
3104 {
3105         struct fec_enet_private *fep = netdev_priv(ndev);
3106         struct sockaddr *addr = p;
3107
3108         if (addr) {
3109                 if (!is_valid_ether_addr(addr->sa_data))
3110                         return -EADDRNOTAVAIL;
3111                 memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
3112         }
3113
3114         /* Add netif status check here to avoid system hang in below case:
3115          * ifconfig ethx down; ifconfig ethx hw ether xx:xx:xx:xx:xx:xx;
3116          * After ethx down, fec all clocks are gated off and then register
3117          * access causes system hang.
3118          */
3119         if (!netif_running(ndev))
3120                 return 0;
3121
3122         writel(ndev->dev_addr[3] | (ndev->dev_addr[2] << 8) |
3123                 (ndev->dev_addr[1] << 16) | (ndev->dev_addr[0] << 24),
3124                 fep->hwp + FEC_ADDR_LOW);
3125         writel((ndev->dev_addr[5] << 16) | (ndev->dev_addr[4] << 24),
3126                 fep->hwp + FEC_ADDR_HIGH);
3127         return 0;
3128 }
3129
3130 #ifdef CONFIG_NET_POLL_CONTROLLER
3131 /**
3132  * fec_poll_controller - FEC Poll controller function
3133  * @dev: The FEC network adapter
3134  *
3135  * Polled functionality used by netconsole and others in non interrupt mode
3136  *
3137  */
3138 static void fec_poll_controller(struct net_device *dev)
3139 {
3140         int i;
3141         struct fec_enet_private *fep = netdev_priv(dev);
3142
3143         for (i = 0; i < FEC_IRQ_NUM; i++) {
3144                 if (fep->irq[i] > 0) {
3145                         disable_irq(fep->irq[i]);
3146                         fec_enet_interrupt(fep->irq[i], dev);
3147                         enable_irq(fep->irq[i]);
3148                 }
3149         }
3150 }
3151 #endif
3152
3153 static inline void fec_enet_set_netdev_features(struct net_device *netdev,
3154         netdev_features_t features)
3155 {
3156         struct fec_enet_private *fep = netdev_priv(netdev);
3157         netdev_features_t changed = features ^ netdev->features;
3158
3159         netdev->features = features;
3160
3161         /* Receive checksum has been changed */
3162         if (changed & NETIF_F_RXCSUM) {
3163                 if (features & NETIF_F_RXCSUM)
3164                         fep->csum_flags |= FLAG_RX_CSUM_ENABLED;
3165                 else
3166                         fep->csum_flags &= ~FLAG_RX_CSUM_ENABLED;
3167         }
3168 }
3169
3170 static int fec_set_features(struct net_device *netdev,
3171         netdev_features_t features)
3172 {
3173         struct fec_enet_private *fep = netdev_priv(netdev);
3174         netdev_features_t changed = features ^ netdev->features;
3175
3176         if (netif_running(netdev) && changed & NETIF_F_RXCSUM) {
3177                 napi_disable(&fep->napi);
3178                 netif_tx_lock_bh(netdev);
3179                 fec_stop(netdev);
3180                 fec_enet_set_netdev_features(netdev, features);
3181                 fec_restart(netdev);
3182                 netif_tx_wake_all_queues(netdev);
3183                 netif_tx_unlock_bh(netdev);
3184                 napi_enable(&fep->napi);
3185         } else {
3186                 fec_enet_set_netdev_features(netdev, features);
3187         }
3188
3189         return 0;
3190 }
3191
3192 static const struct net_device_ops fec_netdev_ops = {
3193         .ndo_open               = fec_enet_open,
3194         .ndo_stop               = fec_enet_close,
3195         .ndo_start_xmit         = fec_enet_start_xmit,
3196         .ndo_set_rx_mode        = set_multicast_list,
3197         .ndo_validate_addr      = eth_validate_addr,
3198         .ndo_tx_timeout         = fec_timeout,
3199         .ndo_set_mac_address    = fec_set_mac_address,
3200         .ndo_do_ioctl           = fec_enet_ioctl,
3201 #ifdef CONFIG_NET_POLL_CONTROLLER
3202         .ndo_poll_controller    = fec_poll_controller,
3203 #endif
3204         .ndo_set_features       = fec_set_features,
3205 };
3206
3207 static const unsigned short offset_des_active_rxq[] = {
3208         FEC_R_DES_ACTIVE_0, FEC_R_DES_ACTIVE_1, FEC_R_DES_ACTIVE_2
3209 };
3210
3211 static const unsigned short offset_des_active_txq[] = {
3212         FEC_X_DES_ACTIVE_0, FEC_X_DES_ACTIVE_1, FEC_X_DES_ACTIVE_2
3213 };
3214
3215  /*
3216   * XXX:  We need to clean up on failure exits here.
3217   *
3218   */
3219 static int fec_enet_init(struct net_device *ndev)
3220 {
3221         struct fec_enet_private *fep = netdev_priv(ndev);
3222         struct bufdesc *cbd_base;
3223         dma_addr_t bd_dma;
3224         int bd_size;
3225         unsigned int i;
3226         unsigned dsize = fep->bufdesc_ex ? sizeof(struct bufdesc_ex) :
3227                         sizeof(struct bufdesc);
3228         unsigned dsize_log2 = __fls(dsize);
3229         int ret;
3230
3231         WARN_ON(dsize != (1 << dsize_log2));
3232 #if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
3233         fep->rx_align = 0xf;
3234         fep->tx_align = 0xf;
3235 #else
3236         fep->rx_align = 0x3;
3237         fep->tx_align = 0x3;
3238 #endif
3239
3240         /* Check mask of the streaming and coherent API */
3241         ret = dma_set_mask_and_coherent(&fep->pdev->dev, DMA_BIT_MASK(32));
3242         if (ret < 0) {
3243                 dev_warn(&fep->pdev->dev, "No suitable DMA available\n");
3244                 return ret;
3245         }
3246
3247         fec_enet_alloc_queue(ndev);
3248
3249         bd_size = (fep->total_tx_ring_size + fep->total_rx_ring_size) * dsize;
3250
3251         /* Allocate memory for buffer descriptors. */
3252         cbd_base = dmam_alloc_coherent(&fep->pdev->dev, bd_size, &bd_dma,
3253                                        GFP_KERNEL);
3254         if (!cbd_base) {
3255                 return -ENOMEM;
3256         }
3257
3258         /* Get the Ethernet address */
3259         fec_get_mac(ndev);
3260         /* make sure MAC we just acquired is programmed into the hw */
3261         fec_set_mac_address(ndev, NULL);
3262
3263         /* Set receive and transmit descriptor base. */
3264         for (i = 0; i < fep->num_rx_queues; i++) {
3265                 struct fec_enet_priv_rx_q *rxq = fep->rx_queue[i];
3266                 unsigned size = dsize * rxq->bd.ring_size;
3267
3268                 rxq->bd.qid = i;
3269                 rxq->bd.base = cbd_base;
3270                 rxq->bd.cur = cbd_base;
3271                 rxq->bd.dma = bd_dma;
3272                 rxq->bd.dsize = dsize;
3273                 rxq->bd.dsize_log2 = dsize_log2;
3274                 rxq->bd.reg_desc_active = fep->hwp + offset_des_active_rxq[i];
3275                 bd_dma += size;
3276                 cbd_base = (struct bufdesc *)(((void *)cbd_base) + size);
3277                 rxq->bd.last = (struct bufdesc *)(((void *)cbd_base) - dsize);
3278         }
3279
3280         for (i = 0; i < fep->num_tx_queues; i++) {
3281                 struct fec_enet_priv_tx_q *txq = fep->tx_queue[i];
3282                 unsigned size = dsize * txq->bd.ring_size;
3283
3284                 txq->bd.qid = i;
3285                 txq->bd.base = cbd_base;
3286                 txq->bd.cur = cbd_base;
3287                 txq->bd.dma = bd_dma;
3288                 txq->bd.dsize = dsize;
3289                 txq->bd.dsize_log2 = dsize_log2;
3290                 txq->bd.reg_desc_active = fep->hwp + offset_des_active_txq[i];
3291                 bd_dma += size;
3292                 cbd_base = (struct bufdesc *)(((void *)cbd_base) + size);
3293                 txq->bd.last = (struct bufdesc *)(((void *)cbd_base) - dsize);
3294         }
3295
3296
3297         /* The FEC Ethernet specific entries in the device structure */
3298         ndev->watchdog_timeo = TX_TIMEOUT;
3299         ndev->netdev_ops = &fec_netdev_ops;
3300         ndev->ethtool_ops = &fec_enet_ethtool_ops;
3301
3302         writel(FEC_RX_DISABLED_IMASK, fep->hwp + FEC_IMASK);
3303         netif_napi_add(ndev, &fep->napi, fec_enet_rx_napi, NAPI_POLL_WEIGHT);
3304
3305         if (fep->quirks & FEC_QUIRK_HAS_VLAN)
3306                 /* enable hw VLAN support */
3307                 ndev->features |= NETIF_F_HW_VLAN_CTAG_RX;
3308
3309         if (fep->quirks & FEC_QUIRK_HAS_CSUM) {
3310                 ndev->gso_max_segs = FEC_MAX_TSO_SEGS;
3311
3312                 /* enable hw accelerator */
3313                 ndev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM
3314                                 | NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_TSO);
3315                 fep->csum_flags |= FLAG_RX_CSUM_ENABLED;
3316         }
3317
3318         if (fep->quirks & FEC_QUIRK_HAS_AVB) {
3319                 fep->tx_align = 0;
3320                 fep->rx_align = 0x3f;
3321         }
3322
3323         ndev->hw_features = ndev->features;
3324
3325         fec_restart(ndev);
3326
3327         if (fep->quirks & FEC_QUIRK_MIB_CLEAR)
3328                 fec_enet_clear_ethtool_stats(ndev);
3329         else
3330                 fec_enet_update_ethtool_stats(ndev);
3331
3332         return 0;
3333 }
3334
3335 #ifdef CONFIG_OF
3336 static int fec_reset_phy(struct platform_device *pdev)
3337 {
3338         int err, phy_reset;
3339         bool active_high = false;
3340         int msec = 1, phy_post_delay = 0;
3341         struct device_node *np = pdev->dev.of_node;
3342
3343         if (!np)
3344                 return 0;
3345
3346         err = of_property_read_u32(np, "phy-reset-duration", &msec);
3347         /* A sane reset duration should not be longer than 1s */
3348         if (!err && msec > 1000)
3349                 msec = 1;
3350
3351         phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0);
3352         if (phy_reset == -EPROBE_DEFER)
3353                 return phy_reset;
3354         else if (!gpio_is_valid(phy_reset))
3355                 return 0;
3356
3357         err = of_property_read_u32(np, "phy-reset-post-delay", &phy_post_delay);
3358         /* valid reset duration should be less than 1s */
3359         if (!err && phy_post_delay > 1000)
3360                 return -EINVAL;
3361
3362         active_high = of_property_read_bool(np, "phy-reset-active-high");
3363
3364         err = devm_gpio_request_one(&pdev->dev, phy_reset,
3365                         active_high ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
3366                         "phy-reset");
3367         if (err) {
3368                 dev_err(&pdev->dev, "failed to get phy-reset-gpios: %d\n", err);
3369                 return err;
3370         }
3371
3372         if (msec > 20)
3373                 msleep(msec);
3374         else
3375                 usleep_range(msec * 1000, msec * 1000 + 1000);
3376
3377         gpio_set_value_cansleep(phy_reset, !active_high);
3378
3379         if (!phy_post_delay)
3380                 return 0;
3381
3382         if (phy_post_delay > 20)
3383                 msleep(phy_post_delay);
3384         else
3385                 usleep_range(phy_post_delay * 1000,
3386                              phy_post_delay * 1000 + 1000);
3387
3388         return 0;
3389 }
3390 #else /* CONFIG_OF */
3391 static int fec_reset_phy(struct platform_device *pdev)
3392 {
3393         /*
3394          * In case of platform probe, the reset has been done
3395          * by machine code.
3396          */
3397         return 0;
3398 }
3399 #endif /* CONFIG_OF */
3400
3401 static void
3402 fec_enet_get_queue_num(struct platform_device *pdev, int *num_tx, int *num_rx)
3403 {
3404         struct device_node *np = pdev->dev.of_node;
3405
3406         *num_tx = *num_rx = 1;
3407
3408         if (!np || !of_device_is_available(np))
3409                 return;
3410
3411         /* parse the num of tx and rx queues */
3412         of_property_read_u32(np, "fsl,num-tx-queues", num_tx);
3413
3414         of_property_read_u32(np, "fsl,num-rx-queues", num_rx);
3415
3416         if (*num_tx < 1 || *num_tx > FEC_ENET_MAX_TX_QS) {
3417                 dev_warn(&pdev->dev, "Invalid num_tx(=%d), fall back to 1\n",
3418                          *num_tx);
3419                 *num_tx = 1;
3420                 return;
3421         }
3422
3423         if (*num_rx < 1 || *num_rx > FEC_ENET_MAX_RX_QS) {
3424                 dev_warn(&pdev->dev, "Invalid num_rx(=%d), fall back to 1\n",
3425                          *num_rx);
3426                 *num_rx = 1;
3427                 return;
3428         }
3429
3430 }
3431
3432 static int fec_enet_get_irq_cnt(struct platform_device *pdev)
3433 {
3434         int irq_cnt = platform_irq_count(pdev);
3435
3436         if (irq_cnt > FEC_IRQ_NUM)
3437                 irq_cnt = FEC_IRQ_NUM;  /* last for pps */
3438         else if (irq_cnt == 2)
3439                 irq_cnt = 1;    /* last for pps */
3440         else if (irq_cnt <= 0)
3441                 irq_cnt = 1;    /* At least 1 irq is needed */
3442         return irq_cnt;
3443 }
3444
3445 static int fec_enet_init_stop_mode(struct fec_enet_private *fep,
3446                                    struct device_node *np)
3447 {
3448         struct device_node *gpr_np;
3449         u32 out_val[3];
3450         int ret = 0;
3451
3452         gpr_np = of_parse_phandle(np, "fsl,stop-mode", 0);
3453         if (!gpr_np)
3454                 return 0;
3455
3456         ret = of_property_read_u32_array(np, "fsl,stop-mode", out_val,
3457                                          ARRAY_SIZE(out_val));
3458         if (ret) {
3459                 dev_dbg(&fep->pdev->dev, "no stop mode property\n");
3460                 return ret;
3461         }
3462
3463         fep->stop_gpr.gpr = syscon_node_to_regmap(gpr_np);
3464         if (IS_ERR(fep->stop_gpr.gpr)) {
3465                 dev_err(&fep->pdev->dev, "could not find gpr regmap\n");
3466                 ret = PTR_ERR(fep->stop_gpr.gpr);
3467                 fep->stop_gpr.gpr = NULL;
3468                 goto out;
3469         }
3470
3471         fep->stop_gpr.reg = out_val[1];
3472         fep->stop_gpr.bit = out_val[2];
3473
3474 out:
3475         of_node_put(gpr_np);
3476
3477         return ret;
3478 }
3479
3480 static int
3481 fec_probe(struct platform_device *pdev)
3482 {
3483         struct fec_enet_private *fep;
3484         struct fec_platform_data *pdata;
3485         phy_interface_t interface;
3486         struct net_device *ndev;
3487         int i, irq, ret = 0;
3488         const struct of_device_id *of_id;
3489         static int dev_id;
3490         struct device_node *np = pdev->dev.of_node, *phy_node;
3491         int num_tx_qs;
3492         int num_rx_qs;
3493         char irq_name[8];
3494         int irq_cnt;
3495         struct fec_devinfo *dev_info;
3496
3497         fec_enet_get_queue_num(pdev, &num_tx_qs, &num_rx_qs);
3498
3499         /* Init network device */
3500         ndev = alloc_etherdev_mqs(sizeof(struct fec_enet_private) +
3501                                   FEC_STATS_SIZE, num_tx_qs, num_rx_qs);
3502         if (!ndev)
3503                 return -ENOMEM;
3504
3505         SET_NETDEV_DEV(ndev, &pdev->dev);
3506
3507         /* setup board info structure */
3508         fep = netdev_priv(ndev);
3509
3510         of_id = of_match_device(fec_dt_ids, &pdev->dev);
3511         if (of_id)
3512                 pdev->id_entry = of_id->data;
3513         dev_info = (struct fec_devinfo *)pdev->id_entry->driver_data;
3514         if (dev_info)
3515                 fep->quirks = dev_info->quirks;
3516
3517         fep->netdev = ndev;
3518         fep->num_rx_queues = num_rx_qs;
3519         fep->num_tx_queues = num_tx_qs;
3520
3521 #if !defined(CONFIG_M5272)
3522         /* default enable pause frame auto negotiation */
3523         if (fep->quirks & FEC_QUIRK_HAS_GBIT)
3524                 fep->pause_flag |= FEC_PAUSE_FLAG_AUTONEG;
3525 #endif
3526
3527         /* Select default pin state */
3528         pinctrl_pm_select_default_state(&pdev->dev);
3529
3530         fep->hwp = devm_platform_ioremap_resource(pdev, 0);
3531         if (IS_ERR(fep->hwp)) {
3532                 ret = PTR_ERR(fep->hwp);
3533                 goto failed_ioremap;
3534         }
3535
3536         fep->pdev = pdev;
3537         fep->dev_id = dev_id++;
3538
3539         platform_set_drvdata(pdev, ndev);
3540
3541         if ((of_machine_is_compatible("fsl,imx6q") ||
3542              of_machine_is_compatible("fsl,imx6dl")) &&
3543             !of_property_read_bool(np, "fsl,err006687-workaround-present"))
3544                 fep->quirks |= FEC_QUIRK_ERR006687;
3545
3546         if (of_get_property(np, "fsl,magic-packet", NULL))
3547                 fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET;
3548
3549         ret = fec_enet_init_stop_mode(fep, np);
3550         if (ret)
3551                 goto failed_stop_mode;
3552
3553         phy_node = of_parse_phandle(np, "phy-handle", 0);
3554         if (!phy_node && of_phy_is_fixed_link(np)) {
3555                 ret = of_phy_register_fixed_link(np);
3556                 if (ret < 0) {
3557                         dev_err(&pdev->dev,
3558                                 "broken fixed-link specification\n");
3559                         goto failed_phy;
3560                 }
3561                 phy_node = of_node_get(np);
3562         }
3563         fep->phy_node = phy_node;
3564
3565         ret = of_get_phy_mode(pdev->dev.of_node, &interface);
3566         if (ret) {
3567                 pdata = dev_get_platdata(&pdev->dev);
3568                 if (pdata)
3569                         fep->phy_interface = pdata->phy;
3570                 else
3571                         fep->phy_interface = PHY_INTERFACE_MODE_MII;
3572         } else {
3573                 fep->phy_interface = interface;
3574         }
3575
3576         fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
3577         if (IS_ERR(fep->clk_ipg)) {
3578                 ret = PTR_ERR(fep->clk_ipg);
3579                 goto failed_clk;
3580         }
3581
3582         fep->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
3583         if (IS_ERR(fep->clk_ahb)) {
3584                 ret = PTR_ERR(fep->clk_ahb);
3585                 goto failed_clk;
3586         }
3587
3588         fep->itr_clk_rate = clk_get_rate(fep->clk_ahb);
3589
3590         /* enet_out is optional, depends on board */
3591         fep->clk_enet_out = devm_clk_get(&pdev->dev, "enet_out");
3592         if (IS_ERR(fep->clk_enet_out))
3593                 fep->clk_enet_out = NULL;
3594
3595         fep->ptp_clk_on = false;
3596         mutex_init(&fep->ptp_clk_mutex);
3597
3598         /* clk_ref is optional, depends on board */
3599         fep->clk_ref = devm_clk_get(&pdev->dev, "enet_clk_ref");
3600         if (IS_ERR(fep->clk_ref))
3601                 fep->clk_ref = NULL;
3602
3603         fep->bufdesc_ex = fep->quirks & FEC_QUIRK_HAS_BUFDESC_EX;
3604         fep->clk_ptp = devm_clk_get(&pdev->dev, "ptp");
3605         if (IS_ERR(fep->clk_ptp)) {
3606                 fep->clk_ptp = NULL;
3607                 fep->bufdesc_ex = false;
3608         }
3609
3610         ret = fec_enet_clk_enable(ndev, true);
3611         if (ret)
3612                 goto failed_clk;
3613
3614         ret = clk_prepare_enable(fep->clk_ipg);
3615         if (ret)
3616                 goto failed_clk_ipg;
3617         ret = clk_prepare_enable(fep->clk_ahb);
3618         if (ret)
3619                 goto failed_clk_ahb;
3620
3621         fep->reg_phy = devm_regulator_get_optional(&pdev->dev, "phy");
3622         if (!IS_ERR(fep->reg_phy)) {
3623                 ret = regulator_enable(fep->reg_phy);
3624                 if (ret) {
3625                         dev_err(&pdev->dev,
3626                                 "Failed to enable phy regulator: %d\n", ret);
3627                         goto failed_regulator;
3628                 }
3629         } else {
3630                 if (PTR_ERR(fep->reg_phy) == -EPROBE_DEFER) {
3631                         ret = -EPROBE_DEFER;
3632                         goto failed_regulator;
3633                 }
3634                 fep->reg_phy = NULL;
3635         }
3636
3637         pm_runtime_set_autosuspend_delay(&pdev->dev, FEC_MDIO_PM_TIMEOUT);
3638         pm_runtime_use_autosuspend(&pdev->dev);
3639         pm_runtime_get_noresume(&pdev->dev);
3640         pm_runtime_set_active(&pdev->dev);
3641         pm_runtime_enable(&pdev->dev);
3642
3643         ret = fec_reset_phy(pdev);
3644         if (ret)
3645                 goto failed_reset;
3646
3647         irq_cnt = fec_enet_get_irq_cnt(pdev);
3648         if (fep->bufdesc_ex)
3649                 fec_ptp_init(pdev, irq_cnt);
3650
3651         ret = fec_enet_init(ndev);
3652         if (ret)
3653                 goto failed_init;
3654
3655         for (i = 0; i < irq_cnt; i++) {
3656                 snprintf(irq_name, sizeof(irq_name), "int%d", i);
3657                 irq = platform_get_irq_byname_optional(pdev, irq_name);
3658                 if (irq < 0)
3659                         irq = platform_get_irq(pdev, i);
3660                 if (irq < 0) {
3661                         ret = irq;
3662                         goto failed_irq;
3663                 }
3664                 ret = devm_request_irq(&pdev->dev, irq, fec_enet_interrupt,
3665                                        0, pdev->name, ndev);
3666                 if (ret)
3667                         goto failed_irq;
3668
3669                 fep->irq[i] = irq;
3670         }
3671
3672         ret = fec_enet_mii_init(pdev);
3673         if (ret)
3674                 goto failed_mii_init;
3675
3676         /* Carrier starts down, phylib will bring it up */
3677         netif_carrier_off(ndev);
3678         fec_enet_clk_enable(ndev, false);
3679         pinctrl_pm_select_sleep_state(&pdev->dev);
3680
3681         ret = register_netdev(ndev);
3682         if (ret)
3683                 goto failed_register;
3684
3685         device_init_wakeup(&ndev->dev, fep->wol_flag &
3686                            FEC_WOL_HAS_MAGIC_PACKET);
3687
3688         if (fep->bufdesc_ex && fep->ptp_clock)
3689                 netdev_info(ndev, "registered PHC device %d\n", fep->dev_id);
3690
3691         fep->rx_copybreak = COPYBREAK_DEFAULT;
3692         INIT_WORK(&fep->tx_timeout_work, fec_enet_timeout_work);
3693
3694         pm_runtime_mark_last_busy(&pdev->dev);
3695         pm_runtime_put_autosuspend(&pdev->dev);
3696
3697         return 0;
3698
3699 failed_register:
3700         fec_enet_mii_remove(fep);
3701 failed_mii_init:
3702 failed_irq:
3703 failed_init:
3704         fec_ptp_stop(pdev);
3705         if (fep->reg_phy)
3706                 regulator_disable(fep->reg_phy);
3707 failed_reset:
3708         pm_runtime_put_noidle(&pdev->dev);
3709         pm_runtime_disable(&pdev->dev);
3710 failed_regulator:
3711         clk_disable_unprepare(fep->clk_ahb);
3712 failed_clk_ahb:
3713         clk_disable_unprepare(fep->clk_ipg);
3714 failed_clk_ipg:
3715         fec_enet_clk_enable(ndev, false);
3716 failed_clk:
3717         if (of_phy_is_fixed_link(np))
3718                 of_phy_deregister_fixed_link(np);
3719         of_node_put(phy_node);
3720 failed_stop_mode:
3721 failed_phy:
3722         dev_id--;
3723 failed_ioremap:
3724         free_netdev(ndev);
3725
3726         return ret;
3727 }
3728
3729 static int
3730 fec_drv_remove(struct platform_device *pdev)
3731 {
3732         struct net_device *ndev = platform_get_drvdata(pdev);
3733         struct fec_enet_private *fep = netdev_priv(ndev);
3734         struct device_node *np = pdev->dev.of_node;
3735         int ret;
3736
3737         ret = pm_runtime_get_sync(&pdev->dev);
3738         if (ret < 0)
3739                 return ret;
3740
3741         cancel_work_sync(&fep->tx_timeout_work);
3742         fec_ptp_stop(pdev);
3743         unregister_netdev(ndev);
3744         fec_enet_mii_remove(fep);
3745         if (fep->reg_phy)
3746                 regulator_disable(fep->reg_phy);
3747
3748         if (of_phy_is_fixed_link(np))
3749                 of_phy_deregister_fixed_link(np);
3750         of_node_put(fep->phy_node);
3751         free_netdev(ndev);
3752
3753         clk_disable_unprepare(fep->clk_ahb);
3754         clk_disable_unprepare(fep->clk_ipg);
3755         pm_runtime_put_noidle(&pdev->dev);
3756         pm_runtime_disable(&pdev->dev);
3757
3758         return 0;
3759 }
3760
3761 static int __maybe_unused fec_suspend(struct device *dev)
3762 {
3763         struct net_device *ndev = dev_get_drvdata(dev);
3764         struct fec_enet_private *fep = netdev_priv(ndev);
3765
3766         rtnl_lock();
3767         if (netif_running(ndev)) {
3768                 if (fep->wol_flag & FEC_WOL_FLAG_ENABLE)
3769                         fep->wol_flag |= FEC_WOL_FLAG_SLEEP_ON;
3770                 phy_stop(ndev->phydev);
3771                 napi_disable(&fep->napi);
3772                 netif_tx_lock_bh(ndev);
3773                 netif_device_detach(ndev);
3774                 netif_tx_unlock_bh(ndev);
3775                 fec_stop(ndev);
3776                 fec_enet_clk_enable(ndev, false);
3777                 if (!(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
3778                         pinctrl_pm_select_sleep_state(&fep->pdev->dev);
3779         }
3780         rtnl_unlock();
3781
3782         if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
3783                 regulator_disable(fep->reg_phy);
3784
3785         /* SOC supply clock to phy, when clock is disabled, phy link down
3786          * SOC control phy regulator, when regulator is disabled, phy link down
3787          */
3788         if (fep->clk_enet_out || fep->reg_phy)
3789                 fep->link = 0;
3790
3791         return 0;
3792 }
3793
3794 static int __maybe_unused fec_resume(struct device *dev)
3795 {
3796         struct net_device *ndev = dev_get_drvdata(dev);
3797         struct fec_enet_private *fep = netdev_priv(ndev);
3798         int ret;
3799         int val;
3800
3801         if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE)) {
3802                 ret = regulator_enable(fep->reg_phy);
3803                 if (ret)
3804                         return ret;
3805         }
3806
3807         rtnl_lock();
3808         if (netif_running(ndev)) {
3809                 ret = fec_enet_clk_enable(ndev, true);
3810                 if (ret) {
3811                         rtnl_unlock();
3812                         goto failed_clk;
3813                 }
3814                 if (fep->wol_flag & FEC_WOL_FLAG_ENABLE) {
3815                         fec_enet_stop_mode(fep, false);
3816
3817                         val = readl(fep->hwp + FEC_ECNTRL);
3818                         val &= ~(FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
3819                         writel(val, fep->hwp + FEC_ECNTRL);
3820                         fep->wol_flag &= ~FEC_WOL_FLAG_SLEEP_ON;
3821                 } else {
3822                         pinctrl_pm_select_default_state(&fep->pdev->dev);
3823                 }
3824                 fec_restart(ndev);
3825                 netif_tx_lock_bh(ndev);
3826                 netif_device_attach(ndev);
3827                 netif_tx_unlock_bh(ndev);
3828                 napi_enable(&fep->napi);
3829                 phy_start(ndev->phydev);
3830         }
3831         rtnl_unlock();
3832
3833         return 0;
3834
3835 failed_clk:
3836         if (fep->reg_phy)
3837                 regulator_disable(fep->reg_phy);
3838         return ret;
3839 }
3840
3841 static int __maybe_unused fec_runtime_suspend(struct device *dev)
3842 {
3843         struct net_device *ndev = dev_get_drvdata(dev);
3844         struct fec_enet_private *fep = netdev_priv(ndev);
3845
3846         clk_disable_unprepare(fep->clk_ahb);
3847         clk_disable_unprepare(fep->clk_ipg);
3848
3849         return 0;
3850 }
3851
3852 static int __maybe_unused fec_runtime_resume(struct device *dev)
3853 {
3854         struct net_device *ndev = dev_get_drvdata(dev);
3855         struct fec_enet_private *fep = netdev_priv(ndev);
3856         int ret;
3857
3858         ret = clk_prepare_enable(fep->clk_ahb);
3859         if (ret)
3860                 return ret;
3861         ret = clk_prepare_enable(fep->clk_ipg);
3862         if (ret)
3863                 goto failed_clk_ipg;
3864
3865         return 0;
3866
3867 failed_clk_ipg:
3868         clk_disable_unprepare(fep->clk_ahb);
3869         return ret;
3870 }
3871
3872 static const struct dev_pm_ops fec_pm_ops = {
3873         SET_SYSTEM_SLEEP_PM_OPS(fec_suspend, fec_resume)
3874         SET_RUNTIME_PM_OPS(fec_runtime_suspend, fec_runtime_resume, NULL)
3875 };
3876
3877 static struct platform_driver fec_driver = {
3878         .driver = {
3879                 .name   = DRIVER_NAME,
3880                 .pm     = &fec_pm_ops,
3881                 .of_match_table = fec_dt_ids,
3882                 .suppress_bind_attrs = true,
3883         },
3884         .id_table = fec_devtype,
3885         .probe  = fec_probe,
3886         .remove = fec_drv_remove,
3887 };
3888
3889 module_platform_driver(fec_driver);
3890
3891 MODULE_ALIAS("platform:"DRIVER_NAME);
3892 MODULE_LICENSE("GPL");