drivers/net/ethernet/cadence/macb_main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Cadence MACB/GEM Ethernet Controller driver
   4  *
   5  * Copyright (C) 2004-2006 Atmel Corporation
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9 #include <linux/clk.h>
  10 #include <linux/clk-provider.h>
  11 #include <linux/crc32.h>
  12 #include <linux/module.h>
  13 #include <linux/moduleparam.h>
  14 #include <linux/kernel.h>
  15 #include <linux/types.h>
  16 #include <linux/circ_buf.h>
  17 #include <linux/slab.h>
  18 #include <linux/init.h>
  19 #include <linux/io.h>
  20 #include <linux/gpio.h>
  21 #include <linux/gpio/consumer.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/netdevice.h>
  24 #include <linux/etherdevice.h>
  25 #include <linux/dma-mapping.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/phylink.h>
  28 #include <linux/of.h>
  29 #include <linux/of_device.h>
  30 #include <linux/of_gpio.h>
  31 #include <linux/of_mdio.h>
  32 #include <linux/of_net.h>
  33 #include <linux/ip.h>
  34 #include <linux/udp.h>
  35 #include <linux/tcp.h>
  36 #include <linux/iopoll.h>
  37 #include <linux/pm_runtime.h>
  38 #include "macb.h"
  39
  40 /* This structure is only used for MACB on SiFive FU540 devices */
  41 struct sifive_fu540_macb_mgmt {
  42         void __iomem *reg;
  43         unsigned long rate;
  44         struct clk_hw hw;
  45 };
  46
  47 #define MACB_RX_BUFFER_SIZE     128
  48 #define RX_BUFFER_MULTIPLE      64  /* bytes */
  49
  50 #define DEFAULT_RX_RING_SIZE    512 /* must be power of 2 */
  51 #define MIN_RX_RING_SIZE        64
  52 #define MAX_RX_RING_SIZE        8192
  53 #define RX_RING_BYTES(bp)       (macb_dma_desc_get_size(bp)     \
  54                                  * (bp)->rx_ring_size)
  55
  56 #define DEFAULT_TX_RING_SIZE    512 /* must be power of 2 */
  57 #define MIN_TX_RING_SIZE        64
  58 #define MAX_TX_RING_SIZE        4096
  59 #define TX_RING_BYTES(bp)       (macb_dma_desc_get_size(bp)     \
  60                                  * (bp)->tx_ring_size)
  61
  62 /* level of occupied TX descriptors under which we wake up TX process */
  63 #define MACB_TX_WAKEUP_THRESH(bp)       (3 * (bp)->tx_ring_size / 4)
  64
  65 #define MACB_RX_INT_FLAGS       (MACB_BIT(RCOMP) | MACB_BIT(ISR_ROVR))
  66 #define MACB_TX_ERR_FLAGS       (MACB_BIT(ISR_TUND)                     \
  67                                         | MACB_BIT(ISR_RLE)             \
  68                                         | MACB_BIT(TXERR))
  69 #define MACB_TX_INT_FLAGS       (MACB_TX_ERR_FLAGS | MACB_BIT(TCOMP)    \
  70                                         | MACB_BIT(TXUBR))
  71
  72 /* Max length of transmit frame must be a multiple of 8 bytes */
  73 #define MACB_TX_LEN_ALIGN       8
  74 #define MACB_MAX_TX_LEN         ((unsigned int)((1 << MACB_TX_FRMLEN_SIZE) - 1) & ~((unsigned int)(MACB_TX_LEN_ALIGN - 1)))
  75 /* Limit maximum TX length as per Cadence TSO errata. This is to avoid a
  76  * false amba_error in TX path from the DMA assuming there is not enough
  77  * space in the SRAM (16KB) even when there is.
  78  */
  79 #define GEM_MAX_TX_LEN          (unsigned int)(0x3FC0)
  80
  81 #define GEM_MTU_MIN_SIZE        ETH_MIN_MTU
  82 #define MACB_NETIF_LSO          NETIF_F_TSO
  83
  84 #define MACB_WOL_HAS_MAGIC_PACKET       (0x1 << 0)
  85 #define MACB_WOL_ENABLED                (0x1 << 1)
  86
  87 #define HS_SPEED_10000M                 4
  88 #define MACB_SERDES_RATE_10G            1
  89
  90 /* Graceful stop timeouts in us. We should allow up to
  91  * 1 frame time (10 Mbits/s, full-duplex, ignoring collisions)
  92  */
  93 #define MACB_HALT_TIMEOUT       1230
  94
  95 #define MACB_PM_TIMEOUT  100 /* ms */
  96
  97 #define MACB_MDIO_TIMEOUT       1000000 /* in usecs */
  98
  99 /* DMA buffer descriptor might be different size
 100  * depends on hardware configuration:
 101  *
 102  * 1. dma address width 32 bits:
 103  *    word 1: 32 bit address of Data Buffer
 104  *    word 2: control
 105  *
 106  * 2. dma address width 64 bits:
 107  *    word 1: 32 bit address of Data Buffer
 108  *    word 2: control
 109  *    word 3: upper 32 bit address of Data Buffer
 110  *    word 4: unused
 111  *
 112  * 3. dma address width 32 bits with hardware timestamping:
 113  *    word 1: 32 bit address of Data Buffer
 114  *    word 2: control
 115  *    word 3: timestamp word 1
 116  *    word 4: timestamp word 2
 117  *
 118  * 4. dma address width 64 bits with hardware timestamping:
 119  *    word 1: 32 bit address of Data Buffer
 120  *    word 2: control
 121  *    word 3: upper 32 bit address of Data Buffer
 122  *    word 4: unused
 123  *    word 5: timestamp word 1
 124  *    word 6: timestamp word 2
 125  */
 126 static unsigned int macb_dma_desc_get_size(struct macb *bp)
 127 {
 128 #ifdef MACB_EXT_DESC
 129         unsigned int desc_size;
 130
 131         switch (bp->hw_dma_cap) {
 132         case HW_DMA_CAP_64B:
 133                 desc_size = sizeof(struct macb_dma_desc)
 134                         + sizeof(struct macb_dma_desc_64);
 135                 break;
 136         case HW_DMA_CAP_PTP:
 137                 desc_size = sizeof(struct macb_dma_desc)
 138                         + sizeof(struct macb_dma_desc_ptp);
 139                 break;
 140         case HW_DMA_CAP_64B_PTP:
 141                 desc_size = sizeof(struct macb_dma_desc)
 142                         + sizeof(struct macb_dma_desc_64)
 143                         + sizeof(struct macb_dma_desc_ptp);
 144                 break;
 145         default:
 146                 desc_size = sizeof(struct macb_dma_desc);
 147         }
 148         return desc_size;
 149 #endif
 150         return sizeof(struct macb_dma_desc);
 151 }
 152
 153 static unsigned int macb_adj_dma_desc_idx(struct macb *bp, unsigned int desc_idx)
 154 {
 155 #ifdef MACB_EXT_DESC
 156         switch (bp->hw_dma_cap) {
 157         case HW_DMA_CAP_64B:
 158         case HW_DMA_CAP_PTP:
 159                 desc_idx <<= 1;
 160                 break;
 161         case HW_DMA_CAP_64B_PTP:
 162                 desc_idx *= 3;
 163                 break;
 164         default:
 165                 break;
 166         }
 167 #endif
 168         return desc_idx;
 169 }
 170
 171 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 172 static struct macb_dma_desc_64 *macb_64b_desc(struct macb *bp, struct macb_dma_desc *desc)
 173 {
 174         return (struct macb_dma_desc_64 *)((void *)desc
 175                 + sizeof(struct macb_dma_desc));
 176 }
 177 #endif
 178
 179 /* Ring buffer accessors */
 180 static unsigned int macb_tx_ring_wrap(struct macb *bp, unsigned int index)
 181 {
 182         return index & (bp->tx_ring_size - 1);
 183 }
 184
 185 static struct macb_dma_desc *macb_tx_desc(struct macb_queue *queue,
 186                                           unsigned int index)
 187 {
 188         index = macb_tx_ring_wrap(queue->bp, index);
 189         index = macb_adj_dma_desc_idx(queue->bp, index);
 190         return &queue->tx_ring[index];
 191 }
 192
 193 static struct macb_tx_skb *macb_tx_skb(struct macb_queue *queue,
 194                                        unsigned int index)
 195 {
 196         return &queue->tx_skb[macb_tx_ring_wrap(queue->bp, index)];
 197 }
 198
 199 static dma_addr_t macb_tx_dma(struct macb_queue *queue, unsigned int index)
 200 {
 201         dma_addr_t offset;
 202
 203         offset = macb_tx_ring_wrap(queue->bp, index) *
 204                         macb_dma_desc_get_size(queue->bp);
 205
 206         return queue->tx_ring_dma + offset;
 207 }
 208
 209 static unsigned int macb_rx_ring_wrap(struct macb *bp, unsigned int index)
 210 {
 211         return index & (bp->rx_ring_size - 1);
 212 }
 213
 214 static struct macb_dma_desc *macb_rx_desc(struct macb_queue *queue, unsigned int index)
 215 {
 216         index = macb_rx_ring_wrap(queue->bp, index);
 217         index = macb_adj_dma_desc_idx(queue->bp, index);
 218         return &queue->rx_ring[index];
 219 }
 220
 221 static void *macb_rx_buffer(struct macb_queue *queue, unsigned int index)
 222 {
 223         return queue->rx_buffers + queue->bp->rx_buffer_size *
 224                macb_rx_ring_wrap(queue->bp, index);
 225 }
 226
 227 /* I/O accessors */
 228 static u32 hw_readl_native(struct macb *bp, int offset)
 229 {
 230         return __raw_readl(bp->regs + offset);
 231 }
 232
 233 static void hw_writel_native(struct macb *bp, int offset, u32 value)
 234 {
 235         __raw_writel(value, bp->regs + offset);
 236 }
 237
 238 static u32 hw_readl(struct macb *bp, int offset)
 239 {
 240         return readl_relaxed(bp->regs + offset);
 241 }
 242
 243 static void hw_writel(struct macb *bp, int offset, u32 value)
 244 {
 245         writel_relaxed(value, bp->regs + offset);
 246 }
 247
 248 /* Find the CPU endianness by using the loopback bit of NCR register. When the
 249  * CPU is in big endian we need to program swapped mode for management
 250  * descriptor access.
 251  */
 252 static bool hw_is_native_io(void __iomem *addr)
 253 {
 254         u32 value = MACB_BIT(LLB);
 255
 256         __raw_writel(value, addr + MACB_NCR);
 257         value = __raw_readl(addr + MACB_NCR);
 258
 259         /* Write 0 back to disable everything */
 260         __raw_writel(0, addr + MACB_NCR);
 261
 262         return value == MACB_BIT(LLB);
 263 }
 264
 265 static bool hw_is_gem(void __iomem *addr, bool native_io)
 266 {
 267         u32 id;
 268
 269         if (native_io)
 270                 id = __raw_readl(addr + MACB_MID);
 271         else
 272                 id = readl_relaxed(addr + MACB_MID);
 273
 274         return MACB_BFEXT(IDNUM, id) >= 0x2;
 275 }
 276
 277 static void macb_set_hwaddr(struct macb *bp)
 278 {
 279         u32 bottom;
 280         u16 top;
 281
 282         bottom = cpu_to_le32(*((u32 *)bp->dev->dev_addr));
 283         macb_or_gem_writel(bp, SA1B, bottom);
 284         top = cpu_to_le16(*((u16 *)(bp->dev->dev_addr + 4)));
 285         macb_or_gem_writel(bp, SA1T, top);
 286
 287         /* Clear unused address register sets */
 288         macb_or_gem_writel(bp, SA2B, 0);
 289         macb_or_gem_writel(bp, SA2T, 0);
 290         macb_or_gem_writel(bp, SA3B, 0);
 291         macb_or_gem_writel(bp, SA3T, 0);
 292         macb_or_gem_writel(bp, SA4B, 0);
 293         macb_or_gem_writel(bp, SA4T, 0);
 294 }
 295
 296 static void macb_get_hwaddr(struct macb *bp)
 297 {
 298         u32 bottom;
 299         u16 top;
 300         u8 addr[6];
 301         int i;
 302
 303         /* Check all 4 address register for valid address */
 304         for (i = 0; i < 4; i++) {
 305                 bottom = macb_or_gem_readl(bp, SA1B + i * 8);
 306                 top = macb_or_gem_readl(bp, SA1T + i * 8);
 307
 308                 addr[0] = bottom & 0xff;
 309                 addr[1] = (bottom >> 8) & 0xff;
 310                 addr[2] = (bottom >> 16) & 0xff;
 311                 addr[3] = (bottom >> 24) & 0xff;
 312                 addr[4] = top & 0xff;
 313                 addr[5] = (top >> 8) & 0xff;
 314
 315                 if (is_valid_ether_addr(addr)) {
 316                         memcpy(bp->dev->dev_addr, addr, sizeof(addr));
 317                         return;
 318                 }
 319         }
 320
 321         dev_info(&bp->pdev->dev, "invalid hw address, using random\n");
 322         eth_hw_addr_random(bp->dev);
 323 }
 324
 325 static int macb_mdio_wait_for_idle(struct macb *bp)
 326 {
 327         u32 val;
 328
 329         return readx_poll_timeout(MACB_READ_NSR, bp, val, val & MACB_BIT(IDLE),
 330                                   1, MACB_MDIO_TIMEOUT);
 331 }
 332
 333 static int macb_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 334 {
 335         struct macb *bp = bus->priv;
 336         int status;
 337
 338         status = pm_runtime_get_sync(&bp->pdev->dev);
 339         if (status < 0) {
 340                 pm_runtime_put_noidle(&bp->pdev->dev);
 341                 goto mdio_pm_exit;
 342         }
 343
 344         status = macb_mdio_wait_for_idle(bp);
 345         if (status < 0)
 346                 goto mdio_read_exit;
 347
 348         if (regnum & MII_ADDR_C45) {
 349                 macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
 350                             | MACB_BF(RW, MACB_MAN_C45_ADDR)
 351                             | MACB_BF(PHYA, mii_id)
 352                             | MACB_BF(REGA, (regnum >> 16) & 0x1F)
 353                             | MACB_BF(DATA, regnum & 0xFFFF)
 354                             | MACB_BF(CODE, MACB_MAN_C45_CODE)));
 355
 356                 status = macb_mdio_wait_for_idle(bp);
 357                 if (status < 0)
 358                         goto mdio_read_exit;
 359
 360                 macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
 361                             | MACB_BF(RW, MACB_MAN_C45_READ)
 362                             | MACB_BF(PHYA, mii_id)
 363                             | MACB_BF(REGA, (regnum >> 16) & 0x1F)
 364                             | MACB_BF(CODE, MACB_MAN_C45_CODE)));
 365         } else {
 366                 macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C22_SOF)
 367                                 | MACB_BF(RW, MACB_MAN_C22_READ)
 368                                 | MACB_BF(PHYA, mii_id)
 369                                 | MACB_BF(REGA, regnum)
 370                                 | MACB_BF(CODE, MACB_MAN_C22_CODE)));
 371         }
 372
 373         status = macb_mdio_wait_for_idle(bp);
 374         if (status < 0)
 375                 goto mdio_read_exit;
 376
 377         status = MACB_BFEXT(DATA, macb_readl(bp, MAN));
 378
 379 mdio_read_exit:
 380         pm_runtime_mark_last_busy(&bp->pdev->dev);
 381         pm_runtime_put_autosuspend(&bp->pdev->dev);
 382 mdio_pm_exit:
 383         return status;
 384 }
 385
 386 static int macb_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
 387                            u16 value)
 388 {
 389         struct macb *bp = bus->priv;
 390         int status;
 391
 392         status = pm_runtime_get_sync(&bp->pdev->dev);
 393         if (status < 0) {
 394                 pm_runtime_put_noidle(&bp->pdev->dev);
 395                 goto mdio_pm_exit;
 396         }
 397
 398         status = macb_mdio_wait_for_idle(bp);
 399         if (status < 0)
 400                 goto mdio_write_exit;
 401
 402         if (regnum & MII_ADDR_C45) {
 403                 macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
 404                             | MACB_BF(RW, MACB_MAN_C45_ADDR)
 405                             | MACB_BF(PHYA, mii_id)
 406                             | MACB_BF(REGA, (regnum >> 16) & 0x1F)
 407                             | MACB_BF(DATA, regnum & 0xFFFF)
 408                             | MACB_BF(CODE, MACB_MAN_C45_CODE)));
 409
 410                 status = macb_mdio_wait_for_idle(bp);
 411                 if (status < 0)
 412                         goto mdio_write_exit;
 413
 414                 macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
 415                             | MACB_BF(RW, MACB_MAN_C45_WRITE)
 416                             | MACB_BF(PHYA, mii_id)
 417                             | MACB_BF(REGA, (regnum >> 16) & 0x1F)
 418                             | MACB_BF(CODE, MACB_MAN_C45_CODE)
 419                             | MACB_BF(DATA, value)));
 420         } else {
 421                 macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C22_SOF)
 422                                 | MACB_BF(RW, MACB_MAN_C22_WRITE)
 423                                 | MACB_BF(PHYA, mii_id)
 424                                 | MACB_BF(REGA, regnum)
 425                                 | MACB_BF(CODE, MACB_MAN_C22_CODE)
 426                                 | MACB_BF(DATA, value)));
 427         }
 428
 429         status = macb_mdio_wait_for_idle(bp);
 430         if (status < 0)
 431                 goto mdio_write_exit;
 432
 433 mdio_write_exit:
 434         pm_runtime_mark_last_busy(&bp->pdev->dev);
 435         pm_runtime_put_autosuspend(&bp->pdev->dev);
 436 mdio_pm_exit:
 437         return status;
 438 }
 439
 440 static void macb_init_buffers(struct macb *bp)
 441 {
 442         struct macb_queue *queue;
 443         unsigned int q;
 444
 445         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
 446                 queue_writel(queue, RBQP, lower_32_bits(queue->rx_ring_dma));
 447 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 448                 if (bp->hw_dma_cap & HW_DMA_CAP_64B)
 449                         queue_writel(queue, RBQPH,
 450                                      upper_32_bits(queue->rx_ring_dma));
 451 #endif
 452                 queue_writel(queue, TBQP, lower_32_bits(queue->tx_ring_dma));
 453 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 454                 if (bp->hw_dma_cap & HW_DMA_CAP_64B)
 455                         queue_writel(queue, TBQPH,
 456                                      upper_32_bits(queue->tx_ring_dma));
 457 #endif
 458         }
 459 }
 460
 461 /**
 462  * macb_set_tx_clk() - Set a clock to a new frequency
 463  * @bp:         pointer to struct macb
 464  * @speed:      New frequency in Hz
 465  */
 466 static void macb_set_tx_clk(struct macb *bp, int speed)
 467 {
 468         long ferr, rate, rate_rounded;
 469
 470         if (!bp->tx_clk || (bp->caps & MACB_CAPS_CLK_HW_CHG))
 471                 return;
 472
 473         /* In case of MII the PHY is the clock master */
 474         if (bp->phy_interface == PHY_INTERFACE_MODE_MII)
 475                 return;
 476
 477         switch (speed) {
 478         case SPEED_10:
 479                 rate = 2500000;
 480                 break;
 481         case SPEED_100:
 482                 rate = 25000000;
 483                 break;
 484         case SPEED_1000:
 485                 rate = 125000000;
 486                 break;
 487         default:
 488                 return;
 489         }
 490
 491         rate_rounded = clk_round_rate(bp->tx_clk, rate);
 492         if (rate_rounded < 0)
 493                 return;
 494
 495         /* RGMII allows 50 ppm frequency error. Test and warn if this limit
 496          * is not satisfied.
 497          */
 498         ferr = abs(rate_rounded - rate);
 499         ferr = DIV_ROUND_UP(ferr, rate / 100000);
 500         if (ferr > 5)
 501                 netdev_warn(bp->dev,
 502                             "unable to generate target frequency: %ld Hz\n",
 503                             rate);
 504
 505         if (clk_set_rate(bp->tx_clk, rate_rounded))
 506                 netdev_err(bp->dev, "adjusting tx_clk failed.\n");
 507 }
 508
 509 static void macb_validate(struct phylink_config *config,
 510                           unsigned long *supported,
 511                           struct phylink_link_state *state)
 512 {
 513         struct net_device *ndev = to_net_dev(config->dev);
 514         __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
 515         struct macb *bp = netdev_priv(ndev);
 516
 517         /* We only support MII, RMII, GMII, RGMII & SGMII. */
 518         if (state->interface != PHY_INTERFACE_MODE_NA &&
 519             state->interface != PHY_INTERFACE_MODE_MII &&
 520             state->interface != PHY_INTERFACE_MODE_RMII &&
 521             state->interface != PHY_INTERFACE_MODE_GMII &&
 522             state->interface != PHY_INTERFACE_MODE_SGMII &&
 523             state->interface != PHY_INTERFACE_MODE_10GBASER &&
 524             !phy_interface_mode_is_rgmii(state->interface)) {
 525                 bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
 526                 return;
 527         }
 528
 529         if (!macb_is_gem(bp) &&
 530             (state->interface == PHY_INTERFACE_MODE_GMII ||
 531              phy_interface_mode_is_rgmii(state->interface))) {
 532                 bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
 533                 return;
 534         }
 535
 536         if (state->interface == PHY_INTERFACE_MODE_10GBASER &&
 537             !(bp->caps & MACB_CAPS_HIGH_SPEED &&
 538               bp->caps & MACB_CAPS_PCS)) {
 539                 bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
 540                 return;
 541         }
 542
 543         phylink_set_port_modes(mask);
 544         phylink_set(mask, Autoneg);
 545         phylink_set(mask, Asym_Pause);
 546
 547         if (bp->caps & MACB_CAPS_GIGABIT_MODE_AVAILABLE &&
 548             (state->interface == PHY_INTERFACE_MODE_NA ||
 549              state->interface == PHY_INTERFACE_MODE_10GBASER)) {
 550                 phylink_set(mask, 10000baseCR_Full);
 551                 phylink_set(mask, 10000baseER_Full);
 552                 phylink_set(mask, 10000baseKR_Full);
 553                 phylink_set(mask, 10000baseLR_Full);
 554                 phylink_set(mask, 10000baseLRM_Full);
 555                 phylink_set(mask, 10000baseSR_Full);
 556                 phylink_set(mask, 10000baseT_Full);
 557                 if (state->interface != PHY_INTERFACE_MODE_NA)
 558                         goto out;
 559         }
 560
 561         phylink_set(mask, 10baseT_Half);
 562         phylink_set(mask, 10baseT_Full);
 563         phylink_set(mask, 100baseT_Half);
 564         phylink_set(mask, 100baseT_Full);
 565
 566         if (bp->caps & MACB_CAPS_GIGABIT_MODE_AVAILABLE &&
 567             (state->interface == PHY_INTERFACE_MODE_NA ||
 568              state->interface == PHY_INTERFACE_MODE_GMII ||
 569              state->interface == PHY_INTERFACE_MODE_SGMII ||
 570              phy_interface_mode_is_rgmii(state->interface))) {
 571                 phylink_set(mask, 1000baseT_Full);
 572                 phylink_set(mask, 1000baseX_Full);
 573
 574                 if (!(bp->caps & MACB_CAPS_NO_GIGABIT_HALF))
 575                         phylink_set(mask, 1000baseT_Half);
 576         }
 577 out:
 578         bitmap_and(supported, supported, mask, __ETHTOOL_LINK_MODE_MASK_NBITS);
 579         bitmap_and(state->advertising, state->advertising, mask,
 580                    __ETHTOOL_LINK_MODE_MASK_NBITS);
 581 }
 582
 583 static void macb_usx_pcs_link_up(struct phylink_pcs *pcs, unsigned int mode,
 584                                  phy_interface_t interface, int speed,
 585                                  int duplex)
 586 {
 587         struct macb *bp = container_of(pcs, struct macb, phylink_pcs);
 588         u32 config;
 589
 590         config = gem_readl(bp, USX_CONTROL);
 591         config = GEM_BFINS(SERDES_RATE, MACB_SERDES_RATE_10G, config);
 592         config = GEM_BFINS(USX_CTRL_SPEED, HS_SPEED_10000M, config);
 593         config &= ~(GEM_BIT(TX_SCR_BYPASS) | GEM_BIT(RX_SCR_BYPASS));
 594         config |= GEM_BIT(TX_EN);
 595         gem_writel(bp, USX_CONTROL, config);
 596 }
 597
 598 static void macb_usx_pcs_get_state(struct phylink_pcs *pcs,
 599                                    struct phylink_link_state *state)
 600 {
 601         struct macb *bp = container_of(pcs, struct macb, phylink_pcs);
 602         u32 val;
 603
 604         state->speed = SPEED_10000;
 605         state->duplex = 1;
 606         state->an_complete = 1;
 607
 608         val = gem_readl(bp, USX_STATUS);
 609         state->link = !!(val & GEM_BIT(USX_BLOCK_LOCK));
 610         val = gem_readl(bp, NCFGR);
 611         if (val & GEM_BIT(PAE))
 612                 state->pause = MLO_PAUSE_RX;
 613 }
 614
 615 static int macb_usx_pcs_config(struct phylink_pcs *pcs,
 616                                unsigned int mode,
 617                                phy_interface_t interface,
 618                                const unsigned long *advertising,
 619                                bool permit_pause_to_mac)
 620 {
 621         struct macb *bp = container_of(pcs, struct macb, phylink_pcs);
 622
 623         gem_writel(bp, USX_CONTROL, gem_readl(bp, USX_CONTROL) |
 624                    GEM_BIT(SIGNAL_OK));
 625
 626         return 0;
 627 }
 628
 629 static void macb_pcs_get_state(struct phylink_pcs *pcs,
 630                                struct phylink_link_state *state)
 631 {
 632         state->link = 0;
 633 }
 634
 635 static void macb_pcs_an_restart(struct phylink_pcs *pcs)
 636 {
 637         /* Not supported */
 638 }
 639
 640 static int macb_pcs_config(struct phylink_pcs *pcs,
 641                            unsigned int mode,
 642                            phy_interface_t interface,
 643                            const unsigned long *advertising,
 644                            bool permit_pause_to_mac)
 645 {
 646         return 0;
 647 }
 648
 649 static const struct phylink_pcs_ops macb_phylink_usx_pcs_ops = {
 650         .pcs_get_state = macb_usx_pcs_get_state,
 651         .pcs_config = macb_usx_pcs_config,
 652         .pcs_link_up = macb_usx_pcs_link_up,
 653 };
 654
 655 static const struct phylink_pcs_ops macb_phylink_pcs_ops = {
 656         .pcs_get_state = macb_pcs_get_state,
 657         .pcs_an_restart = macb_pcs_an_restart,
 658         .pcs_config = macb_pcs_config,
 659 };
 660
 661 static void macb_mac_config(struct phylink_config *config, unsigned int mode,
 662                             const struct phylink_link_state *state)
 663 {
 664         struct net_device *ndev = to_net_dev(config->dev);
 665         struct macb *bp = netdev_priv(ndev);
 666         unsigned long flags;
 667         u32 old_ctrl, ctrl;
 668         u32 old_ncr, ncr;
 669
 670         spin_lock_irqsave(&bp->lock, flags);
 671
 672         old_ctrl = ctrl = macb_or_gem_readl(bp, NCFGR);
 673         old_ncr = ncr = macb_or_gem_readl(bp, NCR);
 674
 675         if (bp->caps & MACB_CAPS_MACB_IS_EMAC) {
 676                 if (state->interface == PHY_INTERFACE_MODE_RMII)
 677                         ctrl |= MACB_BIT(RM9200_RMII);
 678         } else if (macb_is_gem(bp)) {
 679                 ctrl &= ~(GEM_BIT(SGMIIEN) | GEM_BIT(PCSSEL));
 680                 ncr &= ~GEM_BIT(ENABLE_HS_MAC);
 681
 682                 if (state->interface == PHY_INTERFACE_MODE_SGMII) {
 683                         ctrl |= GEM_BIT(SGMIIEN) | GEM_BIT(PCSSEL);
 684                 } else if (state->interface == PHY_INTERFACE_MODE_10GBASER) {
 685                         ctrl |= GEM_BIT(PCSSEL);
 686                         ncr |= GEM_BIT(ENABLE_HS_MAC);
 687                 }
 688         }
 689
 690         /* Apply the new configuration, if any */
 691         if (old_ctrl ^ ctrl)
 692                 macb_or_gem_writel(bp, NCFGR, ctrl);
 693
 694         if (old_ncr ^ ncr)
 695                 macb_or_gem_writel(bp, NCR, ncr);
 696
 697         /* Disable AN for SGMII fixed link configuration, enable otherwise.
 698          * Must be written after PCSSEL is set in NCFGR,
 699          * otherwise writes will not take effect.
 700          */
 701         if (macb_is_gem(bp) && state->interface == PHY_INTERFACE_MODE_SGMII) {
 702                 u32 pcsctrl, old_pcsctrl;
 703
 704                 old_pcsctrl = gem_readl(bp, PCSCNTRL);
 705                 if (mode == MLO_AN_FIXED)
 706                         pcsctrl = old_pcsctrl & ~GEM_BIT(PCSAUTONEG);
 707                 else
 708                         pcsctrl = old_pcsctrl | GEM_BIT(PCSAUTONEG);
 709                 if (old_pcsctrl != pcsctrl)
 710                         gem_writel(bp, PCSCNTRL, pcsctrl);
 711         }
 712
 713         spin_unlock_irqrestore(&bp->lock, flags);
 714 }
 715
 716 static void macb_mac_link_down(struct phylink_config *config, unsigned int mode,
 717                                phy_interface_t interface)
 718 {
 719         struct net_device *ndev = to_net_dev(config->dev);
 720         struct macb *bp = netdev_priv(ndev);
 721         struct macb_queue *queue;
 722         unsigned int q;
 723         u32 ctrl;
 724
 725         if (!(bp->caps & MACB_CAPS_MACB_IS_EMAC))
 726                 for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
 727                         queue_writel(queue, IDR,
 728                                      bp->rx_intr_mask | MACB_TX_INT_FLAGS | MACB_BIT(HRESP));
 729
 730         /* Disable Rx and Tx */
 731         ctrl = macb_readl(bp, NCR) & ~(MACB_BIT(RE) | MACB_BIT(TE));
 732         macb_writel(bp, NCR, ctrl);
 733
 734         netif_tx_stop_all_queues(ndev);
 735 }
 736
 737 static void macb_mac_link_up(struct phylink_config *config,
 738                              struct phy_device *phy,
 739                              unsigned int mode, phy_interface_t interface,
 740                              int speed, int duplex,
 741                              bool tx_pause, bool rx_pause)
 742 {
 743         struct net_device *ndev = to_net_dev(config->dev);
 744         struct macb *bp = netdev_priv(ndev);
 745         struct macb_queue *queue;
 746         unsigned long flags;
 747         unsigned int q;
 748         u32 ctrl;
 749
 750         spin_lock_irqsave(&bp->lock, flags);
 751
 752         ctrl = macb_or_gem_readl(bp, NCFGR);
 753
 754         ctrl &= ~(MACB_BIT(SPD) | MACB_BIT(FD));
 755
 756         if (speed == SPEED_100)
 757                 ctrl |= MACB_BIT(SPD);
 758
 759         if (duplex)
 760                 ctrl |= MACB_BIT(FD);
 761
 762         if (!(bp->caps & MACB_CAPS_MACB_IS_EMAC)) {
 763                 ctrl &= ~MACB_BIT(PAE);
 764                 if (macb_is_gem(bp)) {
 765                         ctrl &= ~GEM_BIT(GBE);
 766
 767                         if (speed == SPEED_1000)
 768                                 ctrl |= GEM_BIT(GBE);
 769                 }
 770
 771                 if (rx_pause)
 772                         ctrl |= MACB_BIT(PAE);
 773
 774                 macb_set_tx_clk(bp, speed);
 775
 776                 /* Initialize rings & buffers as clearing MACB_BIT(TE) in link down
 777                  * cleared the pipeline and control registers.
 778                  */
 779                 bp->macbgem_ops.mog_init_rings(bp);
 780                 macb_init_buffers(bp);
 781
 782                 for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
 783                         queue_writel(queue, IER,
 784                                      bp->rx_intr_mask | MACB_TX_INT_FLAGS | MACB_BIT(HRESP));
 785         }
 786
 787         macb_or_gem_writel(bp, NCFGR, ctrl);
 788
 789         if (bp->phy_interface == PHY_INTERFACE_MODE_10GBASER)
 790                 gem_writel(bp, HS_MAC_CONFIG, GEM_BFINS(HS_MAC_SPEED, HS_SPEED_10000M,
 791                                                         gem_readl(bp, HS_MAC_CONFIG)));
 792
 793         spin_unlock_irqrestore(&bp->lock, flags);
 794
 795         /* Enable Rx and Tx */
 796         macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(RE) | MACB_BIT(TE));
 797
 798         netif_tx_wake_all_queues(ndev);
 799 }
 800
 801 static int macb_mac_prepare(struct phylink_config *config, unsigned int mode,
 802                             phy_interface_t interface)
 803 {
 804         struct net_device *ndev = to_net_dev(config->dev);
 805         struct macb *bp = netdev_priv(ndev);
 806
 807         if (interface == PHY_INTERFACE_MODE_10GBASER)
 808                 bp->phylink_pcs.ops = &macb_phylink_usx_pcs_ops;
 809         else if (interface == PHY_INTERFACE_MODE_SGMII)
 810                 bp->phylink_pcs.ops = &macb_phylink_pcs_ops;
 811         else
 812                 bp->phylink_pcs.ops = NULL;
 813
 814         if (bp->phylink_pcs.ops)
 815                 phylink_set_pcs(bp->phylink, &bp->phylink_pcs);
 816
 817         return 0;
 818 }
 819
 820 static const struct phylink_mac_ops macb_phylink_ops = {
 821         .validate = macb_validate,
 822         .mac_prepare = macb_mac_prepare,
 823         .mac_config = macb_mac_config,
 824         .mac_link_down = macb_mac_link_down,
 825         .mac_link_up = macb_mac_link_up,
 826 };
 827
 828 static bool macb_phy_handle_exists(struct device_node *dn)
 829 {
 830         dn = of_parse_phandle(dn, "phy-handle", 0);
 831         of_node_put(dn);
 832         return dn != NULL;
 833 }
 834
 835 static int macb_phylink_connect(struct macb *bp)
 836 {
 837         struct device_node *dn = bp->pdev->dev.of_node;
 838         struct net_device *dev = bp->dev;
 839         struct phy_device *phydev;
 840         int ret;
 841
 842         if (dn)
 843                 ret = phylink_of_phy_connect(bp->phylink, dn, 0);
 844
 845         if (!dn || (ret && !macb_phy_handle_exists(dn))) {
 846                 phydev = phy_find_first(bp->mii_bus);
 847                 if (!phydev) {
 848                         netdev_err(dev, "no PHY found\n");
 849                         return -ENXIO;
 850                 }
 851
 852                 /* attach the mac to the phy */
 853                 ret = phylink_connect_phy(bp->phylink, phydev);
 854         }
 855
 856         if (ret) {
 857                 netdev_err(dev, "Could not attach PHY (%d)\n", ret);
 858                 return ret;
 859         }
 860
 861         phylink_start(bp->phylink);
 862
 863         return 0;
 864 }
 865
 866 static void macb_get_pcs_fixed_state(struct phylink_config *config,
 867                                      struct phylink_link_state *state)
 868 {
 869         struct net_device *ndev = to_net_dev(config->dev);
 870         struct macb *bp = netdev_priv(ndev);
 871
 872         state->link = (macb_readl(bp, NSR) & MACB_BIT(NSR_LINK)) != 0;
 873 }
 874
 875 /* based on au1000_eth. c*/
 876 static int macb_mii_probe(struct net_device *dev)
 877 {
 878         struct macb *bp = netdev_priv(dev);
 879
 880         bp->phylink_config.dev = &dev->dev;
 881         bp->phylink_config.type = PHYLINK_NETDEV;
 882
 883         if (bp->phy_interface == PHY_INTERFACE_MODE_SGMII) {
 884                 bp->phylink_config.poll_fixed_state = true;
 885                 bp->phylink_config.get_fixed_state = macb_get_pcs_fixed_state;
 886         }
 887
 888         bp->phylink = phylink_create(&bp->phylink_config, bp->pdev->dev.fwnode,
 889                                      bp->phy_interface, &macb_phylink_ops);
 890         if (IS_ERR(bp->phylink)) {
 891                 netdev_err(dev, "Could not create a phylink instance (%ld)\n",
 892                            PTR_ERR(bp->phylink));
 893                 return PTR_ERR(bp->phylink);
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int macb_mdiobus_register(struct macb *bp)
 900 {
 901         struct device_node *child, *np = bp->pdev->dev.of_node;
 902
 903         if (of_phy_is_fixed_link(np))
 904                 return mdiobus_register(bp->mii_bus);
 905
 906         /* Only create the PHY from the device tree if at least one PHY is
 907          * described. Otherwise scan the entire MDIO bus. We do this to support
 908          * old device tree that did not follow the best practices and did not
 909          * describe their network PHYs.
 910          */
 911         for_each_available_child_of_node(np, child)
 912                 if (of_mdiobus_child_is_phy(child)) {
 913                         /* The loop increments the child refcount,
 914                          * decrement it before returning.
 915                          */
 916                         of_node_put(child);
 917
 918                         return of_mdiobus_register(bp->mii_bus, np);
 919                 }
 920
 921         return mdiobus_register(bp->mii_bus);
 922 }
 923
 924 static int macb_mii_init(struct macb *bp)
 925 {
 926         int err = -ENXIO;
 927
 928         /* Enable management port */
 929         macb_writel(bp, NCR, MACB_BIT(MPE));
 930
 931         bp->mii_bus = mdiobus_alloc();
 932         if (!bp->mii_bus) {
 933                 err = -ENOMEM;
 934                 goto err_out;
 935         }
 936
 937         bp->mii_bus->name = "MACB_mii_bus";
 938         bp->mii_bus->read = &macb_mdio_read;
 939         bp->mii_bus->write = &macb_mdio_write;
 940         snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
 941                  bp->pdev->name, bp->pdev->id);
 942         bp->mii_bus->priv = bp;
 943         bp->mii_bus->parent = &bp->pdev->dev;
 944
 945         dev_set_drvdata(&bp->dev->dev, bp->mii_bus);
 946
 947         err = macb_mdiobus_register(bp);
 948         if (err)
 949                 goto err_out_free_mdiobus;
 950
 951         err = macb_mii_probe(bp->dev);
 952         if (err)
 953                 goto err_out_unregister_bus;
 954
 955         return 0;
 956
 957 err_out_unregister_bus:
 958         mdiobus_unregister(bp->mii_bus);
 959 err_out_free_mdiobus:
 960         mdiobus_free(bp->mii_bus);
 961 err_out:
 962         return err;
 963 }
 964
 965 static void macb_update_stats(struct macb *bp)
 966 {
 967         u32 *p = &bp->hw_stats.macb.rx_pause_frames;
 968         u32 *end = &bp->hw_stats.macb.tx_pause_frames + 1;
 969         int offset = MACB_PFR;
 970
 971         WARN_ON((unsigned long)(end - p - 1) != (MACB_TPF - MACB_PFR) / 4);
 972
 973         for (; p < end; p++, offset += 4)
 974                 *p += bp->macb_reg_readl(bp, offset);
 975 }
 976
 977 static int macb_halt_tx(struct macb *bp)
 978 {
 979         unsigned long   halt_time, timeout;
 980         u32             status;
 981
 982         macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(THALT));
 983
 984         timeout = jiffies + usecs_to_jiffies(MACB_HALT_TIMEOUT);
 985         do {
 986                 halt_time = jiffies;
 987                 status = macb_readl(bp, TSR);
 988                 if (!(status & MACB_BIT(TGO)))
 989                         return 0;
 990
 991                 udelay(250);
 992         } while (time_before(halt_time, timeout));
 993
 994         return -ETIMEDOUT;
 995 }
 996
 997 static void macb_tx_unmap(struct macb *bp, struct macb_tx_skb *tx_skb)
 998 {
 999         if (tx_skb->mapping) {
1000                 if (tx_skb->mapped_as_page)
1001                         dma_unmap_page(&bp->pdev->dev, tx_skb->mapping,
1002                                        tx_skb->size, DMA_TO_DEVICE);
1003                 else
1004                         dma_unmap_single(&bp->pdev->dev, tx_skb->mapping,
1005                                          tx_skb->size, DMA_TO_DEVICE);
1006                 tx_skb->mapping = 0;
1007         }
1008
1009         if (tx_skb->skb) {
1010                 dev_kfree_skb_any(tx_skb->skb);
1011                 tx_skb->skb = NULL;
1012         }
1013 }
1014
1015 static void macb_set_addr(struct macb *bp, struct macb_dma_desc *desc, dma_addr_t addr)
1016 {
1017 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1018         struct macb_dma_desc_64 *desc_64;
1019
1020         if (bp->hw_dma_cap & HW_DMA_CAP_64B) {
1021                 desc_64 = macb_64b_desc(bp, desc);
1022                 desc_64->addrh = upper_32_bits(addr);
1023                 /* The low bits of RX address contain the RX_USED bit, clearing
1024                  * of which allows packet RX. Make sure the high bits are also
1025                  * visible to HW at that point.
1026                  */
1027                 dma_wmb();
1028         }
1029 #endif
1030         desc->addr = lower_32_bits(addr);
1031 }
1032
1033 static dma_addr_t macb_get_addr(struct macb *bp, struct macb_dma_desc *desc)
1034 {
1035         dma_addr_t addr = 0;
1036 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1037         struct macb_dma_desc_64 *desc_64;
1038
1039         if (bp->hw_dma_cap & HW_DMA_CAP_64B) {
1040                 desc_64 = macb_64b_desc(bp, desc);
1041                 addr = ((u64)(desc_64->addrh) << 32);
1042         }
1043 #endif
1044         addr |= MACB_BF(RX_WADDR, MACB_BFEXT(RX_WADDR, desc->addr));
1045         return addr;
1046 }
1047
1048 static void macb_tx_error_task(struct work_struct *work)
1049 {
1050         struct macb_queue       *queue = container_of(work, struct macb_queue,
1051                                                       tx_error_task);
1052         struct macb             *bp = queue->bp;
1053         struct macb_tx_skb      *tx_skb;
1054         struct macb_dma_desc    *desc;
1055         struct sk_buff          *skb;
1056         unsigned int            tail;
1057         unsigned long           flags;
1058
1059         netdev_vdbg(bp->dev, "macb_tx_error_task: q = %u, t = %u, h = %u\n",
1060                     (unsigned int)(queue - bp->queues),
1061                     queue->tx_tail, queue->tx_head);
1062
1063         /* Prevent the queue IRQ handlers from running: each of them may call
1064          * macb_tx_interrupt(), which in turn may call netif_wake_subqueue().
1065          * As explained below, we have to halt the transmission before updating
1066          * TBQP registers so we call netif_tx_stop_all_queues() to notify the
1067          * network engine about the macb/gem being halted.
1068          */
1069         spin_lock_irqsave(&bp->lock, flags);
1070
1071         /* Make sure nobody is trying to queue up new packets */
1072         netif_tx_stop_all_queues(bp->dev);
1073
1074         /* Stop transmission now
1075          * (in case we have just queued new packets)
1076          * macb/gem must be halted to write TBQP register
1077          */
1078         if (macb_halt_tx(bp))
1079                 /* Just complain for now, reinitializing TX path can be good */
1080                 netdev_err(bp->dev, "BUG: halt tx timed out\n");
1081
1082         /* Treat frames in TX queue including the ones that caused the error.
1083          * Free transmit buffers in upper layer.
1084          */
1085         for (tail = queue->tx_tail; tail != queue->tx_head; tail++) {
1086                 u32     ctrl;
1087
1088                 desc = macb_tx_desc(queue, tail);
1089                 ctrl = desc->ctrl;
1090                 tx_skb = macb_tx_skb(queue, tail);
1091                 skb = tx_skb->skb;
1092
1093                 if (ctrl & MACB_BIT(TX_USED)) {
1094                         /* skb is set for the last buffer of the frame */
1095                         while (!skb) {
1096                                 macb_tx_unmap(bp, tx_skb);
1097                                 tail++;
1098                                 tx_skb = macb_tx_skb(queue, tail);
1099                                 skb = tx_skb->skb;
1100                         }
1101
1102                         /* ctrl still refers to the first buffer descriptor
1103                          * since it's the only one written back by the hardware
1104                          */
1105                         if (!(ctrl & MACB_BIT(TX_BUF_EXHAUSTED))) {
1106                                 netdev_vdbg(bp->dev, "txerr skb %u (data %p) TX complete\n",
1107                                             macb_tx_ring_wrap(bp, tail),
1108                                             skb->data);
1109                                 bp->dev->stats.tx_packets++;
1110                                 queue->stats.tx_packets++;
1111                                 bp->dev->stats.tx_bytes += skb->len;
1112                                 queue->stats.tx_bytes += skb->len;
1113                         }
1114                 } else {
1115                         /* "Buffers exhausted mid-frame" errors may only happen
1116                          * if the driver is buggy, so complain loudly about
1117                          * those. Statistics are updated by hardware.
1118                          */
1119                         if (ctrl & MACB_BIT(TX_BUF_EXHAUSTED))
1120                                 netdev_err(bp->dev,
1121                                            "BUG: TX buffers exhausted mid-frame\n");
1122
1123                         desc->ctrl = ctrl | MACB_BIT(TX_USED);
1124                 }
1125
1126                 macb_tx_unmap(bp, tx_skb);
1127         }
1128
1129         /* Set end of TX queue */
1130         desc = macb_tx_desc(queue, 0);
1131         macb_set_addr(bp, desc, 0);
1132         desc->ctrl = MACB_BIT(TX_USED);
1133
1134         /* Make descriptor updates visible to hardware */
1135         wmb();
1136
1137         /* Reinitialize the TX desc queue */
1138         queue_writel(queue, TBQP, lower_32_bits(queue->tx_ring_dma));
1139 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1140         if (bp->hw_dma_cap & HW_DMA_CAP_64B)
1141                 queue_writel(queue, TBQPH, upper_32_bits(queue->tx_ring_dma));
1142 #endif
1143         /* Make TX ring reflect state of hardware */
1144         queue->tx_head = 0;
1145         queue->tx_tail = 0;
1146
1147         /* Housework before enabling TX IRQ */
1148         macb_writel(bp, TSR, macb_readl(bp, TSR));
1149         queue_writel(queue, IER, MACB_TX_INT_FLAGS);
1150
1151         /* Now we are ready to start transmission again */
1152         netif_tx_start_all_queues(bp->dev);
1153         macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TSTART));
1154
1155         spin_unlock_irqrestore(&bp->lock, flags);
1156 }
1157
1158 static void macb_tx_interrupt(struct macb_queue *queue)
1159 {
1160         unsigned int tail;
1161         unsigned int head;
1162         u32 status;
1163         struct macb *bp = queue->bp;
1164         u16 queue_index = queue - bp->queues;
1165
1166         status = macb_readl(bp, TSR);
1167         macb_writel(bp, TSR, status);
1168
1169         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1170                 queue_writel(queue, ISR, MACB_BIT(TCOMP));
1171
1172         netdev_vdbg(bp->dev, "macb_tx_interrupt status = 0x%03lx\n",
1173                     (unsigned long)status);
1174
1175         head = queue->tx_head;
1176         for (tail = queue->tx_tail; tail != head; tail++) {
1177                 struct macb_tx_skb      *tx_skb;
1178                 struct sk_buff          *skb;
1179                 struct macb_dma_desc    *desc;
1180                 u32                     ctrl;
1181
1182                 desc = macb_tx_desc(queue, tail);
1183
1184                 /* Make hw descriptor updates visible to CPU */
1185                 rmb();
1186
1187                 ctrl = desc->ctrl;
1188
1189                 /* TX_USED bit is only set by hardware on the very first buffer
1190                  * descriptor of the transmitted frame.
1191                  */
1192                 if (!(ctrl & MACB_BIT(TX_USED)))
1193                         break;
1194
1195                 /* Process all buffers of the current transmitted frame */
1196                 for (;; tail++) {
1197                         tx_skb = macb_tx_skb(queue, tail);
1198                         skb = tx_skb->skb;
1199
1200                         /* First, update TX stats if needed */
1201                         if (skb) {
1202                                 if (unlikely(skb_shinfo(skb)->tx_flags &
1203                                              SKBTX_HW_TSTAMP) &&
1204                                     gem_ptp_do_txstamp(queue, skb, desc) == 0) {
1205                                         /* skb now belongs to timestamp buffer
1206                                          * and will be removed later
1207                                          */
1208                                         tx_skb->skb = NULL;
1209                                 }
1210                                 netdev_vdbg(bp->dev, "skb %u (data %p) TX complete\n",
1211                                             macb_tx_ring_wrap(bp, tail),
1212                                             skb->data);
1213                                 bp->dev->stats.tx_packets++;
1214                                 queue->stats.tx_packets++;
1215                                 bp->dev->stats.tx_bytes += skb->len;
1216                                 queue->stats.tx_bytes += skb->len;
1217                         }
1218
1219                         /* Now we can safely release resources */
1220                         macb_tx_unmap(bp, tx_skb);
1221
1222                         /* skb is set only for the last buffer of the frame.
1223                          * WARNING: at this point skb has been freed by
1224                          * macb_tx_unmap().
1225                          */
1226                         if (skb)
1227                                 break;
1228                 }
1229         }
1230
1231         queue->tx_tail = tail;
1232         if (__netif_subqueue_stopped(bp->dev, queue_index) &&
1233             CIRC_CNT(queue->tx_head, queue->tx_tail,
1234                      bp->tx_ring_size) <= MACB_TX_WAKEUP_THRESH(bp))
1235                 netif_wake_subqueue(bp->dev, queue_index);
1236 }
1237
1238 static void gem_rx_refill(struct macb_queue *queue)
1239 {
1240         unsigned int            entry;
1241         struct sk_buff          *skb;
1242         dma_addr_t              paddr;
1243         struct macb *bp = queue->bp;
1244         struct macb_dma_desc *desc;
1245
1246         while (CIRC_SPACE(queue->rx_prepared_head, queue->rx_tail,
1247                         bp->rx_ring_size) > 0) {
1248                 entry = macb_rx_ring_wrap(bp, queue->rx_prepared_head);
1249
1250                 /* Make hw descriptor updates visible to CPU */
1251                 rmb();
1252
1253                 queue->rx_prepared_head++;
1254                 desc = macb_rx_desc(queue, entry);
1255
1256                 if (!queue->rx_skbuff[entry]) {
1257                         /* allocate sk_buff for this free entry in ring */
1258                         skb = netdev_alloc_skb(bp->dev, bp->rx_buffer_size);
1259                         if (unlikely(!skb)) {
1260                                 netdev_err(bp->dev,
1261                                            "Unable to allocate sk_buff\n");
1262                                 break;
1263                         }
1264
1265                         /* now fill corresponding descriptor entry */
1266                         paddr = dma_map_single(&bp->pdev->dev, skb->data,
1267                                                bp->rx_buffer_size,
1268                                                DMA_FROM_DEVICE);
1269                         if (dma_mapping_error(&bp->pdev->dev, paddr)) {
1270                                 dev_kfree_skb(skb);
1271                                 break;
1272                         }
1273
1274                         queue->rx_skbuff[entry] = skb;
1275
1276                         if (entry == bp->rx_ring_size - 1)
1277                                 paddr |= MACB_BIT(RX_WRAP);
1278                         desc->ctrl = 0;
1279                         /* Setting addr clears RX_USED and allows reception,
1280                          * make sure ctrl is cleared first to avoid a race.
1281                          */
1282                         dma_wmb();
1283                         macb_set_addr(bp, desc, paddr);
1284
1285                         /* properly align Ethernet header */
1286                         skb_reserve(skb, NET_IP_ALIGN);
1287                 } else {
1288                         desc->ctrl = 0;
1289                         dma_wmb();
1290                         desc->addr &= ~MACB_BIT(RX_USED);
1291                 }
1292         }
1293
1294         /* Make descriptor updates visible to hardware */
1295         wmb();
1296
1297         netdev_vdbg(bp->dev, "rx ring: queue: %p, prepared head %d, tail %d\n",
1298                         queue, queue->rx_prepared_head, queue->rx_tail);
1299 }
1300
1301 /* Mark DMA descriptors from begin up to and not including end as unused */
1302 static void discard_partial_frame(struct macb_queue *queue, unsigned int begin,
1303                                   unsigned int end)
1304 {
1305         unsigned int frag;
1306
1307         for (frag = begin; frag != end; frag++) {
1308                 struct macb_dma_desc *desc = macb_rx_desc(queue, frag);
1309
1310                 desc->addr &= ~MACB_BIT(RX_USED);
1311         }
1312
1313         /* Make descriptor updates visible to hardware */
1314         wmb();
1315
1316         /* When this happens, the hardware stats registers for
1317          * whatever caused this is updated, so we don't have to record
1318          * anything.
1319          */
1320 }
1321
1322 static int gem_rx(struct macb_queue *queue, struct napi_struct *napi,
1323                   int budget)
1324 {
1325         struct macb *bp = queue->bp;
1326         unsigned int            len;
1327         unsigned int            entry;
1328         struct sk_buff          *skb;
1329         struct macb_dma_desc    *desc;
1330         int                     count = 0;
1331
1332         while (count < budget) {
1333                 u32 ctrl;
1334                 dma_addr_t addr;
1335                 bool rxused;
1336
1337                 entry = macb_rx_ring_wrap(bp, queue->rx_tail);
1338                 desc = macb_rx_desc(queue, entry);
1339
1340                 /* Make hw descriptor updates visible to CPU */
1341                 rmb();
1342
1343                 rxused = (desc->addr & MACB_BIT(RX_USED)) ? true : false;
1344                 addr = macb_get_addr(bp, desc);
1345
1346                 if (!rxused)
1347                         break;
1348
1349                 /* Ensure ctrl is at least as up-to-date as rxused */
1350                 dma_rmb();
1351
1352                 ctrl = desc->ctrl;
1353
1354                 queue->rx_tail++;
1355                 count++;
1356
1357                 if (!(ctrl & MACB_BIT(RX_SOF) && ctrl & MACB_BIT(RX_EOF))) {
1358                         netdev_err(bp->dev,
1359                                    "not whole frame pointed by descriptor\n");
1360                         bp->dev->stats.rx_dropped++;
1361                         queue->stats.rx_dropped++;
1362                         break;
1363                 }
1364                 skb = queue->rx_skbuff[entry];
1365                 if (unlikely(!skb)) {
1366                         netdev_err(bp->dev,
1367                                    "inconsistent Rx descriptor chain\n");
1368                         bp->dev->stats.rx_dropped++;
1369                         queue->stats.rx_dropped++;
1370                         break;
1371                 }
1372                 /* now everything is ready for receiving packet */
1373                 queue->rx_skbuff[entry] = NULL;
1374                 len = ctrl & bp->rx_frm_len_mask;
1375
1376                 netdev_vdbg(bp->dev, "gem_rx %u (len %u)\n", entry, len);
1377
1378                 skb_put(skb, len);
1379                 dma_unmap_single(&bp->pdev->dev, addr,
1380                                  bp->rx_buffer_size, DMA_FROM_DEVICE);
1381
1382                 skb->protocol = eth_type_trans(skb, bp->dev);
1383                 skb_checksum_none_assert(skb);
1384                 if (bp->dev->features & NETIF_F_RXCSUM &&
1385                     !(bp->dev->flags & IFF_PROMISC) &&
1386                     GEM_BFEXT(RX_CSUM, ctrl) & GEM_RX_CSUM_CHECKED_MASK)
1387                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1388
1389                 bp->dev->stats.rx_packets++;
1390                 queue->stats.rx_packets++;
1391                 bp->dev->stats.rx_bytes += skb->len;
1392                 queue->stats.rx_bytes += skb->len;
1393
1394                 gem_ptp_do_rxstamp(bp, skb, desc);
1395
1396 #if defined(DEBUG) && defined(VERBOSE_DEBUG)
1397                 netdev_vdbg(bp->dev, "received skb of length %u, csum: %08x\n",
1398                             skb->len, skb->csum);
1399                 print_hex_dump(KERN_DEBUG, " mac: ", DUMP_PREFIX_ADDRESS, 16, 1,
1400                                skb_mac_header(skb), 16, true);
1401                 print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_ADDRESS, 16, 1,
1402                                skb->data, 32, true);
1403 #endif
1404
1405                 napi_gro_receive(napi, skb);
1406         }
1407
1408         gem_rx_refill(queue);
1409
1410         return count;
1411 }
1412
1413 static int macb_rx_frame(struct macb_queue *queue, struct napi_struct *napi,
1414                          unsigned int first_frag, unsigned int last_frag)
1415 {
1416         unsigned int len;
1417         unsigned int frag;
1418         unsigned int offset;
1419         struct sk_buff *skb;
1420         struct macb_dma_desc *desc;
1421         struct macb *bp = queue->bp;
1422
1423         desc = macb_rx_desc(queue, last_frag);
1424         len = desc->ctrl & bp->rx_frm_len_mask;
1425
1426         netdev_vdbg(bp->dev, "macb_rx_frame frags %u - %u (len %u)\n",
1427                 macb_rx_ring_wrap(bp, first_frag),
1428                 macb_rx_ring_wrap(bp, last_frag), len);
1429
1430         /* The ethernet header starts NET_IP_ALIGN bytes into the
1431          * first buffer. Since the header is 14 bytes, this makes the
1432          * payload word-aligned.
1433          *
1434          * Instead of calling skb_reserve(NET_IP_ALIGN), we just copy
1435          * the two padding bytes into the skb so that we avoid hitting
1436          * the slowpath in memcpy(), and pull them off afterwards.
1437          */
1438         skb = netdev_alloc_skb(bp->dev, len + NET_IP_ALIGN);
1439         if (!skb) {
1440                 bp->dev->stats.rx_dropped++;
1441                 for (frag = first_frag; ; frag++) {
1442                         desc = macb_rx_desc(queue, frag);
1443                         desc->addr &= ~MACB_BIT(RX_USED);
1444                         if (frag == last_frag)
1445                                 break;
1446                 }
1447
1448                 /* Make descriptor updates visible to hardware */
1449                 wmb();
1450
1451                 return 1;
1452         }
1453
1454         offset = 0;
1455         len += NET_IP_ALIGN;
1456         skb_checksum_none_assert(skb);
1457         skb_put(skb, len);
1458
1459         for (frag = first_frag; ; frag++) {
1460                 unsigned int frag_len = bp->rx_buffer_size;
1461
1462                 if (offset + frag_len > len) {
1463                         if (unlikely(frag != last_frag)) {
1464                                 dev_kfree_skb_any(skb);
1465                                 return -1;
1466                         }
1467                         frag_len = len - offset;
1468                 }
1469                 skb_copy_to_linear_data_offset(skb, offset,
1470                                                macb_rx_buffer(queue, frag),
1471                                                frag_len);
1472                 offset += bp->rx_buffer_size;
1473                 desc = macb_rx_desc(queue, frag);
1474                 desc->addr &= ~MACB_BIT(RX_USED);
1475
1476                 if (frag == last_frag)
1477                         break;
1478         }
1479
1480         /* Make descriptor updates visible to hardware */
1481         wmb();
1482
1483         __skb_pull(skb, NET_IP_ALIGN);
1484         skb->protocol = eth_type_trans(skb, bp->dev);
1485
1486         bp->dev->stats.rx_packets++;
1487         bp->dev->stats.rx_bytes += skb->len;
1488         netdev_vdbg(bp->dev, "received skb of length %u, csum: %08x\n",
1489                     skb->len, skb->csum);
1490         napi_gro_receive(napi, skb);
1491
1492         return 0;
1493 }
1494
1495 static inline void macb_init_rx_ring(struct macb_queue *queue)
1496 {
1497         struct macb *bp = queue->bp;
1498         dma_addr_t addr;
1499         struct macb_dma_desc *desc = NULL;
1500         int i;
1501
1502         addr = queue->rx_buffers_dma;
1503         for (i = 0; i < bp->rx_ring_size; i++) {
1504                 desc = macb_rx_desc(queue, i);
1505                 macb_set_addr(bp, desc, addr);
1506                 desc->ctrl = 0;
1507                 addr += bp->rx_buffer_size;
1508         }
1509         desc->addr |= MACB_BIT(RX_WRAP);
1510         queue->rx_tail = 0;
1511 }
1512
1513 static int macb_rx(struct macb_queue *queue, struct napi_struct *napi,
1514                    int budget)
1515 {
1516         struct macb *bp = queue->bp;
1517         bool reset_rx_queue = false;
1518         int received = 0;
1519         unsigned int tail;
1520         int first_frag = -1;
1521
1522         for (tail = queue->rx_tail; budget > 0; tail++) {
1523                 struct macb_dma_desc *desc = macb_rx_desc(queue, tail);
1524                 u32 ctrl;
1525
1526                 /* Make hw descriptor updates visible to CPU */
1527                 rmb();
1528
1529                 if (!(desc->addr & MACB_BIT(RX_USED)))
1530                         break;
1531
1532                 /* Ensure ctrl is at least as up-to-date as addr */
1533                 dma_rmb();
1534
1535                 ctrl = desc->ctrl;
1536
1537                 if (ctrl & MACB_BIT(RX_SOF)) {
1538                         if (first_frag != -1)
1539                                 discard_partial_frame(queue, first_frag, tail);
1540                         first_frag = tail;
1541                 }
1542
1543                 if (ctrl & MACB_BIT(RX_EOF)) {
1544                         int dropped;
1545
1546                         if (unlikely(first_frag == -1)) {
1547                                 reset_rx_queue = true;
1548                                 continue;
1549                         }
1550
1551                         dropped = macb_rx_frame(queue, napi, first_frag, tail);
1552                         first_frag = -1;
1553                         if (unlikely(dropped < 0)) {
1554                                 reset_rx_queue = true;
1555                                 continue;
1556                         }
1557                         if (!dropped) {
1558                                 received++;
1559                                 budget--;
1560                         }
1561                 }
1562         }
1563
1564         if (unlikely(reset_rx_queue)) {
1565                 unsigned long flags;
1566                 u32 ctrl;
1567
1568                 netdev_err(bp->dev, "RX queue corruption: reset it\n");
1569
1570                 spin_lock_irqsave(&bp->lock, flags);
1571
1572                 ctrl = macb_readl(bp, NCR);
1573                 macb_writel(bp, NCR, ctrl & ~MACB_BIT(RE));
1574
1575                 macb_init_rx_ring(queue);
1576                 queue_writel(queue, RBQP, queue->rx_ring_dma);
1577
1578                 macb_writel(bp, NCR, ctrl | MACB_BIT(RE));
1579
1580                 spin_unlock_irqrestore(&bp->lock, flags);
1581                 return received;
1582         }
1583
1584         if (first_frag != -1)
1585                 queue->rx_tail = first_frag;
1586         else
1587                 queue->rx_tail = tail;
1588
1589         return received;
1590 }
1591
1592 static int macb_poll(struct napi_struct *napi, int budget)
1593 {
1594         struct macb_queue *queue = container_of(napi, struct macb_queue, napi);
1595         struct macb *bp = queue->bp;
1596         int work_done;
1597         u32 status;
1598
1599         status = macb_readl(bp, RSR);
1600         macb_writel(bp, RSR, status);
1601
1602         netdev_vdbg(bp->dev, "poll: status = %08lx, budget = %d\n",
1603                     (unsigned long)status, budget);
1604
1605         work_done = bp->macbgem_ops.mog_rx(queue, napi, budget);
1606         if (work_done < budget) {
1607                 napi_complete_done(napi, work_done);
1608
1609                 /* Packets received while interrupts were disabled */
1610                 status = macb_readl(bp, RSR);
1611                 if (status) {
1612                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1613                                 queue_writel(queue, ISR, MACB_BIT(RCOMP));
1614                         napi_reschedule(napi);
1615                 } else {
1616                         queue_writel(queue, IER, bp->rx_intr_mask);
1617                 }
1618         }
1619
1620         /* TODO: Handle errors */
1621
1622         return work_done;
1623 }
1624
1625 static void macb_hresp_error_task(struct tasklet_struct *t)
1626 {
1627         struct macb *bp = from_tasklet(bp, t, hresp_err_tasklet);
1628         struct net_device *dev = bp->dev;
1629         struct macb_queue *queue;
1630         unsigned int q;
1631         u32 ctrl;
1632
1633         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
1634                 queue_writel(queue, IDR, bp->rx_intr_mask |
1635                                          MACB_TX_INT_FLAGS |
1636                                          MACB_BIT(HRESP));
1637         }
1638         ctrl = macb_readl(bp, NCR);
1639         ctrl &= ~(MACB_BIT(RE) | MACB_BIT(TE));
1640         macb_writel(bp, NCR, ctrl);
1641
1642         netif_tx_stop_all_queues(dev);
1643         netif_carrier_off(dev);
1644
1645         bp->macbgem_ops.mog_init_rings(bp);
1646
1647         /* Initialize TX and RX buffers */
1648         macb_init_buffers(bp);
1649
1650         /* Enable interrupts */
1651         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
1652                 queue_writel(queue, IER,
1653                              bp->rx_intr_mask |
1654                              MACB_TX_INT_FLAGS |
1655                              MACB_BIT(HRESP));
1656
1657         ctrl |= MACB_BIT(RE) | MACB_BIT(TE);
1658         macb_writel(bp, NCR, ctrl);
1659
1660         netif_carrier_on(dev);
1661         netif_tx_start_all_queues(dev);
1662 }
1663
1664 static void macb_tx_restart(struct macb_queue *queue)
1665 {
1666         unsigned int head = queue->tx_head;
1667         unsigned int tail = queue->tx_tail;
1668         struct macb *bp = queue->bp;
1669
1670         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1671                 queue_writel(queue, ISR, MACB_BIT(TXUBR));
1672
1673         if (head == tail)
1674                 return;
1675
1676         macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TSTART));
1677 }
1678
1679 static irqreturn_t macb_wol_interrupt(int irq, void *dev_id)
1680 {
1681         struct macb_queue *queue = dev_id;
1682         struct macb *bp = queue->bp;
1683         u32 status;
1684
1685         status = queue_readl(queue, ISR);
1686
1687         if (unlikely(!status))
1688                 return IRQ_NONE;
1689
1690         spin_lock(&bp->lock);
1691
1692         if (status & MACB_BIT(WOL)) {
1693                 queue_writel(queue, IDR, MACB_BIT(WOL));
1694                 macb_writel(bp, WOL, 0);
1695                 netdev_vdbg(bp->dev, "MACB WoL: queue = %u, isr = 0x%08lx\n",
1696                             (unsigned int)(queue - bp->queues),
1697                             (unsigned long)status);
1698                 if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1699                         queue_writel(queue, ISR, MACB_BIT(WOL));
1700                 pm_wakeup_event(&bp->pdev->dev, 0);
1701         }
1702
1703         spin_unlock(&bp->lock);
1704
1705         return IRQ_HANDLED;
1706 }
1707
1708 static irqreturn_t gem_wol_interrupt(int irq, void *dev_id)
1709 {
1710         struct macb_queue *queue = dev_id;
1711         struct macb *bp = queue->bp;
1712         u32 status;
1713
1714         status = queue_readl(queue, ISR);
1715
1716         if (unlikely(!status))
1717                 return IRQ_NONE;
1718
1719         spin_lock(&bp->lock);
1720
1721         if (status & GEM_BIT(WOL)) {
1722                 queue_writel(queue, IDR, GEM_BIT(WOL));
1723                 gem_writel(bp, WOL, 0);
1724                 netdev_vdbg(bp->dev, "GEM WoL: queue = %u, isr = 0x%08lx\n",
1725                             (unsigned int)(queue - bp->queues),
1726                             (unsigned long)status);
1727                 if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1728                         queue_writel(queue, ISR, GEM_BIT(WOL));
1729                 pm_wakeup_event(&bp->pdev->dev, 0);
1730         }
1731
1732         spin_unlock(&bp->lock);
1733
1734         return IRQ_HANDLED;
1735 }
1736
1737 static irqreturn_t macb_interrupt(int irq, void *dev_id)
1738 {
1739         struct macb_queue *queue = dev_id;
1740         struct macb *bp = queue->bp;
1741         struct net_device *dev = bp->dev;
1742         u32 status, ctrl;
1743
1744         status = queue_readl(queue, ISR);
1745
1746         if (unlikely(!status))
1747                 return IRQ_NONE;
1748
1749         spin_lock(&bp->lock);
1750
1751         while (status) {
1752                 /* close possible race with dev_close */
1753                 if (unlikely(!netif_running(dev))) {
1754                         queue_writel(queue, IDR, -1);
1755                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1756                                 queue_writel(queue, ISR, -1);
1757                         break;
1758                 }
1759
1760                 netdev_vdbg(bp->dev, "queue = %u, isr = 0x%08lx\n",
1761                             (unsigned int)(queue - bp->queues),
1762                             (unsigned long)status);
1763
1764                 if (status & bp->rx_intr_mask) {
1765                         /* There's no point taking any more interrupts
1766                          * until we have processed the buffers. The
1767                          * scheduling call may fail if the poll routine
1768                          * is already scheduled, so disable interrupts
1769                          * now.
1770                          */
1771                         queue_writel(queue, IDR, bp->rx_intr_mask);
1772                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1773                                 queue_writel(queue, ISR, MACB_BIT(RCOMP));
1774
1775                         if (napi_schedule_prep(&queue->napi)) {
1776                                 netdev_vdbg(bp->dev, "scheduling RX softirq\n");
1777                                 __napi_schedule(&queue->napi);
1778                         }
1779                 }
1780
1781                 if (unlikely(status & (MACB_TX_ERR_FLAGS))) {
1782                         queue_writel(queue, IDR, MACB_TX_INT_FLAGS);
1783                         schedule_work(&queue->tx_error_task);
1784
1785                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1786                                 queue_writel(queue, ISR, MACB_TX_ERR_FLAGS);
1787
1788                         break;
1789                 }
1790
1791                 if (status & MACB_BIT(TCOMP))
1792                         macb_tx_interrupt(queue);
1793
1794                 if (status & MACB_BIT(TXUBR))
1795                         macb_tx_restart(queue);
1796
1797                 /* Link change detection isn't possible with RMII, so we'll
1798                  * add that if/when we get our hands on a full-blown MII PHY.
1799                  */
1800
1801                 /* There is a hardware issue under heavy load where DMA can
1802                  * stop, this causes endless "used buffer descriptor read"
1803                  * interrupts but it can be cleared by re-enabling RX. See
1804                  * the at91rm9200 manual, section 41.3.1 or the Zynq manual
1805                  * section 16.7.4 for details. RXUBR is only enabled for
1806                  * these two versions.
1807                  */
1808                 if (status & MACB_BIT(RXUBR)) {
1809                         ctrl = macb_readl(bp, NCR);
1810                         macb_writel(bp, NCR, ctrl & ~MACB_BIT(RE));
1811                         wmb();
1812                         macb_writel(bp, NCR, ctrl | MACB_BIT(RE));
1813
1814                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1815                                 queue_writel(queue, ISR, MACB_BIT(RXUBR));
1816                 }
1817
1818                 if (status & MACB_BIT(ISR_ROVR)) {
1819                         /* We missed at least one packet */
1820                         if (macb_is_gem(bp))
1821                                 bp->hw_stats.gem.rx_overruns++;
1822                         else
1823                                 bp->hw_stats.macb.rx_overruns++;
1824
1825                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1826                                 queue_writel(queue, ISR, MACB_BIT(ISR_ROVR));
1827                 }
1828
1829                 if (status & MACB_BIT(HRESP)) {
1830                         tasklet_schedule(&bp->hresp_err_tasklet);
1831                         netdev_err(dev, "DMA bus error: HRESP not OK\n");
1832
1833                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
1834                                 queue_writel(queue, ISR, MACB_BIT(HRESP));
1835                 }
1836                 status = queue_readl(queue, ISR);
1837         }
1838
1839         spin_unlock(&bp->lock);
1840
1841         return IRQ_HANDLED;
1842 }
1843
1844 #ifdef CONFIG_NET_POLL_CONTROLLER
1845 /* Polling receive - used by netconsole and other diagnostic tools
1846  * to allow network i/o with interrupts disabled.
1847  */
1848 static void macb_poll_controller(struct net_device *dev)
1849 {
1850         struct macb *bp = netdev_priv(dev);
1851         struct macb_queue *queue;
1852         unsigned long flags;
1853         unsigned int q;
1854
1855         local_irq_save(flags);
1856         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
1857                 macb_interrupt(dev->irq, queue);
1858         local_irq_restore(flags);
1859 }
1860 #endif
1861
1862 static unsigned int macb_tx_map(struct macb *bp,
1863                                 struct macb_queue *queue,
1864                                 struct sk_buff *skb,
1865                                 unsigned int hdrlen)
1866 {
1867         dma_addr_t mapping;
1868         unsigned int len, entry, i, tx_head = queue->tx_head;
1869         struct macb_tx_skb *tx_skb = NULL;
1870         struct macb_dma_desc *desc;
1871         unsigned int offset, size, count = 0;
1872         unsigned int f, nr_frags = skb_shinfo(skb)->nr_frags;
1873         unsigned int eof = 1, mss_mfs = 0;
1874         u32 ctrl, lso_ctrl = 0, seq_ctrl = 0;
1875
1876         /* LSO */
1877         if (skb_shinfo(skb)->gso_size != 0) {
1878                 if (ip_hdr(skb)->protocol == IPPROTO_UDP)
1879                         /* UDP - UFO */
1880                         lso_ctrl = MACB_LSO_UFO_ENABLE;
1881                 else
1882                         /* TCP - TSO */
1883                         lso_ctrl = MACB_LSO_TSO_ENABLE;
1884         }
1885
1886         /* First, map non-paged data */
1887         len = skb_headlen(skb);
1888
1889         /* first buffer length */
1890         size = hdrlen;
1891
1892         offset = 0;
1893         while (len) {
1894                 entry = macb_tx_ring_wrap(bp, tx_head);
1895                 tx_skb = &queue->tx_skb[entry];
1896
1897                 mapping = dma_map_single(&bp->pdev->dev,
1898                                          skb->data + offset,
1899                                          size, DMA_TO_DEVICE);
1900                 if (dma_mapping_error(&bp->pdev->dev, mapping))
1901                         goto dma_error;
1902
1903                 /* Save info to properly release resources */
1904                 tx_skb->skb = NULL;
1905                 tx_skb->mapping = mapping;
1906                 tx_skb->size = size;
1907                 tx_skb->mapped_as_page = false;
1908
1909                 len -= size;
1910                 offset += size;
1911                 count++;
1912                 tx_head++;
1913
1914                 size = min(len, bp->max_tx_length);
1915         }
1916
1917         /* Then, map paged data from fragments */
1918         for (f = 0; f < nr_frags; f++) {
1919                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[f];
1920
1921                 len = skb_frag_size(frag);
1922                 offset = 0;
1923                 while (len) {
1924                         size = min(len, bp->max_tx_length);
1925                         entry = macb_tx_ring_wrap(bp, tx_head);
1926                         tx_skb = &queue->tx_skb[entry];
1927
1928                         mapping = skb_frag_dma_map(&bp->pdev->dev, frag,
1929                                                    offset, size, DMA_TO_DEVICE);
1930                         if (dma_mapping_error(&bp->pdev->dev, mapping))
1931                                 goto dma_error;
1932
1933                         /* Save info to properly release resources */
1934                         tx_skb->skb = NULL;
1935                         tx_skb->mapping = mapping;
1936                         tx_skb->size = size;
1937                         tx_skb->mapped_as_page = true;
1938
1939                         len -= size;
1940                         offset += size;
1941                         count++;
1942                         tx_head++;
1943                 }
1944         }
1945
1946         /* Should never happen */
1947         if (unlikely(!tx_skb)) {
1948                 netdev_err(bp->dev, "BUG! empty skb!\n");
1949                 return 0;
1950         }
1951
1952         /* This is the last buffer of the frame: save socket buffer */
1953         tx_skb->skb = skb;
1954
1955         /* Update TX ring: update buffer descriptors in reverse order
1956          * to avoid race condition
1957          */
1958
1959         /* Set 'TX_USED' bit in buffer descriptor at tx_head position
1960          * to set the end of TX queue
1961          */
1962         i = tx_head;
1963         entry = macb_tx_ring_wrap(bp, i);
1964         ctrl = MACB_BIT(TX_USED);
1965         desc = macb_tx_desc(queue, entry);
1966         desc->ctrl = ctrl;
1967
1968         if (lso_ctrl) {
1969                 if (lso_ctrl == MACB_LSO_UFO_ENABLE)
1970                         /* include header and FCS in value given to h/w */
1971                         mss_mfs = skb_shinfo(skb)->gso_size +
1972                                         skb_transport_offset(skb) +
1973                                         ETH_FCS_LEN;
1974                 else /* TSO */ {
1975                         mss_mfs = skb_shinfo(skb)->gso_size;
1976                         /* TCP Sequence Number Source Select
1977                          * can be set only for TSO
1978                          */
1979                         seq_ctrl = 0;
1980                 }
1981         }
1982
1983         do {
1984                 i--;
1985                 entry = macb_tx_ring_wrap(bp, i);
1986                 tx_skb = &queue->tx_skb[entry];
1987                 desc = macb_tx_desc(queue, entry);
1988
1989                 ctrl = (u32)tx_skb->size;
1990                 if (eof) {
1991                         ctrl |= MACB_BIT(TX_LAST);
1992                         eof = 0;
1993                 }
1994                 if (unlikely(entry == (bp->tx_ring_size - 1)))
1995                         ctrl |= MACB_BIT(TX_WRAP);
1996
1997                 /* First descriptor is header descriptor */
1998                 if (i == queue->tx_head) {
1999                         ctrl |= MACB_BF(TX_LSO, lso_ctrl);
2000                         ctrl |= MACB_BF(TX_TCP_SEQ_SRC, seq_ctrl);
2001                         if ((bp->dev->features & NETIF_F_HW_CSUM) &&
2002                             skb->ip_summed != CHECKSUM_PARTIAL && !lso_ctrl)
2003                                 ctrl |= MACB_BIT(TX_NOCRC);
2004                 } else
2005                         /* Only set MSS/MFS on payload descriptors
2006                          * (second or later descriptor)
2007                          */
2008                         ctrl |= MACB_BF(MSS_MFS, mss_mfs);
2009
2010                 /* Set TX buffer descriptor */
2011                 macb_set_addr(bp, desc, tx_skb->mapping);
2012                 /* desc->addr must be visible to hardware before clearing
2013                  * 'TX_USED' bit in desc->ctrl.
2014                  */
2015                 wmb();
2016                 desc->ctrl = ctrl;
2017         } while (i != queue->tx_head);
2018
2019         queue->tx_head = tx_head;
2020
2021         return count;
2022
2023 dma_error:
2024         netdev_err(bp->dev, "TX DMA map failed\n");
2025
2026         for (i = queue->tx_head; i != tx_head; i++) {
2027                 tx_skb = macb_tx_skb(queue, i);
2028
2029                 macb_tx_unmap(bp, tx_skb);
2030         }
2031
2032         return 0;
2033 }
2034
2035 static netdev_features_t macb_features_check(struct sk_buff *skb,
2036                                              struct net_device *dev,
2037                                              netdev_features_t features)
2038 {
2039         unsigned int nr_frags, f;
2040         unsigned int hdrlen;
2041
2042         /* Validate LSO compatibility */
2043
2044         /* there is only one buffer or protocol is not UDP */
2045         if (!skb_is_nonlinear(skb) || (ip_hdr(skb)->protocol != IPPROTO_UDP))
2046                 return features;
2047
2048         /* length of header */
2049         hdrlen = skb_transport_offset(skb);
2050
2051         /* For UFO only:
2052          * When software supplies two or more payload buffers all payload buffers
2053          * apart from the last must be a multiple of 8 bytes in size.
2054          */
2055         if (!IS_ALIGNED(skb_headlen(skb) - hdrlen, MACB_TX_LEN_ALIGN))
2056                 return features & ~MACB_NETIF_LSO;
2057
2058         nr_frags = skb_shinfo(skb)->nr_frags;
2059         /* No need to check last fragment */
2060         nr_frags--;
2061         for (f = 0; f < nr_frags; f++) {
2062                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[f];
2063
2064                 if (!IS_ALIGNED(skb_frag_size(frag), MACB_TX_LEN_ALIGN))
2065                         return features & ~MACB_NETIF_LSO;
2066         }
2067         return features;
2068 }
2069
2070 static inline int macb_clear_csum(struct sk_buff *skb)
2071 {
2072         /* no change for packets without checksum offloading */
2073         if (skb->ip_summed != CHECKSUM_PARTIAL)
2074                 return 0;
2075
2076         /* make sure we can modify the header */
2077         if (unlikely(skb_cow_head(skb, 0)))
2078                 return -1;
2079
2080         /* initialize checksum field
2081          * This is required - at least for Zynq, which otherwise calculates
2082          * wrong UDP header checksums for UDP packets with UDP data len <=2
2083          */
2084         *(__sum16 *)(skb_checksum_start(skb) + skb->csum_offset) = 0;
2085         return 0;
2086 }
2087
2088 static int macb_pad_and_fcs(struct sk_buff **skb, struct net_device *ndev)
2089 {
2090         bool cloned = skb_cloned(*skb) || skb_header_cloned(*skb) ||
2091                       skb_is_nonlinear(*skb);
2092         int padlen = ETH_ZLEN - (*skb)->len;
2093         int headroom = skb_headroom(*skb);
2094         int tailroom = skb_tailroom(*skb);
2095         struct sk_buff *nskb;
2096         u32 fcs;
2097
2098         if (!(ndev->features & NETIF_F_HW_CSUM) ||
2099             !((*skb)->ip_summed != CHECKSUM_PARTIAL) ||
2100             skb_shinfo(*skb)->gso_size) /* Not available for GSO */
2101                 return 0;
2102
2103         if (padlen <= 0) {
2104                 /* FCS could be appeded to tailroom. */
2105                 if (tailroom >= ETH_FCS_LEN)
2106                         goto add_fcs;
2107                 /* FCS could be appeded by moving data to headroom. */
2108                 else if (!cloned && headroom + tailroom >= ETH_FCS_LEN)
2109                         padlen = 0;
2110                 /* No room for FCS, need to reallocate skb. */
2111                 else
2112                         padlen = ETH_FCS_LEN;
2113         } else {
2114                 /* Add room for FCS. */
2115                 padlen += ETH_FCS_LEN;
2116         }
2117
2118         if (!cloned && headroom + tailroom >= padlen) {
2119                 (*skb)->data = memmove((*skb)->head, (*skb)->data, (*skb)->len);
2120                 skb_set_tail_pointer(*skb, (*skb)->len);
2121         } else {
2122                 nskb = skb_copy_expand(*skb, 0, padlen, GFP_ATOMIC);
2123                 if (!nskb)
2124                         return -ENOMEM;
2125
2126                 dev_consume_skb_any(*skb);
2127                 *skb = nskb;
2128         }
2129
2130         if (padlen > ETH_FCS_LEN)
2131                 skb_put_zero(*skb, padlen - ETH_FCS_LEN);
2132
2133 add_fcs:
2134         /* set FCS to packet */
2135         fcs = crc32_le(~0, (*skb)->data, (*skb)->len);
2136         fcs = ~fcs;
2137
2138         skb_put_u8(*skb, fcs            & 0xff);
2139         skb_put_u8(*skb, (fcs >> 8)     & 0xff);
2140         skb_put_u8(*skb, (fcs >> 16)    & 0xff);
2141         skb_put_u8(*skb, (fcs >> 24)    & 0xff);
2142
2143         return 0;
2144 }
2145
2146 static netdev_tx_t macb_start_xmit(struct sk_buff *skb, struct net_device *dev)
2147 {
2148         u16 queue_index = skb_get_queue_mapping(skb);
2149         struct macb *bp = netdev_priv(dev);
2150         struct macb_queue *queue = &bp->queues[queue_index];
2151         unsigned long flags;
2152         unsigned int desc_cnt, nr_frags, frag_size, f;
2153         unsigned int hdrlen;
2154         bool is_lso;
2155         netdev_tx_t ret = NETDEV_TX_OK;
2156
2157         if (macb_clear_csum(skb)) {
2158                 dev_kfree_skb_any(skb);
2159                 return ret;
2160         }
2161
2162         if (macb_pad_and_fcs(&skb, dev)) {
2163                 dev_kfree_skb_any(skb);
2164                 return ret;
2165         }
2166
2167         is_lso = (skb_shinfo(skb)->gso_size != 0);
2168
2169         if (is_lso) {
2170                 /* length of headers */
2171                 if (ip_hdr(skb)->protocol == IPPROTO_UDP)
2172                         /* only queue eth + ip headers separately for UDP */
2173                         hdrlen = skb_transport_offset(skb);
2174                 else
2175                         hdrlen = skb_transport_offset(skb) + tcp_hdrlen(skb);
2176                 if (skb_headlen(skb) < hdrlen) {
2177                         netdev_err(bp->dev, "Error - LSO headers fragmented!!!\n");
2178                         /* if this is required, would need to copy to single buffer */
2179                         return NETDEV_TX_BUSY;
2180                 }
2181         } else
2182                 hdrlen = min(skb_headlen(skb), bp->max_tx_length);
2183
2184 #if defined(DEBUG) && defined(VERBOSE_DEBUG)
2185         netdev_vdbg(bp->dev,
2186                     "start_xmit: queue %hu len %u head %p data %p tail %p end %p\n",
2187                     queue_index, skb->len, skb->head, skb->data,
2188                     skb_tail_pointer(skb), skb_end_pointer(skb));
2189         print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_OFFSET, 16, 1,
2190                        skb->data, 16, true);
2191 #endif
2192
2193         /* Count how many TX buffer descriptors are needed to send this
2194          * socket buffer: skb fragments of jumbo frames may need to be
2195          * split into many buffer descriptors.
2196          */
2197         if (is_lso && (skb_headlen(skb) > hdrlen))
2198                 /* extra header descriptor if also payload in first buffer */
2199                 desc_cnt = DIV_ROUND_UP((skb_headlen(skb) - hdrlen), bp->max_tx_length) + 1;
2200         else
2201                 desc_cnt = DIV_ROUND_UP(skb_headlen(skb), bp->max_tx_length);
2202         nr_frags = skb_shinfo(skb)->nr_frags;
2203         for (f = 0; f < nr_frags; f++) {
2204                 frag_size = skb_frag_size(&skb_shinfo(skb)->frags[f]);
2205                 desc_cnt += DIV_ROUND_UP(frag_size, bp->max_tx_length);
2206         }
2207
2208         spin_lock_irqsave(&bp->lock, flags);
2209
2210         /* This is a hard error, log it. */
2211         if (CIRC_SPACE(queue->tx_head, queue->tx_tail,
2212                        bp->tx_ring_size) < desc_cnt) {
2213                 netif_stop_subqueue(dev, queue_index);
2214                 spin_unlock_irqrestore(&bp->lock, flags);
2215                 netdev_dbg(bp->dev, "tx_head = %u, tx_tail = %u\n",
2216                            queue->tx_head, queue->tx_tail);
2217                 return NETDEV_TX_BUSY;
2218         }
2219
2220         /* Map socket buffer for DMA transfer */
2221         if (!macb_tx_map(bp, queue, skb, hdrlen)) {
2222                 dev_kfree_skb_any(skb);
2223                 goto unlock;
2224         }
2225
2226         /* Make newly initialized descriptor visible to hardware */
2227         wmb();
2228         skb_tx_timestamp(skb);
2229
2230         macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TSTART));
2231
2232         if (CIRC_SPACE(queue->tx_head, queue->tx_tail, bp->tx_ring_size) < 1)
2233                 netif_stop_subqueue(dev, queue_index);
2234
2235 unlock:
2236         spin_unlock_irqrestore(&bp->lock, flags);
2237
2238         return ret;
2239 }
2240
2241 static void macb_init_rx_buffer_size(struct macb *bp, size_t size)
2242 {
2243         if (!macb_is_gem(bp)) {
2244                 bp->rx_buffer_size = MACB_RX_BUFFER_SIZE;
2245         } else {
2246                 bp->rx_buffer_size = size;
2247
2248                 if (bp->rx_buffer_size % RX_BUFFER_MULTIPLE) {
2249                         netdev_dbg(bp->dev,
2250                                    "RX buffer must be multiple of %d bytes, expanding\n",
2251                                    RX_BUFFER_MULTIPLE);
2252                         bp->rx_buffer_size =
2253                                 roundup(bp->rx_buffer_size, RX_BUFFER_MULTIPLE);
2254                 }
2255         }
2256
2257         netdev_dbg(bp->dev, "mtu [%u] rx_buffer_size [%zu]\n",
2258                    bp->dev->mtu, bp->rx_buffer_size);
2259 }
2260
2261 static void gem_free_rx_buffers(struct macb *bp)
2262 {
2263         struct sk_buff          *skb;
2264         struct macb_dma_desc    *desc;
2265         struct macb_queue *queue;
2266         dma_addr_t              addr;
2267         unsigned int q;
2268         int i;
2269
2270         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2271                 if (!queue->rx_skbuff)
2272                         continue;
2273
2274                 for (i = 0; i < bp->rx_ring_size; i++) {
2275                         skb = queue->rx_skbuff[i];
2276
2277                         if (!skb)
2278                                 continue;
2279
2280                         desc = macb_rx_desc(queue, i);
2281                         addr = macb_get_addr(bp, desc);
2282
2283                         dma_unmap_single(&bp->pdev->dev, addr, bp->rx_buffer_size,
2284                                         DMA_FROM_DEVICE);
2285                         dev_kfree_skb_any(skb);
2286                         skb = NULL;
2287                 }
2288
2289                 kfree(queue->rx_skbuff);
2290                 queue->rx_skbuff = NULL;
2291         }
2292 }
2293
2294 static void macb_free_rx_buffers(struct macb *bp)
2295 {
2296         struct macb_queue *queue = &bp->queues[0];
2297
2298         if (queue->rx_buffers) {
2299                 dma_free_coherent(&bp->pdev->dev,
2300                                   bp->rx_ring_size * bp->rx_buffer_size,
2301                                   queue->rx_buffers, queue->rx_buffers_dma);
2302                 queue->rx_buffers = NULL;
2303         }
2304 }
2305
2306 static void macb_free_consistent(struct macb *bp)
2307 {
2308         struct macb_queue *queue;
2309         unsigned int q;
2310         int size;
2311
2312         bp->macbgem_ops.mog_free_rx_buffers(bp);
2313
2314         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2315                 kfree(queue->tx_skb);
2316                 queue->tx_skb = NULL;
2317                 if (queue->tx_ring) {
2318                         size = TX_RING_BYTES(bp) + bp->tx_bd_rd_prefetch;
2319                         dma_free_coherent(&bp->pdev->dev, size,
2320                                           queue->tx_ring, queue->tx_ring_dma);
2321                         queue->tx_ring = NULL;
2322                 }
2323                 if (queue->rx_ring) {
2324                         size = RX_RING_BYTES(bp) + bp->rx_bd_rd_prefetch;
2325                         dma_free_coherent(&bp->pdev->dev, size,
2326                                           queue->rx_ring, queue->rx_ring_dma);
2327                         queue->rx_ring = NULL;
2328                 }
2329         }
2330 }
2331
2332 static int gem_alloc_rx_buffers(struct macb *bp)
2333 {
2334         struct macb_queue *queue;
2335         unsigned int q;
2336         int size;
2337
2338         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2339                 size = bp->rx_ring_size * sizeof(struct sk_buff *);
2340                 queue->rx_skbuff = kzalloc(size, GFP_KERNEL);
2341                 if (!queue->rx_skbuff)
2342                         return -ENOMEM;
2343                 else
2344                         netdev_dbg(bp->dev,
2345                                    "Allocated %d RX struct sk_buff entries at %p\n",
2346                                    bp->rx_ring_size, queue->rx_skbuff);
2347         }
2348         return 0;
2349 }
2350
2351 static int macb_alloc_rx_buffers(struct macb *bp)
2352 {
2353         struct macb_queue *queue = &bp->queues[0];
2354         int size;
2355
2356         size = bp->rx_ring_size * bp->rx_buffer_size;
2357         queue->rx_buffers = dma_alloc_coherent(&bp->pdev->dev, size,
2358                                             &queue->rx_buffers_dma, GFP_KERNEL);
2359         if (!queue->rx_buffers)
2360                 return -ENOMEM;
2361
2362         netdev_dbg(bp->dev,
2363                    "Allocated RX buffers of %d bytes at %08lx (mapped %p)\n",
2364                    size, (unsigned long)queue->rx_buffers_dma, queue->rx_buffers);
2365         return 0;
2366 }
2367
2368 static int macb_alloc_consistent(struct macb *bp)
2369 {
2370         struct macb_queue *queue;
2371         unsigned int q;
2372         int size;
2373
2374         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2375                 size = TX_RING_BYTES(bp) + bp->tx_bd_rd_prefetch;
2376                 queue->tx_ring = dma_alloc_coherent(&bp->pdev->dev, size,
2377                                                     &queue->tx_ring_dma,
2378                                                     GFP_KERNEL);
2379                 if (!queue->tx_ring)
2380                         goto out_err;
2381                 netdev_dbg(bp->dev,
2382                            "Allocated TX ring for queue %u of %d bytes at %08lx (mapped %p)\n",
2383                            q, size, (unsigned long)queue->tx_ring_dma,
2384                            queue->tx_ring);
2385
2386                 size = bp->tx_ring_size * sizeof(struct macb_tx_skb);
2387                 queue->tx_skb = kmalloc(size, GFP_KERNEL);
2388                 if (!queue->tx_skb)
2389                         goto out_err;
2390
2391                 size = RX_RING_BYTES(bp) + bp->rx_bd_rd_prefetch;
2392                 queue->rx_ring = dma_alloc_coherent(&bp->pdev->dev, size,
2393                                                  &queue->rx_ring_dma, GFP_KERNEL);
2394                 if (!queue->rx_ring)
2395                         goto out_err;
2396                 netdev_dbg(bp->dev,
2397                            "Allocated RX ring of %d bytes at %08lx (mapped %p)\n",
2398                            size, (unsigned long)queue->rx_ring_dma, queue->rx_ring);
2399         }
2400         if (bp->macbgem_ops.mog_alloc_rx_buffers(bp))
2401                 goto out_err;
2402
2403         return 0;
2404
2405 out_err:
2406         macb_free_consistent(bp);
2407         return -ENOMEM;
2408 }
2409
2410 static void gem_init_rings(struct macb *bp)
2411 {
2412         struct macb_queue *queue;
2413         struct macb_dma_desc *desc = NULL;
2414         unsigned int q;
2415         int i;
2416
2417         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2418                 for (i = 0; i < bp->tx_ring_size; i++) {
2419                         desc = macb_tx_desc(queue, i);
2420                         macb_set_addr(bp, desc, 0);
2421                         desc->ctrl = MACB_BIT(TX_USED);
2422                 }
2423                 desc->ctrl |= MACB_BIT(TX_WRAP);
2424                 queue->tx_head = 0;
2425                 queue->tx_tail = 0;
2426
2427                 queue->rx_tail = 0;
2428                 queue->rx_prepared_head = 0;
2429
2430                 gem_rx_refill(queue);
2431         }
2432
2433 }
2434
2435 static void macb_init_rings(struct macb *bp)
2436 {
2437         int i;
2438         struct macb_dma_desc *desc = NULL;
2439
2440         macb_init_rx_ring(&bp->queues[0]);
2441
2442         for (i = 0; i < bp->tx_ring_size; i++) {
2443                 desc = macb_tx_desc(&bp->queues[0], i);
2444                 macb_set_addr(bp, desc, 0);
2445                 desc->ctrl = MACB_BIT(TX_USED);
2446         }
2447         bp->queues[0].tx_head = 0;
2448         bp->queues[0].tx_tail = 0;
2449         desc->ctrl |= MACB_BIT(TX_WRAP);
2450 }
2451
2452 static void macb_reset_hw(struct macb *bp)
2453 {
2454         struct macb_queue *queue;
2455         unsigned int q;
2456         u32 ctrl = macb_readl(bp, NCR);
2457
2458         /* Disable RX and TX (XXX: Should we halt the transmission
2459          * more gracefully?)
2460          */
2461         ctrl &= ~(MACB_BIT(RE) | MACB_BIT(TE));
2462
2463         /* Clear the stats registers (XXX: Update stats first?) */
2464         ctrl |= MACB_BIT(CLRSTAT);
2465
2466         macb_writel(bp, NCR, ctrl);
2467
2468         /* Clear all status flags */
2469         macb_writel(bp, TSR, -1);
2470         macb_writel(bp, RSR, -1);
2471
2472         /* Disable all interrupts */
2473         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2474                 queue_writel(queue, IDR, -1);
2475                 queue_readl(queue, ISR);
2476                 if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
2477                         queue_writel(queue, ISR, -1);
2478         }
2479 }
2480
2481 static u32 gem_mdc_clk_div(struct macb *bp)
2482 {
2483         u32 config;
2484         unsigned long pclk_hz = clk_get_rate(bp->pclk);
2485
2486         if (pclk_hz <= 20000000)
2487                 config = GEM_BF(CLK, GEM_CLK_DIV8);
2488         else if (pclk_hz <= 40000000)
2489                 config = GEM_BF(CLK, GEM_CLK_DIV16);
2490         else if (pclk_hz <= 80000000)
2491                 config = GEM_BF(CLK, GEM_CLK_DIV32);
2492         else if (pclk_hz <= 120000000)
2493                 config = GEM_BF(CLK, GEM_CLK_DIV48);
2494         else if (pclk_hz <= 160000000)
2495                 config = GEM_BF(CLK, GEM_CLK_DIV64);
2496         else
2497                 config = GEM_BF(CLK, GEM_CLK_DIV96);
2498
2499         return config;
2500 }
2501
2502 static u32 macb_mdc_clk_div(struct macb *bp)
2503 {
2504         u32 config;
2505         unsigned long pclk_hz;
2506
2507         if (macb_is_gem(bp))
2508                 return gem_mdc_clk_div(bp);
2509
2510         pclk_hz = clk_get_rate(bp->pclk);
2511         if (pclk_hz <= 20000000)
2512                 config = MACB_BF(CLK, MACB_CLK_DIV8);
2513         else if (pclk_hz <= 40000000)
2514                 config = MACB_BF(CLK, MACB_CLK_DIV16);
2515         else if (pclk_hz <= 80000000)
2516                 config = MACB_BF(CLK, MACB_CLK_DIV32);
2517         else
2518                 config = MACB_BF(CLK, MACB_CLK_DIV64);
2519
2520         return config;
2521 }
2522
2523 /* Get the DMA bus width field of the network configuration register that we
2524  * should program.  We find the width from decoding the design configuration
2525  * register to find the maximum supported data bus width.
2526  */
2527 static u32 macb_dbw(struct macb *bp)
2528 {
2529         if (!macb_is_gem(bp))
2530                 return 0;
2531
2532         switch (GEM_BFEXT(DBWDEF, gem_readl(bp, DCFG1))) {
2533         case 4:
2534                 return GEM_BF(DBW, GEM_DBW128);
2535         case 2:
2536                 return GEM_BF(DBW, GEM_DBW64);
2537         case 1:
2538         default:
2539                 return GEM_BF(DBW, GEM_DBW32);
2540         }
2541 }
2542
2543 /* Configure the receive DMA engine
2544  * - use the correct receive buffer size
2545  * - set best burst length for DMA operations
2546  *   (if not supported by FIFO, it will fallback to default)
2547  * - set both rx/tx packet buffers to full memory size
2548  * These are configurable parameters for GEM.
2549  */
2550 static void macb_configure_dma(struct macb *bp)
2551 {
2552         struct macb_queue *queue;
2553         u32 buffer_size;
2554         unsigned int q;
2555         u32 dmacfg;
2556
2557         buffer_size = bp->rx_buffer_size / RX_BUFFER_MULTIPLE;
2558         if (macb_is_gem(bp)) {
2559                 dmacfg = gem_readl(bp, DMACFG) & ~GEM_BF(RXBS, -1L);
2560                 for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2561                         if (q)
2562                                 queue_writel(queue, RBQS, buffer_size);
2563                         else
2564                                 dmacfg |= GEM_BF(RXBS, buffer_size);
2565                 }
2566                 if (bp->dma_burst_length)
2567                         dmacfg = GEM_BFINS(FBLDO, bp->dma_burst_length, dmacfg);
2568                 dmacfg |= GEM_BIT(TXPBMS) | GEM_BF(RXBMS, -1L);
2569                 dmacfg &= ~GEM_BIT(ENDIA_PKT);
2570
2571                 if (bp->native_io)
2572                         dmacfg &= ~GEM_BIT(ENDIA_DESC);
2573                 else
2574                         dmacfg |= GEM_BIT(ENDIA_DESC); /* CPU in big endian */
2575
2576                 if (bp->dev->features & NETIF_F_HW_CSUM)
2577                         dmacfg |= GEM_BIT(TXCOEN);
2578                 else
2579                         dmacfg &= ~GEM_BIT(TXCOEN);
2580
2581                 dmacfg &= ~GEM_BIT(ADDR64);
2582 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
2583                 if (bp->hw_dma_cap & HW_DMA_CAP_64B)
2584                         dmacfg |= GEM_BIT(ADDR64);
2585 #endif
2586 #ifdef CONFIG_MACB_USE_HWSTAMP
2587                 if (bp->hw_dma_cap & HW_DMA_CAP_PTP)
2588                         dmacfg |= GEM_BIT(RXEXT) | GEM_BIT(TXEXT);
2589 #endif
2590                 netdev_dbg(bp->dev, "Cadence configure DMA with 0x%08x\n",
2591                            dmacfg);
2592                 gem_writel(bp, DMACFG, dmacfg);
2593         }
2594 }
2595
2596 static void macb_init_hw(struct macb *bp)
2597 {
2598         u32 config;
2599
2600         macb_reset_hw(bp);
2601         macb_set_hwaddr(bp);
2602
2603         config = macb_mdc_clk_div(bp);
2604         config |= MACB_BF(RBOF, NET_IP_ALIGN);  /* Make eth data aligned */
2605         config |= MACB_BIT(DRFCS);              /* Discard Rx FCS */
2606         if (bp->caps & MACB_CAPS_JUMBO)
2607                 config |= MACB_BIT(JFRAME);     /* Enable jumbo frames */
2608         else
2609                 config |= MACB_BIT(BIG);        /* Receive oversized frames */
2610         if (bp->dev->flags & IFF_PROMISC)
2611                 config |= MACB_BIT(CAF);        /* Copy All Frames */
2612         else if (macb_is_gem(bp) && bp->dev->features & NETIF_F_RXCSUM)
2613                 config |= GEM_BIT(RXCOEN);
2614         if (!(bp->dev->flags & IFF_BROADCAST))
2615                 config |= MACB_BIT(NBC);        /* No BroadCast */
2616         config |= macb_dbw(bp);
2617         macb_writel(bp, NCFGR, config);
2618         if ((bp->caps & MACB_CAPS_JUMBO) && bp->jumbo_max_len)
2619                 gem_writel(bp, JML, bp->jumbo_max_len);
2620         bp->rx_frm_len_mask = MACB_RX_FRMLEN_MASK;
2621         if (bp->caps & MACB_CAPS_JUMBO)
2622                 bp->rx_frm_len_mask = MACB_RX_JFRMLEN_MASK;
2623
2624         macb_configure_dma(bp);
2625 }
2626
2627 /* The hash address register is 64 bits long and takes up two
2628  * locations in the memory map.  The least significant bits are stored
2629  * in EMAC_HSL and the most significant bits in EMAC_HSH.
2630  *
2631  * The unicast hash enable and the multicast hash enable bits in the
2632  * network configuration register enable the reception of hash matched
2633  * frames. The destination address is reduced to a 6 bit index into
2634  * the 64 bit hash register using the following hash function.  The
2635  * hash function is an exclusive or of every sixth bit of the
2636  * destination address.
2637  *
2638  * hi[5] = da[5] ^ da[11] ^ da[17] ^ da[23] ^ da[29] ^ da[35] ^ da[41] ^ da[47]
2639  * hi[4] = da[4] ^ da[10] ^ da[16] ^ da[22] ^ da[28] ^ da[34] ^ da[40] ^ da[46]
2640  * hi[3] = da[3] ^ da[09] ^ da[15] ^ da[21] ^ da[27] ^ da[33] ^ da[39] ^ da[45]
2641  * hi[2] = da[2] ^ da[08] ^ da[14] ^ da[20] ^ da[26] ^ da[32] ^ da[38] ^ da[44]
2642  * hi[1] = da[1] ^ da[07] ^ da[13] ^ da[19] ^ da[25] ^ da[31] ^ da[37] ^ da[43]
2643  * hi[0] = da[0] ^ da[06] ^ da[12] ^ da[18] ^ da[24] ^ da[30] ^ da[36] ^ da[42]
2644  *
2645  * da[0] represents the least significant bit of the first byte
2646  * received, that is, the multicast/unicast indicator, and da[47]
2647  * represents the most significant bit of the last byte received.  If
2648  * the hash index, hi[n], points to a bit that is set in the hash
2649  * register then the frame will be matched according to whether the
2650  * frame is multicast or unicast.  A multicast match will be signalled
2651  * if the multicast hash enable bit is set, da[0] is 1 and the hash
2652  * index points to a bit set in the hash register.  A unicast match
2653  * will be signalled if the unicast hash enable bit is set, da[0] is 0
2654  * and the hash index points to a bit set in the hash register.  To
2655  * receive all multicast frames, the hash register should be set with
2656  * all ones and the multicast hash enable bit should be set in the
2657  * network configuration register.
2658  */
2659
2660 static inline int hash_bit_value(int bitnr, __u8 *addr)
2661 {
2662         if (addr[bitnr / 8] & (1 << (bitnr % 8)))
2663                 return 1;
2664         return 0;
2665 }
2666
2667 /* Return the hash index value for the specified address. */
2668 static int hash_get_index(__u8 *addr)
2669 {
2670         int i, j, bitval;
2671         int hash_index = 0;
2672
2673         for (j = 0; j < 6; j++) {
2674                 for (i = 0, bitval = 0; i < 8; i++)
2675                         bitval ^= hash_bit_value(i * 6 + j, addr);
2676
2677                 hash_index |= (bitval << j);
2678         }
2679
2680         return hash_index;
2681 }
2682
2683 /* Add multicast addresses to the internal multicast-hash table. */
2684 static void macb_sethashtable(struct net_device *dev)
2685 {
2686         struct netdev_hw_addr *ha;
2687         unsigned long mc_filter[2];
2688         unsigned int bitnr;
2689         struct macb *bp = netdev_priv(dev);
2690
2691         mc_filter[0] = 0;
2692         mc_filter[1] = 0;
2693
2694         netdev_for_each_mc_addr(ha, dev) {
2695                 bitnr = hash_get_index(ha->addr);
2696                 mc_filter[bitnr >> 5] |= 1 << (bitnr & 31);
2697         }
2698
2699         macb_or_gem_writel(bp, HRB, mc_filter[0]);
2700         macb_or_gem_writel(bp, HRT, mc_filter[1]);
2701 }
2702
2703 /* Enable/Disable promiscuous and multicast modes. */
2704 static void macb_set_rx_mode(struct net_device *dev)
2705 {
2706         unsigned long cfg;
2707         struct macb *bp = netdev_priv(dev);
2708
2709         cfg = macb_readl(bp, NCFGR);
2710
2711         if (dev->flags & IFF_PROMISC) {
2712                 /* Enable promiscuous mode */
2713                 cfg |= MACB_BIT(CAF);
2714
2715                 /* Disable RX checksum offload */
2716                 if (macb_is_gem(bp))
2717                         cfg &= ~GEM_BIT(RXCOEN);
2718         } else {
2719                 /* Disable promiscuous mode */
2720                 cfg &= ~MACB_BIT(CAF);
2721
2722                 /* Enable RX checksum offload only if requested */
2723                 if (macb_is_gem(bp) && dev->features & NETIF_F_RXCSUM)
2724                         cfg |= GEM_BIT(RXCOEN);
2725         }
2726
2727         if (dev->flags & IFF_ALLMULTI) {
2728                 /* Enable all multicast mode */
2729                 macb_or_gem_writel(bp, HRB, -1);
2730                 macb_or_gem_writel(bp, HRT, -1);
2731                 cfg |= MACB_BIT(NCFGR_MTI);
2732         } else if (!netdev_mc_empty(dev)) {
2733                 /* Enable specific multicasts */
2734                 macb_sethashtable(dev);
2735                 cfg |= MACB_BIT(NCFGR_MTI);
2736         } else if (dev->flags & (~IFF_ALLMULTI)) {
2737                 /* Disable all multicast mode */
2738                 macb_or_gem_writel(bp, HRB, 0);
2739                 macb_or_gem_writel(bp, HRT, 0);
2740                 cfg &= ~MACB_BIT(NCFGR_MTI);
2741         }
2742
2743         macb_writel(bp, NCFGR, cfg);
2744 }
2745
2746 static int macb_open(struct net_device *dev)
2747 {
2748         size_t bufsz = dev->mtu + ETH_HLEN + ETH_FCS_LEN + NET_IP_ALIGN;
2749         struct macb *bp = netdev_priv(dev);
2750         struct macb_queue *queue;
2751         unsigned int q;
2752         int err;
2753
2754         netdev_dbg(bp->dev, "open\n");
2755
2756         err = pm_runtime_get_sync(&bp->pdev->dev);
2757         if (err < 0)
2758                 goto pm_exit;
2759
2760         /* RX buffers initialization */
2761         macb_init_rx_buffer_size(bp, bufsz);
2762
2763         err = macb_alloc_consistent(bp);
2764         if (err) {
2765                 netdev_err(dev, "Unable to allocate DMA memory (error %d)\n",
2766                            err);
2767                 goto pm_exit;
2768         }
2769
2770         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
2771                 napi_enable(&queue->napi);
2772
2773         macb_init_hw(bp);
2774
2775         err = macb_phylink_connect(bp);
2776         if (err)
2777                 goto reset_hw;
2778
2779         netif_tx_start_all_queues(dev);
2780
2781         if (bp->ptp_info)
2782                 bp->ptp_info->ptp_init(dev);
2783
2784         return 0;
2785
2786 reset_hw:
2787         macb_reset_hw(bp);
2788         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
2789                 napi_disable(&queue->napi);
2790         macb_free_consistent(bp);
2791 pm_exit:
2792         pm_runtime_put_sync(&bp->pdev->dev);
2793         return err;
2794 }
2795
2796 static int macb_close(struct net_device *dev)
2797 {
2798         struct macb *bp = netdev_priv(dev);
2799         struct macb_queue *queue;
2800         unsigned long flags;
2801         unsigned int q;
2802
2803         netif_tx_stop_all_queues(dev);
2804
2805         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
2806                 napi_disable(&queue->napi);
2807
2808         phylink_stop(bp->phylink);
2809         phylink_disconnect_phy(bp->phylink);
2810
2811         spin_lock_irqsave(&bp->lock, flags);
2812         macb_reset_hw(bp);
2813         netif_carrier_off(dev);
2814         spin_unlock_irqrestore(&bp->lock, flags);
2815
2816         macb_free_consistent(bp);
2817
2818         if (bp->ptp_info)
2819                 bp->ptp_info->ptp_remove(dev);
2820
2821         pm_runtime_put(&bp->pdev->dev);
2822
2823         return 0;
2824 }
2825
2826 static int macb_change_mtu(struct net_device *dev, int new_mtu)
2827 {
2828         if (netif_running(dev))
2829                 return -EBUSY;
2830
2831         dev->mtu = new_mtu;
2832
2833         return 0;
2834 }
2835
2836 static void gem_update_stats(struct macb *bp)
2837 {
2838         struct macb_queue *queue;
2839         unsigned int i, q, idx;
2840         unsigned long *stat;
2841
2842         u32 *p = &bp->hw_stats.gem.tx_octets_31_0;
2843
2844         for (i = 0; i < GEM_STATS_LEN; ++i, ++p) {
2845                 u32 offset = gem_statistics[i].offset;
2846                 u64 val = bp->macb_reg_readl(bp, offset);
2847
2848                 bp->ethtool_stats[i] += val;
2849                 *p += val;
2850
2851                 if (offset == GEM_OCTTXL || offset == GEM_OCTRXL) {
2852                         /* Add GEM_OCTTXH, GEM_OCTRXH */
2853                         val = bp->macb_reg_readl(bp, offset + 4);
2854                         bp->ethtool_stats[i] += ((u64)val) << 32;
2855                         *(++p) += val;
2856                 }
2857         }
2858
2859         idx = GEM_STATS_LEN;
2860         for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
2861                 for (i = 0, stat = &queue->stats.first; i < QUEUE_STATS_LEN; ++i, ++stat)
2862                         bp->ethtool_stats[idx++] = *stat;
2863 }
2864
2865 static struct net_device_stats *gem_get_stats(struct macb *bp)
2866 {
2867         struct gem_stats *hwstat = &bp->hw_stats.gem;
2868         struct net_device_stats *nstat = &bp->dev->stats;
2869
2870         gem_update_stats(bp);
2871
2872         nstat->rx_errors = (hwstat->rx_frame_check_sequence_errors +
2873                             hwstat->rx_alignment_errors +
2874                             hwstat->rx_resource_errors +
2875                             hwstat->rx_overruns +
2876                             hwstat->rx_oversize_frames +
2877                             hwstat->rx_jabbers +
2878                             hwstat->rx_undersized_frames +
2879                             hwstat->rx_length_field_frame_errors);
2880         nstat->tx_errors = (hwstat->tx_late_collisions +
2881                             hwstat->tx_excessive_collisions +
2882                             hwstat->tx_underrun +
2883                             hwstat->tx_carrier_sense_errors);
2884         nstat->multicast = hwstat->rx_multicast_frames;
2885         nstat->collisions = (hwstat->tx_single_collision_frames +
2886                              hwstat->tx_multiple_collision_frames +
2887                              hwstat->tx_excessive_collisions);
2888         nstat->rx_length_errors = (hwstat->rx_oversize_frames +
2889                                    hwstat->rx_jabbers +
2890                                    hwstat->rx_undersized_frames +
2891                                    hwstat->rx_length_field_frame_errors);
2892         nstat->rx_over_errors = hwstat->rx_resource_errors;
2893         nstat->rx_crc_errors = hwstat->rx_frame_check_sequence_errors;
2894         nstat->rx_frame_errors = hwstat->rx_alignment_errors;
2895         nstat->rx_fifo_errors = hwstat->rx_overruns;
2896         nstat->tx_aborted_errors = hwstat->tx_excessive_collisions;
2897         nstat->tx_carrier_errors = hwstat->tx_carrier_sense_errors;
2898         nstat->tx_fifo_errors = hwstat->tx_underrun;
2899
2900         return nstat;
2901 }
2902
2903 static void gem_get_ethtool_stats(struct net_device *dev,
2904                                   struct ethtool_stats *stats, u64 *data)
2905 {
2906         struct macb *bp;
2907
2908         bp = netdev_priv(dev);
2909         gem_update_stats(bp);
2910         memcpy(data, &bp->ethtool_stats, sizeof(u64)
2911                         * (GEM_STATS_LEN + QUEUE_STATS_LEN * MACB_MAX_QUEUES));
2912 }
2913
2914 static int gem_get_sset_count(struct net_device *dev, int sset)
2915 {
2916         struct macb *bp = netdev_priv(dev);
2917
2918         switch (sset) {
2919         case ETH_SS_STATS:
2920                 return GEM_STATS_LEN + bp->num_queues * QUEUE_STATS_LEN;
2921         default:
2922                 return -EOPNOTSUPP;
2923         }
2924 }
2925
2926 static void gem_get_ethtool_strings(struct net_device *dev, u32 sset, u8 *p)
2927 {
2928         char stat_string[ETH_GSTRING_LEN];
2929         struct macb *bp = netdev_priv(dev);
2930         struct macb_queue *queue;
2931         unsigned int i;
2932         unsigned int q;
2933
2934         switch (sset) {
2935         case ETH_SS_STATS:
2936                 for (i = 0; i < GEM_STATS_LEN; i++, p += ETH_GSTRING_LEN)
2937                         memcpy(p, gem_statistics[i].stat_string,
2938                                ETH_GSTRING_LEN);
2939
2940                 for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
2941                         for (i = 0; i < QUEUE_STATS_LEN; i++, p += ETH_GSTRING_LEN) {
2942                                 snprintf(stat_string, ETH_GSTRING_LEN, "q%d_%s",
2943                                                 q, queue_statistics[i].stat_string);
2944                                 memcpy(p, stat_string, ETH_GSTRING_LEN);
2945                         }
2946                 }
2947                 break;
2948         }
2949 }
2950
2951 static struct net_device_stats *macb_get_stats(struct net_device *dev)
2952 {
2953         struct macb *bp = netdev_priv(dev);
2954         struct net_device_stats *nstat = &bp->dev->stats;
2955         struct macb_stats *hwstat = &bp->hw_stats.macb;
2956
2957         if (macb_is_gem(bp))
2958                 return gem_get_stats(bp);
2959
2960         /* read stats from hardware */
2961         macb_update_stats(bp);
2962
2963         /* Convert HW stats into netdevice stats */
2964         nstat->rx_errors = (hwstat->rx_fcs_errors +
2965                             hwstat->rx_align_errors +
2966                             hwstat->rx_resource_errors +
2967                             hwstat->rx_overruns +
2968                             hwstat->rx_oversize_pkts +
2969                             hwstat->rx_jabbers +
2970                             hwstat->rx_undersize_pkts +
2971                             hwstat->rx_length_mismatch);
2972         nstat->tx_errors = (hwstat->tx_late_cols +
2973                             hwstat->tx_excessive_cols +
2974                             hwstat->tx_underruns +
2975                             hwstat->tx_carrier_errors +
2976                             hwstat->sqe_test_errors);
2977         nstat->collisions = (hwstat->tx_single_cols +
2978                              hwstat->tx_multiple_cols +
2979                              hwstat->tx_excessive_cols);
2980         nstat->rx_length_errors = (hwstat->rx_oversize_pkts +
2981                                    hwstat->rx_jabbers +
2982                                    hwstat->rx_undersize_pkts +
2983                                    hwstat->rx_length_mismatch);
2984         nstat->rx_over_errors = hwstat->rx_resource_errors +
2985                                    hwstat->rx_overruns;
2986         nstat->rx_crc_errors = hwstat->rx_fcs_errors;
2987         nstat->rx_frame_errors = hwstat->rx_align_errors;
2988         nstat->rx_fifo_errors = hwstat->rx_overruns;
2989         /* XXX: What does "missed" mean? */
2990         nstat->tx_aborted_errors = hwstat->tx_excessive_cols;
2991         nstat->tx_carrier_errors = hwstat->tx_carrier_errors;
2992         nstat->tx_fifo_errors = hwstat->tx_underruns;
2993         /* Don't know about heartbeat or window errors... */
2994
2995         return nstat;
2996 }
2997
2998 static int macb_get_regs_len(struct net_device *netdev)
2999 {
3000         return MACB_GREGS_NBR * sizeof(u32);
3001 }
3002
3003 static void macb_get_regs(struct net_device *dev, struct ethtool_regs *regs,
3004                           void *p)
3005 {
3006         struct macb *bp = netdev_priv(dev);
3007         unsigned int tail, head;
3008         u32 *regs_buff = p;
3009
3010         regs->version = (macb_readl(bp, MID) & ((1 << MACB_REV_SIZE) - 1))
3011                         | MACB_GREGS_VERSION;
3012
3013         tail = macb_tx_ring_wrap(bp, bp->queues[0].tx_tail);
3014         head = macb_tx_ring_wrap(bp, bp->queues[0].tx_head);
3015
3016         regs_buff[0]  = macb_readl(bp, NCR);
3017         regs_buff[1]  = macb_or_gem_readl(bp, NCFGR);
3018         regs_buff[2]  = macb_readl(bp, NSR);
3019         regs_buff[3]  = macb_readl(bp, TSR);
3020         regs_buff[4]  = macb_readl(bp, RBQP);
3021         regs_buff[5]  = macb_readl(bp, TBQP);
3022         regs_buff[6]  = macb_readl(bp, RSR);
3023         regs_buff[7]  = macb_readl(bp, IMR);
3024
3025         regs_buff[8]  = tail;
3026         regs_buff[9]  = head;
3027         regs_buff[10] = macb_tx_dma(&bp->queues[0], tail);
3028         regs_buff[11] = macb_tx_dma(&bp->queues[0], head);
3029
3030         if (!(bp->caps & MACB_CAPS_USRIO_DISABLED))
3031                 regs_buff[12] = macb_or_gem_readl(bp, USRIO);
3032         if (macb_is_gem(bp))
3033                 regs_buff[13] = gem_readl(bp, DMACFG);
3034 }
3035
3036 static void macb_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
3037 {
3038         struct macb *bp = netdev_priv(netdev);
3039
3040         if (bp->wol & MACB_WOL_HAS_MAGIC_PACKET) {
3041                 phylink_ethtool_get_wol(bp->phylink, wol);
3042                 wol->supported |= WAKE_MAGIC;
3043
3044                 if (bp->wol & MACB_WOL_ENABLED)
3045                         wol->wolopts |= WAKE_MAGIC;
3046         }
3047 }
3048
3049 static int macb_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
3050 {
3051         struct macb *bp = netdev_priv(netdev);
3052         int ret;
3053
3054         /* Pass the order to phylink layer */
3055         ret = phylink_ethtool_set_wol(bp->phylink, wol);
3056         /* Don't manage WoL on MAC if handled by the PHY
3057          * or if there's a failure in talking to the PHY
3058          */
3059         if (!ret || ret != -EOPNOTSUPP)
3060                 return ret;
3061
3062         if (!(bp->wol & MACB_WOL_HAS_MAGIC_PACKET) ||
3063             (wol->wolopts & ~WAKE_MAGIC))
3064                 return -EOPNOTSUPP;
3065
3066         if (wol->wolopts & WAKE_MAGIC)
3067                 bp->wol |= MACB_WOL_ENABLED;
3068         else
3069                 bp->wol &= ~MACB_WOL_ENABLED;
3070
3071         device_set_wakeup_enable(&bp->pdev->dev, bp->wol & MACB_WOL_ENABLED);
3072
3073         return 0;
3074 }
3075
3076 static int macb_get_link_ksettings(struct net_device *netdev,
3077                                    struct ethtool_link_ksettings *kset)
3078 {
3079         struct macb *bp = netdev_priv(netdev);
3080
3081         return phylink_ethtool_ksettings_get(bp->phylink, kset);
3082 }
3083
3084 static int macb_set_link_ksettings(struct net_device *netdev,
3085                                    const struct ethtool_link_ksettings *kset)
3086 {
3087         struct macb *bp = netdev_priv(netdev);
3088
3089         return phylink_ethtool_ksettings_set(bp->phylink, kset);
3090 }
3091
3092 static void macb_get_ringparam(struct net_device *netdev,
3093                                struct ethtool_ringparam *ring)
3094 {
3095         struct macb *bp = netdev_priv(netdev);
3096
3097         ring->rx_max_pending = MAX_RX_RING_SIZE;
3098         ring->tx_max_pending = MAX_TX_RING_SIZE;
3099
3100         ring->rx_pending = bp->rx_ring_size;
3101         ring->tx_pending = bp->tx_ring_size;
3102 }
3103
3104 static int macb_set_ringparam(struct net_device *netdev,
3105                               struct ethtool_ringparam *ring)
3106 {
3107         struct macb *bp = netdev_priv(netdev);
3108         u32 new_rx_size, new_tx_size;
3109         unsigned int reset = 0;
3110
3111         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
3112                 return -EINVAL;
3113
3114         new_rx_size = clamp_t(u32, ring->rx_pending,
3115                               MIN_RX_RING_SIZE, MAX_RX_RING_SIZE);
3116         new_rx_size = roundup_pow_of_two(new_rx_size);
3117
3118         new_tx_size = clamp_t(u32, ring->tx_pending,
3119                               MIN_TX_RING_SIZE, MAX_TX_RING_SIZE);
3120         new_tx_size = roundup_pow_of_two(new_tx_size);
3121
3122         if ((new_tx_size == bp->tx_ring_size) &&
3123             (new_rx_size == bp->rx_ring_size)) {
3124                 /* nothing to do */
3125                 return 0;
3126         }
3127
3128         if (netif_running(bp->dev)) {
3129                 reset = 1;
3130                 macb_close(bp->dev);
3131         }
3132
3133         bp->rx_ring_size = new_rx_size;
3134         bp->tx_ring_size = new_tx_size;
3135
3136         if (reset)
3137                 macb_open(bp->dev);
3138
3139         return 0;
3140 }
3141
3142 #ifdef CONFIG_MACB_USE_HWSTAMP
3143 static unsigned int gem_get_tsu_rate(struct macb *bp)
3144 {
3145         struct clk *tsu_clk;
3146         unsigned int tsu_rate;
3147
3148         tsu_clk = devm_clk_get(&bp->pdev->dev, "tsu_clk");
3149         if (!IS_ERR(tsu_clk))
3150                 tsu_rate = clk_get_rate(tsu_clk);
3151         /* try pclk instead */
3152         else if (!IS_ERR(bp->pclk)) {
3153                 tsu_clk = bp->pclk;
3154                 tsu_rate = clk_get_rate(tsu_clk);
3155         } else
3156                 return -ENOTSUPP;
3157         return tsu_rate;
3158 }
3159
3160 static s32 gem_get_ptp_max_adj(void)
3161 {
3162         return 64000000;
3163 }
3164
3165 static int gem_get_ts_info(struct net_device *dev,
3166                            struct ethtool_ts_info *info)
3167 {
3168         struct macb *bp = netdev_priv(dev);
3169
3170         if ((bp->hw_dma_cap & HW_DMA_CAP_PTP) == 0) {
3171                 ethtool_op_get_ts_info(dev, info);
3172                 return 0;
3173         }
3174
3175         info->so_timestamping =
3176                 SOF_TIMESTAMPING_TX_SOFTWARE |
3177                 SOF_TIMESTAMPING_RX_SOFTWARE |
3178                 SOF_TIMESTAMPING_SOFTWARE |
3179                 SOF_TIMESTAMPING_TX_HARDWARE |
3180                 SOF_TIMESTAMPING_RX_HARDWARE |
3181                 SOF_TIMESTAMPING_RAW_HARDWARE;
3182         info->tx_types =
3183                 (1 << HWTSTAMP_TX_ONESTEP_SYNC) |
3184                 (1 << HWTSTAMP_TX_OFF) |
3185                 (1 << HWTSTAMP_TX_ON);
3186         info->rx_filters =
3187                 (1 << HWTSTAMP_FILTER_NONE) |
3188                 (1 << HWTSTAMP_FILTER_ALL);
3189
3190         info->phc_index = bp->ptp_clock ? ptp_clock_index(bp->ptp_clock) : -1;
3191
3192         return 0;
3193 }
3194
3195 static struct macb_ptp_info gem_ptp_info = {
3196         .ptp_init        = gem_ptp_init,
3197         .ptp_remove      = gem_ptp_remove,
3198         .get_ptp_max_adj = gem_get_ptp_max_adj,
3199         .get_tsu_rate    = gem_get_tsu_rate,
3200         .get_ts_info     = gem_get_ts_info,
3201         .get_hwtst       = gem_get_hwtst,
3202         .set_hwtst       = gem_set_hwtst,
3203 };
3204 #endif
3205
3206 static int macb_get_ts_info(struct net_device *netdev,
3207                             struct ethtool_ts_info *info)
3208 {
3209         struct macb *bp = netdev_priv(netdev);
3210
3211         if (bp->ptp_info)
3212                 return bp->ptp_info->get_ts_info(netdev, info);
3213
3214         return ethtool_op_get_ts_info(netdev, info);
3215 }
3216
3217 static void gem_enable_flow_filters(struct macb *bp, bool enable)
3218 {
3219         struct net_device *netdev = bp->dev;
3220         struct ethtool_rx_fs_item *item;
3221         u32 t2_scr;
3222         int num_t2_scr;
3223
3224         if (!(netdev->features & NETIF_F_NTUPLE))
3225                 return;
3226
3227         num_t2_scr = GEM_BFEXT(T2SCR, gem_readl(bp, DCFG8));
3228
3229         list_for_each_entry(item, &bp->rx_fs_list.list, list) {
3230                 struct ethtool_rx_flow_spec *fs = &item->fs;
3231                 struct ethtool_tcpip4_spec *tp4sp_m;
3232
3233                 if (fs->location >= num_t2_scr)
3234                         continue;
3235
3236                 t2_scr = gem_readl_n(bp, SCRT2, fs->location);
3237
3238                 /* enable/disable screener regs for the flow entry */
3239                 t2_scr = GEM_BFINS(ETHTEN, enable, t2_scr);
3240
3241                 /* only enable fields with no masking */
3242                 tp4sp_m = &(fs->m_u.tcp_ip4_spec);
3243
3244                 if (enable && (tp4sp_m->ip4src == 0xFFFFFFFF))
3245                         t2_scr = GEM_BFINS(CMPAEN, 1, t2_scr);
3246                 else
3247                         t2_scr = GEM_BFINS(CMPAEN, 0, t2_scr);
3248
3249                 if (enable && (tp4sp_m->ip4dst == 0xFFFFFFFF))
3250                         t2_scr = GEM_BFINS(CMPBEN, 1, t2_scr);
3251                 else
3252                         t2_scr = GEM_BFINS(CMPBEN, 0, t2_scr);
3253
3254                 if (enable && ((tp4sp_m->psrc == 0xFFFF) || (tp4sp_m->pdst == 0xFFFF)))
3255                         t2_scr = GEM_BFINS(CMPCEN, 1, t2_scr);
3256                 else
3257                         t2_scr = GEM_BFINS(CMPCEN, 0, t2_scr);
3258
3259                 gem_writel_n(bp, SCRT2, fs->location, t2_scr);
3260         }
3261 }
3262
3263 static void gem_prog_cmp_regs(struct macb *bp, struct ethtool_rx_flow_spec *fs)
3264 {
3265         struct ethtool_tcpip4_spec *tp4sp_v, *tp4sp_m;
3266         uint16_t index = fs->location;
3267         u32 w0, w1, t2_scr;
3268         bool cmp_a = false;
3269         bool cmp_b = false;
3270         bool cmp_c = false;
3271
3272         tp4sp_v = &(fs->h_u.tcp_ip4_spec);
3273         tp4sp_m = &(fs->m_u.tcp_ip4_spec);
3274
3275         /* ignore field if any masking set */
3276         if (tp4sp_m->ip4src == 0xFFFFFFFF) {
3277                 /* 1st compare reg - IP source address */
3278                 w0 = 0;
3279                 w1 = 0;
3280                 w0 = tp4sp_v->ip4src;
3281                 w1 = GEM_BFINS(T2DISMSK, 1, w1); /* 32-bit compare */
3282                 w1 = GEM_BFINS(T2CMPOFST, GEM_T2COMPOFST_ETYPE, w1);
3283                 w1 = GEM_BFINS(T2OFST, ETYPE_SRCIP_OFFSET, w1);
3284                 gem_writel_n(bp, T2CMPW0, T2CMP_OFST(GEM_IP4SRC_CMP(index)), w0);
3285                 gem_writel_n(bp, T2CMPW1, T2CMP_OFST(GEM_IP4SRC_CMP(index)), w1);
3286                 cmp_a = true;
3287         }
3288
3289         /* ignore field if any masking set */
3290         if (tp4sp_m->ip4dst == 0xFFFFFFFF) {
3291                 /* 2nd compare reg - IP destination address */
3292                 w0 = 0;
3293                 w1 = 0;
3294                 w0 = tp4sp_v->ip4dst;
3295                 w1 = GEM_BFINS(T2DISMSK, 1, w1); /* 32-bit compare */
3296                 w1 = GEM_BFINS(T2CMPOFST, GEM_T2COMPOFST_ETYPE, w1);
3297                 w1 = GEM_BFINS(T2OFST, ETYPE_DSTIP_OFFSET, w1);
3298                 gem_writel_n(bp, T2CMPW0, T2CMP_OFST(GEM_IP4DST_CMP(index)), w0);
3299                 gem_writel_n(bp, T2CMPW1, T2CMP_OFST(GEM_IP4DST_CMP(index)), w1);
3300                 cmp_b = true;
3301         }
3302
3303         /* ignore both port fields if masking set in both */
3304         if ((tp4sp_m->psrc == 0xFFFF) || (tp4sp_m->pdst == 0xFFFF)) {
3305                 /* 3rd compare reg - source port, destination port */
3306                 w0 = 0;
3307                 w1 = 0;
3308                 w1 = GEM_BFINS(T2CMPOFST, GEM_T2COMPOFST_IPHDR, w1);
3309                 if (tp4sp_m->psrc == tp4sp_m->pdst) {
3310                         w0 = GEM_BFINS(T2MASK, tp4sp_v->psrc, w0);
3311                         w0 = GEM_BFINS(T2CMP, tp4sp_v->pdst, w0);
3312                         w1 = GEM_BFINS(T2DISMSK, 1, w1); /* 32-bit compare */
3313                         w1 = GEM_BFINS(T2OFST, IPHDR_SRCPORT_OFFSET, w1);
3314                 } else {
3315                         /* only one port definition */
3316                         w1 = GEM_BFINS(T2DISMSK, 0, w1); /* 16-bit compare */
3317                         w0 = GEM_BFINS(T2MASK, 0xFFFF, w0);
3318                         if (tp4sp_m->psrc == 0xFFFF) { /* src port */
3319                                 w0 = GEM_BFINS(T2CMP, tp4sp_v->psrc, w0);
3320                                 w1 = GEM_BFINS(T2OFST, IPHDR_SRCPORT_OFFSET, w1);
3321                         } else { /* dst port */
3322                                 w0 = GEM_BFINS(T2CMP, tp4sp_v->pdst, w0);
3323                                 w1 = GEM_BFINS(T2OFST, IPHDR_DSTPORT_OFFSET, w1);
3324                         }
3325                 }
3326                 gem_writel_n(bp, T2CMPW0, T2CMP_OFST(GEM_PORT_CMP(index)), w0);
3327                 gem_writel_n(bp, T2CMPW1, T2CMP_OFST(GEM_PORT_CMP(index)), w1);
3328                 cmp_c = true;
3329         }
3330
3331         t2_scr = 0;
3332         t2_scr = GEM_BFINS(QUEUE, (fs->ring_cookie) & 0xFF, t2_scr);
3333         t2_scr = GEM_BFINS(ETHT2IDX, SCRT2_ETHT, t2_scr);
3334         if (cmp_a)
3335                 t2_scr = GEM_BFINS(CMPA, GEM_IP4SRC_CMP(index), t2_scr);
3336         if (cmp_b)
3337                 t2_scr = GEM_BFINS(CMPB, GEM_IP4DST_CMP(index), t2_scr);
3338         if (cmp_c)
3339                 t2_scr = GEM_BFINS(CMPC, GEM_PORT_CMP(index), t2_scr);
3340         gem_writel_n(bp, SCRT2, index, t2_scr);
3341 }
3342
3343 static int gem_add_flow_filter(struct net_device *netdev,
3344                 struct ethtool_rxnfc *cmd)
3345 {
3346         struct macb *bp = netdev_priv(netdev);
3347         struct ethtool_rx_flow_spec *fs = &cmd->fs;
3348         struct ethtool_rx_fs_item *item, *newfs;
3349         unsigned long flags;
3350         int ret = -EINVAL;
3351         bool added = false;
3352
3353         newfs = kmalloc(sizeof(*newfs), GFP_KERNEL);
3354         if (newfs == NULL)
3355                 return -ENOMEM;
3356         memcpy(&newfs->fs, fs, sizeof(newfs->fs));
3357
3358         netdev_dbg(netdev,
3359                         "Adding flow filter entry,type=%u,queue=%u,loc=%u,src=%08X,dst=%08X,ps=%u,pd=%u\n",
3360                         fs->flow_type, (int)fs->ring_cookie, fs->location,
3361                         htonl(fs->h_u.tcp_ip4_spec.ip4src),
3362                         htonl(fs->h_u.tcp_ip4_spec.ip4dst),
3363                         htons(fs->h_u.tcp_ip4_spec.psrc), htons(fs->h_u.tcp_ip4_spec.pdst));
3364
3365         spin_lock_irqsave(&bp->rx_fs_lock, flags);
3366
3367         /* find correct place to add in list */
3368         list_for_each_entry(item, &bp->rx_fs_list.list, list) {
3369                 if (item->fs.location > newfs->fs.location) {
3370                         list_add_tail(&newfs->list, &item->list);
3371                         added = true;
3372                         break;
3373                 } else if (item->fs.location == fs->location) {
3374                         netdev_err(netdev, "Rule not added: location %d not free!\n",
3375                                         fs->location);
3376                         ret = -EBUSY;
3377                         goto err;
3378                 }
3379         }
3380         if (!added)
3381                 list_add_tail(&newfs->list, &bp->rx_fs_list.list);
3382
3383         gem_prog_cmp_regs(bp, fs);
3384         bp->rx_fs_list.count++;
3385         /* enable filtering if NTUPLE on */
3386         gem_enable_flow_filters(bp, 1);
3387
3388         spin_unlock_irqrestore(&bp->rx_fs_lock, flags);
3389         return 0;
3390
3391 err:
3392         spin_unlock_irqrestore(&bp->rx_fs_lock, flags);
3393         kfree(newfs);
3394         return ret;
3395 }
3396
3397 static int gem_del_flow_filter(struct net_device *netdev,
3398                 struct ethtool_rxnfc *cmd)
3399 {
3400         struct macb *bp = netdev_priv(netdev);
3401         struct ethtool_rx_fs_item *item;
3402         struct ethtool_rx_flow_spec *fs;
3403         unsigned long flags;
3404
3405         spin_lock_irqsave(&bp->rx_fs_lock, flags);
3406
3407         list_for_each_entry(item, &bp->rx_fs_list.list, list) {
3408                 if (item->fs.location == cmd->fs.location) {
3409                         /* disable screener regs for the flow entry */
3410                         fs = &(item->fs);
3411                         netdev_dbg(netdev,
3412                                         "Deleting flow filter entry,type=%u,queue=%u,loc=%u,src=%08X,dst=%08X,ps=%u,pd=%u\n",
3413                                         fs->flow_type, (int)fs->ring_cookie, fs->location,
3414                                         htonl(fs->h_u.tcp_ip4_spec.ip4src),
3415                                         htonl(fs->h_u.tcp_ip4_spec.ip4dst),
3416                                         htons(fs->h_u.tcp_ip4_spec.psrc),
3417                                         htons(fs->h_u.tcp_ip4_spec.pdst));
3418
3419                         gem_writel_n(bp, SCRT2, fs->location, 0);
3420
3421                         list_del(&item->list);
3422                         bp->rx_fs_list.count--;
3423                         spin_unlock_irqrestore(&bp->rx_fs_lock, flags);
3424                         kfree(item);
3425                         return 0;
3426                 }
3427         }
3428
3429         spin_unlock_irqrestore(&bp->rx_fs_lock, flags);
3430         return -EINVAL;
3431 }
3432
3433 static int gem_get_flow_entry(struct net_device *netdev,
3434                 struct ethtool_rxnfc *cmd)
3435 {
3436         struct macb *bp = netdev_priv(netdev);
3437         struct ethtool_rx_fs_item *item;
3438
3439         list_for_each_entry(item, &bp->rx_fs_list.list, list) {
3440                 if (item->fs.location == cmd->fs.location) {
3441                         memcpy(&cmd->fs, &item->fs, sizeof(cmd->fs));
3442                         return 0;
3443                 }
3444         }
3445         return -EINVAL;
3446 }
3447
3448 static int gem_get_all_flow_entries(struct net_device *netdev,
3449                 struct ethtool_rxnfc *cmd, u32 *rule_locs)
3450 {
3451         struct macb *bp = netdev_priv(netdev);
3452         struct ethtool_rx_fs_item *item;
3453         uint32_t cnt = 0;
3454
3455         list_for_each_entry(item, &bp->rx_fs_list.list, list) {
3456                 if (cnt == cmd->rule_cnt)
3457                         return -EMSGSIZE;
3458                 rule_locs[cnt] = item->fs.location;
3459                 cnt++;
3460         }
3461         cmd->data = bp->max_tuples;
3462         cmd->rule_cnt = cnt;
3463
3464         return 0;
3465 }
3466
3467 static int gem_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
3468                 u32 *rule_locs)
3469 {
3470         struct macb *bp = netdev_priv(netdev);
3471         int ret = 0;
3472
3473         switch (cmd->cmd) {
3474         case ETHTOOL_GRXRINGS:
3475                 cmd->data = bp->num_queues;
3476                 break;
3477         case ETHTOOL_GRXCLSRLCNT:
3478                 cmd->rule_cnt = bp->rx_fs_list.count;
3479                 break;
3480         case ETHTOOL_GRXCLSRULE:
3481                 ret = gem_get_flow_entry(netdev, cmd);
3482                 break;
3483         case ETHTOOL_GRXCLSRLALL:
3484                 ret = gem_get_all_flow_entries(netdev, cmd, rule_locs);
3485                 break;
3486         default:
3487                 netdev_err(netdev,
3488                           "Command parameter %d is not supported\n", cmd->cmd);
3489                 ret = -EOPNOTSUPP;
3490         }
3491
3492         return ret;
3493 }
3494
3495 static int gem_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
3496 {
3497         struct macb *bp = netdev_priv(netdev);
3498         int ret;
3499
3500         switch (cmd->cmd) {
3501         case ETHTOOL_SRXCLSRLINS:
3502                 if ((cmd->fs.location >= bp->max_tuples)
3503                                 || (cmd->fs.ring_cookie >= bp->num_queues)) {
3504                         ret = -EINVAL;
3505                         break;
3506                 }
3507                 ret = gem_add_flow_filter(netdev, cmd);
3508                 break;
3509         case ETHTOOL_SRXCLSRLDEL:
3510                 ret = gem_del_flow_filter(netdev, cmd);
3511                 break;
3512         default:
3513                 netdev_err(netdev,
3514                           "Command parameter %d is not supported\n", cmd->cmd);
3515                 ret = -EOPNOTSUPP;
3516         }
3517
3518         return ret;
3519 }
3520
3521 static const struct ethtool_ops macb_ethtool_ops = {
3522         .get_regs_len           = macb_get_regs_len,
3523         .get_regs               = macb_get_regs,
3524         .get_link               = ethtool_op_get_link,
3525         .get_ts_info            = ethtool_op_get_ts_info,
3526         .get_wol                = macb_get_wol,
3527         .set_wol                = macb_set_wol,
3528         .get_link_ksettings     = macb_get_link_ksettings,
3529         .set_link_ksettings     = macb_set_link_ksettings,
3530         .get_ringparam          = macb_get_ringparam,
3531         .set_ringparam          = macb_set_ringparam,
3532 };
3533
3534 static const struct ethtool_ops gem_ethtool_ops = {
3535         .get_regs_len           = macb_get_regs_len,
3536         .get_regs               = macb_get_regs,
3537         .get_wol                = macb_get_wol,
3538         .set_wol                = macb_set_wol,
3539         .get_link               = ethtool_op_get_link,
3540         .get_ts_info            = macb_get_ts_info,
3541         .get_ethtool_stats      = gem_get_ethtool_stats,
3542         .get_strings            = gem_get_ethtool_strings,
3543         .get_sset_count         = gem_get_sset_count,
3544         .get_link_ksettings     = macb_get_link_ksettings,
3545         .set_link_ksettings     = macb_set_link_ksettings,
3546         .get_ringparam          = macb_get_ringparam,
3547         .set_ringparam          = macb_set_ringparam,
3548         .get_rxnfc                      = gem_get_rxnfc,
3549         .set_rxnfc                      = gem_set_rxnfc,
3550 };
3551
3552 static int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3553 {
3554         struct macb *bp = netdev_priv(dev);
3555
3556         if (!netif_running(dev))
3557                 return -EINVAL;
3558
3559         if (bp->ptp_info) {
3560                 switch (cmd) {
3561                 case SIOCSHWTSTAMP:
3562                         return bp->ptp_info->set_hwtst(dev, rq, cmd);
3563                 case SIOCGHWTSTAMP:
3564                         return bp->ptp_info->get_hwtst(dev, rq);
3565                 }
3566         }
3567
3568         return phylink_mii_ioctl(bp->phylink, rq, cmd);
3569 }
3570
3571 static inline void macb_set_txcsum_feature(struct macb *bp,
3572                                            netdev_features_t features)
3573 {
3574         u32 val;
3575
3576         if (!macb_is_gem(bp))
3577                 return;
3578
3579         val = gem_readl(bp, DMACFG);
3580         if (features & NETIF_F_HW_CSUM)
3581                 val |= GEM_BIT(TXCOEN);
3582         else
3583                 val &= ~GEM_BIT(TXCOEN);
3584
3585         gem_writel(bp, DMACFG, val);
3586 }
3587
3588 static inline void macb_set_rxcsum_feature(struct macb *bp,
3589                                            netdev_features_t features)
3590 {
3591         struct net_device *netdev = bp->dev;
3592         u32 val;
3593
3594         if (!macb_is_gem(bp))
3595                 return;
3596
3597         val = gem_readl(bp, NCFGR);
3598         if ((features & NETIF_F_RXCSUM) && !(netdev->flags & IFF_PROMISC))
3599                 val |= GEM_BIT(RXCOEN);
3600         else
3601                 val &= ~GEM_BIT(RXCOEN);
3602
3603         gem_writel(bp, NCFGR, val);
3604 }
3605
3606 static inline void macb_set_rxflow_feature(struct macb *bp,
3607                                            netdev_features_t features)
3608 {
3609         if (!macb_is_gem(bp))
3610                 return;
3611
3612         gem_enable_flow_filters(bp, !!(features & NETIF_F_NTUPLE));
3613 }
3614
3615 static int macb_set_features(struct net_device *netdev,
3616                              netdev_features_t features)
3617 {
3618         struct macb *bp = netdev_priv(netdev);
3619         netdev_features_t changed = features ^ netdev->features;
3620
3621         /* TX checksum offload */
3622         if (changed & NETIF_F_HW_CSUM)
3623                 macb_set_txcsum_feature(bp, features);
3624
3625         /* RX checksum offload */
3626         if (changed & NETIF_F_RXCSUM)
3627                 macb_set_rxcsum_feature(bp, features);
3628
3629         /* RX Flow Filters */
3630         if (changed & NETIF_F_NTUPLE)
3631                 macb_set_rxflow_feature(bp, features);
3632
3633         return 0;
3634 }
3635
3636 static void macb_restore_features(struct macb *bp)
3637 {
3638         struct net_device *netdev = bp->dev;
3639         netdev_features_t features = netdev->features;
3640
3641         /* TX checksum offload */
3642         macb_set_txcsum_feature(bp, features);
3643
3644         /* RX checksum offload */
3645         macb_set_rxcsum_feature(bp, features);
3646
3647         /* RX Flow Filters */
3648         macb_set_rxflow_feature(bp, features);
3649 }
3650
3651 static const struct net_device_ops macb_netdev_ops = {
3652         .ndo_open               = macb_open,
3653         .ndo_stop               = macb_close,
3654         .ndo_start_xmit         = macb_start_xmit,
3655         .ndo_set_rx_mode        = macb_set_rx_mode,
3656         .ndo_get_stats          = macb_get_stats,
3657         .ndo_do_ioctl           = macb_ioctl,
3658         .ndo_validate_addr      = eth_validate_addr,
3659         .ndo_change_mtu         = macb_change_mtu,
3660         .ndo_set_mac_address    = eth_mac_addr,
3661 #ifdef CONFIG_NET_POLL_CONTROLLER
3662         .ndo_poll_controller    = macb_poll_controller,
3663 #endif
3664         .ndo_set_features       = macb_set_features,
3665         .ndo_features_check     = macb_features_check,
3666 };
3667
3668 /* Configure peripheral capabilities according to device tree
3669  * and integration options used
3670  */
3671 static void macb_configure_caps(struct macb *bp,
3672                                 const struct macb_config *dt_conf)
3673 {
3674         u32 dcfg;
3675
3676         if (dt_conf)
3677                 bp->caps = dt_conf->caps;
3678
3679         if (hw_is_gem(bp->regs, bp->native_io)) {
3680                 bp->caps |= MACB_CAPS_MACB_IS_GEM;
3681
3682                 dcfg = gem_readl(bp, DCFG1);
3683                 if (GEM_BFEXT(IRQCOR, dcfg) == 0)
3684                         bp->caps |= MACB_CAPS_ISR_CLEAR_ON_WRITE;
3685                 if (GEM_BFEXT(NO_PCS, dcfg) == 0)
3686                         bp->caps |= MACB_CAPS_PCS;
3687                 dcfg = gem_readl(bp, DCFG12);
3688                 if (GEM_BFEXT(HIGH_SPEED, dcfg) == 1)
3689                         bp->caps |= MACB_CAPS_HIGH_SPEED;
3690                 dcfg = gem_readl(bp, DCFG2);
3691                 if ((dcfg & (GEM_BIT(RX_PKT_BUFF) | GEM_BIT(TX_PKT_BUFF))) == 0)
3692                         bp->caps |= MACB_CAPS_FIFO_MODE;
3693 #ifdef CONFIG_MACB_USE_HWSTAMP
3694                 if (gem_has_ptp(bp)) {
3695                         if (!GEM_BFEXT(TSU, gem_readl(bp, DCFG5)))
3696                                 dev_err(&bp->pdev->dev,
3697                                         "GEM doesn't support hardware ptp.\n");
3698                         else {
3699                                 bp->hw_dma_cap |= HW_DMA_CAP_PTP;
3700                                 bp->ptp_info = &gem_ptp_info;
3701                         }
3702                 }
3703 #endif
3704         }
3705
3706         dev_dbg(&bp->pdev->dev, "Cadence caps 0x%08x\n", bp->caps);
3707 }
3708
3709 static void macb_probe_queues(void __iomem *mem,
3710                               bool native_io,
3711                               unsigned int *queue_mask,
3712                               unsigned int *num_queues)
3713 {
3714         *queue_mask = 0x1;
3715         *num_queues = 1;
3716
3717         /* is it macb or gem ?
3718          *
3719          * We need to read directly from the hardware here because
3720          * we are early in the probe process and don't have the
3721          * MACB_CAPS_MACB_IS_GEM flag positioned
3722          */
3723         if (!hw_is_gem(mem, native_io))
3724                 return;
3725
3726         /* bit 0 is never set but queue 0 always exists */
3727         *queue_mask |= readl_relaxed(mem + GEM_DCFG6) & 0xff;
3728         *num_queues = hweight32(*queue_mask);
3729 }
3730
3731 static void macb_clks_disable(struct clk *pclk, struct clk *hclk, struct clk *tx_clk,
3732                               struct clk *rx_clk, struct clk *tsu_clk)
3733 {
3734         struct clk_bulk_data clks[] = {
3735                 { .clk = tsu_clk, },
3736                 { .clk = rx_clk, },
3737                 { .clk = pclk, },
3738                 { .clk = hclk, },
3739                 { .clk = tx_clk },
3740         };
3741
3742         clk_bulk_disable_unprepare(ARRAY_SIZE(clks), clks);
3743 }
3744
3745 static int macb_clk_init(struct platform_device *pdev, struct clk **pclk,
3746                          struct clk **hclk, struct clk **tx_clk,
3747                          struct clk **rx_clk, struct clk **tsu_clk)
3748 {
3749         struct macb_platform_data *pdata;
3750         int err;
3751
3752         pdata = dev_get_platdata(&pdev->dev);
3753         if (pdata) {
3754                 *pclk = pdata->pclk;
3755                 *hclk = pdata->hclk;
3756         } else {
3757                 *pclk = devm_clk_get(&pdev->dev, "pclk");
3758                 *hclk = devm_clk_get(&pdev->dev, "hclk");
3759         }
3760
3761         if (IS_ERR_OR_NULL(*pclk))
3762                 return dev_err_probe(&pdev->dev,
3763                                      IS_ERR(*pclk) ? PTR_ERR(*pclk) : -ENODEV,
3764                                      "failed to get pclk\n");
3765
3766         if (IS_ERR_OR_NULL(*hclk))
3767                 return dev_err_probe(&pdev->dev,
3768                                      IS_ERR(*hclk) ? PTR_ERR(*hclk) : -ENODEV,
3769                                      "failed to get hclk\n");
3770
3771         *tx_clk = devm_clk_get_optional(&pdev->dev, "tx_clk");
3772         if (IS_ERR(*tx_clk))
3773                 return PTR_ERR(*tx_clk);
3774
3775         *rx_clk = devm_clk_get_optional(&pdev->dev, "rx_clk");
3776         if (IS_ERR(*rx_clk))
3777                 return PTR_ERR(*rx_clk);
3778
3779         *tsu_clk = devm_clk_get_optional(&pdev->dev, "tsu_clk");
3780         if (IS_ERR(*tsu_clk))
3781                 return PTR_ERR(*tsu_clk);
3782
3783         err = clk_prepare_enable(*pclk);
3784         if (err) {
3785                 dev_err(&pdev->dev, "failed to enable pclk (%d)\n", err);
3786                 return err;
3787         }
3788
3789         err = clk_prepare_enable(*hclk);
3790         if (err) {
3791                 dev_err(&pdev->dev, "failed to enable hclk (%d)\n", err);
3792                 goto err_disable_pclk;
3793         }
3794
3795         err = clk_prepare_enable(*tx_clk);
3796         if (err) {
3797                 dev_err(&pdev->dev, "failed to enable tx_clk (%d)\n", err);
3798                 goto err_disable_hclk;
3799         }
3800
3801         err = clk_prepare_enable(*rx_clk);
3802         if (err) {
3803                 dev_err(&pdev->dev, "failed to enable rx_clk (%d)\n", err);
3804                 goto err_disable_txclk;
3805         }
3806
3807         err = clk_prepare_enable(*tsu_clk);
3808         if (err) {
3809                 dev_err(&pdev->dev, "failed to enable tsu_clk (%d)\n", err);
3810                 goto err_disable_rxclk;
3811         }
3812
3813         return 0;
3814
3815 err_disable_rxclk:
3816         clk_disable_unprepare(*rx_clk);
3817
3818 err_disable_txclk:
3819         clk_disable_unprepare(*tx_clk);
3820
3821 err_disable_hclk:
3822         clk_disable_unprepare(*hclk);
3823
3824 err_disable_pclk:
3825         clk_disable_unprepare(*pclk);
3826
3827         return err;
3828 }
3829
3830 static int macb_init(struct platform_device *pdev)
3831 {
3832         struct net_device *dev = platform_get_drvdata(pdev);
3833         unsigned int hw_q, q;
3834         struct macb *bp = netdev_priv(dev);
3835         struct macb_queue *queue;
3836         int err;
3837         u32 val, reg;
3838
3839         bp->tx_ring_size = DEFAULT_TX_RING_SIZE;
3840         bp->rx_ring_size = DEFAULT_RX_RING_SIZE;
3841
3842         /* set the queue register mapping once for all: queue0 has a special
3843          * register mapping but we don't want to test the queue index then
3844          * compute the corresponding register offset at run time.
3845          */
3846         for (hw_q = 0, q = 0; hw_q < MACB_MAX_QUEUES; ++hw_q) {
3847                 if (!(bp->queue_mask & (1 << hw_q)))
3848                         continue;
3849
3850                 queue = &bp->queues[q];
3851                 queue->bp = bp;
3852                 netif_napi_add(dev, &queue->napi, macb_poll, NAPI_POLL_WEIGHT);
3853                 if (hw_q) {
3854                         queue->ISR  = GEM_ISR(hw_q - 1);
3855                         queue->IER  = GEM_IER(hw_q - 1);
3856                         queue->IDR  = GEM_IDR(hw_q - 1);
3857                         queue->IMR  = GEM_IMR(hw_q - 1);
3858                         queue->TBQP = GEM_TBQP(hw_q - 1);
3859                         queue->RBQP = GEM_RBQP(hw_q - 1);
3860                         queue->RBQS = GEM_RBQS(hw_q - 1);
3861 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
3862                         if (bp->hw_dma_cap & HW_DMA_CAP_64B) {
3863                                 queue->TBQPH = GEM_TBQPH(hw_q - 1);
3864                                 queue->RBQPH = GEM_RBQPH(hw_q - 1);
3865                         }
3866 #endif
3867                 } else {
3868                         /* queue0 uses legacy registers */
3869                         queue->ISR  = MACB_ISR;
3870                         queue->IER  = MACB_IER;
3871                         queue->IDR  = MACB_IDR;
3872                         queue->IMR  = MACB_IMR;
3873                         queue->TBQP = MACB_TBQP;
3874                         queue->RBQP = MACB_RBQP;
3875 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
3876                         if (bp->hw_dma_cap & HW_DMA_CAP_64B) {
3877                                 queue->TBQPH = MACB_TBQPH;
3878                                 queue->RBQPH = MACB_RBQPH;
3879                         }
3880 #endif
3881                 }
3882
3883                 /* get irq: here we use the linux queue index, not the hardware
3884                  * queue index. the queue irq definitions in the device tree
3885                  * must remove the optional gaps that could exist in the
3886                  * hardware queue mask.
3887                  */
3888                 queue->irq = platform_get_irq(pdev, q);
3889                 err = devm_request_irq(&pdev->dev, queue->irq, macb_interrupt,
3890                                        IRQF_SHARED, dev->name, queue);
3891                 if (err) {
3892                         dev_err(&pdev->dev,
3893                                 "Unable to request IRQ %d (error %d)\n",
3894                                 queue->irq, err);
3895                         return err;
3896                 }
3897
3898                 INIT_WORK(&queue->tx_error_task, macb_tx_error_task);
3899                 q++;
3900         }
3901
3902         dev->netdev_ops = &macb_netdev_ops;
3903
3904         /* setup appropriated routines according to adapter type */
3905         if (macb_is_gem(bp)) {
3906                 bp->max_tx_length = GEM_MAX_TX_LEN;
3907                 bp->macbgem_ops.mog_alloc_rx_buffers = gem_alloc_rx_buffers;
3908                 bp->macbgem_ops.mog_free_rx_buffers = gem_free_rx_buffers;
3909                 bp->macbgem_ops.mog_init_rings = gem_init_rings;
3910                 bp->macbgem_ops.mog_rx = gem_rx;
3911                 dev->ethtool_ops = &gem_ethtool_ops;
3912         } else {
3913                 bp->max_tx_length = MACB_MAX_TX_LEN;
3914                 bp->macbgem_ops.mog_alloc_rx_buffers = macb_alloc_rx_buffers;
3915                 bp->macbgem_ops.mog_free_rx_buffers = macb_free_rx_buffers;
3916                 bp->macbgem_ops.mog_init_rings = macb_init_rings;
3917                 bp->macbgem_ops.mog_rx = macb_rx;
3918                 dev->ethtool_ops = &macb_ethtool_ops;
3919         }
3920
3921         /* Set features */
3922         dev->hw_features = NETIF_F_SG;
3923
3924         /* Check LSO capability */
3925         if (GEM_BFEXT(PBUF_LSO, gem_readl(bp, DCFG6)))
3926                 dev->hw_features |= MACB_NETIF_LSO;
3927
3928         /* Checksum offload is only available on gem with packet buffer */
3929         if (macb_is_gem(bp) && !(bp->caps & MACB_CAPS_FIFO_MODE))
3930                 dev->hw_features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
3931         if (bp->caps & MACB_CAPS_SG_DISABLED)
3932                 dev->hw_features &= ~NETIF_F_SG;
3933         dev->features = dev->hw_features;
3934
3935         /* Check RX Flow Filters support.
3936          * Max Rx flows set by availability of screeners & compare regs:
3937          * each 4-tuple define requires 1 T2 screener reg + 3 compare regs
3938          */
3939         reg = gem_readl(bp, DCFG8);
3940         bp->max_tuples = min((GEM_BFEXT(SCR2CMP, reg) / 3),
3941                         GEM_BFEXT(T2SCR, reg));
3942         if (bp->max_tuples > 0) {
3943                 /* also needs one ethtype match to check IPv4 */
3944                 if (GEM_BFEXT(SCR2ETH, reg) > 0) {
3945                         /* program this reg now */
3946                         reg = 0;
3947                         reg = GEM_BFINS(ETHTCMP, (uint16_t)ETH_P_IP, reg);
3948                         gem_writel_n(bp, ETHT, SCRT2_ETHT, reg);
3949                         /* Filtering is supported in hw but don't enable it in kernel now */
3950                         dev->hw_features |= NETIF_F_NTUPLE;
3951                         /* init Rx flow definitions */
3952                         INIT_LIST_HEAD(&bp->rx_fs_list.list);
3953                         bp->rx_fs_list.count = 0;
3954                         spin_lock_init(&bp->rx_fs_lock);
3955                 } else
3956                         bp->max_tuples = 0;
3957         }
3958
3959         if (!(bp->caps & MACB_CAPS_USRIO_DISABLED)) {
3960                 val = 0;
3961                 if (phy_interface_mode_is_rgmii(bp->phy_interface))
3962                         val = bp->usrio->rgmii;
3963                 else if (bp->phy_interface == PHY_INTERFACE_MODE_RMII &&
3964                          (bp->caps & MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII))
3965                         val = bp->usrio->rmii;
3966                 else if (!(bp->caps & MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII))
3967                         val = bp->usrio->mii;
3968
3969                 if (bp->caps & MACB_CAPS_USRIO_HAS_CLKEN)
3970                         val |= bp->usrio->refclk;
3971
3972                 macb_or_gem_writel(bp, USRIO, val);
3973         }
3974
3975         /* Set MII management clock divider */
3976         val = macb_mdc_clk_div(bp);
3977         val |= macb_dbw(bp);
3978         if (bp->phy_interface == PHY_INTERFACE_MODE_SGMII)
3979                 val |= GEM_BIT(SGMIIEN) | GEM_BIT(PCSSEL);
3980         macb_writel(bp, NCFGR, val);
3981
3982         return 0;
3983 }
3984
3985 static const struct macb_usrio_config macb_default_usrio = {
3986         .mii = MACB_BIT(MII),
3987         .rmii = MACB_BIT(RMII),
3988         .rgmii = GEM_BIT(RGMII),
3989         .refclk = MACB_BIT(CLKEN),
3990 };
3991
3992 #if defined(CONFIG_OF)
3993 /* 1518 rounded up */
3994 #define AT91ETHER_MAX_RBUFF_SZ  0x600
3995 /* max number of receive buffers */
3996 #define AT91ETHER_MAX_RX_DESCR  9
3997
3998 static struct sifive_fu540_macb_mgmt *mgmt;
3999
4000 static int at91ether_alloc_coherent(struct macb *lp)
4001 {
4002         struct macb_queue *q = &lp->queues[0];
4003
4004         q->rx_ring = dma_alloc_coherent(&lp->pdev->dev,
4005                                          (AT91ETHER_MAX_RX_DESCR *
4006                                           macb_dma_desc_get_size(lp)),
4007                                          &q->rx_ring_dma, GFP_KERNEL);
4008         if (!q->rx_ring)
4009                 return -ENOMEM;
4010
4011         q->rx_buffers = dma_alloc_coherent(&lp->pdev->dev,
4012                                             AT91ETHER_MAX_RX_DESCR *
4013                                             AT91ETHER_MAX_RBUFF_SZ,
4014                                             &q->rx_buffers_dma, GFP_KERNEL);
4015         if (!q->rx_buffers) {
4016                 dma_free_coherent(&lp->pdev->dev,
4017                                   AT91ETHER_MAX_RX_DESCR *
4018                                   macb_dma_desc_get_size(lp),
4019                                   q->rx_ring, q->rx_ring_dma);
4020                 q->rx_ring = NULL;
4021                 return -ENOMEM;
4022         }
4023
4024         return 0;
4025 }
4026
4027 static void at91ether_free_coherent(struct macb *lp)
4028 {
4029         struct macb_queue *q = &lp->queues[0];
4030
4031         if (q->rx_ring) {
4032                 dma_free_coherent(&lp->pdev->dev,
4033                                   AT91ETHER_MAX_RX_DESCR *
4034                                   macb_dma_desc_get_size(lp),
4035                                   q->rx_ring, q->rx_ring_dma);
4036                 q->rx_ring = NULL;
4037         }
4038
4039         if (q->rx_buffers) {
4040                 dma_free_coherent(&lp->pdev->dev,
4041                                   AT91ETHER_MAX_RX_DESCR *
4042                                   AT91ETHER_MAX_RBUFF_SZ,
4043                                   q->rx_buffers, q->rx_buffers_dma);
4044                 q->rx_buffers = NULL;
4045         }
4046 }
4047
4048 /* Initialize and start the Receiver and Transmit subsystems */
4049 static int at91ether_start(struct macb *lp)
4050 {
4051         struct macb_queue *q = &lp->queues[0];
4052         struct macb_dma_desc *desc;
4053         dma_addr_t addr;
4054         u32 ctl;
4055         int i, ret;
4056
4057         ret = at91ether_alloc_coherent(lp);
4058         if (ret)
4059                 return ret;
4060
4061         addr = q->rx_buffers_dma;
4062         for (i = 0; i < AT91ETHER_MAX_RX_DESCR; i++) {
4063                 desc = macb_rx_desc(q, i);
4064                 macb_set_addr(lp, desc, addr);
4065                 desc->ctrl = 0;
4066                 addr += AT91ETHER_MAX_RBUFF_SZ;
4067         }
4068
4069         /* Set the Wrap bit on the last descriptor */
4070         desc->addr |= MACB_BIT(RX_WRAP);
4071
4072         /* Reset buffer index */
4073         q->rx_tail = 0;
4074
4075         /* Program address of descriptor list in Rx Buffer Queue register */
4076         macb_writel(lp, RBQP, q->rx_ring_dma);
4077
4078         /* Enable Receive and Transmit */
4079         ctl = macb_readl(lp, NCR);
4080         macb_writel(lp, NCR, ctl | MACB_BIT(RE) | MACB_BIT(TE));
4081
4082         /* Enable MAC interrupts */
4083         macb_writel(lp, IER, MACB_BIT(RCOMP)    |
4084                              MACB_BIT(RXUBR)    |
4085                              MACB_BIT(ISR_TUND) |
4086                              MACB_BIT(ISR_RLE)  |
4087                              MACB_BIT(TCOMP)    |
4088                              MACB_BIT(ISR_ROVR) |
4089                              MACB_BIT(HRESP));
4090
4091         return 0;
4092 }
4093
4094 static void at91ether_stop(struct macb *lp)
4095 {
4096         u32 ctl;
4097
4098         /* Disable MAC interrupts */
4099         macb_writel(lp, IDR, MACB_BIT(RCOMP)    |
4100                              MACB_BIT(RXUBR)    |
4101                              MACB_BIT(ISR_TUND) |
4102                              MACB_BIT(ISR_RLE)  |
4103                              MACB_BIT(TCOMP)    |
4104                              MACB_BIT(ISR_ROVR) |
4105                              MACB_BIT(HRESP));
4106
4107         /* Disable Receiver and Transmitter */
4108         ctl = macb_readl(lp, NCR);
4109         macb_writel(lp, NCR, ctl & ~(MACB_BIT(TE) | MACB_BIT(RE)));
4110
4111         /* Free resources. */
4112         at91ether_free_coherent(lp);
4113 }
4114
4115 /* Open the ethernet interface */
4116 static int at91ether_open(struct net_device *dev)
4117 {
4118         struct macb *lp = netdev_priv(dev);
4119         u32 ctl;
4120         int ret;
4121
4122         ret = pm_runtime_get_sync(&lp->pdev->dev);
4123         if (ret < 0) {
4124                 pm_runtime_put_noidle(&lp->pdev->dev);
4125                 return ret;
4126         }
4127
4128         /* Clear internal statistics */
4129         ctl = macb_readl(lp, NCR);
4130         macb_writel(lp, NCR, ctl | MACB_BIT(CLRSTAT));
4131
4132         macb_set_hwaddr(lp);
4133
4134         ret = at91ether_start(lp);
4135         if (ret)
4136                 goto pm_exit;
4137
4138         ret = macb_phylink_connect(lp);
4139         if (ret)
4140                 goto stop;
4141
4142         netif_start_queue(dev);
4143
4144         return 0;
4145
4146 stop:
4147         at91ether_stop(lp);
4148 pm_exit:
4149         pm_runtime_put_sync(&lp->pdev->dev);
4150         return ret;
4151 }
4152
4153 /* Close the interface */
4154 static int at91ether_close(struct net_device *dev)
4155 {
4156         struct macb *lp = netdev_priv(dev);
4157
4158         netif_stop_queue(dev);
4159
4160         phylink_stop(lp->phylink);
4161         phylink_disconnect_phy(lp->phylink);
4162
4163         at91ether_stop(lp);
4164
4165         return pm_runtime_put(&lp->pdev->dev);
4166 }
4167
4168 /* Transmit packet */
4169 static netdev_tx_t at91ether_start_xmit(struct sk_buff *skb,
4170                                         struct net_device *dev)
4171 {
4172         struct macb *lp = netdev_priv(dev);
4173
4174         if (macb_readl(lp, TSR) & MACB_BIT(RM9200_BNQ)) {
4175                 int desc = 0;
4176
4177                 netif_stop_queue(dev);
4178
4179                 /* Store packet information (to free when Tx completed) */
4180                 lp->rm9200_txq[desc].skb = skb;
4181                 lp->rm9200_txq[desc].size = skb->len;
4182                 lp->rm9200_txq[desc].mapping = dma_map_single(&lp->pdev->dev, skb->data,
4183                                                               skb->len, DMA_TO_DEVICE);
4184                 if (dma_mapping_error(&lp->pdev->dev, lp->rm9200_txq[desc].mapping)) {
4185                         dev_kfree_skb_any(skb);
4186                         dev->stats.tx_dropped++;
4187                         netdev_err(dev, "%s: DMA mapping error\n", __func__);
4188                         return NETDEV_TX_OK;
4189                 }
4190
4191                 /* Set address of the data in the Transmit Address register */
4192                 macb_writel(lp, TAR, lp->rm9200_txq[desc].mapping);
4193                 /* Set length of the packet in the Transmit Control register */
4194                 macb_writel(lp, TCR, skb->len);
4195
4196         } else {
4197                 netdev_err(dev, "%s called, but device is busy!\n", __func__);
4198                 return NETDEV_TX_BUSY;
4199         }
4200
4201         return NETDEV_TX_OK;
4202 }
4203
4204 /* Extract received frame from buffer descriptors and sent to upper layers.
4205  * (Called from interrupt context)
4206  */
4207 static void at91ether_rx(struct net_device *dev)
4208 {
4209         struct macb *lp = netdev_priv(dev);
4210         struct macb_queue *q = &lp->queues[0];
4211         struct macb_dma_desc *desc;
4212         unsigned char *p_recv;
4213         struct sk_buff *skb;
4214         unsigned int pktlen;
4215
4216         desc = macb_rx_desc(q, q->rx_tail);
4217         while (desc->addr & MACB_BIT(RX_USED)) {
4218                 p_recv = q->rx_buffers + q->rx_tail * AT91ETHER_MAX_RBUFF_SZ;
4219                 pktlen = MACB_BF(RX_FRMLEN, desc->ctrl);
4220                 skb = netdev_alloc_skb(dev, pktlen + 2);
4221                 if (skb) {
4222                         skb_reserve(skb, 2);
4223                         skb_put_data(skb, p_recv, pktlen);
4224
4225                         skb->protocol = eth_type_trans(skb, dev);
4226                         dev->stats.rx_packets++;
4227                         dev->stats.rx_bytes += pktlen;
4228                         netif_rx(skb);
4229                 } else {
4230                         dev->stats.rx_dropped++;
4231                 }
4232
4233                 if (desc->ctrl & MACB_BIT(RX_MHASH_MATCH))
4234                         dev->stats.multicast++;
4235
4236                 /* reset ownership bit */
4237                 desc->addr &= ~MACB_BIT(RX_USED);
4238
4239                 /* wrap after last buffer */
4240                 if (q->rx_tail == AT91ETHER_MAX_RX_DESCR - 1)
4241                         q->rx_tail = 0;
4242                 else
4243                         q->rx_tail++;
4244
4245                 desc = macb_rx_desc(q, q->rx_tail);
4246         }
4247 }
4248
4249 /* MAC interrupt handler */
4250 static irqreturn_t at91ether_interrupt(int irq, void *dev_id)
4251 {
4252         struct net_device *dev = dev_id;
4253         struct macb *lp = netdev_priv(dev);
4254         u32 intstatus, ctl;
4255         unsigned int desc;
4256
4257         /* MAC Interrupt Status register indicates what interrupts are pending.
4258          * It is automatically cleared once read.
4259          */
4260         intstatus = macb_readl(lp, ISR);
4261
4262         /* Receive complete */
4263         if (intstatus & MACB_BIT(RCOMP))
4264                 at91ether_rx(dev);
4265
4266         /* Transmit complete */
4267         if (intstatus & MACB_BIT(TCOMP)) {
4268                 /* The TCOM bit is set even if the transmission failed */
4269                 if (intstatus & (MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE)))
4270                         dev->stats.tx_errors++;
4271
4272                 desc = 0;
4273                 if (lp->rm9200_txq[desc].skb) {
4274                         dev_consume_skb_irq(lp->rm9200_txq[desc].skb);
4275                         lp->rm9200_txq[desc].skb = NULL;
4276                         dma_unmap_single(&lp->pdev->dev, lp->rm9200_txq[desc].mapping,
4277                                          lp->rm9200_txq[desc].size, DMA_TO_DEVICE);
4278                         dev->stats.tx_packets++;
4279                         dev->stats.tx_bytes += lp->rm9200_txq[desc].size;
4280                 }
4281                 netif_wake_queue(dev);
4282         }
4283
4284         /* Work-around for EMAC Errata section 41.3.1 */
4285         if (intstatus & MACB_BIT(RXUBR)) {
4286                 ctl = macb_readl(lp, NCR);
4287                 macb_writel(lp, NCR, ctl & ~MACB_BIT(RE));
4288                 wmb();
4289                 macb_writel(lp, NCR, ctl | MACB_BIT(RE));
4290         }
4291
4292         if (intstatus & MACB_BIT(ISR_ROVR))
4293                 netdev_err(dev, "ROVR error\n");
4294
4295         return IRQ_HANDLED;
4296 }
4297
4298 #ifdef CONFIG_NET_POLL_CONTROLLER
4299 static void at91ether_poll_controller(struct net_device *dev)
4300 {
4301         unsigned long flags;
4302
4303         local_irq_save(flags);
4304         at91ether_interrupt(dev->irq, dev);
4305         local_irq_restore(flags);
4306 }
4307 #endif
4308
4309 static const struct net_device_ops at91ether_netdev_ops = {
4310         .ndo_open               = at91ether_open,
4311         .ndo_stop               = at91ether_close,
4312         .ndo_start_xmit         = at91ether_start_xmit,
4313         .ndo_get_stats          = macb_get_stats,
4314         .ndo_set_rx_mode        = macb_set_rx_mode,
4315         .ndo_set_mac_address    = eth_mac_addr,
4316         .ndo_do_ioctl           = macb_ioctl,
4317         .ndo_validate_addr      = eth_validate_addr,
4318 #ifdef CONFIG_NET_POLL_CONTROLLER
4319         .ndo_poll_controller    = at91ether_poll_controller,
4320 #endif
4321 };
4322
4323 static int at91ether_clk_init(struct platform_device *pdev, struct clk **pclk,
4324                               struct clk **hclk, struct clk **tx_clk,
4325                               struct clk **rx_clk, struct clk **tsu_clk)
4326 {
4327         int err;
4328
4329         *hclk = NULL;
4330         *tx_clk = NULL;
4331         *rx_clk = NULL;
4332         *tsu_clk = NULL;
4333
4334         *pclk = devm_clk_get(&pdev->dev, "ether_clk");
4335         if (IS_ERR(*pclk))
4336                 return PTR_ERR(*pclk);
4337
4338         err = clk_prepare_enable(*pclk);
4339         if (err) {
4340                 dev_err(&pdev->dev, "failed to enable pclk (%d)\n", err);
4341                 return err;
4342         }
4343
4344         return 0;
4345 }
4346
4347 static int at91ether_init(struct platform_device *pdev)
4348 {
4349         struct net_device *dev = platform_get_drvdata(pdev);
4350         struct macb *bp = netdev_priv(dev);
4351         int err;
4352
4353         bp->queues[0].bp = bp;
4354
4355         dev->netdev_ops = &at91ether_netdev_ops;
4356         dev->ethtool_ops = &macb_ethtool_ops;
4357
4358         err = devm_request_irq(&pdev->dev, dev->irq, at91ether_interrupt,
4359                                0, dev->name, dev);
4360         if (err)
4361                 return err;
4362
4363         macb_writel(bp, NCR, 0);
4364
4365         macb_writel(bp, NCFGR, MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG));
4366
4367         return 0;
4368 }
4369
4370 static unsigned long fu540_macb_tx_recalc_rate(struct clk_hw *hw,
4371                                                unsigned long parent_rate)
4372 {
4373         return mgmt->rate;
4374 }
4375
4376 static long fu540_macb_tx_round_rate(struct clk_hw *hw, unsigned long rate,
4377                                      unsigned long *parent_rate)
4378 {
4379         if (WARN_ON(rate < 2500000))
4380                 return 2500000;
4381         else if (rate == 2500000)
4382                 return 2500000;
4383         else if (WARN_ON(rate < 13750000))
4384                 return 2500000;
4385         else if (WARN_ON(rate < 25000000))
4386                 return 25000000;
4387         else if (rate == 25000000)
4388                 return 25000000;
4389         else if (WARN_ON(rate < 75000000))
4390                 return 25000000;
4391         else if (WARN_ON(rate < 125000000))
4392                 return 125000000;
4393         else if (rate == 125000000)
4394                 return 125000000;
4395
4396         WARN_ON(rate > 125000000);
4397
4398         return 125000000;
4399 }
4400
4401 static int fu540_macb_tx_set_rate(struct clk_hw *hw, unsigned long rate,
4402                                   unsigned long parent_rate)
4403 {
4404         rate = fu540_macb_tx_round_rate(hw, rate, &parent_rate);
4405         if (rate != 125000000)
4406                 iowrite32(1, mgmt->reg);
4407         else
4408                 iowrite32(0, mgmt->reg);
4409         mgmt->rate = rate;
4410
4411         return 0;
4412 }
4413
4414 static const struct clk_ops fu540_c000_ops = {
4415         .recalc_rate = fu540_macb_tx_recalc_rate,
4416         .round_rate = fu540_macb_tx_round_rate,
4417         .set_rate = fu540_macb_tx_set_rate,
4418 };
4419
4420 static int fu540_c000_clk_init(struct platform_device *pdev, struct clk **pclk,
4421                                struct clk **hclk, struct clk **tx_clk,
4422                                struct clk **rx_clk, struct clk **tsu_clk)
4423 {
4424         struct clk_init_data init;
4425         int err = 0;
4426
4427         err = macb_clk_init(pdev, pclk, hclk, tx_clk, rx_clk, tsu_clk);
4428         if (err)
4429                 return err;
4430
4431         mgmt = devm_kzalloc(&pdev->dev, sizeof(*mgmt), GFP_KERNEL);
4432         if (!mgmt) {
4433                 err = -ENOMEM;
4434                 goto err_disable_clks;
4435         }
4436
4437         init.name = "sifive-gemgxl-mgmt";
4438         init.ops = &fu540_c000_ops;
4439         init.flags = 0;
4440         init.num_parents = 0;
4441
4442         mgmt->rate = 0;
4443         mgmt->hw.init = &init;
4444
4445         *tx_clk = devm_clk_register(&pdev->dev, &mgmt->hw);
4446         if (IS_ERR(*tx_clk)) {
4447                 err = PTR_ERR(*tx_clk);
4448                 goto err_disable_clks;
4449         }
4450
4451         err = clk_prepare_enable(*tx_clk);
4452         if (err) {
4453                 dev_err(&pdev->dev, "failed to enable tx_clk (%u)\n", err);
4454                 *tx_clk = NULL;
4455                 goto err_disable_clks;
4456         } else {
4457                 dev_info(&pdev->dev, "Registered clk switch '%s'\n", init.name);
4458         }
4459
4460         return 0;
4461
4462 err_disable_clks:
4463         macb_clks_disable(*pclk, *hclk, *tx_clk, *rx_clk, *tsu_clk);
4464
4465         return err;
4466 }
4467
4468 static int fu540_c000_init(struct platform_device *pdev)
4469 {
4470         mgmt->reg = devm_platform_ioremap_resource(pdev, 1);
4471         if (IS_ERR(mgmt->reg))
4472                 return PTR_ERR(mgmt->reg);
4473
4474         return macb_init(pdev);
4475 }
4476
4477 static const struct macb_usrio_config sama7g5_usrio = {
4478         .mii = 0,
4479         .rmii = 1,
4480         .rgmii = 2,
4481         .refclk = BIT(2),
4482         .hdfctlen = BIT(6),
4483 };
4484
4485 static const struct macb_config fu540_c000_config = {
4486         .caps = MACB_CAPS_GIGABIT_MODE_AVAILABLE | MACB_CAPS_JUMBO |
4487                 MACB_CAPS_GEM_HAS_PTP,
4488         .dma_burst_length = 16,
4489         .clk_init = fu540_c000_clk_init,
4490         .init = fu540_c000_init,
4491         .jumbo_max_len = 10240,
4492         .usrio = &macb_default_usrio,
4493 };
4494
4495 static const struct macb_config at91sam9260_config = {
4496         .caps = MACB_CAPS_USRIO_HAS_CLKEN | MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII,
4497         .clk_init = macb_clk_init,
4498         .init = macb_init,
4499         .usrio = &macb_default_usrio,
4500 };
4501
4502 static const struct macb_config sama5d3macb_config = {
4503         .caps = MACB_CAPS_SG_DISABLED
4504               | MACB_CAPS_USRIO_HAS_CLKEN | MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII,
4505         .clk_init = macb_clk_init,
4506         .init = macb_init,
4507         .usrio = &macb_default_usrio,
4508 };
4509
4510 static const struct macb_config pc302gem_config = {
4511         .caps = MACB_CAPS_SG_DISABLED | MACB_CAPS_GIGABIT_MODE_AVAILABLE,
4512         .dma_burst_length = 16,
4513         .clk_init = macb_clk_init,
4514         .init = macb_init,
4515         .usrio = &macb_default_usrio,
4516 };
4517
4518 static const struct macb_config sama5d2_config = {
4519         .caps = MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII,
4520         .dma_burst_length = 16,
4521         .clk_init = macb_clk_init,
4522         .init = macb_init,
4523         .usrio = &macb_default_usrio,
4524 };
4525
4526 static const struct macb_config sama5d3_config = {
4527         .caps = MACB_CAPS_SG_DISABLED | MACB_CAPS_GIGABIT_MODE_AVAILABLE
4528               | MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII | MACB_CAPS_JUMBO,
4529         .dma_burst_length = 16,
4530         .clk_init = macb_clk_init,
4531         .init = macb_init,
4532         .jumbo_max_len = 10240,
4533         .usrio = &macb_default_usrio,
4534 };
4535
4536 static const struct macb_config sama5d4_config = {
4537         .caps = MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII,
4538         .dma_burst_length = 4,
4539         .clk_init = macb_clk_init,
4540         .init = macb_init,
4541         .usrio = &macb_default_usrio,
4542 };
4543
4544 static const struct macb_config emac_config = {
4545         .caps = MACB_CAPS_NEEDS_RSTONUBR | MACB_CAPS_MACB_IS_EMAC,
4546         .clk_init = at91ether_clk_init,
4547         .init = at91ether_init,
4548         .usrio = &macb_default_usrio,
4549 };
4550
4551 static const struct macb_config np4_config = {
4552         .caps = MACB_CAPS_USRIO_DISABLED,
4553         .clk_init = macb_clk_init,
4554         .init = macb_init,
4555         .usrio = &macb_default_usrio,
4556 };
4557
4558 static const struct macb_config zynqmp_config = {
4559         .caps = MACB_CAPS_GIGABIT_MODE_AVAILABLE |
4560                         MACB_CAPS_JUMBO |
4561                         MACB_CAPS_GEM_HAS_PTP | MACB_CAPS_BD_RD_PREFETCH,
4562         .dma_burst_length = 16,
4563         .clk_init = macb_clk_init,
4564         .init = macb_init,
4565         .jumbo_max_len = 10240,
4566         .usrio = &macb_default_usrio,
4567 };
4568
4569 static const struct macb_config zynq_config = {
4570         .caps = MACB_CAPS_GIGABIT_MODE_AVAILABLE | MACB_CAPS_NO_GIGABIT_HALF |
4571                 MACB_CAPS_NEEDS_RSTONUBR,
4572         .dma_burst_length = 16,
4573         .clk_init = macb_clk_init,
4574         .init = macb_init,
4575         .usrio = &macb_default_usrio,
4576 };
4577
4578 static const struct macb_config sama7g5_gem_config = {
4579         .caps = MACB_CAPS_GIGABIT_MODE_AVAILABLE | MACB_CAPS_CLK_HW_CHG,
4580         .dma_burst_length = 16,
4581         .clk_init = macb_clk_init,
4582         .init = macb_init,
4583         .usrio = &sama7g5_usrio,
4584 };
4585
4586 static const struct macb_config sama7g5_emac_config = {
4587         .caps = MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII | MACB_CAPS_USRIO_HAS_CLKEN,
4588         .dma_burst_length = 16,
4589         .clk_init = macb_clk_init,
4590         .init = macb_init,
4591         .usrio = &sama7g5_usrio,
4592 };
4593
4594 static const struct of_device_id macb_dt_ids[] = {
4595         { .compatible = "cdns,at32ap7000-macb" },
4596         { .compatible = "cdns,at91sam9260-macb", .data = &at91sam9260_config },
4597         { .compatible = "cdns,macb" },
4598         { .compatible = "cdns,np4-macb", .data = &np4_config },
4599         { .compatible = "cdns,pc302-gem", .data = &pc302gem_config },
4600         { .compatible = "cdns,gem", .data = &pc302gem_config },
4601         { .compatible = "cdns,sam9x60-macb", .data = &at91sam9260_config },
4602         { .compatible = "atmel,sama5d2-gem", .data = &sama5d2_config },
4603         { .compatible = "atmel,sama5d3-gem", .data = &sama5d3_config },
4604         { .compatible = "atmel,sama5d3-macb", .data = &sama5d3macb_config },
4605         { .compatible = "atmel,sama5d4-gem", .data = &sama5d4_config },
4606         { .compatible = "cdns,at91rm9200-emac", .data = &emac_config },
4607         { .compatible = "cdns,emac", .data = &emac_config },
4608         { .compatible = "cdns,zynqmp-gem", .data = &zynqmp_config},
4609         { .compatible = "cdns,zynq-gem", .data = &zynq_config },
4610         { .compatible = "sifive,fu540-c000-gem", .data = &fu540_c000_config },
4611         { .compatible = "microchip,sama7g5-gem", .data = &sama7g5_gem_config },
4612         { .compatible = "microchip,sama7g5-emac", .data = &sama7g5_emac_config },
4613         { /* sentinel */ }
4614 };
4615 MODULE_DEVICE_TABLE(of, macb_dt_ids);
4616 #endif /* CONFIG_OF */
4617
4618 static const struct macb_config default_gem_config = {
4619         .caps = MACB_CAPS_GIGABIT_MODE_AVAILABLE |
4620                         MACB_CAPS_JUMBO |
4621                         MACB_CAPS_GEM_HAS_PTP,
4622         .dma_burst_length = 16,
4623         .clk_init = macb_clk_init,
4624         .init = macb_init,
4625         .usrio = &macb_default_usrio,
4626         .jumbo_max_len = 10240,
4627 };
4628
4629 static int macb_probe(struct platform_device *pdev)
4630 {
4631         const struct macb_config *macb_config = &default_gem_config;
4632         int (*clk_init)(struct platform_device *, struct clk **,
4633                         struct clk **, struct clk **,  struct clk **,
4634                         struct clk **) = macb_config->clk_init;
4635         int (*init)(struct platform_device *) = macb_config->init;
4636         struct device_node *np = pdev->dev.of_node;
4637         struct clk *pclk, *hclk = NULL, *tx_clk = NULL, *rx_clk = NULL;
4638         struct clk *tsu_clk = NULL;
4639         unsigned int queue_mask, num_queues;
4640         bool native_io;
4641         phy_interface_t interface;
4642         struct net_device *dev;
4643         struct resource *regs;
4644         void __iomem *mem;
4645         const char *mac;
4646         struct macb *bp;
4647         int err, val;
4648
4649         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
4650         mem = devm_ioremap_resource(&pdev->dev, regs);
4651         if (IS_ERR(mem))
4652                 return PTR_ERR(mem);
4653
4654         if (np) {
4655                 const struct of_device_id *match;
4656
4657                 match = of_match_node(macb_dt_ids, np);
4658                 if (match && match->data) {
4659                         macb_config = match->data;
4660                         clk_init = macb_config->clk_init;
4661                         init = macb_config->init;
4662                 }
4663         }
4664
4665         err = clk_init(pdev, &pclk, &hclk, &tx_clk, &rx_clk, &tsu_clk);
4666         if (err)
4667                 return err;
4668
4669         pm_runtime_set_autosuspend_delay(&pdev->dev, MACB_PM_TIMEOUT);
4670         pm_runtime_use_autosuspend(&pdev->dev);
4671         pm_runtime_get_noresume(&pdev->dev);
4672         pm_runtime_set_active(&pdev->dev);
4673         pm_runtime_enable(&pdev->dev);
4674         native_io = hw_is_native_io(mem);
4675
4676         macb_probe_queues(mem, native_io, &queue_mask, &num_queues);
4677         dev = alloc_etherdev_mq(sizeof(*bp), num_queues);
4678         if (!dev) {
4679                 err = -ENOMEM;
4680                 goto err_disable_clocks;
4681         }
4682
4683         dev->base_addr = regs->start;
4684
4685         SET_NETDEV_DEV(dev, &pdev->dev);
4686
4687         bp = netdev_priv(dev);
4688         bp->pdev = pdev;
4689         bp->dev = dev;
4690         bp->regs = mem;
4691         bp->native_io = native_io;
4692         if (native_io) {
4693                 bp->macb_reg_readl = hw_readl_native;
4694                 bp->macb_reg_writel = hw_writel_native;
4695         } else {
4696                 bp->macb_reg_readl = hw_readl;
4697                 bp->macb_reg_writel = hw_writel;
4698         }
4699         bp->num_queues = num_queues;
4700         bp->queue_mask = queue_mask;
4701         if (macb_config)
4702                 bp->dma_burst_length = macb_config->dma_burst_length;
4703         bp->pclk = pclk;
4704         bp->hclk = hclk;
4705         bp->tx_clk = tx_clk;
4706         bp->rx_clk = rx_clk;
4707         bp->tsu_clk = tsu_clk;
4708         if (macb_config)
4709                 bp->jumbo_max_len = macb_config->jumbo_max_len;
4710
4711         bp->wol = 0;
4712         if (of_get_property(np, "magic-packet", NULL))
4713                 bp->wol |= MACB_WOL_HAS_MAGIC_PACKET;
4714         device_set_wakeup_capable(&pdev->dev, bp->wol & MACB_WOL_HAS_MAGIC_PACKET);
4715
4716         bp->usrio = macb_config->usrio;
4717
4718         spin_lock_init(&bp->lock);
4719
4720         /* setup capabilities */
4721         macb_configure_caps(bp, macb_config);
4722
4723 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
4724         if (GEM_BFEXT(DAW64, gem_readl(bp, DCFG6))) {
4725                 dma_set_mask(&pdev->dev, DMA_BIT_MASK(44));
4726                 bp->hw_dma_cap |= HW_DMA_CAP_64B;
4727         }
4728 #endif
4729         platform_set_drvdata(pdev, dev);
4730
4731         dev->irq = platform_get_irq(pdev, 0);
4732         if (dev->irq < 0) {
4733                 err = dev->irq;
4734                 goto err_out_free_netdev;
4735         }
4736
4737         /* MTU range: 68 - 1500 or 10240 */
4738         dev->min_mtu = GEM_MTU_MIN_SIZE;
4739         if (bp->caps & MACB_CAPS_JUMBO)
4740                 dev->max_mtu = gem_readl(bp, JML) - ETH_HLEN - ETH_FCS_LEN;
4741         else
4742                 dev->max_mtu = ETH_DATA_LEN;
4743
4744         if (bp->caps & MACB_CAPS_BD_RD_PREFETCH) {
4745                 val = GEM_BFEXT(RXBD_RDBUFF, gem_readl(bp, DCFG10));
4746                 if (val)
4747                         bp->rx_bd_rd_prefetch = (2 << (val - 1)) *
4748                                                 macb_dma_desc_get_size(bp);
4749
4750                 val = GEM_BFEXT(TXBD_RDBUFF, gem_readl(bp, DCFG10));
4751                 if (val)
4752                         bp->tx_bd_rd_prefetch = (2 << (val - 1)) *
4753                                                 macb_dma_desc_get_size(bp);
4754         }
4755
4756         bp->rx_intr_mask = MACB_RX_INT_FLAGS;
4757         if (bp->caps & MACB_CAPS_NEEDS_RSTONUBR)
4758                 bp->rx_intr_mask |= MACB_BIT(RXUBR);
4759
4760         mac = of_get_mac_address(np);
4761         if (PTR_ERR(mac) == -EPROBE_DEFER) {
4762                 err = -EPROBE_DEFER;
4763                 goto err_out_free_netdev;
4764         } else if (!IS_ERR_OR_NULL(mac)) {
4765                 ether_addr_copy(bp->dev->dev_addr, mac);
4766         } else {
4767                 macb_get_hwaddr(bp);
4768         }
4769
4770         err = of_get_phy_mode(np, &interface);
4771         if (err)
4772                 /* not found in DT, MII by default */
4773                 bp->phy_interface = PHY_INTERFACE_MODE_MII;
4774         else
4775                 bp->phy_interface = interface;
4776
4777         /* IP specific init */
4778         err = init(pdev);
4779         if (err)
4780                 goto err_out_free_netdev;
4781
4782         err = macb_mii_init(bp);
4783         if (err)
4784                 goto err_out_free_netdev;
4785
4786         netif_carrier_off(dev);
4787
4788         err = register_netdev(dev);
4789         if (err) {
4790                 dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
4791                 goto err_out_unregister_mdio;
4792         }
4793
4794         tasklet_setup(&bp->hresp_err_tasklet, macb_hresp_error_task);
4795
4796         netdev_info(dev, "Cadence %s rev 0x%08x at 0x%08lx irq %d (%pM)\n",
4797                     macb_is_gem(bp) ? "GEM" : "MACB", macb_readl(bp, MID),
4798                     dev->base_addr, dev->irq, dev->dev_addr);
4799
4800         pm_runtime_mark_last_busy(&bp->pdev->dev);
4801         pm_runtime_put_autosuspend(&bp->pdev->dev);
4802
4803         return 0;
4804
4805 err_out_unregister_mdio:
4806         mdiobus_unregister(bp->mii_bus);
4807         mdiobus_free(bp->mii_bus);
4808
4809 err_out_free_netdev:
4810         free_netdev(dev);
4811
4812 err_disable_clocks:
4813         macb_clks_disable(pclk, hclk, tx_clk, rx_clk, tsu_clk);
4814         pm_runtime_disable(&pdev->dev);
4815         pm_runtime_set_suspended(&pdev->dev);
4816         pm_runtime_dont_use_autosuspend(&pdev->dev);
4817
4818         return err;
4819 }
4820
4821 static int macb_remove(struct platform_device *pdev)
4822 {
4823         struct net_device *dev;
4824         struct macb *bp;
4825
4826         dev = platform_get_drvdata(pdev);
4827
4828         if (dev) {
4829                 bp = netdev_priv(dev);
4830                 mdiobus_unregister(bp->mii_bus);
4831                 mdiobus_free(bp->mii_bus);
4832
4833                 unregister_netdev(dev);
4834                 tasklet_kill(&bp->hresp_err_tasklet);
4835                 pm_runtime_disable(&pdev->dev);
4836                 pm_runtime_dont_use_autosuspend(&pdev->dev);
4837                 if (!pm_runtime_suspended(&pdev->dev)) {
4838                         macb_clks_disable(bp->pclk, bp->hclk, bp->tx_clk,
4839                                           bp->rx_clk, bp->tsu_clk);
4840                         pm_runtime_set_suspended(&pdev->dev);
4841                 }
4842                 phylink_destroy(bp->phylink);
4843                 free_netdev(dev);
4844         }
4845
4846         return 0;
4847 }
4848
4849 static int __maybe_unused macb_suspend(struct device *dev)
4850 {
4851         struct net_device *netdev = dev_get_drvdata(dev);
4852         struct macb *bp = netdev_priv(netdev);
4853         struct macb_queue *queue = bp->queues;
4854         unsigned long flags;
4855         unsigned int q;
4856         int err;
4857
4858         if (!netif_running(netdev))
4859                 return 0;
4860
4861         if (bp->wol & MACB_WOL_ENABLED) {
4862                 spin_lock_irqsave(&bp->lock, flags);
4863                 /* Flush all status bits */
4864                 macb_writel(bp, TSR, -1);
4865                 macb_writel(bp, RSR, -1);
4866                 for (q = 0, queue = bp->queues; q < bp->num_queues;
4867                      ++q, ++queue) {
4868                         /* Disable all interrupts */
4869                         queue_writel(queue, IDR, -1);
4870                         queue_readl(queue, ISR);
4871                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
4872                                 queue_writel(queue, ISR, -1);
4873                 }
4874                 /* Change interrupt handler and
4875                  * Enable WoL IRQ on queue 0
4876                  */
4877                 devm_free_irq(dev, bp->queues[0].irq, bp->queues);
4878                 if (macb_is_gem(bp)) {
4879                         err = devm_request_irq(dev, bp->queues[0].irq, gem_wol_interrupt,
4880                                                IRQF_SHARED, netdev->name, bp->queues);
4881                         if (err) {
4882                                 dev_err(dev,
4883                                         "Unable to request IRQ %d (error %d)\n",
4884                                         bp->queues[0].irq, err);
4885                                 spin_unlock_irqrestore(&bp->lock, flags);
4886                                 return err;
4887                         }
4888                         queue_writel(bp->queues, IER, GEM_BIT(WOL));
4889                         gem_writel(bp, WOL, MACB_BIT(MAG));
4890                 } else {
4891                         err = devm_request_irq(dev, bp->queues[0].irq, macb_wol_interrupt,
4892                                                IRQF_SHARED, netdev->name, bp->queues);
4893                         if (err) {
4894                                 dev_err(dev,
4895                                         "Unable to request IRQ %d (error %d)\n",
4896                                         bp->queues[0].irq, err);
4897                                 spin_unlock_irqrestore(&bp->lock, flags);
4898                                 return err;
4899                         }
4900                         queue_writel(bp->queues, IER, MACB_BIT(WOL));
4901                         macb_writel(bp, WOL, MACB_BIT(MAG));
4902                 }
4903                 spin_unlock_irqrestore(&bp->lock, flags);
4904
4905                 enable_irq_wake(bp->queues[0].irq);
4906         }
4907
4908         netif_device_detach(netdev);
4909         for (q = 0, queue = bp->queues; q < bp->num_queues;
4910              ++q, ++queue)
4911                 napi_disable(&queue->napi);
4912
4913         if (!(bp->wol & MACB_WOL_ENABLED)) {
4914                 rtnl_lock();
4915                 phylink_stop(bp->phylink);
4916                 rtnl_unlock();
4917                 spin_lock_irqsave(&bp->lock, flags);
4918                 macb_reset_hw(bp);
4919                 spin_unlock_irqrestore(&bp->lock, flags);
4920         }
4921
4922         if (!(bp->caps & MACB_CAPS_USRIO_DISABLED))
4923                 bp->pm_data.usrio = macb_or_gem_readl(bp, USRIO);
4924
4925         if (netdev->hw_features & NETIF_F_NTUPLE)
4926                 bp->pm_data.scrt2 = gem_readl_n(bp, ETHT, SCRT2_ETHT);
4927
4928         if (bp->ptp_info)
4929                 bp->ptp_info->ptp_remove(netdev);
4930         if (!device_may_wakeup(dev))
4931                 pm_runtime_force_suspend(dev);
4932
4933         return 0;
4934 }
4935
4936 static int __maybe_unused macb_resume(struct device *dev)
4937 {
4938         struct net_device *netdev = dev_get_drvdata(dev);
4939         struct macb *bp = netdev_priv(netdev);
4940         struct macb_queue *queue = bp->queues;
4941         unsigned long flags;
4942         unsigned int q;
4943         int err;
4944
4945         if (!netif_running(netdev))
4946                 return 0;
4947
4948         if (!device_may_wakeup(dev))
4949                 pm_runtime_force_resume(dev);
4950
4951         if (bp->wol & MACB_WOL_ENABLED) {
4952                 spin_lock_irqsave(&bp->lock, flags);
4953                 /* Disable WoL */
4954                 if (macb_is_gem(bp)) {
4955                         queue_writel(bp->queues, IDR, GEM_BIT(WOL));
4956                         gem_writel(bp, WOL, 0);
4957                 } else {
4958                         queue_writel(bp->queues, IDR, MACB_BIT(WOL));
4959                         macb_writel(bp, WOL, 0);
4960                 }
4961                 /* Clear ISR on queue 0 */
4962                 queue_readl(bp->queues, ISR);
4963                 if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
4964                         queue_writel(bp->queues, ISR, -1);
4965                 /* Replace interrupt handler on queue 0 */
4966                 devm_free_irq(dev, bp->queues[0].irq, bp->queues);
4967                 err = devm_request_irq(dev, bp->queues[0].irq, macb_interrupt,
4968                                        IRQF_SHARED, netdev->name, bp->queues);
4969                 if (err) {
4970                         dev_err(dev,
4971                                 "Unable to request IRQ %d (error %d)\n",
4972                                 bp->queues[0].irq, err);
4973                         spin_unlock_irqrestore(&bp->lock, flags);
4974                         return err;
4975                 }
4976                 spin_unlock_irqrestore(&bp->lock, flags);
4977
4978                 disable_irq_wake(bp->queues[0].irq);
4979
4980                 /* Now make sure we disable phy before moving
4981                  * to common restore path
4982                  */
4983                 rtnl_lock();
4984                 phylink_stop(bp->phylink);
4985                 rtnl_unlock();
4986         }
4987
4988         for (q = 0, queue = bp->queues; q < bp->num_queues;
4989              ++q, ++queue)
4990                 napi_enable(&queue->napi);
4991
4992         if (netdev->hw_features & NETIF_F_NTUPLE)
4993                 gem_writel_n(bp, ETHT, SCRT2_ETHT, bp->pm_data.scrt2);
4994
4995         if (!(bp->caps & MACB_CAPS_USRIO_DISABLED))
4996                 macb_or_gem_writel(bp, USRIO, bp->pm_data.usrio);
4997
4998         macb_writel(bp, NCR, MACB_BIT(MPE));
4999         macb_init_hw(bp);
5000         macb_set_rx_mode(netdev);
5001         macb_restore_features(bp);
5002         rtnl_lock();
5003         phylink_start(bp->phylink);
5004         rtnl_unlock();
5005
5006         netif_device_attach(netdev);
5007         if (bp->ptp_info)
5008                 bp->ptp_info->ptp_init(netdev);
5009
5010         return 0;
5011 }
5012
5013 static int __maybe_unused macb_runtime_suspend(struct device *dev)
5014 {
5015         struct net_device *netdev = dev_get_drvdata(dev);
5016         struct macb *bp = netdev_priv(netdev);
5017
5018         if (!(device_may_wakeup(dev)))
5019                 macb_clks_disable(bp->pclk, bp->hclk, bp->tx_clk, bp->rx_clk, bp->tsu_clk);
5020         else
5021                 macb_clks_disable(NULL, NULL, NULL, NULL, bp->tsu_clk);
5022
5023         return 0;
5024 }
5025
5026 static int __maybe_unused macb_runtime_resume(struct device *dev)
5027 {
5028         struct net_device *netdev = dev_get_drvdata(dev);
5029         struct macb *bp = netdev_priv(netdev);
5030
5031         if (!(device_may_wakeup(dev))) {
5032                 clk_prepare_enable(bp->pclk);
5033                 clk_prepare_enable(bp->hclk);
5034                 clk_prepare_enable(bp->tx_clk);
5035                 clk_prepare_enable(bp->rx_clk);
5036         }
5037         clk_prepare_enable(bp->tsu_clk);
5038
5039         return 0;
5040 }
5041
5042 static const struct dev_pm_ops macb_pm_ops = {
5043         SET_SYSTEM_SLEEP_PM_OPS(macb_suspend, macb_resume)
5044         SET_RUNTIME_PM_OPS(macb_runtime_suspend, macb_runtime_resume, NULL)
5045 };
5046
5047 static struct platform_driver macb_driver = {
5048         .probe          = macb_probe,
5049         .remove         = macb_remove,
5050         .driver         = {
5051                 .name           = "macb",
5052                 .of_match_table = of_match_ptr(macb_dt_ids),
5053                 .pm     = &macb_pm_ops,
5054         },
5055 };
5056
5057 module_platform_driver(macb_driver);
5058
5059 MODULE_LICENSE("GPL");
5060 MODULE_DESCRIPTION("Cadence MACB/GEM Ethernet driver");
5061 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
5062 MODULE_ALIAS("platform:macb");