git.sur5r.net Git - u-boot/blob - drivers/net/mvpp2.c

   1 /*
   2  * Driver for Marvell PPv2 network controller for Armada 375 SoC.
   3  *
   4  * Copyright (C) 2014 Marvell
   5  *
   6  * Marcin Wojtas <mw@semihalf.com>
   7  *
   8  * U-Boot version:
   9  * Copyright (C) 2016 Stefan Roese <sr@denx.de>
  10  *
  11  * This file is licensed under the terms of the GNU General Public
  12  * License version 2. This program is licensed "as is" without any
  13  * warranty of any kind, whether express or implied.
  14  */
  15
  16 #include <common.h>
  17 #include <dm.h>
  18 #include <dm/device-internal.h>
  19 #include <dm/lists.h>
  20 #include <net.h>
  21 #include <netdev.h>
  22 #include <config.h>
  23 #include <malloc.h>
  24 #include <asm/io.h>
  25 #include <linux/errno.h>
  26 #include <phy.h>
  27 #include <miiphy.h>
  28 #include <watchdog.h>
  29 #include <asm/arch/cpu.h>
  30 #include <asm/arch/soc.h>
  31 #include <linux/compat.h>
  32 #include <linux/mbus.h>
  33
  34 DECLARE_GLOBAL_DATA_PTR;
  35
  36 /* Some linux -> U-Boot compatibility stuff */
  37 #define netdev_err(dev, fmt, args...)           \
  38         printf(fmt, ##args)
  39 #define netdev_warn(dev, fmt, args...)          \
  40         printf(fmt, ##args)
  41 #define netdev_info(dev, fmt, args...)          \
  42         printf(fmt, ##args)
  43 #define netdev_dbg(dev, fmt, args...)           \
  44         printf(fmt, ##args)
  45
  46 #define ETH_ALEN        6               /* Octets in one ethernet addr  */
  47
  48 #define __verify_pcpu_ptr(ptr)                                          \
  49 do {                                                                    \
  50         const void __percpu *__vpp_verify = (typeof((ptr) + 0))NULL;    \
  51         (void)__vpp_verify;                                             \
  52 } while (0)
  53
  54 #define VERIFY_PERCPU_PTR(__p)                                          \
  55 ({                                                                      \
  56         __verify_pcpu_ptr(__p);                                         \
  57         (typeof(*(__p)) __kernel __force *)(__p);                       \
  58 })
  59
  60 #define per_cpu_ptr(ptr, cpu)   ({ (void)(cpu); VERIFY_PERCPU_PTR(ptr); })
  61 #define smp_processor_id()      0
  62 #define num_present_cpus()      1
  63 #define for_each_present_cpu(cpu)                       \
  64         for ((cpu) = 0; (cpu) < 1; (cpu)++)
  65
  66 #define NET_SKB_PAD     max(32, MVPP2_CPU_D_CACHE_LINE_SIZE)
  67
  68 #define CONFIG_NR_CPUS          1
  69 #define ETH_HLEN                ETHER_HDR_SIZE  /* Total octets in header */
  70
  71 /* 2(HW hdr) 14(MAC hdr) 4(CRC) 32(extra for cache prefetch) */
  72 #define WRAP                    (2 + ETH_HLEN + 4 + 32)
  73 #define MTU                     1500
  74 #define RX_BUFFER_SIZE          (ALIGN(MTU + WRAP, ARCH_DMA_MINALIGN))
  75
  76 #define MVPP2_SMI_TIMEOUT                       10000
  77
  78 /* RX Fifo Registers */
  79 #define MVPP2_RX_DATA_FIFO_SIZE_REG(port)       (0x00 + 4 * (port))
  80 #define MVPP2_RX_ATTR_FIFO_SIZE_REG(port)       (0x20 + 4 * (port))
  81 #define MVPP2_RX_MIN_PKT_SIZE_REG               0x60
  82 #define MVPP2_RX_FIFO_INIT_REG                  0x64
  83
  84 /* RX DMA Top Registers */
  85 #define MVPP2_RX_CTRL_REG(port)                 (0x140 + 4 * (port))
  86 #define     MVPP2_RX_LOW_LATENCY_PKT_SIZE(s)    (((s) & 0xfff) << 16)
  87 #define     MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK   BIT(31)
  88 #define MVPP2_POOL_BUF_SIZE_REG(pool)           (0x180 + 4 * (pool))
  89 #define     MVPP2_POOL_BUF_SIZE_OFFSET          5
  90 #define MVPP2_RXQ_CONFIG_REG(rxq)               (0x800 + 4 * (rxq))
  91 #define     MVPP2_SNOOP_PKT_SIZE_MASK           0x1ff
  92 #define     MVPP2_SNOOP_BUF_HDR_MASK            BIT(9)
  93 #define     MVPP2_RXQ_POOL_SHORT_OFFS           20
  94 #define     MVPP2_RXQ_POOL_SHORT_MASK           0x700000
  95 #define     MVPP2_RXQ_POOL_LONG_OFFS            24
  96 #define     MVPP2_RXQ_POOL_LONG_MASK            0x7000000
  97 #define     MVPP2_RXQ_PACKET_OFFSET_OFFS        28
  98 #define     MVPP2_RXQ_PACKET_OFFSET_MASK        0x70000000
  99 #define     MVPP2_RXQ_DISABLE_MASK              BIT(31)
 100
 101 /* Parser Registers */
 102 #define MVPP2_PRS_INIT_LOOKUP_REG               0x1000
 103 #define     MVPP2_PRS_PORT_LU_MAX               0xf
 104 #define     MVPP2_PRS_PORT_LU_MASK(port)        (0xff << ((port) * 4))
 105 #define     MVPP2_PRS_PORT_LU_VAL(port, val)    ((val) << ((port) * 4))
 106 #define MVPP2_PRS_INIT_OFFS_REG(port)           (0x1004 + ((port) & 4))
 107 #define     MVPP2_PRS_INIT_OFF_MASK(port)       (0x3f << (((port) % 4) * 8))
 108 #define     MVPP2_PRS_INIT_OFF_VAL(port, val)   ((val) << (((port) % 4) * 8))
 109 #define MVPP2_PRS_MAX_LOOP_REG(port)            (0x100c + ((port) & 4))
 110 #define     MVPP2_PRS_MAX_LOOP_MASK(port)       (0xff << (((port) % 4) * 8))
 111 #define     MVPP2_PRS_MAX_LOOP_VAL(port, val)   ((val) << (((port) % 4) * 8))
 112 #define MVPP2_PRS_TCAM_IDX_REG                  0x1100
 113 #define MVPP2_PRS_TCAM_DATA_REG(idx)            (0x1104 + (idx) * 4)
 114 #define     MVPP2_PRS_TCAM_INV_MASK             BIT(31)
 115 #define MVPP2_PRS_SRAM_IDX_REG                  0x1200
 116 #define MVPP2_PRS_SRAM_DATA_REG(idx)            (0x1204 + (idx) * 4)
 117 #define MVPP2_PRS_TCAM_CTRL_REG                 0x1230
 118 #define     MVPP2_PRS_TCAM_EN_MASK              BIT(0)
 119
 120 /* Classifier Registers */
 121 #define MVPP2_CLS_MODE_REG                      0x1800
 122 #define     MVPP2_CLS_MODE_ACTIVE_MASK          BIT(0)
 123 #define MVPP2_CLS_PORT_WAY_REG                  0x1810
 124 #define     MVPP2_CLS_PORT_WAY_MASK(port)       (1 << (port))
 125 #define MVPP2_CLS_LKP_INDEX_REG                 0x1814
 126 #define     MVPP2_CLS_LKP_INDEX_WAY_OFFS        6
 127 #define MVPP2_CLS_LKP_TBL_REG                   0x1818
 128 #define     MVPP2_CLS_LKP_TBL_RXQ_MASK          0xff
 129 #define     MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK    BIT(25)
 130 #define MVPP2_CLS_FLOW_INDEX_REG                0x1820
 131 #define MVPP2_CLS_FLOW_TBL0_REG                 0x1824
 132 #define MVPP2_CLS_FLOW_TBL1_REG                 0x1828
 133 #define MVPP2_CLS_FLOW_TBL2_REG                 0x182c
 134 #define MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port)    (0x1980 + ((port) * 4))
 135 #define     MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS     3
 136 #define     MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK     0x7
 137 #define MVPP2_CLS_SWFWD_P2HQ_REG(port)          (0x19b0 + ((port) * 4))
 138 #define MVPP2_CLS_SWFWD_PCTRL_REG               0x19d0
 139 #define     MVPP2_CLS_SWFWD_PCTRL_MASK(port)    (1 << (port))
 140
 141 /* Descriptor Manager Top Registers */
 142 #define MVPP2_RXQ_NUM_REG                       0x2040
 143 #define MVPP2_RXQ_DESC_ADDR_REG                 0x2044
 144 #define MVPP2_RXQ_DESC_SIZE_REG                 0x2048
 145 #define     MVPP2_RXQ_DESC_SIZE_MASK            0x3ff0
 146 #define MVPP2_RXQ_STATUS_UPDATE_REG(rxq)        (0x3000 + 4 * (rxq))
 147 #define     MVPP2_RXQ_NUM_PROCESSED_OFFSET      0
 148 #define     MVPP2_RXQ_NUM_NEW_OFFSET            16
 149 #define MVPP2_RXQ_STATUS_REG(rxq)               (0x3400 + 4 * (rxq))
 150 #define     MVPP2_RXQ_OCCUPIED_MASK             0x3fff
 151 #define     MVPP2_RXQ_NON_OCCUPIED_OFFSET       16
 152 #define     MVPP2_RXQ_NON_OCCUPIED_MASK         0x3fff0000
 153 #define MVPP2_RXQ_THRESH_REG                    0x204c
 154 #define     MVPP2_OCCUPIED_THRESH_OFFSET        0
 155 #define     MVPP2_OCCUPIED_THRESH_MASK          0x3fff
 156 #define MVPP2_RXQ_INDEX_REG                     0x2050
 157 #define MVPP2_TXQ_NUM_REG                       0x2080
 158 #define MVPP2_TXQ_DESC_ADDR_REG                 0x2084
 159 #define MVPP2_TXQ_DESC_SIZE_REG                 0x2088
 160 #define     MVPP2_TXQ_DESC_SIZE_MASK            0x3ff0
 161 #define MVPP2_AGGR_TXQ_UPDATE_REG               0x2090
 162 #define MVPP2_TXQ_THRESH_REG                    0x2094
 163 #define     MVPP2_TRANSMITTED_THRESH_OFFSET     16
 164 #define     MVPP2_TRANSMITTED_THRESH_MASK       0x3fff0000
 165 #define MVPP2_TXQ_INDEX_REG                     0x2098
 166 #define MVPP2_TXQ_PREF_BUF_REG                  0x209c
 167 #define     MVPP2_PREF_BUF_PTR(desc)            ((desc) & 0xfff)
 168 #define     MVPP2_PREF_BUF_SIZE_4               (BIT(12) | BIT(13))
 169 #define     MVPP2_PREF_BUF_SIZE_16              (BIT(12) | BIT(14))
 170 #define     MVPP2_PREF_BUF_THRESH(val)          ((val) << 17)
 171 #define     MVPP2_TXQ_DRAIN_EN_MASK             BIT(31)
 172 #define MVPP2_TXQ_PENDING_REG                   0x20a0
 173 #define     MVPP2_TXQ_PENDING_MASK              0x3fff
 174 #define MVPP2_TXQ_INT_STATUS_REG                0x20a4
 175 #define MVPP2_TXQ_SENT_REG(txq)                 (0x3c00 + 4 * (txq))
 176 #define     MVPP2_TRANSMITTED_COUNT_OFFSET      16
 177 #define     MVPP2_TRANSMITTED_COUNT_MASK        0x3fff0000
 178 #define MVPP2_TXQ_RSVD_REQ_REG                  0x20b0
 179 #define     MVPP2_TXQ_RSVD_REQ_Q_OFFSET         16
 180 #define MVPP2_TXQ_RSVD_RSLT_REG                 0x20b4
 181 #define     MVPP2_TXQ_RSVD_RSLT_MASK            0x3fff
 182 #define MVPP2_TXQ_RSVD_CLR_REG                  0x20b8
 183 #define     MVPP2_TXQ_RSVD_CLR_OFFSET           16
 184 #define MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu)       (0x2100 + 4 * (cpu))
 185 #define MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu)       (0x2140 + 4 * (cpu))
 186 #define     MVPP2_AGGR_TXQ_DESC_SIZE_MASK       0x3ff0
 187 #define MVPP2_AGGR_TXQ_STATUS_REG(cpu)          (0x2180 + 4 * (cpu))
 188 #define     MVPP2_AGGR_TXQ_PENDING_MASK         0x3fff
 189 #define MVPP2_AGGR_TXQ_INDEX_REG(cpu)           (0x21c0 + 4 * (cpu))
 190
 191 /* MBUS bridge registers */
 192 #define MVPP2_WIN_BASE(w)                       (0x4000 + ((w) << 2))
 193 #define MVPP2_WIN_SIZE(w)                       (0x4020 + ((w) << 2))
 194 #define MVPP2_WIN_REMAP(w)                      (0x4040 + ((w) << 2))
 195 #define MVPP2_BASE_ADDR_ENABLE                  0x4060
 196
 197 /* Interrupt Cause and Mask registers */
 198 #define MVPP2_ISR_RX_THRESHOLD_REG(rxq)         (0x5200 + 4 * (rxq))
 199 #define MVPP2_ISR_RXQ_GROUP_REG(rxq)            (0x5400 + 4 * (rxq))
 200 #define MVPP2_ISR_ENABLE_REG(port)              (0x5420 + 4 * (port))
 201 #define     MVPP2_ISR_ENABLE_INTERRUPT(mask)    ((mask) & 0xffff)
 202 #define     MVPP2_ISR_DISABLE_INTERRUPT(mask)   (((mask) << 16) & 0xffff0000)
 203 #define MVPP2_ISR_RX_TX_CAUSE_REG(port)         (0x5480 + 4 * (port))
 204 #define     MVPP2_CAUSE_RXQ_OCCUP_DESC_ALL_MASK 0xffff
 205 #define     MVPP2_CAUSE_TXQ_OCCUP_DESC_ALL_MASK 0xff0000
 206 #define     MVPP2_CAUSE_RX_FIFO_OVERRUN_MASK    BIT(24)
 207 #define     MVPP2_CAUSE_FCS_ERR_MASK            BIT(25)
 208 #define     MVPP2_CAUSE_TX_FIFO_UNDERRUN_MASK   BIT(26)
 209 #define     MVPP2_CAUSE_TX_EXCEPTION_SUM_MASK   BIT(29)
 210 #define     MVPP2_CAUSE_RX_EXCEPTION_SUM_MASK   BIT(30)
 211 #define     MVPP2_CAUSE_MISC_SUM_MASK           BIT(31)
 212 #define MVPP2_ISR_RX_TX_MASK_REG(port)          (0x54a0 + 4 * (port))
 213 #define MVPP2_ISR_PON_RX_TX_MASK_REG            0x54bc
 214 #define     MVPP2_PON_CAUSE_RXQ_OCCUP_DESC_ALL_MASK     0xffff
 215 #define     MVPP2_PON_CAUSE_TXP_OCCUP_DESC_ALL_MASK     0x3fc00000
 216 #define     MVPP2_PON_CAUSE_MISC_SUM_MASK               BIT(31)
 217 #define MVPP2_ISR_MISC_CAUSE_REG                0x55b0
 218
 219 /* Buffer Manager registers */
 220 #define MVPP2_BM_POOL_BASE_REG(pool)            (0x6000 + ((pool) * 4))
 221 #define     MVPP2_BM_POOL_BASE_ADDR_MASK        0xfffff80
 222 #define MVPP2_BM_POOL_SIZE_REG(pool)            (0x6040 + ((pool) * 4))
 223 #define     MVPP2_BM_POOL_SIZE_MASK             0xfff0
 224 #define MVPP2_BM_POOL_READ_PTR_REG(pool)        (0x6080 + ((pool) * 4))
 225 #define     MVPP2_BM_POOL_GET_READ_PTR_MASK     0xfff0
 226 #define MVPP2_BM_POOL_PTRS_NUM_REG(pool)        (0x60c0 + ((pool) * 4))
 227 #define     MVPP2_BM_POOL_PTRS_NUM_MASK         0xfff0
 228 #define MVPP2_BM_BPPI_READ_PTR_REG(pool)        (0x6100 + ((pool) * 4))
 229 #define MVPP2_BM_BPPI_PTRS_NUM_REG(pool)        (0x6140 + ((pool) * 4))
 230 #define     MVPP2_BM_BPPI_PTR_NUM_MASK          0x7ff
 231 #define     MVPP2_BM_BPPI_PREFETCH_FULL_MASK    BIT(16)
 232 #define MVPP2_BM_POOL_CTRL_REG(pool)            (0x6200 + ((pool) * 4))
 233 #define     MVPP2_BM_START_MASK                 BIT(0)
 234 #define     MVPP2_BM_STOP_MASK                  BIT(1)
 235 #define     MVPP2_BM_STATE_MASK                 BIT(4)
 236 #define     MVPP2_BM_LOW_THRESH_OFFS            8
 237 #define     MVPP2_BM_LOW_THRESH_MASK            0x7f00
 238 #define     MVPP2_BM_LOW_THRESH_VALUE(val)      ((val) << \
 239                                                 MVPP2_BM_LOW_THRESH_OFFS)
 240 #define     MVPP2_BM_HIGH_THRESH_OFFS           16
 241 #define     MVPP2_BM_HIGH_THRESH_MASK           0x7f0000
 242 #define     MVPP2_BM_HIGH_THRESH_VALUE(val)     ((val) << \
 243                                                 MVPP2_BM_HIGH_THRESH_OFFS)
 244 #define MVPP2_BM_INTR_CAUSE_REG(pool)           (0x6240 + ((pool) * 4))
 245 #define     MVPP2_BM_RELEASED_DELAY_MASK        BIT(0)
 246 #define     MVPP2_BM_ALLOC_FAILED_MASK          BIT(1)
 247 #define     MVPP2_BM_BPPE_EMPTY_MASK            BIT(2)
 248 #define     MVPP2_BM_BPPE_FULL_MASK             BIT(3)
 249 #define     MVPP2_BM_AVAILABLE_BP_LOW_MASK      BIT(4)
 250 #define MVPP2_BM_INTR_MASK_REG(pool)            (0x6280 + ((pool) * 4))
 251 #define MVPP2_BM_PHY_ALLOC_REG(pool)            (0x6400 + ((pool) * 4))
 252 #define     MVPP2_BM_PHY_ALLOC_GRNTD_MASK       BIT(0)
 253 #define MVPP2_BM_VIRT_ALLOC_REG                 0x6440
 254 #define MVPP2_BM_PHY_RLS_REG(pool)              (0x6480 + ((pool) * 4))
 255 #define     MVPP2_BM_PHY_RLS_MC_BUFF_MASK       BIT(0)
 256 #define     MVPP2_BM_PHY_RLS_PRIO_EN_MASK       BIT(1)
 257 #define     MVPP2_BM_PHY_RLS_GRNTD_MASK         BIT(2)
 258 #define MVPP2_BM_VIRT_RLS_REG                   0x64c0
 259 #define MVPP2_BM_MC_RLS_REG                     0x64c4
 260 #define     MVPP2_BM_MC_ID_MASK                 0xfff
 261 #define     MVPP2_BM_FORCE_RELEASE_MASK         BIT(12)
 262
 263 /* TX Scheduler registers */
 264 #define MVPP2_TXP_SCHED_PORT_INDEX_REG          0x8000
 265 #define MVPP2_TXP_SCHED_Q_CMD_REG               0x8004
 266 #define     MVPP2_TXP_SCHED_ENQ_MASK            0xff
 267 #define     MVPP2_TXP_SCHED_DISQ_OFFSET         8
 268 #define MVPP2_TXP_SCHED_CMD_1_REG               0x8010
 269 #define MVPP2_TXP_SCHED_PERIOD_REG              0x8018
 270 #define MVPP2_TXP_SCHED_MTU_REG                 0x801c
 271 #define     MVPP2_TXP_MTU_MAX                   0x7FFFF
 272 #define MVPP2_TXP_SCHED_REFILL_REG              0x8020
 273 #define     MVPP2_TXP_REFILL_TOKENS_ALL_MASK    0x7ffff
 274 #define     MVPP2_TXP_REFILL_PERIOD_ALL_MASK    0x3ff00000
 275 #define     MVPP2_TXP_REFILL_PERIOD_MASK(v)     ((v) << 20)
 276 #define MVPP2_TXP_SCHED_TOKEN_SIZE_REG          0x8024
 277 #define     MVPP2_TXP_TOKEN_SIZE_MAX            0xffffffff
 278 #define MVPP2_TXQ_SCHED_REFILL_REG(q)           (0x8040 + ((q) << 2))
 279 #define     MVPP2_TXQ_REFILL_TOKENS_ALL_MASK    0x7ffff
 280 #define     MVPP2_TXQ_REFILL_PERIOD_ALL_MASK    0x3ff00000
 281 #define     MVPP2_TXQ_REFILL_PERIOD_MASK(v)     ((v) << 20)
 282 #define MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(q)       (0x8060 + ((q) << 2))
 283 #define     MVPP2_TXQ_TOKEN_SIZE_MAX            0x7fffffff
 284 #define MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(q)       (0x8080 + ((q) << 2))
 285 #define     MVPP2_TXQ_TOKEN_CNTR_MAX            0xffffffff
 286
 287 /* TX general registers */
 288 #define MVPP2_TX_SNOOP_REG                      0x8800
 289 #define MVPP2_TX_PORT_FLUSH_REG                 0x8810
 290 #define     MVPP2_TX_PORT_FLUSH_MASK(port)      (1 << (port))
 291
 292 /* LMS registers */
 293 #define MVPP2_SRC_ADDR_MIDDLE                   0x24
 294 #define MVPP2_SRC_ADDR_HIGH                     0x28
 295 #define MVPP2_PHY_AN_CFG0_REG                   0x34
 296 #define     MVPP2_PHY_AN_STOP_SMI0_MASK         BIT(7)
 297 #define MVPP2_MNG_EXTENDED_GLOBAL_CTRL_REG      0x305c
 298 #define     MVPP2_EXT_GLOBAL_CTRL_DEFAULT       0x27
 299
 300 /* Per-port registers */
 301 #define MVPP2_GMAC_CTRL_0_REG                   0x0
 302 #define      MVPP2_GMAC_PORT_EN_MASK            BIT(0)
 303 #define      MVPP2_GMAC_MAX_RX_SIZE_OFFS        2
 304 #define      MVPP2_GMAC_MAX_RX_SIZE_MASK        0x7ffc
 305 #define      MVPP2_GMAC_MIB_CNTR_EN_MASK        BIT(15)
 306 #define MVPP2_GMAC_CTRL_1_REG                   0x4
 307 #define      MVPP2_GMAC_PERIODIC_XON_EN_MASK    BIT(1)
 308 #define      MVPP2_GMAC_GMII_LB_EN_MASK         BIT(5)
 309 #define      MVPP2_GMAC_PCS_LB_EN_BIT           6
 310 #define      MVPP2_GMAC_PCS_LB_EN_MASK          BIT(6)
 311 #define      MVPP2_GMAC_SA_LOW_OFFS             7
 312 #define MVPP2_GMAC_CTRL_2_REG                   0x8
 313 #define      MVPP2_GMAC_INBAND_AN_MASK          BIT(0)
 314 #define      MVPP2_GMAC_PCS_ENABLE_MASK         BIT(3)
 315 #define      MVPP2_GMAC_PORT_RGMII_MASK         BIT(4)
 316 #define      MVPP2_GMAC_PORT_RESET_MASK         BIT(6)
 317 #define MVPP2_GMAC_AUTONEG_CONFIG               0xc
 318 #define      MVPP2_GMAC_FORCE_LINK_DOWN         BIT(0)
 319 #define      MVPP2_GMAC_FORCE_LINK_PASS         BIT(1)
 320 #define      MVPP2_GMAC_CONFIG_MII_SPEED        BIT(5)
 321 #define      MVPP2_GMAC_CONFIG_GMII_SPEED       BIT(6)
 322 #define      MVPP2_GMAC_AN_SPEED_EN             BIT(7)
 323 #define      MVPP2_GMAC_FC_ADV_EN               BIT(9)
 324 #define      MVPP2_GMAC_CONFIG_FULL_DUPLEX      BIT(12)
 325 #define      MVPP2_GMAC_AN_DUPLEX_EN            BIT(13)
 326 #define MVPP2_GMAC_PORT_FIFO_CFG_1_REG          0x1c
 327 #define      MVPP2_GMAC_TX_FIFO_MIN_TH_OFFS     6
 328 #define      MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK 0x1fc0
 329 #define      MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(v)  (((v) << 6) & \
 330                                         MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK)
 331
 332 #define MVPP2_CAUSE_TXQ_SENT_DESC_ALL_MASK      0xff
 333
 334 /* Descriptor ring Macros */
 335 #define MVPP2_QUEUE_NEXT_DESC(q, index) \
 336         (((index) < (q)->last_desc) ? ((index) + 1) : 0)
 337
 338 /* SMI: 0xc0054 -> offset 0x54 to lms_base */
 339 #define MVPP2_SMI                               0x0054
 340 #define     MVPP2_PHY_REG_MASK                  0x1f
 341 /* SMI register fields */
 342 #define     MVPP2_SMI_DATA_OFFS                 0       /* Data */
 343 #define     MVPP2_SMI_DATA_MASK                 (0xffff << MVPP2_SMI_DATA_OFFS)
 344 #define     MVPP2_SMI_DEV_ADDR_OFFS             16      /* PHY device address */
 345 #define     MVPP2_SMI_REG_ADDR_OFFS             21      /* PHY device reg addr*/
 346 #define     MVPP2_SMI_OPCODE_OFFS               26      /* Write/Read opcode */
 347 #define     MVPP2_SMI_OPCODE_READ               (1 << MVPP2_SMI_OPCODE_OFFS)
 348 #define     MVPP2_SMI_READ_VALID                (1 << 27)       /* Read Valid */
 349 #define     MVPP2_SMI_BUSY                      (1 << 28)       /* Busy */
 350
 351 #define     MVPP2_PHY_ADDR_MASK                 0x1f
 352 #define     MVPP2_PHY_REG_MASK                  0x1f
 353
 354 /* Various constants */
 355
 356 /* Coalescing */
 357 #define MVPP2_TXDONE_COAL_PKTS_THRESH   15
 358 #define MVPP2_TXDONE_HRTIMER_PERIOD_NS  1000000UL
 359 #define MVPP2_RX_COAL_PKTS              32
 360 #define MVPP2_RX_COAL_USEC              100
 361
 362 /* The two bytes Marvell header. Either contains a special value used
 363  * by Marvell switches when a specific hardware mode is enabled (not
 364  * supported by this driver) or is filled automatically by zeroes on
 365  * the RX side. Those two bytes being at the front of the Ethernet
 366  * header, they allow to have the IP header aligned on a 4 bytes
 367  * boundary automatically: the hardware skips those two bytes on its
 368  * own.
 369  */
 370 #define MVPP2_MH_SIZE                   2
 371 #define MVPP2_ETH_TYPE_LEN              2
 372 #define MVPP2_PPPOE_HDR_SIZE            8
 373 #define MVPP2_VLAN_TAG_LEN              4
 374
 375 /* Lbtd 802.3 type */
 376 #define MVPP2_IP_LBDT_TYPE              0xfffa
 377
 378 #define MVPP2_CPU_D_CACHE_LINE_SIZE     32
 379 #define MVPP2_TX_CSUM_MAX_SIZE          9800
 380
 381 /* Timeout constants */
 382 #define MVPP2_TX_DISABLE_TIMEOUT_MSEC   1000
 383 #define MVPP2_TX_PENDING_TIMEOUT_MSEC   1000
 384
 385 #define MVPP2_TX_MTU_MAX                0x7ffff
 386
 387 /* Maximum number of T-CONTs of PON port */
 388 #define MVPP2_MAX_TCONT                 16
 389
 390 /* Maximum number of supported ports */
 391 #define MVPP2_MAX_PORTS                 4
 392
 393 /* Maximum number of TXQs used by single port */
 394 #define MVPP2_MAX_TXQ                   8
 395
 396 /* Maximum number of RXQs used by single port */
 397 #define MVPP2_MAX_RXQ                   8
 398
 399 /* Default number of TXQs in use */
 400 #define MVPP2_DEFAULT_TXQ               1
 401
 402 /* Dfault number of RXQs in use */
 403 #define MVPP2_DEFAULT_RXQ               1
 404 #define CONFIG_MV_ETH_RXQ               8       /* increment by 8 */
 405
 406 /* Total number of RXQs available to all ports */
 407 #define MVPP2_RXQ_TOTAL_NUM             (MVPP2_MAX_PORTS * MVPP2_MAX_RXQ)
 408
 409 /* Max number of Rx descriptors */
 410 #define MVPP2_MAX_RXD                   16
 411
 412 /* Max number of Tx descriptors */
 413 #define MVPP2_MAX_TXD                   16
 414
 415 /* Amount of Tx descriptors that can be reserved at once by CPU */
 416 #define MVPP2_CPU_DESC_CHUNK            64
 417
 418 /* Max number of Tx descriptors in each aggregated queue */
 419 #define MVPP2_AGGR_TXQ_SIZE             256
 420
 421 /* Descriptor aligned size */
 422 #define MVPP2_DESC_ALIGNED_SIZE         32
 423
 424 /* Descriptor alignment mask */
 425 #define MVPP2_TX_DESC_ALIGN             (MVPP2_DESC_ALIGNED_SIZE - 1)
 426
 427 /* RX FIFO constants */
 428 #define MVPP2_RX_FIFO_PORT_DATA_SIZE    0x2000
 429 #define MVPP2_RX_FIFO_PORT_ATTR_SIZE    0x80
 430 #define MVPP2_RX_FIFO_PORT_MIN_PKT      0x80
 431
 432 /* RX buffer constants */
 433 #define MVPP2_SKB_SHINFO_SIZE \
 434         0
 435
 436 #define MVPP2_RX_PKT_SIZE(mtu) \
 437         ALIGN((mtu) + MVPP2_MH_SIZE + MVPP2_VLAN_TAG_LEN + \
 438               ETH_HLEN + ETH_FCS_LEN, MVPP2_CPU_D_CACHE_LINE_SIZE)
 439
 440 #define MVPP2_RX_BUF_SIZE(pkt_size)     ((pkt_size) + NET_SKB_PAD)
 441 #define MVPP2_RX_TOTAL_SIZE(buf_size)   ((buf_size) + MVPP2_SKB_SHINFO_SIZE)
 442 #define MVPP2_RX_MAX_PKT_SIZE(total_size) \
 443         ((total_size) - NET_SKB_PAD - MVPP2_SKB_SHINFO_SIZE)
 444
 445 #define MVPP2_BIT_TO_BYTE(bit)          ((bit) / 8)
 446
 447 /* IPv6 max L3 address size */
 448 #define MVPP2_MAX_L3_ADDR_SIZE          16
 449
 450 /* Port flags */
 451 #define MVPP2_F_LOOPBACK                BIT(0)
 452
 453 /* Marvell tag types */
 454 enum mvpp2_tag_type {
 455         MVPP2_TAG_TYPE_NONE = 0,
 456         MVPP2_TAG_TYPE_MH   = 1,
 457         MVPP2_TAG_TYPE_DSA  = 2,
 458         MVPP2_TAG_TYPE_EDSA = 3,
 459         MVPP2_TAG_TYPE_VLAN = 4,
 460         MVPP2_TAG_TYPE_LAST = 5
 461 };
 462
 463 /* Parser constants */
 464 #define MVPP2_PRS_TCAM_SRAM_SIZE        256
 465 #define MVPP2_PRS_TCAM_WORDS            6
 466 #define MVPP2_PRS_SRAM_WORDS            4
 467 #define MVPP2_PRS_FLOW_ID_SIZE          64
 468 #define MVPP2_PRS_FLOW_ID_MASK          0x3f
 469 #define MVPP2_PRS_TCAM_ENTRY_INVALID    1
 470 #define MVPP2_PRS_TCAM_DSA_TAGGED_BIT   BIT(5)
 471 #define MVPP2_PRS_IPV4_HEAD             0x40
 472 #define MVPP2_PRS_IPV4_HEAD_MASK        0xf0
 473 #define MVPP2_PRS_IPV4_MC               0xe0
 474 #define MVPP2_PRS_IPV4_MC_MASK          0xf0
 475 #define MVPP2_PRS_IPV4_BC_MASK          0xff
 476 #define MVPP2_PRS_IPV4_IHL              0x5
 477 #define MVPP2_PRS_IPV4_IHL_MASK         0xf
 478 #define MVPP2_PRS_IPV6_MC               0xff
 479 #define MVPP2_PRS_IPV6_MC_MASK          0xff
 480 #define MVPP2_PRS_IPV6_HOP_MASK         0xff
 481 #define MVPP2_PRS_TCAM_PROTO_MASK       0xff
 482 #define MVPP2_PRS_TCAM_PROTO_MASK_L     0x3f
 483 #define MVPP2_PRS_DBL_VLANS_MAX         100
 484
 485 /* Tcam structure:
 486  * - lookup ID - 4 bits
 487  * - port ID - 1 byte
 488  * - additional information - 1 byte
 489  * - header data - 8 bytes
 490  * The fields are represented by MVPP2_PRS_TCAM_DATA_REG(5)->(0).
 491  */
 492 #define MVPP2_PRS_AI_BITS                       8
 493 #define MVPP2_PRS_PORT_MASK                     0xff
 494 #define MVPP2_PRS_LU_MASK                       0xf
 495 #define MVPP2_PRS_TCAM_DATA_BYTE(offs)          \
 496                                     (((offs) - ((offs) % 2)) * 2 + ((offs) % 2))
 497 #define MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)       \
 498                                               (((offs) * 2) - ((offs) % 2)  + 2)
 499 #define MVPP2_PRS_TCAM_AI_BYTE                  16
 500 #define MVPP2_PRS_TCAM_PORT_BYTE                17
 501 #define MVPP2_PRS_TCAM_LU_BYTE                  20
 502 #define MVPP2_PRS_TCAM_EN_OFFS(offs)            ((offs) + 2)
 503 #define MVPP2_PRS_TCAM_INV_WORD                 5
 504 /* Tcam entries ID */
 505 #define MVPP2_PE_DROP_ALL               0
 506 #define MVPP2_PE_FIRST_FREE_TID         1
 507 #define MVPP2_PE_LAST_FREE_TID          (MVPP2_PRS_TCAM_SRAM_SIZE - 31)
 508 #define MVPP2_PE_IP6_EXT_PROTO_UN       (MVPP2_PRS_TCAM_SRAM_SIZE - 30)
 509 #define MVPP2_PE_MAC_MC_IP6             (MVPP2_PRS_TCAM_SRAM_SIZE - 29)
 510 #define MVPP2_PE_IP6_ADDR_UN            (MVPP2_PRS_TCAM_SRAM_SIZE - 28)
 511 #define MVPP2_PE_IP4_ADDR_UN            (MVPP2_PRS_TCAM_SRAM_SIZE - 27)
 512 #define MVPP2_PE_LAST_DEFAULT_FLOW      (MVPP2_PRS_TCAM_SRAM_SIZE - 26)
 513 #define MVPP2_PE_FIRST_DEFAULT_FLOW     (MVPP2_PRS_TCAM_SRAM_SIZE - 19)
 514 #define MVPP2_PE_EDSA_TAGGED            (MVPP2_PRS_TCAM_SRAM_SIZE - 18)
 515 #define MVPP2_PE_EDSA_UNTAGGED          (MVPP2_PRS_TCAM_SRAM_SIZE - 17)
 516 #define MVPP2_PE_DSA_TAGGED             (MVPP2_PRS_TCAM_SRAM_SIZE - 16)
 517 #define MVPP2_PE_DSA_UNTAGGED           (MVPP2_PRS_TCAM_SRAM_SIZE - 15)
 518 #define MVPP2_PE_ETYPE_EDSA_TAGGED      (MVPP2_PRS_TCAM_SRAM_SIZE - 14)
 519 #define MVPP2_PE_ETYPE_EDSA_UNTAGGED    (MVPP2_PRS_TCAM_SRAM_SIZE - 13)
 520 #define MVPP2_PE_ETYPE_DSA_TAGGED       (MVPP2_PRS_TCAM_SRAM_SIZE - 12)
 521 #define MVPP2_PE_ETYPE_DSA_UNTAGGED     (MVPP2_PRS_TCAM_SRAM_SIZE - 11)
 522 #define MVPP2_PE_MH_DEFAULT             (MVPP2_PRS_TCAM_SRAM_SIZE - 10)
 523 #define MVPP2_PE_DSA_DEFAULT            (MVPP2_PRS_TCAM_SRAM_SIZE - 9)
 524 #define MVPP2_PE_IP6_PROTO_UN           (MVPP2_PRS_TCAM_SRAM_SIZE - 8)
 525 #define MVPP2_PE_IP4_PROTO_UN           (MVPP2_PRS_TCAM_SRAM_SIZE - 7)
 526 #define MVPP2_PE_ETH_TYPE_UN            (MVPP2_PRS_TCAM_SRAM_SIZE - 6)
 527 #define MVPP2_PE_VLAN_DBL               (MVPP2_PRS_TCAM_SRAM_SIZE - 5)
 528 #define MVPP2_PE_VLAN_NONE              (MVPP2_PRS_TCAM_SRAM_SIZE - 4)
 529 #define MVPP2_PE_MAC_MC_ALL             (MVPP2_PRS_TCAM_SRAM_SIZE - 3)
 530 #define MVPP2_PE_MAC_PROMISCUOUS        (MVPP2_PRS_TCAM_SRAM_SIZE - 2)
 531 #define MVPP2_PE_MAC_NON_PROMISCUOUS    (MVPP2_PRS_TCAM_SRAM_SIZE - 1)
 532
 533 /* Sram structure
 534  * The fields are represented by MVPP2_PRS_TCAM_DATA_REG(3)->(0).
 535  */
 536 #define MVPP2_PRS_SRAM_RI_OFFS                  0
 537 #define MVPP2_PRS_SRAM_RI_WORD                  0
 538 #define MVPP2_PRS_SRAM_RI_CTRL_OFFS             32
 539 #define MVPP2_PRS_SRAM_RI_CTRL_WORD             1
 540 #define MVPP2_PRS_SRAM_RI_CTRL_BITS             32
 541 #define MVPP2_PRS_SRAM_SHIFT_OFFS               64
 542 #define MVPP2_PRS_SRAM_SHIFT_SIGN_BIT           72
 543 #define MVPP2_PRS_SRAM_UDF_OFFS                 73
 544 #define MVPP2_PRS_SRAM_UDF_BITS                 8
 545 #define MVPP2_PRS_SRAM_UDF_MASK                 0xff
 546 #define MVPP2_PRS_SRAM_UDF_SIGN_BIT             81
 547 #define MVPP2_PRS_SRAM_UDF_TYPE_OFFS            82
 548 #define MVPP2_PRS_SRAM_UDF_TYPE_MASK            0x7
 549 #define MVPP2_PRS_SRAM_UDF_TYPE_L3              1
 550 #define MVPP2_PRS_SRAM_UDF_TYPE_L4              4
 551 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS        85
 552 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK        0x3
 553 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD         1
 554 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_IP4_ADD     2
 555 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_IP6_ADD     3
 556 #define MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS          87
 557 #define MVPP2_PRS_SRAM_OP_SEL_UDF_BITS          2
 558 #define MVPP2_PRS_SRAM_OP_SEL_UDF_MASK          0x3
 559 #define MVPP2_PRS_SRAM_OP_SEL_UDF_ADD           0
 560 #define MVPP2_PRS_SRAM_OP_SEL_UDF_IP4_ADD       2
 561 #define MVPP2_PRS_SRAM_OP_SEL_UDF_IP6_ADD       3
 562 #define MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS         89
 563 #define MVPP2_PRS_SRAM_AI_OFFS                  90
 564 #define MVPP2_PRS_SRAM_AI_CTRL_OFFS             98
 565 #define MVPP2_PRS_SRAM_AI_CTRL_BITS             8
 566 #define MVPP2_PRS_SRAM_AI_MASK                  0xff
 567 #define MVPP2_PRS_SRAM_NEXT_LU_OFFS             106
 568 #define MVPP2_PRS_SRAM_NEXT_LU_MASK             0xf
 569 #define MVPP2_PRS_SRAM_LU_DONE_BIT              110
 570 #define MVPP2_PRS_SRAM_LU_GEN_BIT               111
 571
 572 /* Sram result info bits assignment */
 573 #define MVPP2_PRS_RI_MAC_ME_MASK                0x1
 574 #define MVPP2_PRS_RI_DSA_MASK                   0x2
 575 #define MVPP2_PRS_RI_VLAN_MASK                  (BIT(2) | BIT(3))
 576 #define MVPP2_PRS_RI_VLAN_NONE                  0x0
 577 #define MVPP2_PRS_RI_VLAN_SINGLE                BIT(2)
 578 #define MVPP2_PRS_RI_VLAN_DOUBLE                BIT(3)
 579 #define MVPP2_PRS_RI_VLAN_TRIPLE                (BIT(2) | BIT(3))
 580 #define MVPP2_PRS_RI_CPU_CODE_MASK              0x70
 581 #define MVPP2_PRS_RI_CPU_CODE_RX_SPEC           BIT(4)
 582 #define MVPP2_PRS_RI_L2_CAST_MASK               (BIT(9) | BIT(10))
 583 #define MVPP2_PRS_RI_L2_UCAST                   0x0
 584 #define MVPP2_PRS_RI_L2_MCAST                   BIT(9)
 585 #define MVPP2_PRS_RI_L2_BCAST                   BIT(10)
 586 #define MVPP2_PRS_RI_PPPOE_MASK                 0x800
 587 #define MVPP2_PRS_RI_L3_PROTO_MASK              (BIT(12) | BIT(13) | BIT(14))
 588 #define MVPP2_PRS_RI_L3_UN                      0x0
 589 #define MVPP2_PRS_RI_L3_IP4                     BIT(12)
 590 #define MVPP2_PRS_RI_L3_IP4_OPT                 BIT(13)
 591 #define MVPP2_PRS_RI_L3_IP4_OTHER               (BIT(12) | BIT(13))
 592 #define MVPP2_PRS_RI_L3_IP6                     BIT(14)
 593 #define MVPP2_PRS_RI_L3_IP6_EXT                 (BIT(12) | BIT(14))
 594 #define MVPP2_PRS_RI_L3_ARP                     (BIT(13) | BIT(14))
 595 #define MVPP2_PRS_RI_L3_ADDR_MASK               (BIT(15) | BIT(16))
 596 #define MVPP2_PRS_RI_L3_UCAST                   0x0
 597 #define MVPP2_PRS_RI_L3_MCAST                   BIT(15)
 598 #define MVPP2_PRS_RI_L3_BCAST                   (BIT(15) | BIT(16))
 599 #define MVPP2_PRS_RI_IP_FRAG_MASK               0x20000
 600 #define MVPP2_PRS_RI_UDF3_MASK                  0x300000
 601 #define MVPP2_PRS_RI_UDF3_RX_SPECIAL            BIT(21)
 602 #define MVPP2_PRS_RI_L4_PROTO_MASK              0x1c00000
 603 #define MVPP2_PRS_RI_L4_TCP                     BIT(22)
 604 #define MVPP2_PRS_RI_L4_UDP                     BIT(23)
 605 #define MVPP2_PRS_RI_L4_OTHER                   (BIT(22) | BIT(23))
 606 #define MVPP2_PRS_RI_UDF7_MASK                  0x60000000
 607 #define MVPP2_PRS_RI_UDF7_IP6_LITE              BIT(29)
 608 #define MVPP2_PRS_RI_DROP_MASK                  0x80000000
 609
 610 /* Sram additional info bits assignment */
 611 #define MVPP2_PRS_IPV4_DIP_AI_BIT               BIT(0)
 612 #define MVPP2_PRS_IPV6_NO_EXT_AI_BIT            BIT(0)
 613 #define MVPP2_PRS_IPV6_EXT_AI_BIT               BIT(1)
 614 #define MVPP2_PRS_IPV6_EXT_AH_AI_BIT            BIT(2)
 615 #define MVPP2_PRS_IPV6_EXT_AH_LEN_AI_BIT        BIT(3)
 616 #define MVPP2_PRS_IPV6_EXT_AH_L4_AI_BIT         BIT(4)
 617 #define MVPP2_PRS_SINGLE_VLAN_AI                0
 618 #define MVPP2_PRS_DBL_VLAN_AI_BIT               BIT(7)
 619
 620 /* DSA/EDSA type */
 621 #define MVPP2_PRS_TAGGED                true
 622 #define MVPP2_PRS_UNTAGGED              false
 623 #define MVPP2_PRS_EDSA                  true
 624 #define MVPP2_PRS_DSA                   false
 625
 626 /* MAC entries, shadow udf */
 627 enum mvpp2_prs_udf {
 628         MVPP2_PRS_UDF_MAC_DEF,
 629         MVPP2_PRS_UDF_MAC_RANGE,
 630         MVPP2_PRS_UDF_L2_DEF,
 631         MVPP2_PRS_UDF_L2_DEF_COPY,
 632         MVPP2_PRS_UDF_L2_USER,
 633 };
 634
 635 /* Lookup ID */
 636 enum mvpp2_prs_lookup {
 637         MVPP2_PRS_LU_MH,
 638         MVPP2_PRS_LU_MAC,
 639         MVPP2_PRS_LU_DSA,
 640         MVPP2_PRS_LU_VLAN,
 641         MVPP2_PRS_LU_L2,
 642         MVPP2_PRS_LU_PPPOE,
 643         MVPP2_PRS_LU_IP4,
 644         MVPP2_PRS_LU_IP6,
 645         MVPP2_PRS_LU_FLOWS,
 646         MVPP2_PRS_LU_LAST,
 647 };
 648
 649 /* L3 cast enum */
 650 enum mvpp2_prs_l3_cast {
 651         MVPP2_PRS_L3_UNI_CAST,
 652         MVPP2_PRS_L3_MULTI_CAST,
 653         MVPP2_PRS_L3_BROAD_CAST
 654 };
 655
 656 /* Classifier constants */
 657 #define MVPP2_CLS_FLOWS_TBL_SIZE        512
 658 #define MVPP2_CLS_FLOWS_TBL_DATA_WORDS  3
 659 #define MVPP2_CLS_LKP_TBL_SIZE          64
 660
 661 /* BM constants */
 662 #define MVPP2_BM_POOLS_NUM              1
 663 #define MVPP2_BM_LONG_BUF_NUM           16
 664 #define MVPP2_BM_SHORT_BUF_NUM          16
 665 #define MVPP2_BM_POOL_SIZE_MAX          (16*1024 - MVPP2_BM_POOL_PTR_ALIGN/4)
 666 #define MVPP2_BM_POOL_PTR_ALIGN         128
 667 #define MVPP2_BM_SWF_LONG_POOL(port)    0
 668
 669 /* BM cookie (32 bits) definition */
 670 #define MVPP2_BM_COOKIE_POOL_OFFS       8
 671 #define MVPP2_BM_COOKIE_CPU_OFFS        24
 672
 673 /* BM short pool packet size
 674  * These value assure that for SWF the total number
 675  * of bytes allocated for each buffer will be 512
 676  */
 677 #define MVPP2_BM_SHORT_PKT_SIZE         MVPP2_RX_MAX_PKT_SIZE(512)
 678
 679 enum mvpp2_bm_type {
 680         MVPP2_BM_FREE,
 681         MVPP2_BM_SWF_LONG,
 682         MVPP2_BM_SWF_SHORT
 683 };
 684
 685 /* Definitions */
 686
 687 /* Shared Packet Processor resources */
 688 struct mvpp2 {
 689         /* Shared registers' base addresses */
 690         void __iomem *base;
 691         void __iomem *lms_base;
 692
 693         /* List of pointers to port structures */
 694         struct mvpp2_port **port_list;
 695
 696         /* Aggregated TXQs */
 697         struct mvpp2_tx_queue *aggr_txqs;
 698
 699         /* BM pools */
 700         struct mvpp2_bm_pool *bm_pools;
 701
 702         /* PRS shadow table */
 703         struct mvpp2_prs_shadow *prs_shadow;
 704         /* PRS auxiliary table for double vlan entries control */
 705         bool *prs_double_vlans;
 706
 707         /* Tclk value */
 708         u32 tclk;
 709
 710         struct mii_dev *bus;
 711 };
 712
 713 struct mvpp2_pcpu_stats {
 714         u64     rx_packets;
 715         u64     rx_bytes;
 716         u64     tx_packets;
 717         u64     tx_bytes;
 718 };
 719
 720 struct mvpp2_port {
 721         u8 id;
 722
 723         int irq;
 724
 725         struct mvpp2 *priv;
 726
 727         /* Per-port registers' base address */
 728         void __iomem *base;
 729
 730         struct mvpp2_rx_queue **rxqs;
 731         struct mvpp2_tx_queue **txqs;
 732
 733         int pkt_size;
 734
 735         u32 pending_cause_rx;
 736
 737         /* Per-CPU port control */
 738         struct mvpp2_port_pcpu __percpu *pcpu;
 739
 740         /* Flags */
 741         unsigned long flags;
 742
 743         u16 tx_ring_size;
 744         u16 rx_ring_size;
 745         struct mvpp2_pcpu_stats __percpu *stats;
 746
 747         struct phy_device *phy_dev;
 748         phy_interface_t phy_interface;
 749         int phy_node;
 750         int phyaddr;
 751         int init;
 752         unsigned int link;
 753         unsigned int duplex;
 754         unsigned int speed;
 755
 756         struct mvpp2_bm_pool *pool_long;
 757         struct mvpp2_bm_pool *pool_short;
 758
 759         /* Index of first port's physical RXQ */
 760         u8 first_rxq;
 761
 762         u8 dev_addr[ETH_ALEN];
 763 };
 764
 765 /* The mvpp2_tx_desc and mvpp2_rx_desc structures describe the
 766  * layout of the transmit and reception DMA descriptors, and their
 767  * layout is therefore defined by the hardware design
 768  */
 769
 770 #define MVPP2_TXD_L3_OFF_SHIFT          0
 771 #define MVPP2_TXD_IP_HLEN_SHIFT         8
 772 #define MVPP2_TXD_L4_CSUM_FRAG          BIT(13)
 773 #define MVPP2_TXD_L4_CSUM_NOT           BIT(14)
 774 #define MVPP2_TXD_IP_CSUM_DISABLE       BIT(15)
 775 #define MVPP2_TXD_PADDING_DISABLE       BIT(23)
 776 #define MVPP2_TXD_L4_UDP                BIT(24)
 777 #define MVPP2_TXD_L3_IP6                BIT(26)
 778 #define MVPP2_TXD_L_DESC                BIT(28)
 779 #define MVPP2_TXD_F_DESC                BIT(29)
 780
 781 #define MVPP2_RXD_ERR_SUMMARY           BIT(15)
 782 #define MVPP2_RXD_ERR_CODE_MASK         (BIT(13) | BIT(14))
 783 #define MVPP2_RXD_ERR_CRC               0x0
 784 #define MVPP2_RXD_ERR_OVERRUN           BIT(13)
 785 #define MVPP2_RXD_ERR_RESOURCE          (BIT(13) | BIT(14))
 786 #define MVPP2_RXD_BM_POOL_ID_OFFS       16
 787 #define MVPP2_RXD_BM_POOL_ID_MASK       (BIT(16) | BIT(17) | BIT(18))
 788 #define MVPP2_RXD_HWF_SYNC              BIT(21)
 789 #define MVPP2_RXD_L4_CSUM_OK            BIT(22)
 790 #define MVPP2_RXD_IP4_HEADER_ERR        BIT(24)
 791 #define MVPP2_RXD_L4_TCP                BIT(25)
 792 #define MVPP2_RXD_L4_UDP                BIT(26)
 793 #define MVPP2_RXD_L3_IP4                BIT(28)
 794 #define MVPP2_RXD_L3_IP6                BIT(30)
 795 #define MVPP2_RXD_BUF_HDR               BIT(31)
 796
 797 struct mvpp2_tx_desc {
 798         u32 command;            /* Options used by HW for packet transmitting.*/
 799         u8  packet_offset;      /* the offset from the buffer beginning */
 800         u8  phys_txq;           /* destination queue ID                 */
 801         u16 data_size;          /* data size of transmitted packet in bytes */
 802         u32 buf_phys_addr;      /* physical addr of transmitted buffer  */
 803         u32 buf_cookie;         /* cookie for access to TX buffer in tx path */
 804         u32 reserved1[3];       /* hw_cmd (for future use, BM, PON, PNC) */
 805         u32 reserved2;          /* reserved (for future use)            */
 806 };
 807
 808 struct mvpp2_rx_desc {
 809         u32 status;             /* info about received packet           */
 810         u16 reserved1;          /* parser_info (for future use, PnC)    */
 811         u16 data_size;          /* size of received packet in bytes     */
 812         u32 buf_phys_addr;      /* physical address of the buffer       */
 813         u32 buf_cookie;         /* cookie for access to RX buffer in rx path */
 814         u16 reserved2;          /* gem_port_id (for future use, PON)    */
 815         u16 reserved3;          /* csum_l4 (for future use, PnC)        */
 816         u8  reserved4;          /* bm_qset (for future use, BM)         */
 817         u8  reserved5;
 818         u16 reserved6;          /* classify_info (for future use, PnC)  */
 819         u32 reserved7;          /* flow_id (for future use, PnC) */
 820         u32 reserved8;
 821 };
 822
 823 /* Per-CPU Tx queue control */
 824 struct mvpp2_txq_pcpu {
 825         int cpu;
 826
 827         /* Number of Tx DMA descriptors in the descriptor ring */
 828         int size;
 829
 830         /* Number of currently used Tx DMA descriptor in the
 831          * descriptor ring
 832          */
 833         int count;
 834
 835         /* Number of Tx DMA descriptors reserved for each CPU */
 836         int reserved_num;
 837
 838         /* Index of last TX DMA descriptor that was inserted */
 839         int txq_put_index;
 840
 841         /* Index of the TX DMA descriptor to be cleaned up */
 842         int txq_get_index;
 843 };
 844
 845 struct mvpp2_tx_queue {
 846         /* Physical number of this Tx queue */
 847         u8 id;
 848
 849         /* Logical number of this Tx queue */
 850         u8 log_id;
 851
 852         /* Number of Tx DMA descriptors in the descriptor ring */
 853         int size;
 854
 855         /* Number of currently used Tx DMA descriptor in the descriptor ring */
 856         int count;
 857
 858         /* Per-CPU control of physical Tx queues */
 859         struct mvpp2_txq_pcpu __percpu *pcpu;
 860
 861         u32 done_pkts_coal;
 862
 863         /* Virtual address of thex Tx DMA descriptors array */
 864         struct mvpp2_tx_desc *descs;
 865
 866         /* DMA address of the Tx DMA descriptors array */
 867         dma_addr_t descs_phys;
 868
 869         /* Index of the last Tx DMA descriptor */
 870         int last_desc;
 871
 872         /* Index of the next Tx DMA descriptor to process */
 873         int next_desc_to_proc;
 874 };
 875
 876 struct mvpp2_rx_queue {
 877         /* RX queue number, in the range 0-31 for physical RXQs */
 878         u8 id;
 879
 880         /* Num of rx descriptors in the rx descriptor ring */
 881         int size;
 882
 883         u32 pkts_coal;
 884         u32 time_coal;
 885
 886         /* Virtual address of the RX DMA descriptors array */
 887         struct mvpp2_rx_desc *descs;
 888
 889         /* DMA address of the RX DMA descriptors array */
 890         dma_addr_t descs_phys;
 891
 892         /* Index of the last RX DMA descriptor */
 893         int last_desc;
 894
 895         /* Index of the next RX DMA descriptor to process */
 896         int next_desc_to_proc;
 897
 898         /* ID of port to which physical RXQ is mapped */
 899         int port;
 900
 901         /* Port's logic RXQ number to which physical RXQ is mapped */
 902         int logic_rxq;
 903 };
 904
 905 union mvpp2_prs_tcam_entry {
 906         u32 word[MVPP2_PRS_TCAM_WORDS];
 907         u8  byte[MVPP2_PRS_TCAM_WORDS * 4];
 908 };
 909
 910 union mvpp2_prs_sram_entry {
 911         u32 word[MVPP2_PRS_SRAM_WORDS];
 912         u8  byte[MVPP2_PRS_SRAM_WORDS * 4];
 913 };
 914
 915 struct mvpp2_prs_entry {
 916         u32 index;
 917         union mvpp2_prs_tcam_entry tcam;
 918         union mvpp2_prs_sram_entry sram;
 919 };
 920
 921 struct mvpp2_prs_shadow {
 922         bool valid;
 923         bool finish;
 924
 925         /* Lookup ID */
 926         int lu;
 927
 928         /* User defined offset */
 929         int udf;
 930
 931         /* Result info */
 932         u32 ri;
 933         u32 ri_mask;
 934 };
 935
 936 struct mvpp2_cls_flow_entry {
 937         u32 index;
 938         u32 data[MVPP2_CLS_FLOWS_TBL_DATA_WORDS];
 939 };
 940
 941 struct mvpp2_cls_lookup_entry {
 942         u32 lkpid;
 943         u32 way;
 944         u32 data;
 945 };
 946
 947 struct mvpp2_bm_pool {
 948         /* Pool number in the range 0-7 */
 949         int id;
 950         enum mvpp2_bm_type type;
 951
 952         /* Buffer Pointers Pool External (BPPE) size */
 953         int size;
 954         /* Number of buffers for this pool */
 955         int buf_num;
 956         /* Pool buffer size */
 957         int buf_size;
 958         /* Packet size */
 959         int pkt_size;
 960
 961         /* BPPE virtual base address */
 962         unsigned long *virt_addr;
 963         /* BPPE physical base address */
 964         dma_addr_t phys_addr;
 965
 966         /* Ports using BM pool */
 967         u32 port_map;
 968
 969         /* Occupied buffers indicator */
 970         int in_use_thresh;
 971 };
 972
 973 struct mvpp2_buff_hdr {
 974         u32 next_buff_phys_addr;
 975         u32 next_buff_virt_addr;
 976         u16 byte_count;
 977         u16 info;
 978         u8  reserved1;          /* bm_qset (for future use, BM)         */
 979 };
 980
 981 /* Buffer header info bits */
 982 #define MVPP2_B_HDR_INFO_MC_ID_MASK     0xfff
 983 #define MVPP2_B_HDR_INFO_MC_ID(info)    ((info) & MVPP2_B_HDR_INFO_MC_ID_MASK)
 984 #define MVPP2_B_HDR_INFO_LAST_OFFS      12
 985 #define MVPP2_B_HDR_INFO_LAST_MASK      BIT(12)
 986 #define MVPP2_B_HDR_INFO_IS_LAST(info) \
 987            ((info & MVPP2_B_HDR_INFO_LAST_MASK) >> MVPP2_B_HDR_INFO_LAST_OFFS)
 988
 989 /* Static declaractions */
 990
 991 /* Number of RXQs used by single port */
 992 static int rxq_number = MVPP2_DEFAULT_RXQ;
 993 /* Number of TXQs used by single port */
 994 static int txq_number = MVPP2_DEFAULT_TXQ;
 995
 996 #define MVPP2_DRIVER_NAME "mvpp2"
 997 #define MVPP2_DRIVER_VERSION "1.0"
 998
 999 /*
1000  * U-Boot internal data, mostly uncached buffers for descriptors and data
1001  */
1002 struct buffer_location {
1003         struct mvpp2_tx_desc *aggr_tx_descs;
1004         struct mvpp2_tx_desc *tx_descs;
1005         struct mvpp2_rx_desc *rx_descs;
1006         unsigned long *bm_pool[MVPP2_BM_POOLS_NUM];
1007         unsigned long *rx_buffer[MVPP2_BM_LONG_BUF_NUM];
1008         int first_rxq;
1009 };
1010
1011 /*
1012  * All 4 interfaces use the same global buffer, since only one interface
1013  * can be enabled at once
1014  */
1015 static struct buffer_location buffer_loc;
1016
1017 /*
1018  * Page table entries are set to 1MB, or multiples of 1MB
1019  * (not < 1MB). driver uses less bd's so use 1MB bdspace.
1020  */
1021 #define BD_SPACE        (1 << 20)
1022
1023 /* Utility/helper methods */
1024
1025 static void mvpp2_write(struct mvpp2 *priv, u32 offset, u32 data)
1026 {
1027         writel(data, priv->base + offset);
1028 }
1029
1030 static u32 mvpp2_read(struct mvpp2 *priv, u32 offset)
1031 {
1032         return readl(priv->base + offset);
1033 }
1034
1035 static void mvpp2_txq_inc_get(struct mvpp2_txq_pcpu *txq_pcpu)
1036 {
1037         txq_pcpu->txq_get_index++;
1038         if (txq_pcpu->txq_get_index == txq_pcpu->size)
1039                 txq_pcpu->txq_get_index = 0;
1040 }
1041
1042 /* Get number of physical egress port */
1043 static inline int mvpp2_egress_port(struct mvpp2_port *port)
1044 {
1045         return MVPP2_MAX_TCONT + port->id;
1046 }
1047
1048 /* Get number of physical TXQ */
1049 static inline int mvpp2_txq_phys(int port, int txq)
1050 {
1051         return (MVPP2_MAX_TCONT + port) * MVPP2_MAX_TXQ + txq;
1052 }
1053
1054 /* Parser configuration routines */
1055
1056 /* Update parser tcam and sram hw entries */
1057 static int mvpp2_prs_hw_write(struct mvpp2 *priv, struct mvpp2_prs_entry *pe)
1058 {
1059         int i;
1060
1061         if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1)
1062                 return -EINVAL;
1063
1064         /* Clear entry invalidation bit */
1065         pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] &= ~MVPP2_PRS_TCAM_INV_MASK;
1066
1067         /* Write tcam index - indirect access */
1068         mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index);
1069         for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++)
1070                 mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(i), pe->tcam.word[i]);
1071
1072         /* Write sram index - indirect access */
1073         mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index);
1074         for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++)
1075                 mvpp2_write(priv, MVPP2_PRS_SRAM_DATA_REG(i), pe->sram.word[i]);
1076
1077         return 0;
1078 }
1079
1080 /* Read tcam entry from hw */
1081 static int mvpp2_prs_hw_read(struct mvpp2 *priv, struct mvpp2_prs_entry *pe)
1082 {
1083         int i;
1084
1085         if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1)
1086                 return -EINVAL;
1087
1088         /* Write tcam index - indirect access */
1089         mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index);
1090
1091         pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] = mvpp2_read(priv,
1092                               MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD));
1093         if (pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] & MVPP2_PRS_TCAM_INV_MASK)
1094                 return MVPP2_PRS_TCAM_ENTRY_INVALID;
1095
1096         for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++)
1097                 pe->tcam.word[i] = mvpp2_read(priv, MVPP2_PRS_TCAM_DATA_REG(i));
1098
1099         /* Write sram index - indirect access */
1100         mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index);
1101         for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++)
1102                 pe->sram.word[i] = mvpp2_read(priv, MVPP2_PRS_SRAM_DATA_REG(i));
1103
1104         return 0;
1105 }
1106
1107 /* Invalidate tcam hw entry */
1108 static void mvpp2_prs_hw_inv(struct mvpp2 *priv, int index)
1109 {
1110         /* Write index - indirect access */
1111         mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, index);
1112         mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD),
1113                     MVPP2_PRS_TCAM_INV_MASK);
1114 }
1115
1116 /* Enable shadow table entry and set its lookup ID */
1117 static void mvpp2_prs_shadow_set(struct mvpp2 *priv, int index, int lu)
1118 {
1119         priv->prs_shadow[index].valid = true;
1120         priv->prs_shadow[index].lu = lu;
1121 }
1122
1123 /* Update ri fields in shadow table entry */
1124 static void mvpp2_prs_shadow_ri_set(struct mvpp2 *priv, int index,
1125                                     unsigned int ri, unsigned int ri_mask)
1126 {
1127         priv->prs_shadow[index].ri_mask = ri_mask;
1128         priv->prs_shadow[index].ri = ri;
1129 }
1130
1131 /* Update lookup field in tcam sw entry */
1132 static void mvpp2_prs_tcam_lu_set(struct mvpp2_prs_entry *pe, unsigned int lu)
1133 {
1134         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_LU_BYTE);
1135
1136         pe->tcam.byte[MVPP2_PRS_TCAM_LU_BYTE] = lu;
1137         pe->tcam.byte[enable_off] = MVPP2_PRS_LU_MASK;
1138 }
1139
1140 /* Update mask for single port in tcam sw entry */
1141 static void mvpp2_prs_tcam_port_set(struct mvpp2_prs_entry *pe,
1142                                     unsigned int port, bool add)
1143 {
1144         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE);
1145
1146         if (add)
1147                 pe->tcam.byte[enable_off] &= ~(1 << port);
1148         else
1149                 pe->tcam.byte[enable_off] |= 1 << port;
1150 }
1151
1152 /* Update port map in tcam sw entry */
1153 static void mvpp2_prs_tcam_port_map_set(struct mvpp2_prs_entry *pe,
1154                                         unsigned int ports)
1155 {
1156         unsigned char port_mask = MVPP2_PRS_PORT_MASK;
1157         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE);
1158
1159         pe->tcam.byte[MVPP2_PRS_TCAM_PORT_BYTE] = 0;
1160         pe->tcam.byte[enable_off] &= ~port_mask;
1161         pe->tcam.byte[enable_off] |= ~ports & MVPP2_PRS_PORT_MASK;
1162 }
1163
1164 /* Obtain port map from tcam sw entry */
1165 static unsigned int mvpp2_prs_tcam_port_map_get(struct mvpp2_prs_entry *pe)
1166 {
1167         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE);
1168
1169         return ~(pe->tcam.byte[enable_off]) & MVPP2_PRS_PORT_MASK;
1170 }
1171
1172 /* Set byte of data and its enable bits in tcam sw entry */
1173 static void mvpp2_prs_tcam_data_byte_set(struct mvpp2_prs_entry *pe,
1174                                          unsigned int offs, unsigned char byte,
1175                                          unsigned char enable)
1176 {
1177         pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(offs)] = byte;
1178         pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)] = enable;
1179 }
1180
1181 /* Get byte of data and its enable bits from tcam sw entry */
1182 static void mvpp2_prs_tcam_data_byte_get(struct mvpp2_prs_entry *pe,
1183                                          unsigned int offs, unsigned char *byte,
1184                                          unsigned char *enable)
1185 {
1186         *byte = pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(offs)];
1187         *enable = pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)];
1188 }
1189
1190 /* Set ethertype in tcam sw entry */
1191 static void mvpp2_prs_match_etype(struct mvpp2_prs_entry *pe, int offset,
1192                                   unsigned short ethertype)
1193 {
1194         mvpp2_prs_tcam_data_byte_set(pe, offset + 0, ethertype >> 8, 0xff);
1195         mvpp2_prs_tcam_data_byte_set(pe, offset + 1, ethertype & 0xff, 0xff);
1196 }
1197
1198 /* Set bits in sram sw entry */
1199 static void mvpp2_prs_sram_bits_set(struct mvpp2_prs_entry *pe, int bit_num,
1200                                     int val)
1201 {
1202         pe->sram.byte[MVPP2_BIT_TO_BYTE(bit_num)] |= (val << (bit_num % 8));
1203 }
1204
1205 /* Clear bits in sram sw entry */
1206 static void mvpp2_prs_sram_bits_clear(struct mvpp2_prs_entry *pe, int bit_num,
1207                                       int val)
1208 {
1209         pe->sram.byte[MVPP2_BIT_TO_BYTE(bit_num)] &= ~(val << (bit_num % 8));
1210 }
1211
1212 /* Update ri bits in sram sw entry */
1213 static void mvpp2_prs_sram_ri_update(struct mvpp2_prs_entry *pe,
1214                                      unsigned int bits, unsigned int mask)
1215 {
1216         unsigned int i;
1217
1218         for (i = 0; i < MVPP2_PRS_SRAM_RI_CTRL_BITS; i++) {
1219                 int ri_off = MVPP2_PRS_SRAM_RI_OFFS;
1220
1221                 if (!(mask & BIT(i)))
1222                         continue;
1223
1224                 if (bits & BIT(i))
1225                         mvpp2_prs_sram_bits_set(pe, ri_off + i, 1);
1226                 else
1227                         mvpp2_prs_sram_bits_clear(pe, ri_off + i, 1);
1228
1229                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_RI_CTRL_OFFS + i, 1);
1230         }
1231 }
1232
1233 /* Update ai bits in sram sw entry */
1234 static void mvpp2_prs_sram_ai_update(struct mvpp2_prs_entry *pe,
1235                                      unsigned int bits, unsigned int mask)
1236 {
1237         unsigned int i;
1238         int ai_off = MVPP2_PRS_SRAM_AI_OFFS;
1239
1240         for (i = 0; i < MVPP2_PRS_SRAM_AI_CTRL_BITS; i++) {
1241
1242                 if (!(mask & BIT(i)))
1243                         continue;
1244
1245                 if (bits & BIT(i))
1246                         mvpp2_prs_sram_bits_set(pe, ai_off + i, 1);
1247                 else
1248                         mvpp2_prs_sram_bits_clear(pe, ai_off + i, 1);
1249
1250                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_AI_CTRL_OFFS + i, 1);
1251         }
1252 }
1253
1254 /* Read ai bits from sram sw entry */
1255 static int mvpp2_prs_sram_ai_get(struct mvpp2_prs_entry *pe)
1256 {
1257         u8 bits;
1258         int ai_off = MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_AI_OFFS);
1259         int ai_en_off = ai_off + 1;
1260         int ai_shift = MVPP2_PRS_SRAM_AI_OFFS % 8;
1261
1262         bits = (pe->sram.byte[ai_off] >> ai_shift) |
1263                (pe->sram.byte[ai_en_off] << (8 - ai_shift));
1264
1265         return bits;
1266 }
1267
1268 /* In sram sw entry set lookup ID field of the tcam key to be used in the next
1269  * lookup interation
1270  */
1271 static void mvpp2_prs_sram_next_lu_set(struct mvpp2_prs_entry *pe,
1272                                        unsigned int lu)
1273 {
1274         int sram_next_off = MVPP2_PRS_SRAM_NEXT_LU_OFFS;
1275
1276         mvpp2_prs_sram_bits_clear(pe, sram_next_off,
1277                                   MVPP2_PRS_SRAM_NEXT_LU_MASK);
1278         mvpp2_prs_sram_bits_set(pe, sram_next_off, lu);
1279 }
1280
1281 /* In the sram sw entry set sign and value of the next lookup offset
1282  * and the offset value generated to the classifier
1283  */
1284 static void mvpp2_prs_sram_shift_set(struct mvpp2_prs_entry *pe, int shift,
1285                                      unsigned int op)
1286 {
1287         /* Set sign */
1288         if (shift < 0) {
1289                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1);
1290                 shift = 0 - shift;
1291         } else {
1292                 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1);
1293         }
1294
1295         /* Set value */
1296         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_SHIFT_OFFS)] =
1297                                                            (unsigned char)shift;
1298
1299         /* Reset and set operation */
1300         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS,
1301                                   MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK);
1302         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS, op);
1303
1304         /* Set base offset as current */
1305         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1);
1306 }
1307
1308 /* In the sram sw entry set sign and value of the user defined offset
1309  * generated to the classifier
1310  */
1311 static void mvpp2_prs_sram_offset_set(struct mvpp2_prs_entry *pe,
1312                                       unsigned int type, int offset,
1313                                       unsigned int op)
1314 {
1315         /* Set sign */
1316         if (offset < 0) {
1317                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1);
1318                 offset = 0 - offset;
1319         } else {
1320                 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1);
1321         }
1322
1323         /* Set value */
1324         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_OFFS,
1325                                   MVPP2_PRS_SRAM_UDF_MASK);
1326         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_OFFS, offset);
1327         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_UDF_OFFS +
1328                                         MVPP2_PRS_SRAM_UDF_BITS)] &=
1329               ~(MVPP2_PRS_SRAM_UDF_MASK >> (8 - (MVPP2_PRS_SRAM_UDF_OFFS % 8)));
1330         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_UDF_OFFS +
1331                                         MVPP2_PRS_SRAM_UDF_BITS)] |=
1332                                 (offset >> (8 - (MVPP2_PRS_SRAM_UDF_OFFS % 8)));
1333
1334         /* Set offset type */
1335         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS,
1336                                   MVPP2_PRS_SRAM_UDF_TYPE_MASK);
1337         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS, type);
1338
1339         /* Set offset operation */
1340         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS,
1341                                   MVPP2_PRS_SRAM_OP_SEL_UDF_MASK);
1342         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS, op);
1343
1344         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS +
1345                                         MVPP2_PRS_SRAM_OP_SEL_UDF_BITS)] &=
1346                                              ~(MVPP2_PRS_SRAM_OP_SEL_UDF_MASK >>
1347                                     (8 - (MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS % 8)));
1348
1349         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS +
1350                                         MVPP2_PRS_SRAM_OP_SEL_UDF_BITS)] |=
1351                              (op >> (8 - (MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS % 8)));
1352
1353         /* Set base offset as current */
1354         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1);
1355 }
1356
1357 /* Find parser flow entry */
1358 static struct mvpp2_prs_entry *mvpp2_prs_flow_find(struct mvpp2 *priv, int flow)
1359 {
1360         struct mvpp2_prs_entry *pe;
1361         int tid;
1362
1363         pe = kzalloc(sizeof(*pe), GFP_KERNEL);
1364         if (!pe)
1365                 return NULL;
1366         mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_FLOWS);
1367
1368         /* Go through the all entires with MVPP2_PRS_LU_FLOWS */
1369         for (tid = MVPP2_PRS_TCAM_SRAM_SIZE - 1; tid >= 0; tid--) {
1370                 u8 bits;
1371
1372                 if (!priv->prs_shadow[tid].valid ||
1373                     priv->prs_shadow[tid].lu != MVPP2_PRS_LU_FLOWS)
1374                         continue;
1375
1376                 pe->index = tid;
1377                 mvpp2_prs_hw_read(priv, pe);
1378                 bits = mvpp2_prs_sram_ai_get(pe);
1379
1380                 /* Sram store classification lookup ID in AI bits [5:0] */
1381                 if ((bits & MVPP2_PRS_FLOW_ID_MASK) == flow)
1382                         return pe;
1383         }
1384         kfree(pe);
1385
1386         return NULL;
1387 }
1388
1389 /* Return first free tcam index, seeking from start to end */
1390 static int mvpp2_prs_tcam_first_free(struct mvpp2 *priv, unsigned char start,
1391                                      unsigned char end)
1392 {
1393         int tid;
1394
1395         if (start > end)
1396                 swap(start, end);
1397
1398         if (end >= MVPP2_PRS_TCAM_SRAM_SIZE)
1399                 end = MVPP2_PRS_TCAM_SRAM_SIZE - 1;
1400
1401         for (tid = start; tid <= end; tid++) {
1402                 if (!priv->prs_shadow[tid].valid)
1403                         return tid;
1404         }
1405
1406         return -EINVAL;
1407 }
1408
1409 /* Enable/disable dropping all mac da's */
1410 static void mvpp2_prs_mac_drop_all_set(struct mvpp2 *priv, int port, bool add)
1411 {
1412         struct mvpp2_prs_entry pe;
1413
1414         if (priv->prs_shadow[MVPP2_PE_DROP_ALL].valid) {
1415                 /* Entry exist - update port only */
1416                 pe.index = MVPP2_PE_DROP_ALL;
1417                 mvpp2_prs_hw_read(priv, &pe);
1418         } else {
1419                 /* Entry doesn't exist - create new */
1420                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1421                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1422                 pe.index = MVPP2_PE_DROP_ALL;
1423
1424                 /* Non-promiscuous mode for all ports - DROP unknown packets */
1425                 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK,
1426                                          MVPP2_PRS_RI_DROP_MASK);
1427
1428                 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1429                 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1430
1431                 /* Update shadow table */
1432                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1433
1434                 /* Mask all ports */
1435                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1436         }
1437
1438         /* Update port mask */
1439         mvpp2_prs_tcam_port_set(&pe, port, add);
1440
1441         mvpp2_prs_hw_write(priv, &pe);
1442 }
1443
1444 /* Set port to promiscuous mode */
1445 static void mvpp2_prs_mac_promisc_set(struct mvpp2 *priv, int port, bool add)
1446 {
1447         struct mvpp2_prs_entry pe;
1448
1449         /* Promiscuous mode - Accept unknown packets */
1450
1451         if (priv->prs_shadow[MVPP2_PE_MAC_PROMISCUOUS].valid) {
1452                 /* Entry exist - update port only */
1453                 pe.index = MVPP2_PE_MAC_PROMISCUOUS;
1454                 mvpp2_prs_hw_read(priv, &pe);
1455         } else {
1456                 /* Entry doesn't exist - create new */
1457                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1458                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1459                 pe.index = MVPP2_PE_MAC_PROMISCUOUS;
1460
1461                 /* Continue - set next lookup */
1462                 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_DSA);
1463
1464                 /* Set result info bits */
1465                 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L2_UCAST,
1466                                          MVPP2_PRS_RI_L2_CAST_MASK);
1467
1468                 /* Shift to ethertype */
1469                 mvpp2_prs_sram_shift_set(&pe, 2 * ETH_ALEN,
1470                                          MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1471
1472                 /* Mask all ports */
1473                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1474
1475                 /* Update shadow table */
1476                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1477         }
1478
1479         /* Update port mask */
1480         mvpp2_prs_tcam_port_set(&pe, port, add);
1481
1482         mvpp2_prs_hw_write(priv, &pe);
1483 }
1484
1485 /* Accept multicast */
1486 static void mvpp2_prs_mac_multi_set(struct mvpp2 *priv, int port, int index,
1487                                     bool add)
1488 {
1489         struct mvpp2_prs_entry pe;
1490         unsigned char da_mc;
1491
1492         /* Ethernet multicast address first byte is
1493          * 0x01 for IPv4 and 0x33 for IPv6
1494          */
1495         da_mc = (index == MVPP2_PE_MAC_MC_ALL) ? 0x01 : 0x33;
1496
1497         if (priv->prs_shadow[index].valid) {
1498                 /* Entry exist - update port only */
1499                 pe.index = index;
1500                 mvpp2_prs_hw_read(priv, &pe);
1501         } else {
1502                 /* Entry doesn't exist - create new */
1503                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1504                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1505                 pe.index = index;
1506
1507                 /* Continue - set next lookup */
1508                 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_DSA);
1509
1510                 /* Set result info bits */
1511                 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L2_MCAST,
1512                                          MVPP2_PRS_RI_L2_CAST_MASK);
1513
1514                 /* Update tcam entry data first byte */
1515                 mvpp2_prs_tcam_data_byte_set(&pe, 0, da_mc, 0xff);
1516
1517                 /* Shift to ethertype */
1518                 mvpp2_prs_sram_shift_set(&pe, 2 * ETH_ALEN,
1519                                          MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1520
1521                 /* Mask all ports */
1522                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1523
1524                 /* Update shadow table */
1525                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1526         }
1527
1528         /* Update port mask */
1529         mvpp2_prs_tcam_port_set(&pe, port, add);
1530
1531         mvpp2_prs_hw_write(priv, &pe);
1532 }
1533
1534 /* Parser per-port initialization */
1535 static void mvpp2_prs_hw_port_init(struct mvpp2 *priv, int port, int lu_first,
1536                                    int lu_max, int offset)
1537 {
1538         u32 val;
1539
1540         /* Set lookup ID */
1541         val = mvpp2_read(priv, MVPP2_PRS_INIT_LOOKUP_REG);
1542         val &= ~MVPP2_PRS_PORT_LU_MASK(port);
1543         val |=  MVPP2_PRS_PORT_LU_VAL(port, lu_first);
1544         mvpp2_write(priv, MVPP2_PRS_INIT_LOOKUP_REG, val);
1545
1546         /* Set maximum number of loops for packet received from port */
1547         val = mvpp2_read(priv, MVPP2_PRS_MAX_LOOP_REG(port));
1548         val &= ~MVPP2_PRS_MAX_LOOP_MASK(port);
1549         val |= MVPP2_PRS_MAX_LOOP_VAL(port, lu_max);
1550         mvpp2_write(priv, MVPP2_PRS_MAX_LOOP_REG(port), val);
1551
1552         /* Set initial offset for packet header extraction for the first
1553          * searching loop
1554          */
1555         val = mvpp2_read(priv, MVPP2_PRS_INIT_OFFS_REG(port));
1556         val &= ~MVPP2_PRS_INIT_OFF_MASK(port);
1557         val |= MVPP2_PRS_INIT_OFF_VAL(port, offset);
1558         mvpp2_write(priv, MVPP2_PRS_INIT_OFFS_REG(port), val);
1559 }
1560
1561 /* Default flow entries initialization for all ports */
1562 static void mvpp2_prs_def_flow_init(struct mvpp2 *priv)
1563 {
1564         struct mvpp2_prs_entry pe;
1565         int port;
1566
1567         for (port = 0; port < MVPP2_MAX_PORTS; port++) {
1568                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1569                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1570                 pe.index = MVPP2_PE_FIRST_DEFAULT_FLOW - port;
1571
1572                 /* Mask all ports */
1573                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1574
1575                 /* Set flow ID*/
1576                 mvpp2_prs_sram_ai_update(&pe, port, MVPP2_PRS_FLOW_ID_MASK);
1577                 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1);
1578
1579                 /* Update shadow table and hw entry */
1580                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_FLOWS);
1581                 mvpp2_prs_hw_write(priv, &pe);
1582         }
1583 }
1584
1585 /* Set default entry for Marvell Header field */
1586 static void mvpp2_prs_mh_init(struct mvpp2 *priv)
1587 {
1588         struct mvpp2_prs_entry pe;
1589
1590         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1591
1592         pe.index = MVPP2_PE_MH_DEFAULT;
1593         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MH);
1594         mvpp2_prs_sram_shift_set(&pe, MVPP2_MH_SIZE,
1595                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1596         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_MAC);
1597
1598         /* Unmask all ports */
1599         mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
1600
1601         /* Update shadow table and hw entry */
1602         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MH);
1603         mvpp2_prs_hw_write(priv, &pe);
1604 }
1605
1606 /* Set default entires (place holder) for promiscuous, non-promiscuous and
1607  * multicast MAC addresses
1608  */
1609 static void mvpp2_prs_mac_init(struct mvpp2 *priv)
1610 {
1611         struct mvpp2_prs_entry pe;
1612
1613         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1614
1615         /* Non-promiscuous mode for all ports - DROP unknown packets */
1616         pe.index = MVPP2_PE_MAC_NON_PROMISCUOUS;
1617         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1618
1619         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK,
1620                                  MVPP2_PRS_RI_DROP_MASK);
1621         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1622         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1623
1624         /* Unmask all ports */
1625         mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
1626
1627         /* Update shadow table and hw entry */
1628         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1629         mvpp2_prs_hw_write(priv, &pe);
1630
1631         /* place holders only - no ports */
1632         mvpp2_prs_mac_drop_all_set(priv, 0, false);
1633         mvpp2_prs_mac_promisc_set(priv, 0, false);
1634         mvpp2_prs_mac_multi_set(priv, MVPP2_PE_MAC_MC_ALL, 0, false);
1635         mvpp2_prs_mac_multi_set(priv, MVPP2_PE_MAC_MC_IP6, 0, false);
1636 }
1637
1638 /* Match basic ethertypes */
1639 static int mvpp2_prs_etype_init(struct mvpp2 *priv)
1640 {
1641         struct mvpp2_prs_entry pe;
1642         int tid;
1643
1644         /* Ethertype: PPPoE */
1645         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1646                                         MVPP2_PE_LAST_FREE_TID);
1647         if (tid < 0)
1648                 return tid;
1649
1650         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1651         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1652         pe.index = tid;
1653
1654         mvpp2_prs_match_etype(&pe, 0, PROT_PPP_SES);
1655
1656         mvpp2_prs_sram_shift_set(&pe, MVPP2_PPPOE_HDR_SIZE,
1657                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1658         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_PPPOE);
1659         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_PPPOE_MASK,
1660                                  MVPP2_PRS_RI_PPPOE_MASK);
1661
1662         /* Update shadow table and hw entry */
1663         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1664         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1665         priv->prs_shadow[pe.index].finish = false;
1666         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_PPPOE_MASK,
1667                                 MVPP2_PRS_RI_PPPOE_MASK);
1668         mvpp2_prs_hw_write(priv, &pe);
1669
1670         /* Ethertype: ARP */
1671         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1672                                         MVPP2_PE_LAST_FREE_TID);
1673         if (tid < 0)
1674                 return tid;
1675
1676         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1677         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1678         pe.index = tid;
1679
1680         mvpp2_prs_match_etype(&pe, 0, PROT_ARP);
1681
1682         /* Generate flow in the next iteration*/
1683         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1684         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1685         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_ARP,
1686                                  MVPP2_PRS_RI_L3_PROTO_MASK);
1687         /* Set L3 offset */
1688         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
1689                                   MVPP2_ETH_TYPE_LEN,
1690                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
1691
1692         /* Update shadow table and hw entry */
1693         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1694         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1695         priv->prs_shadow[pe.index].finish = true;
1696         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_ARP,
1697                                 MVPP2_PRS_RI_L3_PROTO_MASK);
1698         mvpp2_prs_hw_write(priv, &pe);
1699
1700         /* Ethertype: LBTD */
1701         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1702                                         MVPP2_PE_LAST_FREE_TID);
1703         if (tid < 0)
1704                 return tid;
1705
1706         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1707         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1708         pe.index = tid;
1709
1710         mvpp2_prs_match_etype(&pe, 0, MVPP2_IP_LBDT_TYPE);
1711
1712         /* Generate flow in the next iteration*/
1713         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1714         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1715         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_CPU_CODE_RX_SPEC |
1716                                  MVPP2_PRS_RI_UDF3_RX_SPECIAL,
1717                                  MVPP2_PRS_RI_CPU_CODE_MASK |
1718                                  MVPP2_PRS_RI_UDF3_MASK);
1719         /* Set L3 offset */
1720         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
1721                                   MVPP2_ETH_TYPE_LEN,
1722                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
1723
1724         /* Update shadow table and hw entry */
1725         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1726         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1727         priv->prs_shadow[pe.index].finish = true;
1728         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_CPU_CODE_RX_SPEC |
1729                                 MVPP2_PRS_RI_UDF3_RX_SPECIAL,
1730                                 MVPP2_PRS_RI_CPU_CODE_MASK |
1731                                 MVPP2_PRS_RI_UDF3_MASK);
1732         mvpp2_prs_hw_write(priv, &pe);
1733
1734         /* Ethertype: IPv4 without options */
1735         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1736                                         MVPP2_PE_LAST_FREE_TID);
1737         if (tid < 0)
1738                 return tid;
1739
1740         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1741         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1742         pe.index = tid;
1743
1744         mvpp2_prs_match_etype(&pe, 0, PROT_IP);
1745         mvpp2_prs_tcam_data_byte_set(&pe, MVPP2_ETH_TYPE_LEN,
1746                                      MVPP2_PRS_IPV4_HEAD | MVPP2_PRS_IPV4_IHL,
1747                                      MVPP2_PRS_IPV4_HEAD_MASK |
1748                                      MVPP2_PRS_IPV4_IHL_MASK);
1749
1750         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP4);
1751         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4,
1752                                  MVPP2_PRS_RI_L3_PROTO_MASK);
1753         /* Skip eth_type + 4 bytes of IP header */
1754         mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 4,
1755                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1756         /* Set L3 offset */
1757         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
1758                                   MVPP2_ETH_TYPE_LEN,
1759                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
1760
1761         /* Update shadow table and hw entry */
1762         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1763         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1764         priv->prs_shadow[pe.index].finish = false;
1765         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP4,
1766                                 MVPP2_PRS_RI_L3_PROTO_MASK);
1767         mvpp2_prs_hw_write(priv, &pe);
1768
1769         /* Ethertype: IPv4 with options */
1770         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1771                                         MVPP2_PE_LAST_FREE_TID);
1772         if (tid < 0)
1773                 return tid;
1774
1775         pe.index = tid;
1776
1777         /* Clear tcam data before updating */
1778         pe.tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(MVPP2_ETH_TYPE_LEN)] = 0x0;
1779         pe.tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(MVPP2_ETH_TYPE_LEN)] = 0x0;
1780
1781         mvpp2_prs_tcam_data_byte_set(&pe, MVPP2_ETH_TYPE_LEN,
1782                                      MVPP2_PRS_IPV4_HEAD,
1783                                      MVPP2_PRS_IPV4_HEAD_MASK);
1784
1785         /* Clear ri before updating */
1786         pe.sram.word[MVPP2_PRS_SRAM_RI_WORD] = 0x0;
1787         pe.sram.word[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0;
1788         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4_OPT,
1789                                  MVPP2_PRS_RI_L3_PROTO_MASK);
1790
1791         /* Update shadow table and hw entry */
1792         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1793         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1794         priv->prs_shadow[pe.index].finish = false;
1795         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP4_OPT,
1796                                 MVPP2_PRS_RI_L3_PROTO_MASK);
1797         mvpp2_prs_hw_write(priv, &pe);
1798
1799         /* Ethertype: IPv6 without options */
1800         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1801                                         MVPP2_PE_LAST_FREE_TID);
1802         if (tid < 0)
1803                 return tid;
1804
1805         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1806         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1807         pe.index = tid;
1808
1809         mvpp2_prs_match_etype(&pe, 0, PROT_IPV6);
1810
1811         /* Skip DIP of IPV6 header */
1812         mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 8 +
1813                                  MVPP2_MAX_L3_ADDR_SIZE,
1814                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1815         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6);
1816         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP6,
1817                                  MVPP2_PRS_RI_L3_PROTO_MASK);
1818         /* Set L3 offset */
1819         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
1820                                   MVPP2_ETH_TYPE_LEN,
1821                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
1822
1823         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1824         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1825         priv->prs_shadow[pe.index].finish = false;
1826         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP6,
1827                                 MVPP2_PRS_RI_L3_PROTO_MASK);
1828         mvpp2_prs_hw_write(priv, &pe);
1829
1830         /* Default entry for MVPP2_PRS_LU_L2 - Unknown ethtype */
1831         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1832         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1833         pe.index = MVPP2_PE_ETH_TYPE_UN;
1834
1835         /* Unmask all ports */
1836         mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
1837
1838         /* Generate flow in the next iteration*/
1839         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1840         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1841         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UN,
1842                                  MVPP2_PRS_RI_L3_PROTO_MASK);
1843         /* Set L3 offset even it's unknown L3 */
1844         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
1845                                   MVPP2_ETH_TYPE_LEN,
1846                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
1847
1848         /* Update shadow table and hw entry */
1849         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
1850         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
1851         priv->prs_shadow[pe.index].finish = true;
1852         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_UN,
1853                                 MVPP2_PRS_RI_L3_PROTO_MASK);
1854         mvpp2_prs_hw_write(priv, &pe);
1855
1856         return 0;
1857 }
1858
1859 /* Parser default initialization */
1860 static int mvpp2_prs_default_init(struct udevice *dev,
1861                                   struct mvpp2 *priv)
1862 {
1863         int err, index, i;
1864
1865         /* Enable tcam table */
1866         mvpp2_write(priv, MVPP2_PRS_TCAM_CTRL_REG, MVPP2_PRS_TCAM_EN_MASK);
1867
1868         /* Clear all tcam and sram entries */
1869         for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++) {
1870                 mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, index);
1871                 for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++)
1872                         mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(i), 0);
1873
1874                 mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, index);
1875                 for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++)
1876                         mvpp2_write(priv, MVPP2_PRS_SRAM_DATA_REG(i), 0);
1877         }
1878
1879         /* Invalidate all tcam entries */
1880         for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++)
1881                 mvpp2_prs_hw_inv(priv, index);
1882
1883         priv->prs_shadow = devm_kcalloc(dev, MVPP2_PRS_TCAM_SRAM_SIZE,
1884                                         sizeof(struct mvpp2_prs_shadow),
1885                                         GFP_KERNEL);
1886         if (!priv->prs_shadow)
1887                 return -ENOMEM;
1888
1889         /* Always start from lookup = 0 */
1890         for (index = 0; index < MVPP2_MAX_PORTS; index++)
1891                 mvpp2_prs_hw_port_init(priv, index, MVPP2_PRS_LU_MH,
1892                                        MVPP2_PRS_PORT_LU_MAX, 0);
1893
1894         mvpp2_prs_def_flow_init(priv);
1895
1896         mvpp2_prs_mh_init(priv);
1897
1898         mvpp2_prs_mac_init(priv);
1899
1900         err = mvpp2_prs_etype_init(priv);
1901         if (err)
1902                 return err;
1903
1904         return 0;
1905 }
1906
1907 /* Compare MAC DA with tcam entry data */
1908 static bool mvpp2_prs_mac_range_equals(struct mvpp2_prs_entry *pe,
1909                                        const u8 *da, unsigned char *mask)
1910 {
1911         unsigned char tcam_byte, tcam_mask;
1912         int index;
1913
1914         for (index = 0; index < ETH_ALEN; index++) {
1915                 mvpp2_prs_tcam_data_byte_get(pe, index, &tcam_byte, &tcam_mask);
1916                 if (tcam_mask != mask[index])
1917                         return false;
1918
1919                 if ((tcam_mask & tcam_byte) != (da[index] & mask[index]))
1920                         return false;
1921         }
1922
1923         return true;
1924 }
1925
1926 /* Find tcam entry with matched pair <MAC DA, port> */
1927 static struct mvpp2_prs_entry *
1928 mvpp2_prs_mac_da_range_find(struct mvpp2 *priv, int pmap, const u8 *da,
1929                             unsigned char *mask, int udf_type)
1930 {
1931         struct mvpp2_prs_entry *pe;
1932         int tid;
1933
1934         pe = kzalloc(sizeof(*pe), GFP_KERNEL);
1935         if (!pe)
1936                 return NULL;
1937         mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_MAC);
1938
1939         /* Go through the all entires with MVPP2_PRS_LU_MAC */
1940         for (tid = MVPP2_PE_FIRST_FREE_TID;
1941              tid <= MVPP2_PE_LAST_FREE_TID; tid++) {
1942                 unsigned int entry_pmap;
1943
1944                 if (!priv->prs_shadow[tid].valid ||
1945                     (priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC) ||
1946                     (priv->prs_shadow[tid].udf != udf_type))
1947                         continue;
1948
1949                 pe->index = tid;
1950                 mvpp2_prs_hw_read(priv, pe);
1951                 entry_pmap = mvpp2_prs_tcam_port_map_get(pe);
1952
1953                 if (mvpp2_prs_mac_range_equals(pe, da, mask) &&
1954                     entry_pmap == pmap)
1955                         return pe;
1956         }
1957         kfree(pe);
1958
1959         return NULL;
1960 }
1961
1962 /* Update parser's mac da entry */
1963 static int mvpp2_prs_mac_da_accept(struct mvpp2 *priv, int port,
1964                                    const u8 *da, bool add)
1965 {
1966         struct mvpp2_prs_entry *pe;
1967         unsigned int pmap, len, ri;
1968         unsigned char mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1969         int tid;
1970
1971         /* Scan TCAM and see if entry with this <MAC DA, port> already exist */
1972         pe = mvpp2_prs_mac_da_range_find(priv, (1 << port), da, mask,
1973                                          MVPP2_PRS_UDF_MAC_DEF);
1974
1975         /* No such entry */
1976         if (!pe) {
1977                 if (!add)
1978                         return 0;
1979
1980                 /* Create new TCAM entry */
1981                 /* Find first range mac entry*/
1982                 for (tid = MVPP2_PE_FIRST_FREE_TID;
1983                      tid <= MVPP2_PE_LAST_FREE_TID; tid++)
1984                         if (priv->prs_shadow[tid].valid &&
1985                             (priv->prs_shadow[tid].lu == MVPP2_PRS_LU_MAC) &&
1986                             (priv->prs_shadow[tid].udf ==
1987                                                        MVPP2_PRS_UDF_MAC_RANGE))
1988                                 break;
1989
1990                 /* Go through the all entries from first to last */
1991                 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1992                                                 tid - 1);
1993                 if (tid < 0)
1994                         return tid;
1995
1996                 pe = kzalloc(sizeof(*pe), GFP_KERNEL);
1997                 if (!pe)
1998                         return -1;
1999                 mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_MAC);
2000                 pe->index = tid;
2001
2002                 /* Mask all ports */
2003                 mvpp2_prs_tcam_port_map_set(pe, 0);
2004         }
2005
2006         /* Update port mask */
2007         mvpp2_prs_tcam_port_set(pe, port, add);
2008
2009         /* Invalidate the entry if no ports are left enabled */
2010         pmap = mvpp2_prs_tcam_port_map_get(pe);
2011         if (pmap == 0) {
2012                 if (add) {
2013                         kfree(pe);
2014                         return -1;
2015                 }
2016                 mvpp2_prs_hw_inv(priv, pe->index);
2017                 priv->prs_shadow[pe->index].valid = false;
2018                 kfree(pe);
2019                 return 0;
2020         }
2021
2022         /* Continue - set next lookup */
2023         mvpp2_prs_sram_next_lu_set(pe, MVPP2_PRS_LU_DSA);
2024
2025         /* Set match on DA */
2026         len = ETH_ALEN;
2027         while (len--)
2028                 mvpp2_prs_tcam_data_byte_set(pe, len, da[len], 0xff);
2029
2030         /* Set result info bits */
2031         ri = MVPP2_PRS_RI_L2_UCAST | MVPP2_PRS_RI_MAC_ME_MASK;
2032
2033         mvpp2_prs_sram_ri_update(pe, ri, MVPP2_PRS_RI_L2_CAST_MASK |
2034                                  MVPP2_PRS_RI_MAC_ME_MASK);
2035         mvpp2_prs_shadow_ri_set(priv, pe->index, ri, MVPP2_PRS_RI_L2_CAST_MASK |
2036                                 MVPP2_PRS_RI_MAC_ME_MASK);
2037
2038         /* Shift to ethertype */
2039         mvpp2_prs_sram_shift_set(pe, 2 * ETH_ALEN,
2040                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
2041
2042         /* Update shadow table and hw entry */
2043         priv->prs_shadow[pe->index].udf = MVPP2_PRS_UDF_MAC_DEF;
2044         mvpp2_prs_shadow_set(priv, pe->index, MVPP2_PRS_LU_MAC);
2045         mvpp2_prs_hw_write(priv, pe);
2046
2047         kfree(pe);
2048
2049         return 0;
2050 }
2051
2052 static int mvpp2_prs_update_mac_da(struct mvpp2_port *port, const u8 *da)
2053 {
2054         int err;
2055
2056         /* Remove old parser entry */
2057         err = mvpp2_prs_mac_da_accept(port->priv, port->id, port->dev_addr,
2058                                       false);
2059         if (err)
2060                 return err;
2061
2062         /* Add new parser entry */
2063         err = mvpp2_prs_mac_da_accept(port->priv, port->id, da, true);
2064         if (err)
2065                 return err;
2066
2067         /* Set addr in the device */
2068         memcpy(port->dev_addr, da, ETH_ALEN);
2069
2070         return 0;
2071 }
2072
2073 /* Set prs flow for the port */
2074 static int mvpp2_prs_def_flow(struct mvpp2_port *port)
2075 {
2076         struct mvpp2_prs_entry *pe;
2077         int tid;
2078
2079         pe = mvpp2_prs_flow_find(port->priv, port->id);
2080
2081         /* Such entry not exist */
2082         if (!pe) {
2083                 /* Go through the all entires from last to first */
2084                 tid = mvpp2_prs_tcam_first_free(port->priv,
2085                                                 MVPP2_PE_LAST_FREE_TID,
2086                                                MVPP2_PE_FIRST_FREE_TID);
2087                 if (tid < 0)
2088                         return tid;
2089
2090                 pe = kzalloc(sizeof(*pe), GFP_KERNEL);
2091                 if (!pe)
2092                         return -ENOMEM;
2093
2094                 mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_FLOWS);
2095                 pe->index = tid;
2096
2097                 /* Set flow ID*/
2098                 mvpp2_prs_sram_ai_update(pe, port->id, MVPP2_PRS_FLOW_ID_MASK);
2099                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1);
2100
2101                 /* Update shadow table */
2102                 mvpp2_prs_shadow_set(port->priv, pe->index, MVPP2_PRS_LU_FLOWS);
2103         }
2104
2105         mvpp2_prs_tcam_port_map_set(pe, (1 << port->id));
2106         mvpp2_prs_hw_write(port->priv, pe);
2107         kfree(pe);
2108
2109         return 0;
2110 }
2111
2112 /* Classifier configuration routines */
2113
2114 /* Update classification flow table registers */
2115 static void mvpp2_cls_flow_write(struct mvpp2 *priv,
2116                                  struct mvpp2_cls_flow_entry *fe)
2117 {
2118         mvpp2_write(priv, MVPP2_CLS_FLOW_INDEX_REG, fe->index);
2119         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL0_REG,  fe->data[0]);
2120         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL1_REG,  fe->data[1]);
2121         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL2_REG,  fe->data[2]);
2122 }
2123
2124 /* Update classification lookup table register */
2125 static void mvpp2_cls_lookup_write(struct mvpp2 *priv,
2126                                    struct mvpp2_cls_lookup_entry *le)
2127 {
2128         u32 val;
2129
2130         val = (le->way << MVPP2_CLS_LKP_INDEX_WAY_OFFS) | le->lkpid;
2131         mvpp2_write(priv, MVPP2_CLS_LKP_INDEX_REG, val);
2132         mvpp2_write(priv, MVPP2_CLS_LKP_TBL_REG, le->data);
2133 }
2134
2135 /* Classifier default initialization */
2136 static void mvpp2_cls_init(struct mvpp2 *priv)
2137 {
2138         struct mvpp2_cls_lookup_entry le;
2139         struct mvpp2_cls_flow_entry fe;
2140         int index;
2141
2142         /* Enable classifier */
2143         mvpp2_write(priv, MVPP2_CLS_MODE_REG, MVPP2_CLS_MODE_ACTIVE_MASK);
2144
2145         /* Clear classifier flow table */
2146         memset(&fe.data, 0, MVPP2_CLS_FLOWS_TBL_DATA_WORDS);
2147         for (index = 0; index < MVPP2_CLS_FLOWS_TBL_SIZE; index++) {
2148                 fe.index = index;
2149                 mvpp2_cls_flow_write(priv, &fe);
2150         }
2151
2152         /* Clear classifier lookup table */
2153         le.data = 0;
2154         for (index = 0; index < MVPP2_CLS_LKP_TBL_SIZE; index++) {
2155                 le.lkpid = index;
2156                 le.way = 0;
2157                 mvpp2_cls_lookup_write(priv, &le);
2158
2159                 le.way = 1;
2160                 mvpp2_cls_lookup_write(priv, &le);
2161         }
2162 }
2163
2164 static void mvpp2_cls_port_config(struct mvpp2_port *port)
2165 {
2166         struct mvpp2_cls_lookup_entry le;
2167         u32 val;
2168
2169         /* Set way for the port */
2170         val = mvpp2_read(port->priv, MVPP2_CLS_PORT_WAY_REG);
2171         val &= ~MVPP2_CLS_PORT_WAY_MASK(port->id);
2172         mvpp2_write(port->priv, MVPP2_CLS_PORT_WAY_REG, val);
2173
2174         /* Pick the entry to be accessed in lookup ID decoding table
2175          * according to the way and lkpid.
2176          */
2177         le.lkpid = port->id;
2178         le.way = 0;
2179         le.data = 0;
2180
2181         /* Set initial CPU queue for receiving packets */
2182         le.data &= ~MVPP2_CLS_LKP_TBL_RXQ_MASK;
2183         le.data |= port->first_rxq;
2184
2185         /* Disable classification engines */
2186         le.data &= ~MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK;
2187
2188         /* Update lookup ID table entry */
2189         mvpp2_cls_lookup_write(port->priv, &le);
2190 }
2191
2192 /* Set CPU queue number for oversize packets */
2193 static void mvpp2_cls_oversize_rxq_set(struct mvpp2_port *port)
2194 {
2195         u32 val;
2196
2197         mvpp2_write(port->priv, MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port->id),
2198                     port->first_rxq & MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK);
2199
2200         mvpp2_write(port->priv, MVPP2_CLS_SWFWD_P2HQ_REG(port->id),
2201                     (port->first_rxq >> MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS));
2202
2203         val = mvpp2_read(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG);
2204         val |= MVPP2_CLS_SWFWD_PCTRL_MASK(port->id);
2205         mvpp2_write(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG, val);
2206 }
2207
2208 /* Buffer Manager configuration routines */
2209
2210 /* Create pool */
2211 static int mvpp2_bm_pool_create(struct udevice *dev,
2212                                 struct mvpp2 *priv,
2213                                 struct mvpp2_bm_pool *bm_pool, int size)
2214 {
2215         u32 val;
2216
2217         bm_pool->virt_addr = buffer_loc.bm_pool[bm_pool->id];
2218         bm_pool->phys_addr = (dma_addr_t)buffer_loc.bm_pool[bm_pool->id];
2219         if (!bm_pool->virt_addr)
2220                 return -ENOMEM;
2221
2222         if (!IS_ALIGNED((unsigned long)bm_pool->virt_addr,
2223                         MVPP2_BM_POOL_PTR_ALIGN)) {
2224                 dev_err(&pdev->dev, "BM pool %d is not %d bytes aligned\n",
2225                         bm_pool->id, MVPP2_BM_POOL_PTR_ALIGN);
2226                 return -ENOMEM;
2227         }
2228
2229         mvpp2_write(priv, MVPP2_BM_POOL_BASE_REG(bm_pool->id),
2230                     bm_pool->phys_addr);
2231         mvpp2_write(priv, MVPP2_BM_POOL_SIZE_REG(bm_pool->id), size);
2232
2233         val = mvpp2_read(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id));
2234         val |= MVPP2_BM_START_MASK;
2235         mvpp2_write(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id), val);
2236
2237         bm_pool->type = MVPP2_BM_FREE;
2238         bm_pool->size = size;
2239         bm_pool->pkt_size = 0;
2240         bm_pool->buf_num = 0;
2241
2242         return 0;
2243 }
2244
2245 /* Set pool buffer size */
2246 static void mvpp2_bm_pool_bufsize_set(struct mvpp2 *priv,
2247                                       struct mvpp2_bm_pool *bm_pool,
2248                                       int buf_size)
2249 {
2250         u32 val;
2251
2252         bm_pool->buf_size = buf_size;
2253
2254         val = ALIGN(buf_size, 1 << MVPP2_POOL_BUF_SIZE_OFFSET);
2255         mvpp2_write(priv, MVPP2_POOL_BUF_SIZE_REG(bm_pool->id), val);
2256 }
2257
2258 /* Free all buffers from the pool */
2259 static void mvpp2_bm_bufs_free(struct udevice *dev, struct mvpp2 *priv,
2260                                struct mvpp2_bm_pool *bm_pool)
2261 {
2262         bm_pool->buf_num = 0;
2263 }
2264
2265 /* Cleanup pool */
2266 static int mvpp2_bm_pool_destroy(struct udevice *dev,
2267                                  struct mvpp2 *priv,
2268                                  struct mvpp2_bm_pool *bm_pool)
2269 {
2270         u32 val;
2271
2272         mvpp2_bm_bufs_free(dev, priv, bm_pool);
2273         if (bm_pool->buf_num) {
2274                 dev_err(dev, "cannot free all buffers in pool %d\n", bm_pool->id);
2275                 return 0;
2276         }
2277
2278         val = mvpp2_read(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id));
2279         val |= MVPP2_BM_STOP_MASK;
2280         mvpp2_write(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id), val);
2281
2282         return 0;
2283 }
2284
2285 static int mvpp2_bm_pools_init(struct udevice *dev,
2286                                struct mvpp2 *priv)
2287 {
2288         int i, err, size;
2289         struct mvpp2_bm_pool *bm_pool;
2290
2291         /* Create all pools with maximum size */
2292         size = MVPP2_BM_POOL_SIZE_MAX;
2293         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
2294                 bm_pool = &priv->bm_pools[i];
2295                 bm_pool->id = i;
2296                 err = mvpp2_bm_pool_create(dev, priv, bm_pool, size);
2297                 if (err)
2298                         goto err_unroll_pools;
2299                 mvpp2_bm_pool_bufsize_set(priv, bm_pool, 0);
2300         }
2301         return 0;
2302
2303 err_unroll_pools:
2304         dev_err(&pdev->dev, "failed to create BM pool %d, size %d\n", i, size);
2305         for (i = i - 1; i >= 0; i--)
2306                 mvpp2_bm_pool_destroy(dev, priv, &priv->bm_pools[i]);
2307         return err;
2308 }
2309
2310 static int mvpp2_bm_init(struct udevice *dev, struct mvpp2 *priv)
2311 {
2312         int i, err;
2313
2314         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
2315                 /* Mask BM all interrupts */
2316                 mvpp2_write(priv, MVPP2_BM_INTR_MASK_REG(i), 0);
2317                 /* Clear BM cause register */
2318                 mvpp2_write(priv, MVPP2_BM_INTR_CAUSE_REG(i), 0);
2319         }
2320
2321         /* Allocate and initialize BM pools */
2322         priv->bm_pools = devm_kcalloc(dev, MVPP2_BM_POOLS_NUM,
2323                                      sizeof(struct mvpp2_bm_pool), GFP_KERNEL);
2324         if (!priv->bm_pools)
2325                 return -ENOMEM;
2326
2327         err = mvpp2_bm_pools_init(dev, priv);
2328         if (err < 0)
2329                 return err;
2330         return 0;
2331 }
2332
2333 /* Attach long pool to rxq */
2334 static void mvpp2_rxq_long_pool_set(struct mvpp2_port *port,
2335                                     int lrxq, int long_pool)
2336 {
2337         u32 val;
2338         int prxq;
2339
2340         /* Get queue physical ID */
2341         prxq = port->rxqs[lrxq]->id;
2342
2343         val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq));
2344         val &= ~MVPP2_RXQ_POOL_LONG_MASK;
2345         val |= ((long_pool << MVPP2_RXQ_POOL_LONG_OFFS) &
2346                     MVPP2_RXQ_POOL_LONG_MASK);
2347
2348         mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val);
2349 }
2350
2351 /* Set pool number in a BM cookie */
2352 static inline u32 mvpp2_bm_cookie_pool_set(u32 cookie, int pool)
2353 {
2354         u32 bm;
2355
2356         bm = cookie & ~(0xFF << MVPP2_BM_COOKIE_POOL_OFFS);
2357         bm |= ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS);
2358
2359         return bm;
2360 }
2361
2362 /* Get pool number from a BM cookie */
2363 static inline int mvpp2_bm_cookie_pool_get(unsigned long cookie)
2364 {
2365         return (cookie >> MVPP2_BM_COOKIE_POOL_OFFS) & 0xFF;
2366 }
2367
2368 /* Release buffer to BM */
2369 static inline void mvpp2_bm_pool_put(struct mvpp2_port *port, int pool,
2370                                      dma_addr_t buf_phys_addr,
2371                                      unsigned long buf_virt_addr)
2372 {
2373         mvpp2_write(port->priv, MVPP2_BM_VIRT_RLS_REG, buf_virt_addr);
2374         mvpp2_write(port->priv, MVPP2_BM_PHY_RLS_REG(pool), buf_phys_addr);
2375 }
2376
2377 /* Refill BM pool */
2378 static void mvpp2_pool_refill(struct mvpp2_port *port, u32 bm,
2379                               u32 phys_addr, u32 cookie)
2380 {
2381         int pool = mvpp2_bm_cookie_pool_get(bm);
2382
2383         mvpp2_bm_pool_put(port, pool, phys_addr, cookie);
2384 }
2385
2386 /* Allocate buffers for the pool */
2387 static int mvpp2_bm_bufs_add(struct mvpp2_port *port,
2388                              struct mvpp2_bm_pool *bm_pool, int buf_num)
2389 {
2390         int i;
2391
2392         if (buf_num < 0 ||
2393             (buf_num + bm_pool->buf_num > bm_pool->size)) {
2394                 netdev_err(port->dev,
2395                            "cannot allocate %d buffers for pool %d\n",
2396                            buf_num, bm_pool->id);
2397                 return 0;
2398         }
2399
2400         for (i = 0; i < buf_num; i++) {
2401                 mvpp2_bm_pool_put(port, bm_pool->id,
2402                                   (dma_addr_t)buffer_loc.rx_buffer[i],
2403                                   (unsigned long)buffer_loc.rx_buffer[i]);
2404
2405         }
2406
2407         /* Update BM driver with number of buffers added to pool */
2408         bm_pool->buf_num += i;
2409         bm_pool->in_use_thresh = bm_pool->buf_num / 4;
2410
2411         return i;
2412 }
2413
2414 /* Notify the driver that BM pool is being used as specific type and return the
2415  * pool pointer on success
2416  */
2417 static struct mvpp2_bm_pool *
2418 mvpp2_bm_pool_use(struct mvpp2_port *port, int pool, enum mvpp2_bm_type type,
2419                   int pkt_size)
2420 {
2421         struct mvpp2_bm_pool *new_pool = &port->priv->bm_pools[pool];
2422         int num;
2423
2424         if (new_pool->type != MVPP2_BM_FREE && new_pool->type != type) {
2425                 netdev_err(port->dev, "mixing pool types is forbidden\n");
2426                 return NULL;
2427         }
2428
2429         if (new_pool->type == MVPP2_BM_FREE)
2430                 new_pool->type = type;
2431
2432         /* Allocate buffers in case BM pool is used as long pool, but packet
2433          * size doesn't match MTU or BM pool hasn't being used yet
2434          */
2435         if (((type == MVPP2_BM_SWF_LONG) && (pkt_size > new_pool->pkt_size)) ||
2436             (new_pool->pkt_size == 0)) {
2437                 int pkts_num;
2438
2439                 /* Set default buffer number or free all the buffers in case
2440                  * the pool is not empty
2441                  */
2442                 pkts_num = new_pool->buf_num;
2443                 if (pkts_num == 0)
2444                         pkts_num = type == MVPP2_BM_SWF_LONG ?
2445                                    MVPP2_BM_LONG_BUF_NUM :
2446                                    MVPP2_BM_SHORT_BUF_NUM;
2447                 else
2448                         mvpp2_bm_bufs_free(NULL,
2449                                            port->priv, new_pool);
2450
2451                 new_pool->pkt_size = pkt_size;
2452
2453                 /* Allocate buffers for this pool */
2454                 num = mvpp2_bm_bufs_add(port, new_pool, pkts_num);
2455                 if (num != pkts_num) {
2456                         dev_err(dev, "pool %d: %d of %d allocated\n",
2457                                 new_pool->id, num, pkts_num);
2458                         return NULL;
2459                 }
2460         }
2461
2462         mvpp2_bm_pool_bufsize_set(port->priv, new_pool,
2463                                   MVPP2_RX_BUF_SIZE(new_pool->pkt_size));
2464
2465         return new_pool;
2466 }
2467
2468 /* Initialize pools for swf */
2469 static int mvpp2_swf_bm_pool_init(struct mvpp2_port *port)
2470 {
2471         int rxq;
2472
2473         if (!port->pool_long) {
2474                 port->pool_long =
2475                        mvpp2_bm_pool_use(port, MVPP2_BM_SWF_LONG_POOL(port->id),
2476                                          MVPP2_BM_SWF_LONG,
2477                                          port->pkt_size);
2478                 if (!port->pool_long)
2479                         return -ENOMEM;
2480
2481                 port->pool_long->port_map |= (1 << port->id);
2482
2483                 for (rxq = 0; rxq < rxq_number; rxq++)
2484                         mvpp2_rxq_long_pool_set(port, rxq, port->pool_long->id);
2485         }
2486
2487         return 0;
2488 }
2489
2490 /* Port configuration routines */
2491
2492 static void mvpp2_port_mii_set(struct mvpp2_port *port)
2493 {
2494         u32 val;
2495
2496         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
2497
2498         switch (port->phy_interface) {
2499         case PHY_INTERFACE_MODE_SGMII:
2500                 val |= MVPP2_GMAC_INBAND_AN_MASK;
2501                 break;
2502         case PHY_INTERFACE_MODE_RGMII:
2503                 val |= MVPP2_GMAC_PORT_RGMII_MASK;
2504         default:
2505                 val &= ~MVPP2_GMAC_PCS_ENABLE_MASK;
2506         }
2507
2508         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2509 }
2510
2511 static void mvpp2_port_fc_adv_enable(struct mvpp2_port *port)
2512 {
2513         u32 val;
2514
2515         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
2516         val |= MVPP2_GMAC_FC_ADV_EN;
2517         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
2518 }
2519
2520 static void mvpp2_port_enable(struct mvpp2_port *port)
2521 {
2522         u32 val;
2523
2524         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2525         val |= MVPP2_GMAC_PORT_EN_MASK;
2526         val |= MVPP2_GMAC_MIB_CNTR_EN_MASK;
2527         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2528 }
2529
2530 static void mvpp2_port_disable(struct mvpp2_port *port)
2531 {
2532         u32 val;
2533
2534         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2535         val &= ~(MVPP2_GMAC_PORT_EN_MASK);
2536         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2537 }
2538
2539 /* Set IEEE 802.3x Flow Control Xon Packet Transmission Mode */
2540 static void mvpp2_port_periodic_xon_disable(struct mvpp2_port *port)
2541 {
2542         u32 val;
2543
2544         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG) &
2545                     ~MVPP2_GMAC_PERIODIC_XON_EN_MASK;
2546         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
2547 }
2548
2549 /* Configure loopback port */
2550 static void mvpp2_port_loopback_set(struct mvpp2_port *port)
2551 {
2552         u32 val;
2553
2554         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG);
2555
2556         if (port->speed == 1000)
2557                 val |= MVPP2_GMAC_GMII_LB_EN_MASK;
2558         else
2559                 val &= ~MVPP2_GMAC_GMII_LB_EN_MASK;
2560
2561         if (port->phy_interface == PHY_INTERFACE_MODE_SGMII)
2562                 val |= MVPP2_GMAC_PCS_LB_EN_MASK;
2563         else
2564                 val &= ~MVPP2_GMAC_PCS_LB_EN_MASK;
2565
2566         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
2567 }
2568
2569 static void mvpp2_port_reset(struct mvpp2_port *port)
2570 {
2571         u32 val;
2572
2573         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG) &
2574                     ~MVPP2_GMAC_PORT_RESET_MASK;
2575         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2576
2577         while (readl(port->base + MVPP2_GMAC_CTRL_2_REG) &
2578                MVPP2_GMAC_PORT_RESET_MASK)
2579                 continue;
2580 }
2581
2582 /* Change maximum receive size of the port */
2583 static inline void mvpp2_gmac_max_rx_size_set(struct mvpp2_port *port)
2584 {
2585         u32 val;
2586
2587         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2588         val &= ~MVPP2_GMAC_MAX_RX_SIZE_MASK;
2589         val |= (((port->pkt_size - MVPP2_MH_SIZE) / 2) <<
2590                     MVPP2_GMAC_MAX_RX_SIZE_OFFS);
2591         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2592 }
2593
2594 /* Set defaults to the MVPP2 port */
2595 static void mvpp2_defaults_set(struct mvpp2_port *port)
2596 {
2597         int tx_port_num, val, queue, ptxq, lrxq;
2598
2599         /* Configure port to loopback if needed */
2600         if (port->flags & MVPP2_F_LOOPBACK)
2601                 mvpp2_port_loopback_set(port);
2602
2603         /* Update TX FIFO MIN Threshold */
2604         val = readl(port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
2605         val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK;
2606         /* Min. TX threshold must be less than minimal packet length */
2607         val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(64 - 4 - 2);
2608         writel(val, port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
2609
2610         /* Disable Legacy WRR, Disable EJP, Release from reset */
2611         tx_port_num = mvpp2_egress_port(port);
2612         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG,
2613                     tx_port_num);
2614         mvpp2_write(port->priv, MVPP2_TXP_SCHED_CMD_1_REG, 0);
2615
2616         /* Close bandwidth for all queues */
2617         for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) {
2618                 ptxq = mvpp2_txq_phys(port->id, queue);
2619                 mvpp2_write(port->priv,
2620                             MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(ptxq), 0);
2621         }
2622
2623         /* Set refill period to 1 usec, refill tokens
2624          * and bucket size to maximum
2625          */
2626         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PERIOD_REG, 0xc8);
2627         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_REFILL_REG);
2628         val &= ~MVPP2_TXP_REFILL_PERIOD_ALL_MASK;
2629         val |= MVPP2_TXP_REFILL_PERIOD_MASK(1);
2630         val |= MVPP2_TXP_REFILL_TOKENS_ALL_MASK;
2631         mvpp2_write(port->priv, MVPP2_TXP_SCHED_REFILL_REG, val);
2632         val = MVPP2_TXP_TOKEN_SIZE_MAX;
2633         mvpp2_write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val);
2634
2635         /* Set MaximumLowLatencyPacketSize value to 256 */
2636         mvpp2_write(port->priv, MVPP2_RX_CTRL_REG(port->id),
2637                     MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK |
2638                     MVPP2_RX_LOW_LATENCY_PKT_SIZE(256));
2639
2640         /* Enable Rx cache snoop */
2641         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
2642                 queue = port->rxqs[lrxq]->id;
2643                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
2644                 val |= MVPP2_SNOOP_PKT_SIZE_MASK |
2645                            MVPP2_SNOOP_BUF_HDR_MASK;
2646                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
2647         }
2648 }
2649
2650 /* Enable/disable receiving packets */
2651 static void mvpp2_ingress_enable(struct mvpp2_port *port)
2652 {
2653         u32 val;
2654         int lrxq, queue;
2655
2656         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
2657                 queue = port->rxqs[lrxq]->id;
2658                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
2659                 val &= ~MVPP2_RXQ_DISABLE_MASK;
2660                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
2661         }
2662 }
2663
2664 static void mvpp2_ingress_disable(struct mvpp2_port *port)
2665 {
2666         u32 val;
2667         int lrxq, queue;
2668
2669         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
2670                 queue = port->rxqs[lrxq]->id;
2671                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
2672                 val |= MVPP2_RXQ_DISABLE_MASK;
2673                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
2674         }
2675 }
2676
2677 /* Enable transmit via physical egress queue
2678  * - HW starts take descriptors from DRAM
2679  */
2680 static void mvpp2_egress_enable(struct mvpp2_port *port)
2681 {
2682         u32 qmap;
2683         int queue;
2684         int tx_port_num = mvpp2_egress_port(port);
2685
2686         /* Enable all initialized TXs. */
2687         qmap = 0;
2688         for (queue = 0; queue < txq_number; queue++) {
2689                 struct mvpp2_tx_queue *txq = port->txqs[queue];
2690
2691                 if (txq->descs != NULL)
2692                         qmap |= (1 << queue);
2693         }
2694
2695         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
2696         mvpp2_write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG, qmap);
2697 }
2698
2699 /* Disable transmit via physical egress queue
2700  * - HW doesn't take descriptors from DRAM
2701  */
2702 static void mvpp2_egress_disable(struct mvpp2_port *port)
2703 {
2704         u32 reg_data;
2705         int delay;
2706         int tx_port_num = mvpp2_egress_port(port);
2707
2708         /* Issue stop command for active channels only */
2709         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
2710         reg_data = (mvpp2_read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG)) &
2711                     MVPP2_TXP_SCHED_ENQ_MASK;
2712         if (reg_data != 0)
2713                 mvpp2_write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG,
2714                             (reg_data << MVPP2_TXP_SCHED_DISQ_OFFSET));
2715
2716         /* Wait for all Tx activity to terminate. */
2717         delay = 0;
2718         do {
2719                 if (delay >= MVPP2_TX_DISABLE_TIMEOUT_MSEC) {
2720                         netdev_warn(port->dev,
2721                                     "Tx stop timed out, status=0x%08x\n",
2722                                     reg_data);
2723                         break;
2724                 }
2725                 mdelay(1);
2726                 delay++;
2727
2728                 /* Check port TX Command register that all
2729                  * Tx queues are stopped
2730                  */
2731                 reg_data = mvpp2_read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG);
2732         } while (reg_data & MVPP2_TXP_SCHED_ENQ_MASK);
2733 }
2734
2735 /* Rx descriptors helper methods */
2736
2737 /* Get number of Rx descriptors occupied by received packets */
2738 static inline int
2739 mvpp2_rxq_received(struct mvpp2_port *port, int rxq_id)
2740 {
2741         u32 val = mvpp2_read(port->priv, MVPP2_RXQ_STATUS_REG(rxq_id));
2742
2743         return val & MVPP2_RXQ_OCCUPIED_MASK;
2744 }
2745
2746 /* Update Rx queue status with the number of occupied and available
2747  * Rx descriptor slots.
2748  */
2749 static inline void
2750 mvpp2_rxq_status_update(struct mvpp2_port *port, int rxq_id,
2751                         int used_count, int free_count)
2752 {
2753         /* Decrement the number of used descriptors and increment count
2754          * increment the number of free descriptors.
2755          */
2756         u32 val = used_count | (free_count << MVPP2_RXQ_NUM_NEW_OFFSET);
2757
2758         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_UPDATE_REG(rxq_id), val);
2759 }
2760
2761 /* Get pointer to next RX descriptor to be processed by SW */
2762 static inline struct mvpp2_rx_desc *
2763 mvpp2_rxq_next_desc_get(struct mvpp2_rx_queue *rxq)
2764 {
2765         int rx_desc = rxq->next_desc_to_proc;
2766
2767         rxq->next_desc_to_proc = MVPP2_QUEUE_NEXT_DESC(rxq, rx_desc);
2768         prefetch(rxq->descs + rxq->next_desc_to_proc);
2769         return rxq->descs + rx_desc;
2770 }
2771
2772 /* Set rx queue offset */
2773 static void mvpp2_rxq_offset_set(struct mvpp2_port *port,
2774                                  int prxq, int offset)
2775 {
2776         u32 val;
2777
2778         /* Convert offset from bytes to units of 32 bytes */
2779         offset = offset >> 5;
2780
2781         val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq));
2782         val &= ~MVPP2_RXQ_PACKET_OFFSET_MASK;
2783
2784         /* Offset is in */
2785         val |= ((offset << MVPP2_RXQ_PACKET_OFFSET_OFFS) &
2786                     MVPP2_RXQ_PACKET_OFFSET_MASK);
2787
2788         mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val);
2789 }
2790
2791 /* Obtain BM cookie information from descriptor */
2792 static u32 mvpp2_bm_cookie_build(struct mvpp2_rx_desc *rx_desc)
2793 {
2794         int pool = (rx_desc->status & MVPP2_RXD_BM_POOL_ID_MASK) >>
2795                    MVPP2_RXD_BM_POOL_ID_OFFS;
2796         int cpu = smp_processor_id();
2797
2798         return ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS) |
2799                ((cpu & 0xFF) << MVPP2_BM_COOKIE_CPU_OFFS);
2800 }
2801
2802 /* Tx descriptors helper methods */
2803
2804 /* Get number of Tx descriptors waiting to be transmitted by HW */
2805 static int mvpp2_txq_pend_desc_num_get(struct mvpp2_port *port,
2806                                        struct mvpp2_tx_queue *txq)
2807 {
2808         u32 val;
2809
2810         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
2811         val = mvpp2_read(port->priv, MVPP2_TXQ_PENDING_REG);
2812
2813         return val & MVPP2_TXQ_PENDING_MASK;
2814 }
2815
2816 /* Get pointer to next Tx descriptor to be processed (send) by HW */
2817 static struct mvpp2_tx_desc *
2818 mvpp2_txq_next_desc_get(struct mvpp2_tx_queue *txq)
2819 {
2820         int tx_desc = txq->next_desc_to_proc;
2821
2822         txq->next_desc_to_proc = MVPP2_QUEUE_NEXT_DESC(txq, tx_desc);
2823         return txq->descs + tx_desc;
2824 }
2825
2826 /* Update HW with number of aggregated Tx descriptors to be sent */
2827 static void mvpp2_aggr_txq_pend_desc_add(struct mvpp2_port *port, int pending)
2828 {
2829         /* aggregated access - relevant TXQ number is written in TX desc */
2830         mvpp2_write(port->priv, MVPP2_AGGR_TXQ_UPDATE_REG, pending);
2831 }
2832
2833 /* Get number of sent descriptors and decrement counter.
2834  * The number of sent descriptors is returned.
2835  * Per-CPU access
2836  */
2837 static inline int mvpp2_txq_sent_desc_proc(struct mvpp2_port *port,
2838                                            struct mvpp2_tx_queue *txq)
2839 {
2840         u32 val;
2841
2842         /* Reading status reg resets transmitted descriptor counter */
2843         val = mvpp2_read(port->priv, MVPP2_TXQ_SENT_REG(txq->id));
2844
2845         return (val & MVPP2_TRANSMITTED_COUNT_MASK) >>
2846                 MVPP2_TRANSMITTED_COUNT_OFFSET;
2847 }
2848
2849 static void mvpp2_txq_sent_counter_clear(void *arg)
2850 {
2851         struct mvpp2_port *port = arg;
2852         int queue;
2853
2854         for (queue = 0; queue < txq_number; queue++) {
2855                 int id = port->txqs[queue]->id;
2856
2857                 mvpp2_read(port->priv, MVPP2_TXQ_SENT_REG(id));
2858         }
2859 }
2860
2861 /* Set max sizes for Tx queues */
2862 static void mvpp2_txp_max_tx_size_set(struct mvpp2_port *port)
2863 {
2864         u32     val, size, mtu;
2865         int     txq, tx_port_num;
2866
2867         mtu = port->pkt_size * 8;
2868         if (mtu > MVPP2_TXP_MTU_MAX)
2869                 mtu = MVPP2_TXP_MTU_MAX;
2870
2871         /* WA for wrong Token bucket update: Set MTU value = 3*real MTU value */
2872         mtu = 3 * mtu;
2873
2874         /* Indirect access to registers */
2875         tx_port_num = mvpp2_egress_port(port);
2876         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
2877
2878         /* Set MTU */
2879         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_MTU_REG);
2880         val &= ~MVPP2_TXP_MTU_MAX;
2881         val |= mtu;
2882         mvpp2_write(port->priv, MVPP2_TXP_SCHED_MTU_REG, val);
2883
2884         /* TXP token size and all TXQs token size must be larger that MTU */
2885         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG);
2886         size = val & MVPP2_TXP_TOKEN_SIZE_MAX;
2887         if (size < mtu) {
2888                 size = mtu;
2889                 val &= ~MVPP2_TXP_TOKEN_SIZE_MAX;
2890                 val |= size;
2891                 mvpp2_write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val);
2892         }
2893
2894         for (txq = 0; txq < txq_number; txq++) {
2895                 val = mvpp2_read(port->priv,
2896                                  MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq));
2897                 size = val & MVPP2_TXQ_TOKEN_SIZE_MAX;
2898
2899                 if (size < mtu) {
2900                         size = mtu;
2901                         val &= ~MVPP2_TXQ_TOKEN_SIZE_MAX;
2902                         val |= size;
2903                         mvpp2_write(port->priv,
2904                                     MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq),
2905                                     val);
2906                 }
2907         }
2908 }
2909
2910 /* Free Tx queue skbuffs */
2911 static void mvpp2_txq_bufs_free(struct mvpp2_port *port,
2912                                 struct mvpp2_tx_queue *txq,
2913                                 struct mvpp2_txq_pcpu *txq_pcpu, int num)
2914 {
2915         int i;
2916
2917         for (i = 0; i < num; i++)
2918                 mvpp2_txq_inc_get(txq_pcpu);
2919 }
2920
2921 static inline struct mvpp2_rx_queue *mvpp2_get_rx_queue(struct mvpp2_port *port,
2922                                                         u32 cause)
2923 {
2924         int queue = fls(cause) - 1;
2925
2926         return port->rxqs[queue];
2927 }
2928
2929 static inline struct mvpp2_tx_queue *mvpp2_get_tx_queue(struct mvpp2_port *port,
2930                                                         u32 cause)
2931 {
2932         int queue = fls(cause) - 1;
2933
2934         return port->txqs[queue];
2935 }
2936
2937 /* Rx/Tx queue initialization/cleanup methods */
2938
2939 /* Allocate and initialize descriptors for aggr TXQ */
2940 static int mvpp2_aggr_txq_init(struct udevice *dev,
2941                                struct mvpp2_tx_queue *aggr_txq,
2942                                int desc_num, int cpu,
2943                                struct mvpp2 *priv)
2944 {
2945         /* Allocate memory for TX descriptors */
2946         aggr_txq->descs = buffer_loc.aggr_tx_descs;
2947         aggr_txq->descs_phys = (dma_addr_t)buffer_loc.aggr_tx_descs;
2948         if (!aggr_txq->descs)
2949                 return -ENOMEM;
2950
2951         /* Make sure descriptor address is cache line size aligned  */
2952         BUG_ON(aggr_txq->descs !=
2953                PTR_ALIGN(aggr_txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
2954
2955         aggr_txq->last_desc = aggr_txq->size - 1;
2956
2957         /* Aggr TXQ no reset WA */
2958         aggr_txq->next_desc_to_proc = mvpp2_read(priv,
2959                                                  MVPP2_AGGR_TXQ_INDEX_REG(cpu));
2960
2961         /* Set Tx descriptors queue starting address */
2962         /* indirect access */
2963         mvpp2_write(priv, MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu),
2964                     aggr_txq->descs_phys);
2965         mvpp2_write(priv, MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu), desc_num);
2966
2967         return 0;
2968 }
2969
2970 /* Create a specified Rx queue */
2971 static int mvpp2_rxq_init(struct mvpp2_port *port,
2972                           struct mvpp2_rx_queue *rxq)
2973
2974 {
2975         rxq->size = port->rx_ring_size;
2976
2977         /* Allocate memory for RX descriptors */
2978         rxq->descs = buffer_loc.rx_descs;
2979         rxq->descs_phys = (dma_addr_t)buffer_loc.rx_descs;
2980         if (!rxq->descs)
2981                 return -ENOMEM;
2982
2983         BUG_ON(rxq->descs !=
2984                PTR_ALIGN(rxq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
2985
2986         rxq->last_desc = rxq->size - 1;
2987
2988         /* Zero occupied and non-occupied counters - direct access */
2989         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
2990
2991         /* Set Rx descriptors queue starting address - indirect access */
2992         mvpp2_write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id);
2993         mvpp2_write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, rxq->descs_phys);
2994         mvpp2_write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, rxq->size);
2995         mvpp2_write(port->priv, MVPP2_RXQ_INDEX_REG, 0);
2996
2997         /* Set Offset */
2998         mvpp2_rxq_offset_set(port, rxq->id, NET_SKB_PAD);
2999
3000         /* Add number of descriptors ready for receiving packets */
3001         mvpp2_rxq_status_update(port, rxq->id, 0, rxq->size);
3002
3003         return 0;
3004 }
3005
3006 /* Push packets received by the RXQ to BM pool */
3007 static void mvpp2_rxq_drop_pkts(struct mvpp2_port *port,
3008                                 struct mvpp2_rx_queue *rxq)
3009 {
3010         int rx_received, i;
3011
3012         rx_received = mvpp2_rxq_received(port, rxq->id);
3013         if (!rx_received)
3014                 return;
3015
3016         for (i = 0; i < rx_received; i++) {
3017                 struct mvpp2_rx_desc *rx_desc = mvpp2_rxq_next_desc_get(rxq);
3018                 u32 bm = mvpp2_bm_cookie_build(rx_desc);
3019
3020                 mvpp2_pool_refill(port, bm, rx_desc->buf_phys_addr,
3021                                   rx_desc->buf_cookie);
3022         }
3023         mvpp2_rxq_status_update(port, rxq->id, rx_received, rx_received);
3024 }
3025
3026 /* Cleanup Rx queue */
3027 static void mvpp2_rxq_deinit(struct mvpp2_port *port,
3028                              struct mvpp2_rx_queue *rxq)
3029 {
3030         mvpp2_rxq_drop_pkts(port, rxq);
3031
3032         rxq->descs             = NULL;
3033         rxq->last_desc         = 0;
3034         rxq->next_desc_to_proc = 0;
3035         rxq->descs_phys        = 0;
3036
3037         /* Clear Rx descriptors queue starting address and size;
3038          * free descriptor number
3039          */
3040         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
3041         mvpp2_write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id);
3042         mvpp2_write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, 0);
3043         mvpp2_write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, 0);
3044 }
3045
3046 /* Create and initialize a Tx queue */
3047 static int mvpp2_txq_init(struct mvpp2_port *port,
3048                           struct mvpp2_tx_queue *txq)
3049 {
3050         u32 val;
3051         int cpu, desc, desc_per_txq, tx_port_num;
3052         struct mvpp2_txq_pcpu *txq_pcpu;
3053
3054         txq->size = port->tx_ring_size;
3055
3056         /* Allocate memory for Tx descriptors */
3057         txq->descs = buffer_loc.tx_descs;
3058         txq->descs_phys = (dma_addr_t)buffer_loc.tx_descs;
3059         if (!txq->descs)
3060                 return -ENOMEM;
3061
3062         /* Make sure descriptor address is cache line size aligned  */
3063         BUG_ON(txq->descs !=
3064                PTR_ALIGN(txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
3065
3066         txq->last_desc = txq->size - 1;
3067
3068         /* Set Tx descriptors queue starting address - indirect access */
3069         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3070         mvpp2_write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, txq->descs_phys);
3071         mvpp2_write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, txq->size &
3072                                              MVPP2_TXQ_DESC_SIZE_MASK);
3073         mvpp2_write(port->priv, MVPP2_TXQ_INDEX_REG, 0);
3074         mvpp2_write(port->priv, MVPP2_TXQ_RSVD_CLR_REG,
3075                     txq->id << MVPP2_TXQ_RSVD_CLR_OFFSET);
3076         val = mvpp2_read(port->priv, MVPP2_TXQ_PENDING_REG);
3077         val &= ~MVPP2_TXQ_PENDING_MASK;
3078         mvpp2_write(port->priv, MVPP2_TXQ_PENDING_REG, val);
3079
3080         /* Calculate base address in prefetch buffer. We reserve 16 descriptors
3081          * for each existing TXQ.
3082          * TCONTS for PON port must be continuous from 0 to MVPP2_MAX_TCONT
3083          * GBE ports assumed to be continious from 0 to MVPP2_MAX_PORTS
3084          */
3085         desc_per_txq = 16;
3086         desc = (port->id * MVPP2_MAX_TXQ * desc_per_txq) +
3087                (txq->log_id * desc_per_txq);
3088
3089         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG,
3090                     MVPP2_PREF_BUF_PTR(desc) | MVPP2_PREF_BUF_SIZE_16 |
3091                     MVPP2_PREF_BUF_THRESH(desc_per_txq/2));
3092
3093         /* WRR / EJP configuration - indirect access */
3094         tx_port_num = mvpp2_egress_port(port);
3095         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
3096
3097         val = mvpp2_read(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->log_id));
3098         val &= ~MVPP2_TXQ_REFILL_PERIOD_ALL_MASK;
3099         val |= MVPP2_TXQ_REFILL_PERIOD_MASK(1);
3100         val |= MVPP2_TXQ_REFILL_TOKENS_ALL_MASK;
3101         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->log_id), val);
3102
3103         val = MVPP2_TXQ_TOKEN_SIZE_MAX;
3104         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq->log_id),
3105                     val);
3106
3107         for_each_present_cpu(cpu) {
3108                 txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
3109                 txq_pcpu->size = txq->size;
3110         }
3111
3112         return 0;
3113 }
3114
3115 /* Free allocated TXQ resources */
3116 static void mvpp2_txq_deinit(struct mvpp2_port *port,
3117                              struct mvpp2_tx_queue *txq)
3118 {
3119         txq->descs             = NULL;
3120         txq->last_desc         = 0;
3121         txq->next_desc_to_proc = 0;
3122         txq->descs_phys        = 0;
3123
3124         /* Set minimum bandwidth for disabled TXQs */
3125         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0);
3126
3127         /* Set Tx descriptors queue starting address and size */
3128         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3129         mvpp2_write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, 0);
3130         mvpp2_write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, 0);
3131 }
3132
3133 /* Cleanup Tx ports */
3134 static void mvpp2_txq_clean(struct mvpp2_port *port, struct mvpp2_tx_queue *txq)
3135 {
3136         struct mvpp2_txq_pcpu *txq_pcpu;
3137         int delay, pending, cpu;
3138         u32 val;
3139
3140         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3141         val = mvpp2_read(port->priv, MVPP2_TXQ_PREF_BUF_REG);
3142         val |= MVPP2_TXQ_DRAIN_EN_MASK;
3143         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
3144
3145         /* The napi queue has been stopped so wait for all packets
3146          * to be transmitted.
3147          */
3148         delay = 0;
3149         do {
3150                 if (delay >= MVPP2_TX_PENDING_TIMEOUT_MSEC) {
3151                         netdev_warn(port->dev,
3152                                     "port %d: cleaning queue %d timed out\n",
3153                                     port->id, txq->log_id);
3154                         break;
3155                 }
3156                 mdelay(1);
3157                 delay++;
3158
3159                 pending = mvpp2_txq_pend_desc_num_get(port, txq);
3160         } while (pending);
3161
3162         val &= ~MVPP2_TXQ_DRAIN_EN_MASK;
3163         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
3164
3165         for_each_present_cpu(cpu) {
3166                 txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
3167
3168                 /* Release all packets */
3169                 mvpp2_txq_bufs_free(port, txq, txq_pcpu, txq_pcpu->count);
3170
3171                 /* Reset queue */
3172                 txq_pcpu->count = 0;
3173                 txq_pcpu->txq_put_index = 0;
3174                 txq_pcpu->txq_get_index = 0;
3175         }
3176 }
3177
3178 /* Cleanup all Tx queues */
3179 static void mvpp2_cleanup_txqs(struct mvpp2_port *port)
3180 {
3181         struct mvpp2_tx_queue *txq;
3182         int queue;
3183         u32 val;
3184
3185         val = mvpp2_read(port->priv, MVPP2_TX_PORT_FLUSH_REG);
3186
3187         /* Reset Tx ports and delete Tx queues */
3188         val |= MVPP2_TX_PORT_FLUSH_MASK(port->id);
3189         mvpp2_write(port->priv, MVPP2_TX_PORT_FLUSH_REG, val);
3190
3191         for (queue = 0; queue < txq_number; queue++) {
3192                 txq = port->txqs[queue];
3193                 mvpp2_txq_clean(port, txq);
3194                 mvpp2_txq_deinit(port, txq);
3195         }
3196
3197         mvpp2_txq_sent_counter_clear(port);
3198
3199         val &= ~MVPP2_TX_PORT_FLUSH_MASK(port->id);
3200         mvpp2_write(port->priv, MVPP2_TX_PORT_FLUSH_REG, val);
3201 }
3202
3203 /* Cleanup all Rx queues */
3204 static void mvpp2_cleanup_rxqs(struct mvpp2_port *port)
3205 {
3206         int queue;
3207
3208         for (queue = 0; queue < rxq_number; queue++)
3209                 mvpp2_rxq_deinit(port, port->rxqs[queue]);
3210 }
3211
3212 /* Init all Rx queues for port */
3213 static int mvpp2_setup_rxqs(struct mvpp2_port *port)
3214 {
3215         int queue, err;
3216
3217         for (queue = 0; queue < rxq_number; queue++) {
3218                 err = mvpp2_rxq_init(port, port->rxqs[queue]);
3219                 if (err)
3220                         goto err_cleanup;
3221         }
3222         return 0;
3223
3224 err_cleanup:
3225         mvpp2_cleanup_rxqs(port);
3226         return err;
3227 }
3228
3229 /* Init all tx queues for port */
3230 static int mvpp2_setup_txqs(struct mvpp2_port *port)
3231 {
3232         struct mvpp2_tx_queue *txq;
3233         int queue, err;
3234
3235         for (queue = 0; queue < txq_number; queue++) {
3236                 txq = port->txqs[queue];
3237                 err = mvpp2_txq_init(port, txq);
3238                 if (err)
3239                         goto err_cleanup;
3240         }
3241
3242         mvpp2_txq_sent_counter_clear(port);
3243         return 0;
3244
3245 err_cleanup:
3246         mvpp2_cleanup_txqs(port);
3247         return err;
3248 }
3249
3250 /* Adjust link */
3251 static void mvpp2_link_event(struct mvpp2_port *port)
3252 {
3253         struct phy_device *phydev = port->phy_dev;
3254         int status_change = 0;
3255         u32 val;
3256
3257         if (phydev->link) {
3258                 if ((port->speed != phydev->speed) ||
3259                     (port->duplex != phydev->duplex)) {
3260                         u32 val;
3261
3262                         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3263                         val &= ~(MVPP2_GMAC_CONFIG_MII_SPEED |
3264                                  MVPP2_GMAC_CONFIG_GMII_SPEED |
3265                                  MVPP2_GMAC_CONFIG_FULL_DUPLEX |
3266                                  MVPP2_GMAC_AN_SPEED_EN |
3267                                  MVPP2_GMAC_AN_DUPLEX_EN);
3268
3269                         if (phydev->duplex)
3270                                 val |= MVPP2_GMAC_CONFIG_FULL_DUPLEX;
3271
3272                         if (phydev->speed == SPEED_1000)
3273                                 val |= MVPP2_GMAC_CONFIG_GMII_SPEED;
3274                         else if (phydev->speed == SPEED_100)
3275                                 val |= MVPP2_GMAC_CONFIG_MII_SPEED;
3276
3277                         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3278
3279                         port->duplex = phydev->duplex;
3280                         port->speed  = phydev->speed;
3281                 }
3282         }
3283
3284         if (phydev->link != port->link) {
3285                 if (!phydev->link) {
3286                         port->duplex = -1;
3287                         port->speed = 0;
3288                 }
3289
3290                 port->link = phydev->link;
3291                 status_change = 1;
3292         }
3293
3294         if (status_change) {
3295                 if (phydev->link) {
3296                         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3297                         val |= (MVPP2_GMAC_FORCE_LINK_PASS |
3298                                 MVPP2_GMAC_FORCE_LINK_DOWN);
3299                         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3300                         mvpp2_egress_enable(port);
3301                         mvpp2_ingress_enable(port);
3302                 } else {
3303                         mvpp2_ingress_disable(port);
3304                         mvpp2_egress_disable(port);
3305                 }
3306         }
3307 }
3308
3309 /* Main RX/TX processing routines */
3310
3311 /* Display more error info */
3312 static void mvpp2_rx_error(struct mvpp2_port *port,
3313                            struct mvpp2_rx_desc *rx_desc)
3314 {
3315         u32 status = rx_desc->status;
3316
3317         switch (status & MVPP2_RXD_ERR_CODE_MASK) {
3318         case MVPP2_RXD_ERR_CRC:
3319                 netdev_err(port->dev, "bad rx status %08x (crc error), size=%d\n",
3320                            status, rx_desc->data_size);
3321                 break;
3322         case MVPP2_RXD_ERR_OVERRUN:
3323                 netdev_err(port->dev, "bad rx status %08x (overrun error), size=%d\n",
3324                            status, rx_desc->data_size);
3325                 break;
3326         case MVPP2_RXD_ERR_RESOURCE:
3327                 netdev_err(port->dev, "bad rx status %08x (resource error), size=%d\n",
3328                            status, rx_desc->data_size);
3329                 break;
3330         }
3331 }
3332
3333 /* Reuse skb if possible, or allocate a new skb and add it to BM pool */
3334 static int mvpp2_rx_refill(struct mvpp2_port *port,
3335                            struct mvpp2_bm_pool *bm_pool,
3336                            u32 bm, u32 phys_addr)
3337 {
3338         mvpp2_pool_refill(port, bm, phys_addr, (unsigned long)phys_addr);
3339         return 0;
3340 }
3341
3342 /* Set hw internals when starting port */
3343 static void mvpp2_start_dev(struct mvpp2_port *port)
3344 {
3345         mvpp2_gmac_max_rx_size_set(port);
3346         mvpp2_txp_max_tx_size_set(port);
3347
3348         mvpp2_port_enable(port);
3349 }
3350
3351 /* Set hw internals when stopping port */
3352 static void mvpp2_stop_dev(struct mvpp2_port *port)
3353 {
3354         /* Stop new packets from arriving to RXQs */
3355         mvpp2_ingress_disable(port);
3356
3357         mvpp2_egress_disable(port);
3358         mvpp2_port_disable(port);
3359 }
3360
3361 static int mvpp2_phy_connect(struct udevice *dev, struct mvpp2_port *port)
3362 {
3363         struct phy_device *phy_dev;
3364
3365         if (!port->init || port->link == 0) {
3366                 phy_dev = phy_connect(port->priv->bus, port->phyaddr, dev,
3367                                       port->phy_interface);
3368                 port->phy_dev = phy_dev;
3369                 if (!phy_dev) {
3370                         netdev_err(port->dev, "cannot connect to phy\n");
3371                         return -ENODEV;
3372                 }
3373                 phy_dev->supported &= PHY_GBIT_FEATURES;
3374                 phy_dev->advertising = phy_dev->supported;
3375
3376                 port->phy_dev = phy_dev;
3377                 port->link    = 0;
3378                 port->duplex  = 0;
3379                 port->speed   = 0;
3380
3381                 phy_config(phy_dev);
3382                 phy_startup(phy_dev);
3383                 if (!phy_dev->link) {
3384                         printf("%s: No link\n", phy_dev->dev->name);
3385                         return -1;
3386                 }
3387
3388                 port->init = 1;
3389         } else {
3390                 mvpp2_egress_enable(port);
3391                 mvpp2_ingress_enable(port);
3392         }
3393
3394         return 0;
3395 }
3396
3397 static int mvpp2_open(struct udevice *dev, struct mvpp2_port *port)
3398 {
3399         unsigned char mac_bcast[ETH_ALEN] = {
3400                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
3401         int err;
3402
3403         err = mvpp2_prs_mac_da_accept(port->priv, port->id, mac_bcast, true);
3404         if (err) {
3405                 netdev_err(dev, "mvpp2_prs_mac_da_accept BC failed\n");
3406                 return err;
3407         }
3408         err = mvpp2_prs_mac_da_accept(port->priv, port->id,
3409                                       port->dev_addr, true);
3410         if (err) {
3411                 netdev_err(dev, "mvpp2_prs_mac_da_accept MC failed\n");
3412                 return err;
3413         }
3414         err = mvpp2_prs_def_flow(port);
3415         if (err) {
3416                 netdev_err(dev, "mvpp2_prs_def_flow failed\n");
3417                 return err;
3418         }
3419
3420         /* Allocate the Rx/Tx queues */
3421         err = mvpp2_setup_rxqs(port);
3422         if (err) {
3423                 netdev_err(port->dev, "cannot allocate Rx queues\n");
3424                 return err;
3425         }
3426
3427         err = mvpp2_setup_txqs(port);
3428         if (err) {
3429                 netdev_err(port->dev, "cannot allocate Tx queues\n");
3430                 return err;
3431         }
3432
3433         err = mvpp2_phy_connect(dev, port);
3434         if (err < 0)
3435                 return err;
3436
3437         mvpp2_link_event(port);
3438
3439         mvpp2_start_dev(port);
3440
3441         return 0;
3442 }
3443
3444 /* No Device ops here in U-Boot */
3445
3446 /* Driver initialization */
3447
3448 static void mvpp2_port_power_up(struct mvpp2_port *port)
3449 {
3450         mvpp2_port_mii_set(port);
3451         mvpp2_port_periodic_xon_disable(port);
3452         mvpp2_port_fc_adv_enable(port);
3453         mvpp2_port_reset(port);
3454 }
3455
3456 /* Initialize port HW */
3457 static int mvpp2_port_init(struct udevice *dev, struct mvpp2_port *port)
3458 {
3459         struct mvpp2 *priv = port->priv;
3460         struct mvpp2_txq_pcpu *txq_pcpu;
3461         int queue, cpu, err;
3462
3463         if (port->first_rxq + rxq_number > MVPP2_RXQ_TOTAL_NUM)
3464                 return -EINVAL;
3465
3466         /* Disable port */
3467         mvpp2_egress_disable(port);
3468         mvpp2_port_disable(port);
3469
3470         port->txqs = devm_kcalloc(dev, txq_number, sizeof(*port->txqs),
3471                                   GFP_KERNEL);
3472         if (!port->txqs)
3473                 return -ENOMEM;
3474
3475         /* Associate physical Tx queues to this port and initialize.
3476          * The mapping is predefined.
3477          */
3478         for (queue = 0; queue < txq_number; queue++) {
3479                 int queue_phy_id = mvpp2_txq_phys(port->id, queue);
3480                 struct mvpp2_tx_queue *txq;
3481
3482                 txq = devm_kzalloc(dev, sizeof(*txq), GFP_KERNEL);
3483                 if (!txq)
3484                         return -ENOMEM;
3485
3486                 txq->pcpu = devm_kzalloc(dev, sizeof(struct mvpp2_txq_pcpu),
3487                                          GFP_KERNEL);
3488                 if (!txq->pcpu)
3489                         return -ENOMEM;
3490
3491                 txq->id = queue_phy_id;
3492                 txq->log_id = queue;
3493                 txq->done_pkts_coal = MVPP2_TXDONE_COAL_PKTS_THRESH;
3494                 for_each_present_cpu(cpu) {
3495                         txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
3496                         txq_pcpu->cpu = cpu;
3497                 }
3498
3499                 port->txqs[queue] = txq;
3500         }
3501
3502         port->rxqs = devm_kcalloc(dev, rxq_number, sizeof(*port->rxqs),
3503                                   GFP_KERNEL);
3504         if (!port->rxqs)
3505                 return -ENOMEM;
3506
3507         /* Allocate and initialize Rx queue for this port */
3508         for (queue = 0; queue < rxq_number; queue++) {
3509                 struct mvpp2_rx_queue *rxq;
3510
3511                 /* Map physical Rx queue to port's logical Rx queue */
3512                 rxq = devm_kzalloc(dev, sizeof(*rxq), GFP_KERNEL);
3513                 if (!rxq)
3514                         return -ENOMEM;
3515                 /* Map this Rx queue to a physical queue */
3516                 rxq->id = port->first_rxq + queue;
3517                 rxq->port = port->id;
3518                 rxq->logic_rxq = queue;
3519
3520                 port->rxqs[queue] = rxq;
3521         }
3522
3523         /* Configure Rx queue group interrupt for this port */
3524         mvpp2_write(priv, MVPP2_ISR_RXQ_GROUP_REG(port->id), CONFIG_MV_ETH_RXQ);
3525
3526         /* Create Rx descriptor rings */
3527         for (queue = 0; queue < rxq_number; queue++) {
3528                 struct mvpp2_rx_queue *rxq = port->rxqs[queue];
3529
3530                 rxq->size = port->rx_ring_size;
3531                 rxq->pkts_coal = MVPP2_RX_COAL_PKTS;
3532                 rxq->time_coal = MVPP2_RX_COAL_USEC;
3533         }
3534
3535         mvpp2_ingress_disable(port);
3536
3537         /* Port default configuration */
3538         mvpp2_defaults_set(port);
3539
3540         /* Port's classifier configuration */
3541         mvpp2_cls_oversize_rxq_set(port);
3542         mvpp2_cls_port_config(port);
3543
3544         /* Provide an initial Rx packet size */
3545         port->pkt_size = MVPP2_RX_PKT_SIZE(PKTSIZE_ALIGN);
3546
3547         /* Initialize pools for swf */
3548         err = mvpp2_swf_bm_pool_init(port);
3549         if (err)
3550                 return err;
3551
3552         return 0;
3553 }
3554
3555 /* Ports initialization */
3556 static int mvpp2_port_probe(struct udevice *dev,
3557                             struct mvpp2_port *port,
3558                             int port_node,
3559                             struct mvpp2 *priv,
3560                             int *next_first_rxq)
3561 {
3562         int phy_node;
3563         u32 id;
3564         u32 phyaddr;
3565         const char *phy_mode_str;
3566         int phy_mode = -1;
3567         int priv_common_regs_num = 2;
3568         int err;
3569
3570         phy_node = fdtdec_lookup_phandle(gd->fdt_blob, port_node, "phy");
3571         if (phy_node < 0) {
3572                 dev_err(&pdev->dev, "missing phy\n");
3573                 return -ENODEV;
3574         }
3575
3576         phy_mode_str = fdt_getprop(gd->fdt_blob, port_node, "phy-mode", NULL);
3577         if (phy_mode_str)
3578                 phy_mode = phy_get_interface_by_name(phy_mode_str);
3579         if (phy_mode == -1) {
3580                 dev_err(&pdev->dev, "incorrect phy mode\n");
3581                 return -EINVAL;
3582         }
3583
3584         id = fdtdec_get_int(gd->fdt_blob, port_node, "port-id", -1);
3585         if (id == -1) {
3586                 dev_err(&pdev->dev, "missing port-id value\n");
3587                 return -EINVAL;
3588         }
3589
3590         phyaddr = fdtdec_get_int(gd->fdt_blob, phy_node, "reg", 0);
3591
3592         port->priv = priv;
3593         port->id = id;
3594         port->first_rxq = *next_first_rxq;
3595         port->phy_node = phy_node;
3596         port->phy_interface = phy_mode;
3597         port->phyaddr = phyaddr;
3598
3599         port->base = (void __iomem *)dev_get_addr_index(dev->parent,
3600                                                         priv_common_regs_num
3601                                                         + id);
3602         if (IS_ERR(port->base))
3603                 return PTR_ERR(port->base);
3604
3605         port->tx_ring_size = MVPP2_MAX_TXD;
3606         port->rx_ring_size = MVPP2_MAX_RXD;
3607
3608         err = mvpp2_port_init(dev, port);
3609         if (err < 0) {
3610                 dev_err(&pdev->dev, "failed to init port %d\n", id);
3611                 return err;
3612         }
3613         mvpp2_port_power_up(port);
3614
3615         /* Increment the first Rx queue number to be used by the next port */
3616         *next_first_rxq += CONFIG_MV_ETH_RXQ;
3617         priv->port_list[id] = port;
3618         return 0;
3619 }
3620
3621 /* Initialize decoding windows */
3622 static void mvpp2_conf_mbus_windows(const struct mbus_dram_target_info *dram,
3623                                     struct mvpp2 *priv)
3624 {
3625         u32 win_enable;
3626         int i;
3627
3628         for (i = 0; i < 6; i++) {
3629                 mvpp2_write(priv, MVPP2_WIN_BASE(i), 0);
3630                 mvpp2_write(priv, MVPP2_WIN_SIZE(i), 0);
3631
3632                 if (i < 4)
3633                         mvpp2_write(priv, MVPP2_WIN_REMAP(i), 0);
3634         }
3635
3636         win_enable = 0;
3637
3638         for (i = 0; i < dram->num_cs; i++) {
3639                 const struct mbus_dram_window *cs = dram->cs + i;
3640
3641                 mvpp2_write(priv, MVPP2_WIN_BASE(i),
3642                             (cs->base & 0xffff0000) | (cs->mbus_attr << 8) |
3643                             dram->mbus_dram_target_id);
3644
3645                 mvpp2_write(priv, MVPP2_WIN_SIZE(i),
3646                             (cs->size - 1) & 0xffff0000);
3647
3648                 win_enable |= (1 << i);
3649         }
3650
3651         mvpp2_write(priv, MVPP2_BASE_ADDR_ENABLE, win_enable);
3652 }
3653
3654 /* Initialize Rx FIFO's */
3655 static void mvpp2_rx_fifo_init(struct mvpp2 *priv)
3656 {
3657         int port;
3658
3659         for (port = 0; port < MVPP2_MAX_PORTS; port++) {
3660                 mvpp2_write(priv, MVPP2_RX_DATA_FIFO_SIZE_REG(port),
3661                             MVPP2_RX_FIFO_PORT_DATA_SIZE);
3662                 mvpp2_write(priv, MVPP2_RX_ATTR_FIFO_SIZE_REG(port),
3663                             MVPP2_RX_FIFO_PORT_ATTR_SIZE);
3664         }
3665
3666         mvpp2_write(priv, MVPP2_RX_MIN_PKT_SIZE_REG,
3667                     MVPP2_RX_FIFO_PORT_MIN_PKT);
3668         mvpp2_write(priv, MVPP2_RX_FIFO_INIT_REG, 0x1);
3669 }
3670
3671 /* Initialize network controller common part HW */
3672 static int mvpp2_init(struct udevice *dev, struct mvpp2 *priv)
3673 {
3674         const struct mbus_dram_target_info *dram_target_info;
3675         int err, i;
3676         u32 val;
3677
3678         /* Checks for hardware constraints (U-Boot uses only one rxq) */
3679         if ((rxq_number > MVPP2_MAX_RXQ) || (txq_number > MVPP2_MAX_TXQ)) {
3680                 dev_err(&pdev->dev, "invalid queue size parameter\n");
3681                 return -EINVAL;
3682         }
3683
3684         /* MBUS windows configuration */
3685         dram_target_info = mvebu_mbus_dram_info();
3686         if (dram_target_info)
3687                 mvpp2_conf_mbus_windows(dram_target_info, priv);
3688
3689         /* Disable HW PHY polling */
3690         val = readl(priv->lms_base + MVPP2_PHY_AN_CFG0_REG);
3691         val |= MVPP2_PHY_AN_STOP_SMI0_MASK;
3692         writel(val, priv->lms_base + MVPP2_PHY_AN_CFG0_REG);
3693
3694         /* Allocate and initialize aggregated TXQs */
3695         priv->aggr_txqs = devm_kcalloc(dev, num_present_cpus(),
3696                                        sizeof(struct mvpp2_tx_queue),
3697                                        GFP_KERNEL);
3698         if (!priv->aggr_txqs)
3699                 return -ENOMEM;
3700
3701         for_each_present_cpu(i) {
3702                 priv->aggr_txqs[i].id = i;
3703                 priv->aggr_txqs[i].size = MVPP2_AGGR_TXQ_SIZE;
3704                 err = mvpp2_aggr_txq_init(dev, &priv->aggr_txqs[i],
3705                                           MVPP2_AGGR_TXQ_SIZE, i, priv);
3706                 if (err < 0)
3707                         return err;
3708         }
3709
3710         /* Rx Fifo Init */
3711         mvpp2_rx_fifo_init(priv);
3712
3713         /* Reset Rx queue group interrupt configuration */
3714         for (i = 0; i < MVPP2_MAX_PORTS; i++)
3715                 mvpp2_write(priv, MVPP2_ISR_RXQ_GROUP_REG(i),
3716                             CONFIG_MV_ETH_RXQ);
3717
3718         writel(MVPP2_EXT_GLOBAL_CTRL_DEFAULT,
3719                priv->lms_base + MVPP2_MNG_EXTENDED_GLOBAL_CTRL_REG);
3720
3721         /* Allow cache snoop when transmiting packets */
3722         mvpp2_write(priv, MVPP2_TX_SNOOP_REG, 0x1);
3723
3724         /* Buffer Manager initialization */
3725         err = mvpp2_bm_init(dev, priv);
3726         if (err < 0)
3727                 return err;
3728
3729         /* Parser default initialization */
3730         err = mvpp2_prs_default_init(dev, priv);
3731         if (err < 0)
3732                 return err;
3733
3734         /* Classifier default initialization */
3735         mvpp2_cls_init(priv);
3736
3737         return 0;
3738 }
3739
3740 /* SMI / MDIO functions */
3741
3742 static int smi_wait_ready(struct mvpp2 *priv)
3743 {
3744         u32 timeout = MVPP2_SMI_TIMEOUT;
3745         u32 smi_reg;
3746
3747         /* wait till the SMI is not busy */
3748         do {
3749                 /* read smi register */
3750                 smi_reg = readl(priv->lms_base + MVPP2_SMI);
3751                 if (timeout-- == 0) {
3752                         printf("Error: SMI busy timeout\n");
3753                         return -EFAULT;
3754                 }
3755         } while (smi_reg & MVPP2_SMI_BUSY);
3756
3757         return 0;
3758 }
3759
3760 /*
3761  * mpp2_mdio_read - miiphy_read callback function.
3762  *
3763  * Returns 16bit phy register value, or 0xffff on error
3764  */
3765 static int mpp2_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
3766 {
3767         struct mvpp2 *priv = bus->priv;
3768         u32 smi_reg;
3769         u32 timeout;
3770
3771         /* check parameters */
3772         if (addr > MVPP2_PHY_ADDR_MASK) {
3773                 printf("Error: Invalid PHY address %d\n", addr);
3774                 return -EFAULT;
3775         }
3776
3777         if (reg > MVPP2_PHY_REG_MASK) {
3778                 printf("Err: Invalid register offset %d\n", reg);
3779                 return -EFAULT;
3780         }
3781
3782         /* wait till the SMI is not busy */
3783         if (smi_wait_ready(priv) < 0)
3784                 return -EFAULT;
3785
3786         /* fill the phy address and regiser offset and read opcode */
3787         smi_reg = (addr << MVPP2_SMI_DEV_ADDR_OFFS)
3788                 | (reg << MVPP2_SMI_REG_ADDR_OFFS)
3789                 | MVPP2_SMI_OPCODE_READ;
3790
3791         /* write the smi register */
3792         writel(smi_reg, priv->lms_base + MVPP2_SMI);
3793
3794         /* wait till read value is ready */
3795         timeout = MVPP2_SMI_TIMEOUT;
3796
3797         do {
3798                 /* read smi register */
3799                 smi_reg = readl(priv->lms_base + MVPP2_SMI);
3800                 if (timeout-- == 0) {
3801                         printf("Err: SMI read ready timeout\n");
3802                         return -EFAULT;
3803                 }
3804         } while (!(smi_reg & MVPP2_SMI_READ_VALID));
3805
3806         /* Wait for the data to update in the SMI register */
3807         for (timeout = 0; timeout < MVPP2_SMI_TIMEOUT; timeout++)
3808                 ;
3809
3810         return readl(priv->lms_base + MVPP2_SMI) & MVPP2_SMI_DATA_MASK;
3811 }
3812
3813 /*
3814  * mpp2_mdio_write - miiphy_write callback function.
3815  *
3816  * Returns 0 if write succeed, -EINVAL on bad parameters
3817  * -ETIME on timeout
3818  */
3819 static int mpp2_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
3820                            u16 value)
3821 {
3822         struct mvpp2 *priv = bus->priv;
3823         u32 smi_reg;
3824
3825         /* check parameters */
3826         if (addr > MVPP2_PHY_ADDR_MASK) {
3827                 printf("Error: Invalid PHY address %d\n", addr);
3828                 return -EFAULT;
3829         }
3830
3831         if (reg > MVPP2_PHY_REG_MASK) {
3832                 printf("Err: Invalid register offset %d\n", reg);
3833                 return -EFAULT;
3834         }
3835
3836         /* wait till the SMI is not busy */
3837         if (smi_wait_ready(priv) < 0)
3838                 return -EFAULT;
3839
3840         /* fill the phy addr and reg offset and write opcode and data */
3841         smi_reg = value << MVPP2_SMI_DATA_OFFS;
3842         smi_reg |= (addr << MVPP2_SMI_DEV_ADDR_OFFS)
3843                 | (reg << MVPP2_SMI_REG_ADDR_OFFS);
3844         smi_reg &= ~MVPP2_SMI_OPCODE_READ;
3845
3846         /* write the smi register */
3847         writel(smi_reg, priv->lms_base + MVPP2_SMI);
3848
3849         return 0;
3850 }
3851
3852 static int mvpp2_recv(struct udevice *dev, int flags, uchar **packetp)
3853 {
3854         struct mvpp2_port *port = dev_get_priv(dev);
3855         struct mvpp2_rx_desc *rx_desc;
3856         struct mvpp2_bm_pool *bm_pool;
3857         dma_addr_t phys_addr;
3858         u32 bm, rx_status;
3859         int pool, rx_bytes, err;
3860         int rx_received;
3861         struct mvpp2_rx_queue *rxq;
3862         u32 cause_rx_tx, cause_rx, cause_misc;
3863         u8 *data;
3864
3865         cause_rx_tx = mvpp2_read(port->priv,
3866                                  MVPP2_ISR_RX_TX_CAUSE_REG(port->id));
3867         cause_rx_tx &= ~MVPP2_CAUSE_TXQ_OCCUP_DESC_ALL_MASK;
3868         cause_misc = cause_rx_tx & MVPP2_CAUSE_MISC_SUM_MASK;
3869         if (!cause_rx_tx && !cause_misc)
3870                 return 0;
3871
3872         cause_rx = cause_rx_tx & MVPP2_CAUSE_RXQ_OCCUP_DESC_ALL_MASK;
3873
3874         /* Process RX packets */
3875         cause_rx |= port->pending_cause_rx;
3876         rxq = mvpp2_get_rx_queue(port, cause_rx);
3877
3878         /* Get number of received packets and clamp the to-do */
3879         rx_received = mvpp2_rxq_received(port, rxq->id);
3880
3881         /* Return if no packets are received */
3882         if (!rx_received)
3883                 return 0;
3884
3885         rx_desc = mvpp2_rxq_next_desc_get(rxq);
3886         rx_status = rx_desc->status;
3887         rx_bytes = rx_desc->data_size - MVPP2_MH_SIZE;
3888         phys_addr = rx_desc->buf_phys_addr;
3889
3890         bm = mvpp2_bm_cookie_build(rx_desc);
3891         pool = mvpp2_bm_cookie_pool_get(bm);
3892         bm_pool = &port->priv->bm_pools[pool];
3893
3894         /* Check if buffer header is used */
3895         if (rx_status & MVPP2_RXD_BUF_HDR)
3896                 return 0;
3897
3898         /* In case of an error, release the requested buffer pointer
3899          * to the Buffer Manager. This request process is controlled
3900          * by the hardware, and the information about the buffer is
3901          * comprised by the RX descriptor.
3902          */
3903         if (rx_status & MVPP2_RXD_ERR_SUMMARY) {
3904                 mvpp2_rx_error(port, rx_desc);
3905                 /* Return the buffer to the pool */
3906                 mvpp2_pool_refill(port, bm, rx_desc->buf_phys_addr,
3907                                   rx_desc->buf_cookie);
3908                 return 0;
3909         }
3910
3911         err = mvpp2_rx_refill(port, bm_pool, bm, phys_addr);
3912         if (err) {
3913                 netdev_err(port->dev, "failed to refill BM pools\n");
3914                 return 0;
3915         }
3916
3917         /* Update Rx queue management counters */
3918         mb();
3919         mvpp2_rxq_status_update(port, rxq->id, 1, 1);
3920
3921         /* give packet to stack - skip on first n bytes */
3922         data = (u8 *)phys_addr + 2 + 32;
3923
3924         if (rx_bytes <= 0)
3925                 return 0;
3926
3927         /*
3928          * No cache invalidation needed here, since the rx_buffer's are
3929          * located in a uncached memory region
3930          */
3931         *packetp = data;
3932
3933         return rx_bytes;
3934 }
3935
3936 /* Drain Txq */
3937 static void mvpp2_txq_drain(struct mvpp2_port *port, struct mvpp2_tx_queue *txq,
3938                             int enable)
3939 {
3940         u32 val;
3941
3942         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3943         val = mvpp2_read(port->priv, MVPP2_TXQ_PREF_BUF_REG);
3944         if (enable)
3945                 val |= MVPP2_TXQ_DRAIN_EN_MASK;
3946         else
3947                 val &= ~MVPP2_TXQ_DRAIN_EN_MASK;
3948         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
3949 }
3950
3951 static int mvpp2_send(struct udevice *dev, void *packet, int length)
3952 {
3953         struct mvpp2_port *port = dev_get_priv(dev);
3954         struct mvpp2_tx_queue *txq, *aggr_txq;
3955         struct mvpp2_tx_desc *tx_desc;
3956         int tx_done;
3957         int timeout;
3958
3959         txq = port->txqs[0];
3960         aggr_txq = &port->priv->aggr_txqs[smp_processor_id()];
3961
3962         /* Get a descriptor for the first part of the packet */
3963         tx_desc = mvpp2_txq_next_desc_get(aggr_txq);
3964         tx_desc->phys_txq = txq->id;
3965         tx_desc->data_size = length;
3966         tx_desc->packet_offset = (unsigned long)packet & MVPP2_TX_DESC_ALIGN;
3967         tx_desc->buf_phys_addr = (unsigned long)packet & ~MVPP2_TX_DESC_ALIGN;
3968         /* First and Last descriptor */
3969         tx_desc->command = MVPP2_TXD_L4_CSUM_NOT | MVPP2_TXD_IP_CSUM_DISABLE
3970                 | MVPP2_TXD_F_DESC | MVPP2_TXD_L_DESC;
3971
3972         /* Flush tx data */
3973         flush_dcache_range((unsigned long)packet,
3974                            (unsigned long)packet + ALIGN(length, PKTALIGN));
3975
3976         /* Enable transmit */
3977         mb();
3978         mvpp2_aggr_txq_pend_desc_add(port, 1);
3979
3980         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3981
3982         timeout = 0;
3983         do {
3984                 if (timeout++ > 10000) {
3985                         printf("timeout: packet not sent from aggregated to phys TXQ\n");
3986                         return 0;
3987                 }
3988                 tx_done = mvpp2_txq_pend_desc_num_get(port, txq);
3989         } while (tx_done);
3990
3991         /* Enable TXQ drain */
3992         mvpp2_txq_drain(port, txq, 1);
3993
3994         timeout = 0;
3995         do {
3996                 if (timeout++ > 10000) {
3997                         printf("timeout: packet not sent\n");
3998                         return 0;
3999                 }
4000                 tx_done = mvpp2_txq_sent_desc_proc(port, txq);
4001         } while (!tx_done);
4002
4003         /* Disable TXQ drain */
4004         mvpp2_txq_drain(port, txq, 0);
4005
4006         return 0;
4007 }
4008
4009 static int mvpp2_start(struct udevice *dev)
4010 {
4011         struct eth_pdata *pdata = dev_get_platdata(dev);
4012         struct mvpp2_port *port = dev_get_priv(dev);
4013
4014         /* Load current MAC address */
4015         memcpy(port->dev_addr, pdata->enetaddr, ETH_ALEN);
4016
4017         /* Reconfigure parser accept the original MAC address */
4018         mvpp2_prs_update_mac_da(port, port->dev_addr);
4019
4020         mvpp2_port_power_up(port);
4021
4022         mvpp2_open(dev, port);
4023
4024         return 0;
4025 }
4026
4027 static void mvpp2_stop(struct udevice *dev)
4028 {
4029         struct mvpp2_port *port = dev_get_priv(dev);
4030
4031         mvpp2_stop_dev(port);
4032         mvpp2_cleanup_rxqs(port);
4033         mvpp2_cleanup_txqs(port);
4034 }
4035
4036 static int mvpp2_probe(struct udevice *dev)
4037 {
4038         struct mvpp2_port *port = dev_get_priv(dev);
4039         struct mvpp2 *priv = dev_get_priv(dev->parent);
4040         int err;
4041
4042         /* Initialize network controller */
4043         err = mvpp2_init(dev, priv);
4044         if (err < 0) {
4045                 dev_err(&pdev->dev, "failed to initialize controller\n");
4046                 return err;
4047         }
4048
4049         return mvpp2_port_probe(dev, port, dev_of_offset(dev), priv,
4050                                 &buffer_loc.first_rxq);
4051 }
4052
4053 static const struct eth_ops mvpp2_ops = {
4054         .start          = mvpp2_start,
4055         .send           = mvpp2_send,
4056         .recv           = mvpp2_recv,
4057         .stop           = mvpp2_stop,
4058 };
4059
4060 static struct driver mvpp2_driver = {
4061         .name   = "mvpp2",
4062         .id     = UCLASS_ETH,
4063         .probe  = mvpp2_probe,
4064         .ops    = &mvpp2_ops,
4065         .priv_auto_alloc_size = sizeof(struct mvpp2_port),
4066         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
4067 };
4068
4069 /*
4070  * Use a MISC device to bind the n instances (child nodes) of the
4071  * network base controller in UCLASS_ETH.
4072  */
4073 static int mvpp2_base_probe(struct udevice *dev)
4074 {
4075         struct mvpp2 *priv = dev_get_priv(dev);
4076         struct mii_dev *bus;
4077         void *bd_space;
4078         u32 size = 0;
4079         int i;
4080
4081         /*
4082          * U-Boot special buffer handling:
4083          *
4084          * Allocate buffer area for descs and rx_buffers. This is only
4085          * done once for all interfaces. As only one interface can
4086          * be active. Make this area DMA-safe by disabling the D-cache
4087          */
4088
4089         /* Align buffer area for descs and rx_buffers to 1MiB */
4090         bd_space = memalign(1 << MMU_SECTION_SHIFT, BD_SPACE);
4091         mmu_set_region_dcache_behaviour((unsigned long)bd_space,
4092                                         BD_SPACE, DCACHE_OFF);
4093
4094         buffer_loc.aggr_tx_descs = (struct mvpp2_tx_desc *)bd_space;
4095         size += MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE;
4096
4097         buffer_loc.tx_descs =
4098                 (struct mvpp2_tx_desc *)((unsigned long)bd_space + size);
4099         size += MVPP2_MAX_TXD * MVPP2_DESC_ALIGNED_SIZE;
4100
4101         buffer_loc.rx_descs =
4102                 (struct mvpp2_rx_desc *)((unsigned long)bd_space + size);
4103         size += MVPP2_MAX_RXD * MVPP2_DESC_ALIGNED_SIZE;
4104
4105         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
4106                 buffer_loc.bm_pool[i] =
4107                         (unsigned long *)((unsigned long)bd_space + size);
4108                 size += MVPP2_BM_POOL_SIZE_MAX * sizeof(u32);
4109         }
4110
4111         for (i = 0; i < MVPP2_BM_LONG_BUF_NUM; i++) {
4112                 buffer_loc.rx_buffer[i] =
4113                         (unsigned long *)((unsigned long)bd_space + size);
4114                 size += RX_BUFFER_SIZE;
4115         }
4116
4117         /* Save base addresses for later use */
4118         priv->base = (void *)dev_get_addr_index(dev, 0);
4119         if (IS_ERR(priv->base))
4120                 return PTR_ERR(priv->base);
4121
4122         priv->lms_base = (void *)dev_get_addr_index(dev, 1);
4123         if (IS_ERR(priv->lms_base))
4124                 return PTR_ERR(priv->lms_base);
4125
4126         /* Finally create and register the MDIO bus driver */
4127         bus = mdio_alloc();
4128         if (!bus) {
4129                 printf("Failed to allocate MDIO bus\n");
4130                 return -ENOMEM;
4131         }
4132
4133         bus->read = mpp2_mdio_read;
4134         bus->write = mpp2_mdio_write;
4135         snprintf(bus->name, sizeof(bus->name), dev->name);
4136         bus->priv = (void *)priv;
4137         priv->bus = bus;
4138
4139         return mdio_register(bus);
4140 }
4141
4142 static int mvpp2_base_bind(struct udevice *parent)
4143 {
4144         const void *blob = gd->fdt_blob;
4145         int node = dev_of_offset(parent);
4146         struct uclass_driver *drv;
4147         struct udevice *dev;
4148         struct eth_pdata *plat;
4149         char *name;
4150         int subnode;
4151         u32 id;
4152
4153         /* Lookup eth driver */
4154         drv = lists_uclass_lookup(UCLASS_ETH);
4155         if (!drv) {
4156                 puts("Cannot find eth driver\n");
4157                 return -ENOENT;
4158         }
4159
4160         fdt_for_each_subnode(subnode, blob, node) {
4161                 /* Skip disabled ports */
4162                 if (!fdtdec_get_is_enabled(blob, subnode))
4163                         continue;
4164
4165                 plat = calloc(1, sizeof(*plat));
4166                 if (!plat)
4167                         return -ENOMEM;
4168
4169                 id = fdtdec_get_int(blob, subnode, "port-id", -1);
4170
4171                 name = calloc(1, 16);
4172                 sprintf(name, "mvpp2-%d", id);
4173
4174                 /* Create child device UCLASS_ETH and bind it */
4175                 device_bind(parent, &mvpp2_driver, name, plat, subnode, &dev);
4176                 dev_set_of_offset(dev, subnode);
4177         }
4178
4179         return 0;
4180 }
4181
4182 static const struct udevice_id mvpp2_ids[] = {
4183         { .compatible = "marvell,armada-375-pp2" },
4184         { }
4185 };
4186
4187 U_BOOT_DRIVER(mvpp2_base) = {
4188         .name   = "mvpp2_base",
4189         .id     = UCLASS_MISC,
4190         .of_match = mvpp2_ids,
4191         .bind   = mvpp2_base_bind,
4192         .probe  = mvpp2_base_probe,
4193         .priv_auto_alloc_size = sizeof(struct mvpp2),
4194 };