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_dma_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_dma_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_dma;
 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_dma;
 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 DMA base address */
 964         dma_addr_t dma_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_dma_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->dma_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->dma_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_dma_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_dma_addr);
2375 }
2376
2377 /* Refill BM pool */
2378 static void mvpp2_pool_refill(struct mvpp2_port *port, u32 bm,
2379                               dma_addr_t dma_addr,
2380                               u32 cookie)
2381 {
2382         int pool = mvpp2_bm_cookie_pool_get(bm);
2383
2384         mvpp2_bm_pool_put(port, pool, dma_addr, cookie);
2385 }
2386
2387 /* Allocate buffers for the pool */
2388 static int mvpp2_bm_bufs_add(struct mvpp2_port *port,
2389                              struct mvpp2_bm_pool *bm_pool, int buf_num)
2390 {
2391         int i;
2392
2393         if (buf_num < 0 ||
2394             (buf_num + bm_pool->buf_num > bm_pool->size)) {
2395                 netdev_err(port->dev,
2396                            "cannot allocate %d buffers for pool %d\n",
2397                            buf_num, bm_pool->id);
2398                 return 0;
2399         }
2400
2401         for (i = 0; i < buf_num; i++) {
2402                 mvpp2_bm_pool_put(port, bm_pool->id,
2403                                   (dma_addr_t)buffer_loc.rx_buffer[i],
2404                                   (unsigned long)buffer_loc.rx_buffer[i]);
2405
2406         }
2407
2408         /* Update BM driver with number of buffers added to pool */
2409         bm_pool->buf_num += i;
2410         bm_pool->in_use_thresh = bm_pool->buf_num / 4;
2411
2412         return i;
2413 }
2414
2415 /* Notify the driver that BM pool is being used as specific type and return the
2416  * pool pointer on success
2417  */
2418 static struct mvpp2_bm_pool *
2419 mvpp2_bm_pool_use(struct mvpp2_port *port, int pool, enum mvpp2_bm_type type,
2420                   int pkt_size)
2421 {
2422         struct mvpp2_bm_pool *new_pool = &port->priv->bm_pools[pool];
2423         int num;
2424
2425         if (new_pool->type != MVPP2_BM_FREE && new_pool->type != type) {
2426                 netdev_err(port->dev, "mixing pool types is forbidden\n");
2427                 return NULL;
2428         }
2429
2430         if (new_pool->type == MVPP2_BM_FREE)
2431                 new_pool->type = type;
2432
2433         /* Allocate buffers in case BM pool is used as long pool, but packet
2434          * size doesn't match MTU or BM pool hasn't being used yet
2435          */
2436         if (((type == MVPP2_BM_SWF_LONG) && (pkt_size > new_pool->pkt_size)) ||
2437             (new_pool->pkt_size == 0)) {
2438                 int pkts_num;
2439
2440                 /* Set default buffer number or free all the buffers in case
2441                  * the pool is not empty
2442                  */
2443                 pkts_num = new_pool->buf_num;
2444                 if (pkts_num == 0)
2445                         pkts_num = type == MVPP2_BM_SWF_LONG ?
2446                                    MVPP2_BM_LONG_BUF_NUM :
2447                                    MVPP2_BM_SHORT_BUF_NUM;
2448                 else
2449                         mvpp2_bm_bufs_free(NULL,
2450                                            port->priv, new_pool);
2451
2452                 new_pool->pkt_size = pkt_size;
2453
2454                 /* Allocate buffers for this pool */
2455                 num = mvpp2_bm_bufs_add(port, new_pool, pkts_num);
2456                 if (num != pkts_num) {
2457                         dev_err(dev, "pool %d: %d of %d allocated\n",
2458                                 new_pool->id, num, pkts_num);
2459                         return NULL;
2460                 }
2461         }
2462
2463         mvpp2_bm_pool_bufsize_set(port->priv, new_pool,
2464                                   MVPP2_RX_BUF_SIZE(new_pool->pkt_size));
2465
2466         return new_pool;
2467 }
2468
2469 /* Initialize pools for swf */
2470 static int mvpp2_swf_bm_pool_init(struct mvpp2_port *port)
2471 {
2472         int rxq;
2473
2474         if (!port->pool_long) {
2475                 port->pool_long =
2476                        mvpp2_bm_pool_use(port, MVPP2_BM_SWF_LONG_POOL(port->id),
2477                                          MVPP2_BM_SWF_LONG,
2478                                          port->pkt_size);
2479                 if (!port->pool_long)
2480                         return -ENOMEM;
2481
2482                 port->pool_long->port_map |= (1 << port->id);
2483
2484                 for (rxq = 0; rxq < rxq_number; rxq++)
2485                         mvpp2_rxq_long_pool_set(port, rxq, port->pool_long->id);
2486         }
2487
2488         return 0;
2489 }
2490
2491 /* Port configuration routines */
2492
2493 static void mvpp2_port_mii_set(struct mvpp2_port *port)
2494 {
2495         u32 val;
2496
2497         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
2498
2499         switch (port->phy_interface) {
2500         case PHY_INTERFACE_MODE_SGMII:
2501                 val |= MVPP2_GMAC_INBAND_AN_MASK;
2502                 break;
2503         case PHY_INTERFACE_MODE_RGMII:
2504                 val |= MVPP2_GMAC_PORT_RGMII_MASK;
2505         default:
2506                 val &= ~MVPP2_GMAC_PCS_ENABLE_MASK;
2507         }
2508
2509         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2510 }
2511
2512 static void mvpp2_port_fc_adv_enable(struct mvpp2_port *port)
2513 {
2514         u32 val;
2515
2516         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
2517         val |= MVPP2_GMAC_FC_ADV_EN;
2518         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
2519 }
2520
2521 static void mvpp2_port_enable(struct mvpp2_port *port)
2522 {
2523         u32 val;
2524
2525         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2526         val |= MVPP2_GMAC_PORT_EN_MASK;
2527         val |= MVPP2_GMAC_MIB_CNTR_EN_MASK;
2528         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2529 }
2530
2531 static void mvpp2_port_disable(struct mvpp2_port *port)
2532 {
2533         u32 val;
2534
2535         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2536         val &= ~(MVPP2_GMAC_PORT_EN_MASK);
2537         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2538 }
2539
2540 /* Set IEEE 802.3x Flow Control Xon Packet Transmission Mode */
2541 static void mvpp2_port_periodic_xon_disable(struct mvpp2_port *port)
2542 {
2543         u32 val;
2544
2545         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG) &
2546                     ~MVPP2_GMAC_PERIODIC_XON_EN_MASK;
2547         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
2548 }
2549
2550 /* Configure loopback port */
2551 static void mvpp2_port_loopback_set(struct mvpp2_port *port)
2552 {
2553         u32 val;
2554
2555         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG);
2556
2557         if (port->speed == 1000)
2558                 val |= MVPP2_GMAC_GMII_LB_EN_MASK;
2559         else
2560                 val &= ~MVPP2_GMAC_GMII_LB_EN_MASK;
2561
2562         if (port->phy_interface == PHY_INTERFACE_MODE_SGMII)
2563                 val |= MVPP2_GMAC_PCS_LB_EN_MASK;
2564         else
2565                 val &= ~MVPP2_GMAC_PCS_LB_EN_MASK;
2566
2567         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
2568 }
2569
2570 static void mvpp2_port_reset(struct mvpp2_port *port)
2571 {
2572         u32 val;
2573
2574         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG) &
2575                     ~MVPP2_GMAC_PORT_RESET_MASK;
2576         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2577
2578         while (readl(port->base + MVPP2_GMAC_CTRL_2_REG) &
2579                MVPP2_GMAC_PORT_RESET_MASK)
2580                 continue;
2581 }
2582
2583 /* Change maximum receive size of the port */
2584 static inline void mvpp2_gmac_max_rx_size_set(struct mvpp2_port *port)
2585 {
2586         u32 val;
2587
2588         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2589         val &= ~MVPP2_GMAC_MAX_RX_SIZE_MASK;
2590         val |= (((port->pkt_size - MVPP2_MH_SIZE) / 2) <<
2591                     MVPP2_GMAC_MAX_RX_SIZE_OFFS);
2592         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2593 }
2594
2595 /* Set defaults to the MVPP2 port */
2596 static void mvpp2_defaults_set(struct mvpp2_port *port)
2597 {
2598         int tx_port_num, val, queue, ptxq, lrxq;
2599
2600         /* Configure port to loopback if needed */
2601         if (port->flags & MVPP2_F_LOOPBACK)
2602                 mvpp2_port_loopback_set(port);
2603
2604         /* Update TX FIFO MIN Threshold */
2605         val = readl(port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
2606         val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK;
2607         /* Min. TX threshold must be less than minimal packet length */
2608         val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(64 - 4 - 2);
2609         writel(val, port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
2610
2611         /* Disable Legacy WRR, Disable EJP, Release from reset */
2612         tx_port_num = mvpp2_egress_port(port);
2613         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG,
2614                     tx_port_num);
2615         mvpp2_write(port->priv, MVPP2_TXP_SCHED_CMD_1_REG, 0);
2616
2617         /* Close bandwidth for all queues */
2618         for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) {
2619                 ptxq = mvpp2_txq_phys(port->id, queue);
2620                 mvpp2_write(port->priv,
2621                             MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(ptxq), 0);
2622         }
2623
2624         /* Set refill period to 1 usec, refill tokens
2625          * and bucket size to maximum
2626          */
2627         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PERIOD_REG, 0xc8);
2628         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_REFILL_REG);
2629         val &= ~MVPP2_TXP_REFILL_PERIOD_ALL_MASK;
2630         val |= MVPP2_TXP_REFILL_PERIOD_MASK(1);
2631         val |= MVPP2_TXP_REFILL_TOKENS_ALL_MASK;
2632         mvpp2_write(port->priv, MVPP2_TXP_SCHED_REFILL_REG, val);
2633         val = MVPP2_TXP_TOKEN_SIZE_MAX;
2634         mvpp2_write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val);
2635
2636         /* Set MaximumLowLatencyPacketSize value to 256 */
2637         mvpp2_write(port->priv, MVPP2_RX_CTRL_REG(port->id),
2638                     MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK |
2639                     MVPP2_RX_LOW_LATENCY_PKT_SIZE(256));
2640
2641         /* Enable Rx cache snoop */
2642         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
2643                 queue = port->rxqs[lrxq]->id;
2644                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
2645                 val |= MVPP2_SNOOP_PKT_SIZE_MASK |
2646                            MVPP2_SNOOP_BUF_HDR_MASK;
2647                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
2648         }
2649 }
2650
2651 /* Enable/disable receiving packets */
2652 static void mvpp2_ingress_enable(struct mvpp2_port *port)
2653 {
2654         u32 val;
2655         int lrxq, queue;
2656
2657         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
2658                 queue = port->rxqs[lrxq]->id;
2659                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
2660                 val &= ~MVPP2_RXQ_DISABLE_MASK;
2661                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
2662         }
2663 }
2664
2665 static void mvpp2_ingress_disable(struct mvpp2_port *port)
2666 {
2667         u32 val;
2668         int lrxq, queue;
2669
2670         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
2671                 queue = port->rxqs[lrxq]->id;
2672                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
2673                 val |= MVPP2_RXQ_DISABLE_MASK;
2674                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
2675         }
2676 }
2677
2678 /* Enable transmit via physical egress queue
2679  * - HW starts take descriptors from DRAM
2680  */
2681 static void mvpp2_egress_enable(struct mvpp2_port *port)
2682 {
2683         u32 qmap;
2684         int queue;
2685         int tx_port_num = mvpp2_egress_port(port);
2686
2687         /* Enable all initialized TXs. */
2688         qmap = 0;
2689         for (queue = 0; queue < txq_number; queue++) {
2690                 struct mvpp2_tx_queue *txq = port->txqs[queue];
2691
2692                 if (txq->descs != NULL)
2693                         qmap |= (1 << queue);
2694         }
2695
2696         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
2697         mvpp2_write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG, qmap);
2698 }
2699
2700 /* Disable transmit via physical egress queue
2701  * - HW doesn't take descriptors from DRAM
2702  */
2703 static void mvpp2_egress_disable(struct mvpp2_port *port)
2704 {
2705         u32 reg_data;
2706         int delay;
2707         int tx_port_num = mvpp2_egress_port(port);
2708
2709         /* Issue stop command for active channels only */
2710         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
2711         reg_data = (mvpp2_read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG)) &
2712                     MVPP2_TXP_SCHED_ENQ_MASK;
2713         if (reg_data != 0)
2714                 mvpp2_write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG,
2715                             (reg_data << MVPP2_TXP_SCHED_DISQ_OFFSET));
2716
2717         /* Wait for all Tx activity to terminate. */
2718         delay = 0;
2719         do {
2720                 if (delay >= MVPP2_TX_DISABLE_TIMEOUT_MSEC) {
2721                         netdev_warn(port->dev,
2722                                     "Tx stop timed out, status=0x%08x\n",
2723                                     reg_data);
2724                         break;
2725                 }
2726                 mdelay(1);
2727                 delay++;
2728
2729                 /* Check port TX Command register that all
2730                  * Tx queues are stopped
2731                  */
2732                 reg_data = mvpp2_read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG);
2733         } while (reg_data & MVPP2_TXP_SCHED_ENQ_MASK);
2734 }
2735
2736 /* Rx descriptors helper methods */
2737
2738 /* Get number of Rx descriptors occupied by received packets */
2739 static inline int
2740 mvpp2_rxq_received(struct mvpp2_port *port, int rxq_id)
2741 {
2742         u32 val = mvpp2_read(port->priv, MVPP2_RXQ_STATUS_REG(rxq_id));
2743
2744         return val & MVPP2_RXQ_OCCUPIED_MASK;
2745 }
2746
2747 /* Update Rx queue status with the number of occupied and available
2748  * Rx descriptor slots.
2749  */
2750 static inline void
2751 mvpp2_rxq_status_update(struct mvpp2_port *port, int rxq_id,
2752                         int used_count, int free_count)
2753 {
2754         /* Decrement the number of used descriptors and increment count
2755          * increment the number of free descriptors.
2756          */
2757         u32 val = used_count | (free_count << MVPP2_RXQ_NUM_NEW_OFFSET);
2758
2759         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_UPDATE_REG(rxq_id), val);
2760 }
2761
2762 /* Get pointer to next RX descriptor to be processed by SW */
2763 static inline struct mvpp2_rx_desc *
2764 mvpp2_rxq_next_desc_get(struct mvpp2_rx_queue *rxq)
2765 {
2766         int rx_desc = rxq->next_desc_to_proc;
2767
2768         rxq->next_desc_to_proc = MVPP2_QUEUE_NEXT_DESC(rxq, rx_desc);
2769         prefetch(rxq->descs + rxq->next_desc_to_proc);
2770         return rxq->descs + rx_desc;
2771 }
2772
2773 /* Set rx queue offset */
2774 static void mvpp2_rxq_offset_set(struct mvpp2_port *port,
2775                                  int prxq, int offset)
2776 {
2777         u32 val;
2778
2779         /* Convert offset from bytes to units of 32 bytes */
2780         offset = offset >> 5;
2781
2782         val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq));
2783         val &= ~MVPP2_RXQ_PACKET_OFFSET_MASK;
2784
2785         /* Offset is in */
2786         val |= ((offset << MVPP2_RXQ_PACKET_OFFSET_OFFS) &
2787                     MVPP2_RXQ_PACKET_OFFSET_MASK);
2788
2789         mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val);
2790 }
2791
2792 /* Obtain BM cookie information from descriptor */
2793 static u32 mvpp2_bm_cookie_build(struct mvpp2_rx_desc *rx_desc)
2794 {
2795         int pool = (rx_desc->status & MVPP2_RXD_BM_POOL_ID_MASK) >>
2796                    MVPP2_RXD_BM_POOL_ID_OFFS;
2797         int cpu = smp_processor_id();
2798
2799         return ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS) |
2800                ((cpu & 0xFF) << MVPP2_BM_COOKIE_CPU_OFFS);
2801 }
2802
2803 /* Tx descriptors helper methods */
2804
2805 /* Get number of Tx descriptors waiting to be transmitted by HW */
2806 static int mvpp2_txq_pend_desc_num_get(struct mvpp2_port *port,
2807                                        struct mvpp2_tx_queue *txq)
2808 {
2809         u32 val;
2810
2811         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
2812         val = mvpp2_read(port->priv, MVPP2_TXQ_PENDING_REG);
2813
2814         return val & MVPP2_TXQ_PENDING_MASK;
2815 }
2816
2817 /* Get pointer to next Tx descriptor to be processed (send) by HW */
2818 static struct mvpp2_tx_desc *
2819 mvpp2_txq_next_desc_get(struct mvpp2_tx_queue *txq)
2820 {
2821         int tx_desc = txq->next_desc_to_proc;
2822
2823         txq->next_desc_to_proc = MVPP2_QUEUE_NEXT_DESC(txq, tx_desc);
2824         return txq->descs + tx_desc;
2825 }
2826
2827 /* Update HW with number of aggregated Tx descriptors to be sent */
2828 static void mvpp2_aggr_txq_pend_desc_add(struct mvpp2_port *port, int pending)
2829 {
2830         /* aggregated access - relevant TXQ number is written in TX desc */
2831         mvpp2_write(port->priv, MVPP2_AGGR_TXQ_UPDATE_REG, pending);
2832 }
2833
2834 /* Get number of sent descriptors and decrement counter.
2835  * The number of sent descriptors is returned.
2836  * Per-CPU access
2837  */
2838 static inline int mvpp2_txq_sent_desc_proc(struct mvpp2_port *port,
2839                                            struct mvpp2_tx_queue *txq)
2840 {
2841         u32 val;
2842
2843         /* Reading status reg resets transmitted descriptor counter */
2844         val = mvpp2_read(port->priv, MVPP2_TXQ_SENT_REG(txq->id));
2845
2846         return (val & MVPP2_TRANSMITTED_COUNT_MASK) >>
2847                 MVPP2_TRANSMITTED_COUNT_OFFSET;
2848 }
2849
2850 static void mvpp2_txq_sent_counter_clear(void *arg)
2851 {
2852         struct mvpp2_port *port = arg;
2853         int queue;
2854
2855         for (queue = 0; queue < txq_number; queue++) {
2856                 int id = port->txqs[queue]->id;
2857
2858                 mvpp2_read(port->priv, MVPP2_TXQ_SENT_REG(id));
2859         }
2860 }
2861
2862 /* Set max sizes for Tx queues */
2863 static void mvpp2_txp_max_tx_size_set(struct mvpp2_port *port)
2864 {
2865         u32     val, size, mtu;
2866         int     txq, tx_port_num;
2867
2868         mtu = port->pkt_size * 8;
2869         if (mtu > MVPP2_TXP_MTU_MAX)
2870                 mtu = MVPP2_TXP_MTU_MAX;
2871
2872         /* WA for wrong Token bucket update: Set MTU value = 3*real MTU value */
2873         mtu = 3 * mtu;
2874
2875         /* Indirect access to registers */
2876         tx_port_num = mvpp2_egress_port(port);
2877         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
2878
2879         /* Set MTU */
2880         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_MTU_REG);
2881         val &= ~MVPP2_TXP_MTU_MAX;
2882         val |= mtu;
2883         mvpp2_write(port->priv, MVPP2_TXP_SCHED_MTU_REG, val);
2884
2885         /* TXP token size and all TXQs token size must be larger that MTU */
2886         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG);
2887         size = val & MVPP2_TXP_TOKEN_SIZE_MAX;
2888         if (size < mtu) {
2889                 size = mtu;
2890                 val &= ~MVPP2_TXP_TOKEN_SIZE_MAX;
2891                 val |= size;
2892                 mvpp2_write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val);
2893         }
2894
2895         for (txq = 0; txq < txq_number; txq++) {
2896                 val = mvpp2_read(port->priv,
2897                                  MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq));
2898                 size = val & MVPP2_TXQ_TOKEN_SIZE_MAX;
2899
2900                 if (size < mtu) {
2901                         size = mtu;
2902                         val &= ~MVPP2_TXQ_TOKEN_SIZE_MAX;
2903                         val |= size;
2904                         mvpp2_write(port->priv,
2905                                     MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq),
2906                                     val);
2907                 }
2908         }
2909 }
2910
2911 /* Free Tx queue skbuffs */
2912 static void mvpp2_txq_bufs_free(struct mvpp2_port *port,
2913                                 struct mvpp2_tx_queue *txq,
2914                                 struct mvpp2_txq_pcpu *txq_pcpu, int num)
2915 {
2916         int i;
2917
2918         for (i = 0; i < num; i++)
2919                 mvpp2_txq_inc_get(txq_pcpu);
2920 }
2921
2922 static inline struct mvpp2_rx_queue *mvpp2_get_rx_queue(struct mvpp2_port *port,
2923                                                         u32 cause)
2924 {
2925         int queue = fls(cause) - 1;
2926
2927         return port->rxqs[queue];
2928 }
2929
2930 static inline struct mvpp2_tx_queue *mvpp2_get_tx_queue(struct mvpp2_port *port,
2931                                                         u32 cause)
2932 {
2933         int queue = fls(cause) - 1;
2934
2935         return port->txqs[queue];
2936 }
2937
2938 /* Rx/Tx queue initialization/cleanup methods */
2939
2940 /* Allocate and initialize descriptors for aggr TXQ */
2941 static int mvpp2_aggr_txq_init(struct udevice *dev,
2942                                struct mvpp2_tx_queue *aggr_txq,
2943                                int desc_num, int cpu,
2944                                struct mvpp2 *priv)
2945 {
2946         /* Allocate memory for TX descriptors */
2947         aggr_txq->descs = buffer_loc.aggr_tx_descs;
2948         aggr_txq->descs_dma = (dma_addr_t)buffer_loc.aggr_tx_descs;
2949         if (!aggr_txq->descs)
2950                 return -ENOMEM;
2951
2952         /* Make sure descriptor address is cache line size aligned  */
2953         BUG_ON(aggr_txq->descs !=
2954                PTR_ALIGN(aggr_txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
2955
2956         aggr_txq->last_desc = aggr_txq->size - 1;
2957
2958         /* Aggr TXQ no reset WA */
2959         aggr_txq->next_desc_to_proc = mvpp2_read(priv,
2960                                                  MVPP2_AGGR_TXQ_INDEX_REG(cpu));
2961
2962         /* Set Tx descriptors queue starting address */
2963         /* indirect access */
2964         mvpp2_write(priv, MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu),
2965                     aggr_txq->descs_dma);
2966         mvpp2_write(priv, MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu), desc_num);
2967
2968         return 0;
2969 }
2970
2971 /* Create a specified Rx queue */
2972 static int mvpp2_rxq_init(struct mvpp2_port *port,
2973                           struct mvpp2_rx_queue *rxq)
2974
2975 {
2976         rxq->size = port->rx_ring_size;
2977
2978         /* Allocate memory for RX descriptors */
2979         rxq->descs = buffer_loc.rx_descs;
2980         rxq->descs_dma = (dma_addr_t)buffer_loc.rx_descs;
2981         if (!rxq->descs)
2982                 return -ENOMEM;
2983
2984         BUG_ON(rxq->descs !=
2985                PTR_ALIGN(rxq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
2986
2987         rxq->last_desc = rxq->size - 1;
2988
2989         /* Zero occupied and non-occupied counters - direct access */
2990         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
2991
2992         /* Set Rx descriptors queue starting address - indirect access */
2993         mvpp2_write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id);
2994         mvpp2_write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, rxq->descs_dma);
2995         mvpp2_write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, rxq->size);
2996         mvpp2_write(port->priv, MVPP2_RXQ_INDEX_REG, 0);
2997
2998         /* Set Offset */
2999         mvpp2_rxq_offset_set(port, rxq->id, NET_SKB_PAD);
3000
3001         /* Add number of descriptors ready for receiving packets */
3002         mvpp2_rxq_status_update(port, rxq->id, 0, rxq->size);
3003
3004         return 0;
3005 }
3006
3007 /* Push packets received by the RXQ to BM pool */
3008 static void mvpp2_rxq_drop_pkts(struct mvpp2_port *port,
3009                                 struct mvpp2_rx_queue *rxq)
3010 {
3011         int rx_received, i;
3012
3013         rx_received = mvpp2_rxq_received(port, rxq->id);
3014         if (!rx_received)
3015                 return;
3016
3017         for (i = 0; i < rx_received; i++) {
3018                 struct mvpp2_rx_desc *rx_desc = mvpp2_rxq_next_desc_get(rxq);
3019                 u32 bm = mvpp2_bm_cookie_build(rx_desc);
3020
3021                 mvpp2_pool_refill(port, bm, rx_desc->buf_dma_addr,
3022                                   rx_desc->buf_cookie);
3023         }
3024         mvpp2_rxq_status_update(port, rxq->id, rx_received, rx_received);
3025 }
3026
3027 /* Cleanup Rx queue */
3028 static void mvpp2_rxq_deinit(struct mvpp2_port *port,
3029                              struct mvpp2_rx_queue *rxq)
3030 {
3031         mvpp2_rxq_drop_pkts(port, rxq);
3032
3033         rxq->descs             = NULL;
3034         rxq->last_desc         = 0;
3035         rxq->next_desc_to_proc = 0;
3036         rxq->descs_dma         = 0;
3037
3038         /* Clear Rx descriptors queue starting address and size;
3039          * free descriptor number
3040          */
3041         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
3042         mvpp2_write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id);
3043         mvpp2_write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, 0);
3044         mvpp2_write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, 0);
3045 }
3046
3047 /* Create and initialize a Tx queue */
3048 static int mvpp2_txq_init(struct mvpp2_port *port,
3049                           struct mvpp2_tx_queue *txq)
3050 {
3051         u32 val;
3052         int cpu, desc, desc_per_txq, tx_port_num;
3053         struct mvpp2_txq_pcpu *txq_pcpu;
3054
3055         txq->size = port->tx_ring_size;
3056
3057         /* Allocate memory for Tx descriptors */
3058         txq->descs = buffer_loc.tx_descs;
3059         txq->descs_dma = (dma_addr_t)buffer_loc.tx_descs;
3060         if (!txq->descs)
3061                 return -ENOMEM;
3062
3063         /* Make sure descriptor address is cache line size aligned  */
3064         BUG_ON(txq->descs !=
3065                PTR_ALIGN(txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
3066
3067         txq->last_desc = txq->size - 1;
3068
3069         /* Set Tx descriptors queue starting address - indirect access */
3070         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3071         mvpp2_write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, txq->descs_dma);
3072         mvpp2_write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, txq->size &
3073                                              MVPP2_TXQ_DESC_SIZE_MASK);
3074         mvpp2_write(port->priv, MVPP2_TXQ_INDEX_REG, 0);
3075         mvpp2_write(port->priv, MVPP2_TXQ_RSVD_CLR_REG,
3076                     txq->id << MVPP2_TXQ_RSVD_CLR_OFFSET);
3077         val = mvpp2_read(port->priv, MVPP2_TXQ_PENDING_REG);
3078         val &= ~MVPP2_TXQ_PENDING_MASK;
3079         mvpp2_write(port->priv, MVPP2_TXQ_PENDING_REG, val);
3080
3081         /* Calculate base address in prefetch buffer. We reserve 16 descriptors
3082          * for each existing TXQ.
3083          * TCONTS for PON port must be continuous from 0 to MVPP2_MAX_TCONT
3084          * GBE ports assumed to be continious from 0 to MVPP2_MAX_PORTS
3085          */
3086         desc_per_txq = 16;
3087         desc = (port->id * MVPP2_MAX_TXQ * desc_per_txq) +
3088                (txq->log_id * desc_per_txq);
3089
3090         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG,
3091                     MVPP2_PREF_BUF_PTR(desc) | MVPP2_PREF_BUF_SIZE_16 |
3092                     MVPP2_PREF_BUF_THRESH(desc_per_txq/2));
3093
3094         /* WRR / EJP configuration - indirect access */
3095         tx_port_num = mvpp2_egress_port(port);
3096         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
3097
3098         val = mvpp2_read(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->log_id));
3099         val &= ~MVPP2_TXQ_REFILL_PERIOD_ALL_MASK;
3100         val |= MVPP2_TXQ_REFILL_PERIOD_MASK(1);
3101         val |= MVPP2_TXQ_REFILL_TOKENS_ALL_MASK;
3102         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->log_id), val);
3103
3104         val = MVPP2_TXQ_TOKEN_SIZE_MAX;
3105         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq->log_id),
3106                     val);
3107
3108         for_each_present_cpu(cpu) {
3109                 txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
3110                 txq_pcpu->size = txq->size;
3111         }
3112
3113         return 0;
3114 }
3115
3116 /* Free allocated TXQ resources */
3117 static void mvpp2_txq_deinit(struct mvpp2_port *port,
3118                              struct mvpp2_tx_queue *txq)
3119 {
3120         txq->descs             = NULL;
3121         txq->last_desc         = 0;
3122         txq->next_desc_to_proc = 0;
3123         txq->descs_dma         = 0;
3124
3125         /* Set minimum bandwidth for disabled TXQs */
3126         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0);
3127
3128         /* Set Tx descriptors queue starting address and size */
3129         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3130         mvpp2_write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, 0);
3131         mvpp2_write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, 0);
3132 }
3133
3134 /* Cleanup Tx ports */
3135 static void mvpp2_txq_clean(struct mvpp2_port *port, struct mvpp2_tx_queue *txq)
3136 {
3137         struct mvpp2_txq_pcpu *txq_pcpu;
3138         int delay, pending, cpu;
3139         u32 val;
3140
3141         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3142         val = mvpp2_read(port->priv, MVPP2_TXQ_PREF_BUF_REG);
3143         val |= MVPP2_TXQ_DRAIN_EN_MASK;
3144         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
3145
3146         /* The napi queue has been stopped so wait for all packets
3147          * to be transmitted.
3148          */
3149         delay = 0;
3150         do {
3151                 if (delay >= MVPP2_TX_PENDING_TIMEOUT_MSEC) {
3152                         netdev_warn(port->dev,
3153                                     "port %d: cleaning queue %d timed out\n",
3154                                     port->id, txq->log_id);
3155                         break;
3156                 }
3157                 mdelay(1);
3158                 delay++;
3159
3160                 pending = mvpp2_txq_pend_desc_num_get(port, txq);
3161         } while (pending);
3162
3163         val &= ~MVPP2_TXQ_DRAIN_EN_MASK;
3164         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
3165
3166         for_each_present_cpu(cpu) {
3167                 txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
3168
3169                 /* Release all packets */
3170                 mvpp2_txq_bufs_free(port, txq, txq_pcpu, txq_pcpu->count);
3171
3172                 /* Reset queue */
3173                 txq_pcpu->count = 0;
3174                 txq_pcpu->txq_put_index = 0;
3175                 txq_pcpu->txq_get_index = 0;
3176         }
3177 }
3178
3179 /* Cleanup all Tx queues */
3180 static void mvpp2_cleanup_txqs(struct mvpp2_port *port)
3181 {
3182         struct mvpp2_tx_queue *txq;
3183         int queue;
3184         u32 val;
3185
3186         val = mvpp2_read(port->priv, MVPP2_TX_PORT_FLUSH_REG);
3187
3188         /* Reset Tx ports and delete Tx queues */
3189         val |= MVPP2_TX_PORT_FLUSH_MASK(port->id);
3190         mvpp2_write(port->priv, MVPP2_TX_PORT_FLUSH_REG, val);
3191
3192         for (queue = 0; queue < txq_number; queue++) {
3193                 txq = port->txqs[queue];
3194                 mvpp2_txq_clean(port, txq);
3195                 mvpp2_txq_deinit(port, txq);
3196         }
3197
3198         mvpp2_txq_sent_counter_clear(port);
3199
3200         val &= ~MVPP2_TX_PORT_FLUSH_MASK(port->id);
3201         mvpp2_write(port->priv, MVPP2_TX_PORT_FLUSH_REG, val);
3202 }
3203
3204 /* Cleanup all Rx queues */
3205 static void mvpp2_cleanup_rxqs(struct mvpp2_port *port)
3206 {
3207         int queue;
3208
3209         for (queue = 0; queue < rxq_number; queue++)
3210                 mvpp2_rxq_deinit(port, port->rxqs[queue]);
3211 }
3212
3213 /* Init all Rx queues for port */
3214 static int mvpp2_setup_rxqs(struct mvpp2_port *port)
3215 {
3216         int queue, err;
3217
3218         for (queue = 0; queue < rxq_number; queue++) {
3219                 err = mvpp2_rxq_init(port, port->rxqs[queue]);
3220                 if (err)
3221                         goto err_cleanup;
3222         }
3223         return 0;
3224
3225 err_cleanup:
3226         mvpp2_cleanup_rxqs(port);
3227         return err;
3228 }
3229
3230 /* Init all tx queues for port */
3231 static int mvpp2_setup_txqs(struct mvpp2_port *port)
3232 {
3233         struct mvpp2_tx_queue *txq;
3234         int queue, err;
3235
3236         for (queue = 0; queue < txq_number; queue++) {
3237                 txq = port->txqs[queue];
3238                 err = mvpp2_txq_init(port, txq);
3239                 if (err)
3240                         goto err_cleanup;
3241         }
3242
3243         mvpp2_txq_sent_counter_clear(port);
3244         return 0;
3245
3246 err_cleanup:
3247         mvpp2_cleanup_txqs(port);
3248         return err;
3249 }
3250
3251 /* Adjust link */
3252 static void mvpp2_link_event(struct mvpp2_port *port)
3253 {
3254         struct phy_device *phydev = port->phy_dev;
3255         int status_change = 0;
3256         u32 val;
3257
3258         if (phydev->link) {
3259                 if ((port->speed != phydev->speed) ||
3260                     (port->duplex != phydev->duplex)) {
3261                         u32 val;
3262
3263                         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3264                         val &= ~(MVPP2_GMAC_CONFIG_MII_SPEED |
3265                                  MVPP2_GMAC_CONFIG_GMII_SPEED |
3266                                  MVPP2_GMAC_CONFIG_FULL_DUPLEX |
3267                                  MVPP2_GMAC_AN_SPEED_EN |
3268                                  MVPP2_GMAC_AN_DUPLEX_EN);
3269
3270                         if (phydev->duplex)
3271                                 val |= MVPP2_GMAC_CONFIG_FULL_DUPLEX;
3272
3273                         if (phydev->speed == SPEED_1000)
3274                                 val |= MVPP2_GMAC_CONFIG_GMII_SPEED;
3275                         else if (phydev->speed == SPEED_100)
3276                                 val |= MVPP2_GMAC_CONFIG_MII_SPEED;
3277
3278                         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3279
3280                         port->duplex = phydev->duplex;
3281                         port->speed  = phydev->speed;
3282                 }
3283         }
3284
3285         if (phydev->link != port->link) {
3286                 if (!phydev->link) {
3287                         port->duplex = -1;
3288                         port->speed = 0;
3289                 }
3290
3291                 port->link = phydev->link;
3292                 status_change = 1;
3293         }
3294
3295         if (status_change) {
3296                 if (phydev->link) {
3297                         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3298                         val |= (MVPP2_GMAC_FORCE_LINK_PASS |
3299                                 MVPP2_GMAC_FORCE_LINK_DOWN);
3300                         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3301                         mvpp2_egress_enable(port);
3302                         mvpp2_ingress_enable(port);
3303                 } else {
3304                         mvpp2_ingress_disable(port);
3305                         mvpp2_egress_disable(port);
3306                 }
3307         }
3308 }
3309
3310 /* Main RX/TX processing routines */
3311
3312 /* Display more error info */
3313 static void mvpp2_rx_error(struct mvpp2_port *port,
3314                            struct mvpp2_rx_desc *rx_desc)
3315 {
3316         u32 status = rx_desc->status;
3317
3318         switch (status & MVPP2_RXD_ERR_CODE_MASK) {
3319         case MVPP2_RXD_ERR_CRC:
3320                 netdev_err(port->dev, "bad rx status %08x (crc error), size=%d\n",
3321                            status, rx_desc->data_size);
3322                 break;
3323         case MVPP2_RXD_ERR_OVERRUN:
3324                 netdev_err(port->dev, "bad rx status %08x (overrun error), size=%d\n",
3325                            status, rx_desc->data_size);
3326                 break;
3327         case MVPP2_RXD_ERR_RESOURCE:
3328                 netdev_err(port->dev, "bad rx status %08x (resource error), size=%d\n",
3329                            status, rx_desc->data_size);
3330                 break;
3331         }
3332 }
3333
3334 /* Reuse skb if possible, or allocate a new skb and add it to BM pool */
3335 static int mvpp2_rx_refill(struct mvpp2_port *port,
3336                            struct mvpp2_bm_pool *bm_pool,
3337                            u32 bm, dma_addr_t dma_addr)
3338 {
3339         mvpp2_pool_refill(port, bm, dma_addr, (unsigned long)dma_addr);
3340         return 0;
3341 }
3342
3343 /* Set hw internals when starting port */
3344 static void mvpp2_start_dev(struct mvpp2_port *port)
3345 {
3346         mvpp2_gmac_max_rx_size_set(port);
3347         mvpp2_txp_max_tx_size_set(port);
3348
3349         mvpp2_port_enable(port);
3350 }
3351
3352 /* Set hw internals when stopping port */
3353 static void mvpp2_stop_dev(struct mvpp2_port *port)
3354 {
3355         /* Stop new packets from arriving to RXQs */
3356         mvpp2_ingress_disable(port);
3357
3358         mvpp2_egress_disable(port);
3359         mvpp2_port_disable(port);
3360 }
3361
3362 static int mvpp2_phy_connect(struct udevice *dev, struct mvpp2_port *port)
3363 {
3364         struct phy_device *phy_dev;
3365
3366         if (!port->init || port->link == 0) {
3367                 phy_dev = phy_connect(port->priv->bus, port->phyaddr, dev,
3368                                       port->phy_interface);
3369                 port->phy_dev = phy_dev;
3370                 if (!phy_dev) {
3371                         netdev_err(port->dev, "cannot connect to phy\n");
3372                         return -ENODEV;
3373                 }
3374                 phy_dev->supported &= PHY_GBIT_FEATURES;
3375                 phy_dev->advertising = phy_dev->supported;
3376
3377                 port->phy_dev = phy_dev;
3378                 port->link    = 0;
3379                 port->duplex  = 0;
3380                 port->speed   = 0;
3381
3382                 phy_config(phy_dev);
3383                 phy_startup(phy_dev);
3384                 if (!phy_dev->link) {
3385                         printf("%s: No link\n", phy_dev->dev->name);
3386                         return -1;
3387                 }
3388
3389                 port->init = 1;
3390         } else {
3391                 mvpp2_egress_enable(port);
3392                 mvpp2_ingress_enable(port);
3393         }
3394
3395         return 0;
3396 }
3397
3398 static int mvpp2_open(struct udevice *dev, struct mvpp2_port *port)
3399 {
3400         unsigned char mac_bcast[ETH_ALEN] = {
3401                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
3402         int err;
3403
3404         err = mvpp2_prs_mac_da_accept(port->priv, port->id, mac_bcast, true);
3405         if (err) {
3406                 netdev_err(dev, "mvpp2_prs_mac_da_accept BC failed\n");
3407                 return err;
3408         }
3409         err = mvpp2_prs_mac_da_accept(port->priv, port->id,
3410                                       port->dev_addr, true);
3411         if (err) {
3412                 netdev_err(dev, "mvpp2_prs_mac_da_accept MC failed\n");
3413                 return err;
3414         }
3415         err = mvpp2_prs_def_flow(port);
3416         if (err) {
3417                 netdev_err(dev, "mvpp2_prs_def_flow failed\n");
3418                 return err;
3419         }
3420
3421         /* Allocate the Rx/Tx queues */
3422         err = mvpp2_setup_rxqs(port);
3423         if (err) {
3424                 netdev_err(port->dev, "cannot allocate Rx queues\n");
3425                 return err;
3426         }
3427
3428         err = mvpp2_setup_txqs(port);
3429         if (err) {
3430                 netdev_err(port->dev, "cannot allocate Tx queues\n");
3431                 return err;
3432         }
3433
3434         err = mvpp2_phy_connect(dev, port);
3435         if (err < 0)
3436                 return err;
3437
3438         mvpp2_link_event(port);
3439
3440         mvpp2_start_dev(port);
3441
3442         return 0;
3443 }
3444
3445 /* No Device ops here in U-Boot */
3446
3447 /* Driver initialization */
3448
3449 static void mvpp2_port_power_up(struct mvpp2_port *port)
3450 {
3451         mvpp2_port_mii_set(port);
3452         mvpp2_port_periodic_xon_disable(port);
3453         mvpp2_port_fc_adv_enable(port);
3454         mvpp2_port_reset(port);
3455 }
3456
3457 /* Initialize port HW */
3458 static int mvpp2_port_init(struct udevice *dev, struct mvpp2_port *port)
3459 {
3460         struct mvpp2 *priv = port->priv;
3461         struct mvpp2_txq_pcpu *txq_pcpu;
3462         int queue, cpu, err;
3463
3464         if (port->first_rxq + rxq_number > MVPP2_RXQ_TOTAL_NUM)
3465                 return -EINVAL;
3466
3467         /* Disable port */
3468         mvpp2_egress_disable(port);
3469         mvpp2_port_disable(port);
3470
3471         port->txqs = devm_kcalloc(dev, txq_number, sizeof(*port->txqs),
3472                                   GFP_KERNEL);
3473         if (!port->txqs)
3474                 return -ENOMEM;
3475
3476         /* Associate physical Tx queues to this port and initialize.
3477          * The mapping is predefined.
3478          */
3479         for (queue = 0; queue < txq_number; queue++) {
3480                 int queue_phy_id = mvpp2_txq_phys(port->id, queue);
3481                 struct mvpp2_tx_queue *txq;
3482
3483                 txq = devm_kzalloc(dev, sizeof(*txq), GFP_KERNEL);
3484                 if (!txq)
3485                         return -ENOMEM;
3486
3487                 txq->pcpu = devm_kzalloc(dev, sizeof(struct mvpp2_txq_pcpu),
3488                                          GFP_KERNEL);
3489                 if (!txq->pcpu)
3490                         return -ENOMEM;
3491
3492                 txq->id = queue_phy_id;
3493                 txq->log_id = queue;
3494                 txq->done_pkts_coal = MVPP2_TXDONE_COAL_PKTS_THRESH;
3495                 for_each_present_cpu(cpu) {
3496                         txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
3497                         txq_pcpu->cpu = cpu;
3498                 }
3499
3500                 port->txqs[queue] = txq;
3501         }
3502
3503         port->rxqs = devm_kcalloc(dev, rxq_number, sizeof(*port->rxqs),
3504                                   GFP_KERNEL);
3505         if (!port->rxqs)
3506                 return -ENOMEM;
3507
3508         /* Allocate and initialize Rx queue for this port */
3509         for (queue = 0; queue < rxq_number; queue++) {
3510                 struct mvpp2_rx_queue *rxq;
3511
3512                 /* Map physical Rx queue to port's logical Rx queue */
3513                 rxq = devm_kzalloc(dev, sizeof(*rxq), GFP_KERNEL);
3514                 if (!rxq)
3515                         return -ENOMEM;
3516                 /* Map this Rx queue to a physical queue */
3517                 rxq->id = port->first_rxq + queue;
3518                 rxq->port = port->id;
3519                 rxq->logic_rxq = queue;
3520
3521                 port->rxqs[queue] = rxq;
3522         }
3523
3524         /* Configure Rx queue group interrupt for this port */
3525         mvpp2_write(priv, MVPP2_ISR_RXQ_GROUP_REG(port->id), CONFIG_MV_ETH_RXQ);
3526
3527         /* Create Rx descriptor rings */
3528         for (queue = 0; queue < rxq_number; queue++) {
3529                 struct mvpp2_rx_queue *rxq = port->rxqs[queue];
3530
3531                 rxq->size = port->rx_ring_size;
3532                 rxq->pkts_coal = MVPP2_RX_COAL_PKTS;
3533                 rxq->time_coal = MVPP2_RX_COAL_USEC;
3534         }
3535
3536         mvpp2_ingress_disable(port);
3537
3538         /* Port default configuration */
3539         mvpp2_defaults_set(port);
3540
3541         /* Port's classifier configuration */
3542         mvpp2_cls_oversize_rxq_set(port);
3543         mvpp2_cls_port_config(port);
3544
3545         /* Provide an initial Rx packet size */
3546         port->pkt_size = MVPP2_RX_PKT_SIZE(PKTSIZE_ALIGN);
3547
3548         /* Initialize pools for swf */
3549         err = mvpp2_swf_bm_pool_init(port);
3550         if (err)
3551                 return err;
3552
3553         return 0;
3554 }
3555
3556 /* Ports initialization */
3557 static int mvpp2_port_probe(struct udevice *dev,
3558                             struct mvpp2_port *port,
3559                             int port_node,
3560                             struct mvpp2 *priv,
3561                             int *next_first_rxq)
3562 {
3563         int phy_node;
3564         u32 id;
3565         u32 phyaddr;
3566         const char *phy_mode_str;
3567         int phy_mode = -1;
3568         int priv_common_regs_num = 2;
3569         int err;
3570
3571         phy_node = fdtdec_lookup_phandle(gd->fdt_blob, port_node, "phy");
3572         if (phy_node < 0) {
3573                 dev_err(&pdev->dev, "missing phy\n");
3574                 return -ENODEV;
3575         }
3576
3577         phy_mode_str = fdt_getprop(gd->fdt_blob, port_node, "phy-mode", NULL);
3578         if (phy_mode_str)
3579                 phy_mode = phy_get_interface_by_name(phy_mode_str);
3580         if (phy_mode == -1) {
3581                 dev_err(&pdev->dev, "incorrect phy mode\n");
3582                 return -EINVAL;
3583         }
3584
3585         id = fdtdec_get_int(gd->fdt_blob, port_node, "port-id", -1);
3586         if (id == -1) {
3587                 dev_err(&pdev->dev, "missing port-id value\n");
3588                 return -EINVAL;
3589         }
3590
3591         phyaddr = fdtdec_get_int(gd->fdt_blob, phy_node, "reg", 0);
3592
3593         port->priv = priv;
3594         port->id = id;
3595         port->first_rxq = *next_first_rxq;
3596         port->phy_node = phy_node;
3597         port->phy_interface = phy_mode;
3598         port->phyaddr = phyaddr;
3599
3600         port->base = (void __iomem *)dev_get_addr_index(dev->parent,
3601                                                         priv_common_regs_num
3602                                                         + id);
3603         if (IS_ERR(port->base))
3604                 return PTR_ERR(port->base);
3605
3606         port->tx_ring_size = MVPP2_MAX_TXD;
3607         port->rx_ring_size = MVPP2_MAX_RXD;
3608
3609         err = mvpp2_port_init(dev, port);
3610         if (err < 0) {
3611                 dev_err(&pdev->dev, "failed to init port %d\n", id);
3612                 return err;
3613         }
3614         mvpp2_port_power_up(port);
3615
3616         /* Increment the first Rx queue number to be used by the next port */
3617         *next_first_rxq += CONFIG_MV_ETH_RXQ;
3618         priv->port_list[id] = port;
3619         return 0;
3620 }
3621
3622 /* Initialize decoding windows */
3623 static void mvpp2_conf_mbus_windows(const struct mbus_dram_target_info *dram,
3624                                     struct mvpp2 *priv)
3625 {
3626         u32 win_enable;
3627         int i;
3628
3629         for (i = 0; i < 6; i++) {
3630                 mvpp2_write(priv, MVPP2_WIN_BASE(i), 0);
3631                 mvpp2_write(priv, MVPP2_WIN_SIZE(i), 0);
3632
3633                 if (i < 4)
3634                         mvpp2_write(priv, MVPP2_WIN_REMAP(i), 0);
3635         }
3636
3637         win_enable = 0;
3638
3639         for (i = 0; i < dram->num_cs; i++) {
3640                 const struct mbus_dram_window *cs = dram->cs + i;
3641
3642                 mvpp2_write(priv, MVPP2_WIN_BASE(i),
3643                             (cs->base & 0xffff0000) | (cs->mbus_attr << 8) |
3644                             dram->mbus_dram_target_id);
3645
3646                 mvpp2_write(priv, MVPP2_WIN_SIZE(i),
3647                             (cs->size - 1) & 0xffff0000);
3648
3649                 win_enable |= (1 << i);
3650         }
3651
3652         mvpp2_write(priv, MVPP2_BASE_ADDR_ENABLE, win_enable);
3653 }
3654
3655 /* Initialize Rx FIFO's */
3656 static void mvpp2_rx_fifo_init(struct mvpp2 *priv)
3657 {
3658         int port;
3659
3660         for (port = 0; port < MVPP2_MAX_PORTS; port++) {
3661                 mvpp2_write(priv, MVPP2_RX_DATA_FIFO_SIZE_REG(port),
3662                             MVPP2_RX_FIFO_PORT_DATA_SIZE);
3663                 mvpp2_write(priv, MVPP2_RX_ATTR_FIFO_SIZE_REG(port),
3664                             MVPP2_RX_FIFO_PORT_ATTR_SIZE);
3665         }
3666
3667         mvpp2_write(priv, MVPP2_RX_MIN_PKT_SIZE_REG,
3668                     MVPP2_RX_FIFO_PORT_MIN_PKT);
3669         mvpp2_write(priv, MVPP2_RX_FIFO_INIT_REG, 0x1);
3670 }
3671
3672 /* Initialize network controller common part HW */
3673 static int mvpp2_init(struct udevice *dev, struct mvpp2 *priv)
3674 {
3675         const struct mbus_dram_target_info *dram_target_info;
3676         int err, i;
3677         u32 val;
3678
3679         /* Checks for hardware constraints (U-Boot uses only one rxq) */
3680         if ((rxq_number > MVPP2_MAX_RXQ) || (txq_number > MVPP2_MAX_TXQ)) {
3681                 dev_err(&pdev->dev, "invalid queue size parameter\n");
3682                 return -EINVAL;
3683         }
3684
3685         /* MBUS windows configuration */
3686         dram_target_info = mvebu_mbus_dram_info();
3687         if (dram_target_info)
3688                 mvpp2_conf_mbus_windows(dram_target_info, priv);
3689
3690         /* Disable HW PHY polling */
3691         val = readl(priv->lms_base + MVPP2_PHY_AN_CFG0_REG);
3692         val |= MVPP2_PHY_AN_STOP_SMI0_MASK;
3693         writel(val, priv->lms_base + MVPP2_PHY_AN_CFG0_REG);
3694
3695         /* Allocate and initialize aggregated TXQs */
3696         priv->aggr_txqs = devm_kcalloc(dev, num_present_cpus(),
3697                                        sizeof(struct mvpp2_tx_queue),
3698                                        GFP_KERNEL);
3699         if (!priv->aggr_txqs)
3700                 return -ENOMEM;
3701
3702         for_each_present_cpu(i) {
3703                 priv->aggr_txqs[i].id = i;
3704                 priv->aggr_txqs[i].size = MVPP2_AGGR_TXQ_SIZE;
3705                 err = mvpp2_aggr_txq_init(dev, &priv->aggr_txqs[i],
3706                                           MVPP2_AGGR_TXQ_SIZE, i, priv);
3707                 if (err < 0)
3708                         return err;
3709         }
3710
3711         /* Rx Fifo Init */
3712         mvpp2_rx_fifo_init(priv);
3713
3714         /* Reset Rx queue group interrupt configuration */
3715         for (i = 0; i < MVPP2_MAX_PORTS; i++)
3716                 mvpp2_write(priv, MVPP2_ISR_RXQ_GROUP_REG(i),
3717                             CONFIG_MV_ETH_RXQ);
3718
3719         writel(MVPP2_EXT_GLOBAL_CTRL_DEFAULT,
3720                priv->lms_base + MVPP2_MNG_EXTENDED_GLOBAL_CTRL_REG);
3721
3722         /* Allow cache snoop when transmiting packets */
3723         mvpp2_write(priv, MVPP2_TX_SNOOP_REG, 0x1);
3724
3725         /* Buffer Manager initialization */
3726         err = mvpp2_bm_init(dev, priv);
3727         if (err < 0)
3728                 return err;
3729
3730         /* Parser default initialization */
3731         err = mvpp2_prs_default_init(dev, priv);
3732         if (err < 0)
3733                 return err;
3734
3735         /* Classifier default initialization */
3736         mvpp2_cls_init(priv);
3737
3738         return 0;
3739 }
3740
3741 /* SMI / MDIO functions */
3742
3743 static int smi_wait_ready(struct mvpp2 *priv)
3744 {
3745         u32 timeout = MVPP2_SMI_TIMEOUT;
3746         u32 smi_reg;
3747
3748         /* wait till the SMI is not busy */
3749         do {
3750                 /* read smi register */
3751                 smi_reg = readl(priv->lms_base + MVPP2_SMI);
3752                 if (timeout-- == 0) {
3753                         printf("Error: SMI busy timeout\n");
3754                         return -EFAULT;
3755                 }
3756         } while (smi_reg & MVPP2_SMI_BUSY);
3757
3758         return 0;
3759 }
3760
3761 /*
3762  * mpp2_mdio_read - miiphy_read callback function.
3763  *
3764  * Returns 16bit phy register value, or 0xffff on error
3765  */
3766 static int mpp2_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
3767 {
3768         struct mvpp2 *priv = bus->priv;
3769         u32 smi_reg;
3770         u32 timeout;
3771
3772         /* check parameters */
3773         if (addr > MVPP2_PHY_ADDR_MASK) {
3774                 printf("Error: Invalid PHY address %d\n", addr);
3775                 return -EFAULT;
3776         }
3777
3778         if (reg > MVPP2_PHY_REG_MASK) {
3779                 printf("Err: Invalid register offset %d\n", reg);
3780                 return -EFAULT;
3781         }
3782
3783         /* wait till the SMI is not busy */
3784         if (smi_wait_ready(priv) < 0)
3785                 return -EFAULT;
3786
3787         /* fill the phy address and regiser offset and read opcode */
3788         smi_reg = (addr << MVPP2_SMI_DEV_ADDR_OFFS)
3789                 | (reg << MVPP2_SMI_REG_ADDR_OFFS)
3790                 | MVPP2_SMI_OPCODE_READ;
3791
3792         /* write the smi register */
3793         writel(smi_reg, priv->lms_base + MVPP2_SMI);
3794
3795         /* wait till read value is ready */
3796         timeout = MVPP2_SMI_TIMEOUT;
3797
3798         do {
3799                 /* read smi register */
3800                 smi_reg = readl(priv->lms_base + MVPP2_SMI);
3801                 if (timeout-- == 0) {
3802                         printf("Err: SMI read ready timeout\n");
3803                         return -EFAULT;
3804                 }
3805         } while (!(smi_reg & MVPP2_SMI_READ_VALID));
3806
3807         /* Wait for the data to update in the SMI register */
3808         for (timeout = 0; timeout < MVPP2_SMI_TIMEOUT; timeout++)
3809                 ;
3810
3811         return readl(priv->lms_base + MVPP2_SMI) & MVPP2_SMI_DATA_MASK;
3812 }
3813
3814 /*
3815  * mpp2_mdio_write - miiphy_write callback function.
3816  *
3817  * Returns 0 if write succeed, -EINVAL on bad parameters
3818  * -ETIME on timeout
3819  */
3820 static int mpp2_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
3821                            u16 value)
3822 {
3823         struct mvpp2 *priv = bus->priv;
3824         u32 smi_reg;
3825
3826         /* check parameters */
3827         if (addr > MVPP2_PHY_ADDR_MASK) {
3828                 printf("Error: Invalid PHY address %d\n", addr);
3829                 return -EFAULT;
3830         }
3831
3832         if (reg > MVPP2_PHY_REG_MASK) {
3833                 printf("Err: Invalid register offset %d\n", reg);
3834                 return -EFAULT;
3835         }
3836
3837         /* wait till the SMI is not busy */
3838         if (smi_wait_ready(priv) < 0)
3839                 return -EFAULT;
3840
3841         /* fill the phy addr and reg offset and write opcode and data */
3842         smi_reg = value << MVPP2_SMI_DATA_OFFS;
3843         smi_reg |= (addr << MVPP2_SMI_DEV_ADDR_OFFS)
3844                 | (reg << MVPP2_SMI_REG_ADDR_OFFS);
3845         smi_reg &= ~MVPP2_SMI_OPCODE_READ;
3846
3847         /* write the smi register */
3848         writel(smi_reg, priv->lms_base + MVPP2_SMI);
3849
3850         return 0;
3851 }
3852
3853 static int mvpp2_recv(struct udevice *dev, int flags, uchar **packetp)
3854 {
3855         struct mvpp2_port *port = dev_get_priv(dev);
3856         struct mvpp2_rx_desc *rx_desc;
3857         struct mvpp2_bm_pool *bm_pool;
3858         dma_addr_t dma_addr;
3859         u32 bm, rx_status;
3860         int pool, rx_bytes, err;
3861         int rx_received;
3862         struct mvpp2_rx_queue *rxq;
3863         u32 cause_rx_tx, cause_rx, cause_misc;
3864         u8 *data;
3865
3866         cause_rx_tx = mvpp2_read(port->priv,
3867                                  MVPP2_ISR_RX_TX_CAUSE_REG(port->id));
3868         cause_rx_tx &= ~MVPP2_CAUSE_TXQ_OCCUP_DESC_ALL_MASK;
3869         cause_misc = cause_rx_tx & MVPP2_CAUSE_MISC_SUM_MASK;
3870         if (!cause_rx_tx && !cause_misc)
3871                 return 0;
3872
3873         cause_rx = cause_rx_tx & MVPP2_CAUSE_RXQ_OCCUP_DESC_ALL_MASK;
3874
3875         /* Process RX packets */
3876         cause_rx |= port->pending_cause_rx;
3877         rxq = mvpp2_get_rx_queue(port, cause_rx);
3878
3879         /* Get number of received packets and clamp the to-do */
3880         rx_received = mvpp2_rxq_received(port, rxq->id);
3881
3882         /* Return if no packets are received */
3883         if (!rx_received)
3884                 return 0;
3885
3886         rx_desc = mvpp2_rxq_next_desc_get(rxq);
3887         rx_status = rx_desc->status;
3888         rx_bytes = rx_desc->data_size - MVPP2_MH_SIZE;
3889         dma_addr = rx_desc->buf_dma_addr;
3890
3891         bm = mvpp2_bm_cookie_build(rx_desc);
3892         pool = mvpp2_bm_cookie_pool_get(bm);
3893         bm_pool = &port->priv->bm_pools[pool];
3894
3895         /* Check if buffer header is used */
3896         if (rx_status & MVPP2_RXD_BUF_HDR)
3897                 return 0;
3898
3899         /* In case of an error, release the requested buffer pointer
3900          * to the Buffer Manager. This request process is controlled
3901          * by the hardware, and the information about the buffer is
3902          * comprised by the RX descriptor.
3903          */
3904         if (rx_status & MVPP2_RXD_ERR_SUMMARY) {
3905                 mvpp2_rx_error(port, rx_desc);
3906                 /* Return the buffer to the pool */
3907                 mvpp2_pool_refill(port, bm, rx_desc->buf_dma_addr,
3908                                   rx_desc->buf_cookie);
3909                 return 0;
3910         }
3911
3912         err = mvpp2_rx_refill(port, bm_pool, bm, dma_addr);
3913         if (err) {
3914                 netdev_err(port->dev, "failed to refill BM pools\n");
3915                 return 0;
3916         }
3917
3918         /* Update Rx queue management counters */
3919         mb();
3920         mvpp2_rxq_status_update(port, rxq->id, 1, 1);
3921
3922         /* give packet to stack - skip on first n bytes */
3923         data = (u8 *)dma_addr + 2 + 32;
3924
3925         if (rx_bytes <= 0)
3926                 return 0;
3927
3928         /*
3929          * No cache invalidation needed here, since the rx_buffer's are
3930          * located in a uncached memory region
3931          */
3932         *packetp = data;
3933
3934         return rx_bytes;
3935 }
3936
3937 /* Drain Txq */
3938 static void mvpp2_txq_drain(struct mvpp2_port *port, struct mvpp2_tx_queue *txq,
3939                             int enable)
3940 {
3941         u32 val;
3942
3943         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3944         val = mvpp2_read(port->priv, MVPP2_TXQ_PREF_BUF_REG);
3945         if (enable)
3946                 val |= MVPP2_TXQ_DRAIN_EN_MASK;
3947         else
3948                 val &= ~MVPP2_TXQ_DRAIN_EN_MASK;
3949         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
3950 }
3951
3952 static int mvpp2_send(struct udevice *dev, void *packet, int length)
3953 {
3954         struct mvpp2_port *port = dev_get_priv(dev);
3955         struct mvpp2_tx_queue *txq, *aggr_txq;
3956         struct mvpp2_tx_desc *tx_desc;
3957         int tx_done;
3958         int timeout;
3959
3960         txq = port->txqs[0];
3961         aggr_txq = &port->priv->aggr_txqs[smp_processor_id()];
3962
3963         /* Get a descriptor for the first part of the packet */
3964         tx_desc = mvpp2_txq_next_desc_get(aggr_txq);
3965         tx_desc->phys_txq = txq->id;
3966         tx_desc->data_size = length;
3967         tx_desc->packet_offset = (unsigned long)packet & MVPP2_TX_DESC_ALIGN;
3968         tx_desc->buf_dma_addr = (unsigned long)packet & ~MVPP2_TX_DESC_ALIGN;
3969         /* First and Last descriptor */
3970         tx_desc->command = MVPP2_TXD_L4_CSUM_NOT | MVPP2_TXD_IP_CSUM_DISABLE
3971                 | MVPP2_TXD_F_DESC | MVPP2_TXD_L_DESC;
3972
3973         /* Flush tx data */
3974         flush_dcache_range((unsigned long)packet,
3975                            (unsigned long)packet + ALIGN(length, PKTALIGN));
3976
3977         /* Enable transmit */
3978         mb();
3979         mvpp2_aggr_txq_pend_desc_add(port, 1);
3980
3981         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3982
3983         timeout = 0;
3984         do {
3985                 if (timeout++ > 10000) {
3986                         printf("timeout: packet not sent from aggregated to phys TXQ\n");
3987                         return 0;
3988                 }
3989                 tx_done = mvpp2_txq_pend_desc_num_get(port, txq);
3990         } while (tx_done);
3991
3992         /* Enable TXQ drain */
3993         mvpp2_txq_drain(port, txq, 1);
3994
3995         timeout = 0;
3996         do {
3997                 if (timeout++ > 10000) {
3998                         printf("timeout: packet not sent\n");
3999                         return 0;
4000                 }
4001                 tx_done = mvpp2_txq_sent_desc_proc(port, txq);
4002         } while (!tx_done);
4003
4004         /* Disable TXQ drain */
4005         mvpp2_txq_drain(port, txq, 0);
4006
4007         return 0;
4008 }
4009
4010 static int mvpp2_start(struct udevice *dev)
4011 {
4012         struct eth_pdata *pdata = dev_get_platdata(dev);
4013         struct mvpp2_port *port = dev_get_priv(dev);
4014
4015         /* Load current MAC address */
4016         memcpy(port->dev_addr, pdata->enetaddr, ETH_ALEN);
4017
4018         /* Reconfigure parser accept the original MAC address */
4019         mvpp2_prs_update_mac_da(port, port->dev_addr);
4020
4021         mvpp2_port_power_up(port);
4022
4023         mvpp2_open(dev, port);
4024
4025         return 0;
4026 }
4027
4028 static void mvpp2_stop(struct udevice *dev)
4029 {
4030         struct mvpp2_port *port = dev_get_priv(dev);
4031
4032         mvpp2_stop_dev(port);
4033         mvpp2_cleanup_rxqs(port);
4034         mvpp2_cleanup_txqs(port);
4035 }
4036
4037 static int mvpp2_probe(struct udevice *dev)
4038 {
4039         struct mvpp2_port *port = dev_get_priv(dev);
4040         struct mvpp2 *priv = dev_get_priv(dev->parent);
4041         int err;
4042
4043         /* Initialize network controller */
4044         err = mvpp2_init(dev, priv);
4045         if (err < 0) {
4046                 dev_err(&pdev->dev, "failed to initialize controller\n");
4047                 return err;
4048         }
4049
4050         return mvpp2_port_probe(dev, port, dev_of_offset(dev), priv,
4051                                 &buffer_loc.first_rxq);
4052 }
4053
4054 static const struct eth_ops mvpp2_ops = {
4055         .start          = mvpp2_start,
4056         .send           = mvpp2_send,
4057         .recv           = mvpp2_recv,
4058         .stop           = mvpp2_stop,
4059 };
4060
4061 static struct driver mvpp2_driver = {
4062         .name   = "mvpp2",
4063         .id     = UCLASS_ETH,
4064         .probe  = mvpp2_probe,
4065         .ops    = &mvpp2_ops,
4066         .priv_auto_alloc_size = sizeof(struct mvpp2_port),
4067         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
4068 };
4069
4070 /*
4071  * Use a MISC device to bind the n instances (child nodes) of the
4072  * network base controller in UCLASS_ETH.
4073  */
4074 static int mvpp2_base_probe(struct udevice *dev)
4075 {
4076         struct mvpp2 *priv = dev_get_priv(dev);
4077         struct mii_dev *bus;
4078         void *bd_space;
4079         u32 size = 0;
4080         int i;
4081
4082         /*
4083          * U-Boot special buffer handling:
4084          *
4085          * Allocate buffer area for descs and rx_buffers. This is only
4086          * done once for all interfaces. As only one interface can
4087          * be active. Make this area DMA-safe by disabling the D-cache
4088          */
4089
4090         /* Align buffer area for descs and rx_buffers to 1MiB */
4091         bd_space = memalign(1 << MMU_SECTION_SHIFT, BD_SPACE);
4092         mmu_set_region_dcache_behaviour((unsigned long)bd_space,
4093                                         BD_SPACE, DCACHE_OFF);
4094
4095         buffer_loc.aggr_tx_descs = (struct mvpp2_tx_desc *)bd_space;
4096         size += MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE;
4097
4098         buffer_loc.tx_descs =
4099                 (struct mvpp2_tx_desc *)((unsigned long)bd_space + size);
4100         size += MVPP2_MAX_TXD * MVPP2_DESC_ALIGNED_SIZE;
4101
4102         buffer_loc.rx_descs =
4103                 (struct mvpp2_rx_desc *)((unsigned long)bd_space + size);
4104         size += MVPP2_MAX_RXD * MVPP2_DESC_ALIGNED_SIZE;
4105
4106         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
4107                 buffer_loc.bm_pool[i] =
4108                         (unsigned long *)((unsigned long)bd_space + size);
4109                 size += MVPP2_BM_POOL_SIZE_MAX * sizeof(u32);
4110         }
4111
4112         for (i = 0; i < MVPP2_BM_LONG_BUF_NUM; i++) {
4113                 buffer_loc.rx_buffer[i] =
4114                         (unsigned long *)((unsigned long)bd_space + size);
4115                 size += RX_BUFFER_SIZE;
4116         }
4117
4118         /* Save base addresses for later use */
4119         priv->base = (void *)dev_get_addr_index(dev, 0);
4120         if (IS_ERR(priv->base))
4121                 return PTR_ERR(priv->base);
4122
4123         priv->lms_base = (void *)dev_get_addr_index(dev, 1);
4124         if (IS_ERR(priv->lms_base))
4125                 return PTR_ERR(priv->lms_base);
4126
4127         /* Finally create and register the MDIO bus driver */
4128         bus = mdio_alloc();
4129         if (!bus) {
4130                 printf("Failed to allocate MDIO bus\n");
4131                 return -ENOMEM;
4132         }
4133
4134         bus->read = mpp2_mdio_read;
4135         bus->write = mpp2_mdio_write;
4136         snprintf(bus->name, sizeof(bus->name), dev->name);
4137         bus->priv = (void *)priv;
4138         priv->bus = bus;
4139
4140         return mdio_register(bus);
4141 }
4142
4143 static int mvpp2_base_bind(struct udevice *parent)
4144 {
4145         const void *blob = gd->fdt_blob;
4146         int node = dev_of_offset(parent);
4147         struct uclass_driver *drv;
4148         struct udevice *dev;
4149         struct eth_pdata *plat;
4150         char *name;
4151         int subnode;
4152         u32 id;
4153
4154         /* Lookup eth driver */
4155         drv = lists_uclass_lookup(UCLASS_ETH);
4156         if (!drv) {
4157                 puts("Cannot find eth driver\n");
4158                 return -ENOENT;
4159         }
4160
4161         fdt_for_each_subnode(subnode, blob, node) {
4162                 /* Skip disabled ports */
4163                 if (!fdtdec_get_is_enabled(blob, subnode))
4164                         continue;
4165
4166                 plat = calloc(1, sizeof(*plat));
4167                 if (!plat)
4168                         return -ENOMEM;
4169
4170                 id = fdtdec_get_int(blob, subnode, "port-id", -1);
4171
4172                 name = calloc(1, 16);
4173                 sprintf(name, "mvpp2-%d", id);
4174
4175                 /* Create child device UCLASS_ETH and bind it */
4176                 device_bind(parent, &mvpp2_driver, name, plat, subnode, &dev);
4177                 dev_set_of_offset(dev, subnode);
4178         }
4179
4180         return 0;
4181 }
4182
4183 static const struct udevice_id mvpp2_ids[] = {
4184         { .compatible = "marvell,armada-375-pp2" },
4185         { }
4186 };
4187
4188 U_BOOT_DRIVER(mvpp2_base) = {
4189         .name   = "mvpp2_base",
4190         .id     = UCLASS_MISC,
4191         .of_match = mvpp2_ids,
4192         .bind   = mvpp2_base_bind,
4193         .probe  = mvpp2_base_probe,
4194         .priv_auto_alloc_size = sizeof(struct mvpp2),
4195 };