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-2017 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 <cpu_func.h>
  18 #include <dm.h>
  19 #include <asm/cache.h>
  20 #include <dm/device-internal.h>
  21 #include <dm/device_compat.h>
  22 #include <dm/devres.h>
  23 #include <dm/lists.h>
  24 #include <net.h>
  25 #include <netdev.h>
  26 #include <config.h>
  27 #include <malloc.h>
  28 #include <asm/io.h>
  29 #include <linux/bitops.h>
  30 #include <linux/bug.h>
  31 #include <linux/delay.h>
  32 #include <linux/err.h>
  33 #include <linux/errno.h>
  34 #include <phy.h>
  35 #include <miiphy.h>
  36 #include <watchdog.h>
  37 #include <asm/arch/cpu.h>
  38 #include <asm/arch/soc.h>
  39 #include <linux/compat.h>
  40 #include <linux/libfdt.h>
  41 #include <linux/mbus.h>
  42 #include <asm-generic/gpio.h>
  43 #include <fdt_support.h>
  44 #include <linux/mdio.h>
  45
  46 DECLARE_GLOBAL_DATA_PTR;
  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
  70 /* 2(HW hdr) 14(MAC hdr) 4(CRC) 32(extra for cache prefetch) */
  71 #define WRAP                    (2 + ETH_HLEN + 4 + 32)
  72 #define MTU                     1500
  73 #define RX_BUFFER_SIZE          (ALIGN(MTU + WRAP, ARCH_DMA_MINALIGN))
  74
  75 /* RX Fifo Registers */
  76 #define MVPP2_RX_DATA_FIFO_SIZE_REG(port)       (0x00 + 4 * (port))
  77 #define MVPP2_RX_ATTR_FIFO_SIZE_REG(port)       (0x20 + 4 * (port))
  78 #define MVPP2_RX_MIN_PKT_SIZE_REG               0x60
  79 #define MVPP2_RX_FIFO_INIT_REG                  0x64
  80
  81 /* RX DMA Top Registers */
  82 #define MVPP2_RX_CTRL_REG(port)                 (0x140 + 4 * (port))
  83 #define     MVPP2_RX_LOW_LATENCY_PKT_SIZE(s)    (((s) & 0xfff) << 16)
  84 #define     MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK   BIT(31)
  85 #define MVPP2_POOL_BUF_SIZE_REG(pool)           (0x180 + 4 * (pool))
  86 #define     MVPP2_POOL_BUF_SIZE_OFFSET          5
  87 #define MVPP2_RXQ_CONFIG_REG(rxq)               (0x800 + 4 * (rxq))
  88 #define     MVPP2_SNOOP_PKT_SIZE_MASK           0x1ff
  89 #define     MVPP2_SNOOP_BUF_HDR_MASK            BIT(9)
  90 #define     MVPP2_RXQ_POOL_SHORT_OFFS           20
  91 #define     MVPP21_RXQ_POOL_SHORT_MASK          0x700000
  92 #define     MVPP22_RXQ_POOL_SHORT_MASK          0xf00000
  93 #define     MVPP2_RXQ_POOL_LONG_OFFS            24
  94 #define     MVPP21_RXQ_POOL_LONG_MASK           0x7000000
  95 #define     MVPP22_RXQ_POOL_LONG_MASK           0xf000000
  96 #define     MVPP2_RXQ_PACKET_OFFSET_OFFS        28
  97 #define     MVPP2_RXQ_PACKET_OFFSET_MASK        0x70000000
  98 #define     MVPP2_RXQ_DISABLE_MASK              BIT(31)
  99
 100 /* Parser Registers */
 101 #define MVPP2_PRS_INIT_LOOKUP_REG               0x1000
 102 #define     MVPP2_PRS_PORT_LU_MAX               0xf
 103 #define     MVPP2_PRS_PORT_LU_MASK(port)        (0xff << ((port) * 4))
 104 #define     MVPP2_PRS_PORT_LU_VAL(port, val)    ((val) << ((port) * 4))
 105 #define MVPP2_PRS_INIT_OFFS_REG(port)           (0x1004 + ((port) & 4))
 106 #define     MVPP2_PRS_INIT_OFF_MASK(port)       (0x3f << (((port) % 4) * 8))
 107 #define     MVPP2_PRS_INIT_OFF_VAL(port, val)   ((val) << (((port) % 4) * 8))
 108 #define MVPP2_PRS_MAX_LOOP_REG(port)            (0x100c + ((port) & 4))
 109 #define     MVPP2_PRS_MAX_LOOP_MASK(port)       (0xff << (((port) % 4) * 8))
 110 #define     MVPP2_PRS_MAX_LOOP_VAL(port, val)   ((val) << (((port) % 4) * 8))
 111 #define MVPP2_PRS_TCAM_IDX_REG                  0x1100
 112 #define MVPP2_PRS_TCAM_DATA_REG(idx)            (0x1104 + (idx) * 4)
 113 #define     MVPP2_PRS_TCAM_INV_MASK             BIT(31)
 114 #define MVPP2_PRS_SRAM_IDX_REG                  0x1200
 115 #define MVPP2_PRS_SRAM_DATA_REG(idx)            (0x1204 + (idx) * 4)
 116 #define MVPP2_PRS_TCAM_CTRL_REG                 0x1230
 117 #define     MVPP2_PRS_TCAM_EN_MASK              BIT(0)
 118
 119 /* Classifier Registers */
 120 #define MVPP2_CLS_MODE_REG                      0x1800
 121 #define     MVPP2_CLS_MODE_ACTIVE_MASK          BIT(0)
 122 #define MVPP2_CLS_PORT_WAY_REG                  0x1810
 123 #define     MVPP2_CLS_PORT_WAY_MASK(port)       (1 << (port))
 124 #define MVPP2_CLS_LKP_INDEX_REG                 0x1814
 125 #define     MVPP2_CLS_LKP_INDEX_WAY_OFFS        6
 126 #define MVPP2_CLS_LKP_TBL_REG                   0x1818
 127 #define     MVPP2_CLS_LKP_TBL_RXQ_MASK          0xff
 128 #define     MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK    BIT(25)
 129 #define MVPP2_CLS_FLOW_INDEX_REG                0x1820
 130 #define MVPP2_CLS_FLOW_TBL0_REG                 0x1824
 131 #define MVPP2_CLS_FLOW_TBL1_REG                 0x1828
 132 #define MVPP2_CLS_FLOW_TBL2_REG                 0x182c
 133 #define MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port)    (0x1980 + ((port) * 4))
 134 #define     MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS     3
 135 #define     MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK     0x7
 136 #define MVPP2_CLS_SWFWD_P2HQ_REG(port)          (0x19b0 + ((port) * 4))
 137 #define MVPP2_CLS_SWFWD_PCTRL_REG               0x19d0
 138 #define     MVPP2_CLS_SWFWD_PCTRL_MASK(port)    (1 << (port))
 139
 140 /* Descriptor Manager Top Registers */
 141 #define MVPP2_RXQ_NUM_REG                       0x2040
 142 #define MVPP2_RXQ_DESC_ADDR_REG                 0x2044
 143 #define     MVPP22_DESC_ADDR_OFFS               8
 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     MVPP22_AGGR_TXQ_DESC_ADDR_OFFS      8
 186 #define MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu)       (0x2140 + 4 * (cpu))
 187 #define     MVPP2_AGGR_TXQ_DESC_SIZE_MASK       0x3ff0
 188 #define MVPP2_AGGR_TXQ_STATUS_REG(cpu)          (0x2180 + 4 * (cpu))
 189 #define     MVPP2_AGGR_TXQ_PENDING_MASK         0x3fff
 190 #define MVPP2_AGGR_TXQ_INDEX_REG(cpu)           (0x21c0 + 4 * (cpu))
 191
 192 /* MBUS bridge registers */
 193 #define MVPP2_WIN_BASE(w)                       (0x4000 + ((w) << 2))
 194 #define MVPP2_WIN_SIZE(w)                       (0x4020 + ((w) << 2))
 195 #define MVPP2_WIN_REMAP(w)                      (0x4040 + ((w) << 2))
 196 #define MVPP2_BASE_ADDR_ENABLE                  0x4060
 197
 198 /* AXI Bridge Registers */
 199 #define MVPP22_AXI_BM_WR_ATTR_REG               0x4100
 200 #define MVPP22_AXI_BM_RD_ATTR_REG               0x4104
 201 #define MVPP22_AXI_AGGRQ_DESCR_RD_ATTR_REG      0x4110
 202 #define MVPP22_AXI_TXQ_DESCR_WR_ATTR_REG        0x4114
 203 #define MVPP22_AXI_TXQ_DESCR_RD_ATTR_REG        0x4118
 204 #define MVPP22_AXI_RXQ_DESCR_WR_ATTR_REG        0x411c
 205 #define MVPP22_AXI_RX_DATA_WR_ATTR_REG          0x4120
 206 #define MVPP22_AXI_TX_DATA_RD_ATTR_REG          0x4130
 207 #define MVPP22_AXI_RD_NORMAL_CODE_REG           0x4150
 208 #define MVPP22_AXI_RD_SNOOP_CODE_REG            0x4154
 209 #define MVPP22_AXI_WR_NORMAL_CODE_REG           0x4160
 210 #define MVPP22_AXI_WR_SNOOP_CODE_REG            0x4164
 211
 212 /* Values for AXI Bridge registers */
 213 #define MVPP22_AXI_ATTR_CACHE_OFFS              0
 214 #define MVPP22_AXI_ATTR_DOMAIN_OFFS             12
 215
 216 #define MVPP22_AXI_CODE_CACHE_OFFS              0
 217 #define MVPP22_AXI_CODE_DOMAIN_OFFS             4
 218
 219 #define MVPP22_AXI_CODE_CACHE_NON_CACHE         0x3
 220 #define MVPP22_AXI_CODE_CACHE_WR_CACHE          0x7
 221 #define MVPP22_AXI_CODE_CACHE_RD_CACHE          0xb
 222
 223 #define MVPP22_AXI_CODE_DOMAIN_OUTER_DOM        2
 224 #define MVPP22_AXI_CODE_DOMAIN_SYSTEM           3
 225
 226 /* Interrupt Cause and Mask registers */
 227 #define MVPP2_ISR_RX_THRESHOLD_REG(rxq)         (0x5200 + 4 * (rxq))
 228 #define MVPP21_ISR_RXQ_GROUP_REG(rxq)           (0x5400 + 4 * (rxq))
 229
 230 #define MVPP22_ISR_RXQ_GROUP_INDEX_REG          0x5400
 231 #define MVPP22_ISR_RXQ_GROUP_INDEX_SUBGROUP_MASK 0xf
 232 #define MVPP22_ISR_RXQ_GROUP_INDEX_GROUP_MASK   0x380
 233 #define MVPP22_ISR_RXQ_GROUP_INDEX_GROUP_OFFSET 7
 234
 235 #define MVPP22_ISR_RXQ_GROUP_INDEX_SUBGROUP_MASK 0xf
 236 #define MVPP22_ISR_RXQ_GROUP_INDEX_GROUP_MASK   0x380
 237
 238 #define MVPP22_ISR_RXQ_SUB_GROUP_CONFIG_REG     0x5404
 239 #define MVPP22_ISR_RXQ_SUB_GROUP_STARTQ_MASK    0x1f
 240 #define MVPP22_ISR_RXQ_SUB_GROUP_SIZE_MASK      0xf00
 241 #define MVPP22_ISR_RXQ_SUB_GROUP_SIZE_OFFSET    8
 242
 243 #define MVPP2_ISR_ENABLE_REG(port)              (0x5420 + 4 * (port))
 244 #define     MVPP2_ISR_ENABLE_INTERRUPT(mask)    ((mask) & 0xffff)
 245 #define     MVPP2_ISR_DISABLE_INTERRUPT(mask)   (((mask) << 16) & 0xffff0000)
 246 #define MVPP2_ISR_RX_TX_CAUSE_REG(port)         (0x5480 + 4 * (port))
 247 #define     MVPP2_CAUSE_RXQ_OCCUP_DESC_ALL_MASK 0xffff
 248 #define     MVPP2_CAUSE_TXQ_OCCUP_DESC_ALL_MASK 0xff0000
 249 #define     MVPP2_CAUSE_RX_FIFO_OVERRUN_MASK    BIT(24)
 250 #define     MVPP2_CAUSE_FCS_ERR_MASK            BIT(25)
 251 #define     MVPP2_CAUSE_TX_FIFO_UNDERRUN_MASK   BIT(26)
 252 #define     MVPP2_CAUSE_TX_EXCEPTION_SUM_MASK   BIT(29)
 253 #define     MVPP2_CAUSE_RX_EXCEPTION_SUM_MASK   BIT(30)
 254 #define     MVPP2_CAUSE_MISC_SUM_MASK           BIT(31)
 255 #define MVPP2_ISR_RX_TX_MASK_REG(port)          (0x54a0 + 4 * (port))
 256 #define MVPP2_ISR_PON_RX_TX_MASK_REG            0x54bc
 257 #define     MVPP2_PON_CAUSE_RXQ_OCCUP_DESC_ALL_MASK     0xffff
 258 #define     MVPP2_PON_CAUSE_TXP_OCCUP_DESC_ALL_MASK     0x3fc00000
 259 #define     MVPP2_PON_CAUSE_MISC_SUM_MASK               BIT(31)
 260 #define MVPP2_ISR_MISC_CAUSE_REG                0x55b0
 261
 262 /* Buffer Manager registers */
 263 #define MVPP2_BM_POOL_BASE_REG(pool)            (0x6000 + ((pool) * 4))
 264 #define     MVPP2_BM_POOL_BASE_ADDR_MASK        0xfffff80
 265 #define MVPP2_BM_POOL_SIZE_REG(pool)            (0x6040 + ((pool) * 4))
 266 #define     MVPP2_BM_POOL_SIZE_MASK             0xfff0
 267 #define MVPP2_BM_POOL_READ_PTR_REG(pool)        (0x6080 + ((pool) * 4))
 268 #define     MVPP2_BM_POOL_GET_READ_PTR_MASK     0xfff0
 269 #define MVPP2_BM_POOL_PTRS_NUM_REG(pool)        (0x60c0 + ((pool) * 4))
 270 #define     MVPP2_BM_POOL_PTRS_NUM_MASK         0xfff0
 271 #define MVPP2_BM_BPPI_READ_PTR_REG(pool)        (0x6100 + ((pool) * 4))
 272 #define MVPP2_BM_BPPI_PTRS_NUM_REG(pool)        (0x6140 + ((pool) * 4))
 273 #define     MVPP2_BM_BPPI_PTR_NUM_MASK          0x7ff
 274 #define     MVPP2_BM_BPPI_PREFETCH_FULL_MASK    BIT(16)
 275 #define MVPP2_BM_POOL_CTRL_REG(pool)            (0x6200 + ((pool) * 4))
 276 #define     MVPP2_BM_START_MASK                 BIT(0)
 277 #define     MVPP2_BM_STOP_MASK                  BIT(1)
 278 #define     MVPP2_BM_STATE_MASK                 BIT(4)
 279 #define     MVPP2_BM_LOW_THRESH_OFFS            8
 280 #define     MVPP2_BM_LOW_THRESH_MASK            0x7f00
 281 #define     MVPP2_BM_LOW_THRESH_VALUE(val)      ((val) << \
 282                                                 MVPP2_BM_LOW_THRESH_OFFS)
 283 #define     MVPP2_BM_HIGH_THRESH_OFFS           16
 284 #define     MVPP2_BM_HIGH_THRESH_MASK           0x7f0000
 285 #define     MVPP2_BM_HIGH_THRESH_VALUE(val)     ((val) << \
 286                                                 MVPP2_BM_HIGH_THRESH_OFFS)
 287 #define MVPP2_BM_INTR_CAUSE_REG(pool)           (0x6240 + ((pool) * 4))
 288 #define     MVPP2_BM_RELEASED_DELAY_MASK        BIT(0)
 289 #define     MVPP2_BM_ALLOC_FAILED_MASK          BIT(1)
 290 #define     MVPP2_BM_BPPE_EMPTY_MASK            BIT(2)
 291 #define     MVPP2_BM_BPPE_FULL_MASK             BIT(3)
 292 #define     MVPP2_BM_AVAILABLE_BP_LOW_MASK      BIT(4)
 293 #define MVPP2_BM_INTR_MASK_REG(pool)            (0x6280 + ((pool) * 4))
 294 #define MVPP2_BM_PHY_ALLOC_REG(pool)            (0x6400 + ((pool) * 4))
 295 #define     MVPP2_BM_PHY_ALLOC_GRNTD_MASK       BIT(0)
 296 #define MVPP2_BM_VIRT_ALLOC_REG                 0x6440
 297 #define MVPP2_BM_ADDR_HIGH_ALLOC                0x6444
 298 #define     MVPP2_BM_ADDR_HIGH_PHYS_MASK        0xff
 299 #define     MVPP2_BM_ADDR_HIGH_VIRT_MASK        0xff00
 300 #define     MVPP2_BM_ADDR_HIGH_VIRT_SHIFT       8
 301 #define MVPP2_BM_PHY_RLS_REG(pool)              (0x6480 + ((pool) * 4))
 302 #define     MVPP2_BM_PHY_RLS_MC_BUFF_MASK       BIT(0)
 303 #define     MVPP2_BM_PHY_RLS_PRIO_EN_MASK       BIT(1)
 304 #define     MVPP2_BM_PHY_RLS_GRNTD_MASK         BIT(2)
 305 #define MVPP2_BM_VIRT_RLS_REG                   0x64c0
 306 #define MVPP21_BM_MC_RLS_REG                    0x64c4
 307 #define     MVPP2_BM_MC_ID_MASK                 0xfff
 308 #define     MVPP2_BM_FORCE_RELEASE_MASK         BIT(12)
 309 #define MVPP22_BM_ADDR_HIGH_RLS_REG             0x64c4
 310 #define     MVPP22_BM_ADDR_HIGH_PHYS_RLS_MASK   0xff
 311 #define     MVPP22_BM_ADDR_HIGH_VIRT_RLS_MASK   0xff00
 312 #define     MVPP22_BM_ADDR_HIGH_VIRT_RLS_SHIFT  8
 313 #define MVPP22_BM_MC_RLS_REG                    0x64d4
 314 #define MVPP22_BM_POOL_BASE_HIGH_REG            0x6310
 315 #define MVPP22_BM_POOL_BASE_HIGH_MASK           0xff
 316
 317 /* TX Scheduler registers */
 318 #define MVPP2_TXP_SCHED_PORT_INDEX_REG          0x8000
 319 #define MVPP2_TXP_SCHED_Q_CMD_REG               0x8004
 320 #define     MVPP2_TXP_SCHED_ENQ_MASK            0xff
 321 #define     MVPP2_TXP_SCHED_DISQ_OFFSET         8
 322 #define MVPP2_TXP_SCHED_CMD_1_REG               0x8010
 323 #define MVPP2_TXP_SCHED_PERIOD_REG              0x8018
 324 #define MVPP2_TXP_SCHED_MTU_REG                 0x801c
 325 #define     MVPP2_TXP_MTU_MAX                   0x7FFFF
 326 #define MVPP2_TXP_SCHED_REFILL_REG              0x8020
 327 #define     MVPP2_TXP_REFILL_TOKENS_ALL_MASK    0x7ffff
 328 #define     MVPP2_TXP_REFILL_PERIOD_ALL_MASK    0x3ff00000
 329 #define     MVPP2_TXP_REFILL_PERIOD_MASK(v)     ((v) << 20)
 330 #define MVPP2_TXP_SCHED_TOKEN_SIZE_REG          0x8024
 331 #define     MVPP2_TXP_TOKEN_SIZE_MAX            0xffffffff
 332 #define MVPP2_TXQ_SCHED_REFILL_REG(q)           (0x8040 + ((q) << 2))
 333 #define     MVPP2_TXQ_REFILL_TOKENS_ALL_MASK    0x7ffff
 334 #define     MVPP2_TXQ_REFILL_PERIOD_ALL_MASK    0x3ff00000
 335 #define     MVPP2_TXQ_REFILL_PERIOD_MASK(v)     ((v) << 20)
 336 #define MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(q)       (0x8060 + ((q) << 2))
 337 #define     MVPP2_TXQ_TOKEN_SIZE_MAX            0x7fffffff
 338 #define MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(q)       (0x8080 + ((q) << 2))
 339 #define     MVPP2_TXQ_TOKEN_CNTR_MAX            0xffffffff
 340
 341 /* TX general registers */
 342 #define MVPP2_TX_SNOOP_REG                      0x8800
 343 #define MVPP2_TX_PORT_FLUSH_REG                 0x8810
 344 #define     MVPP2_TX_PORT_FLUSH_MASK(port)      (1 << (port))
 345
 346 /* LMS registers */
 347 #define MVPP2_SRC_ADDR_MIDDLE                   0x24
 348 #define MVPP2_SRC_ADDR_HIGH                     0x28
 349 #define MVPP2_PHY_AN_CFG0_REG                   0x34
 350 #define     MVPP2_PHY_AN_STOP_SMI0_MASK         BIT(7)
 351 #define MVPP2_MNG_EXTENDED_GLOBAL_CTRL_REG      0x305c
 352 #define     MVPP2_EXT_GLOBAL_CTRL_DEFAULT       0x27
 353
 354 /* Per-port registers */
 355 #define MVPP2_GMAC_CTRL_0_REG                   0x0
 356 #define      MVPP2_GMAC_PORT_EN_MASK            BIT(0)
 357 #define      MVPP2_GMAC_PORT_TYPE_MASK          BIT(1)
 358 #define      MVPP2_GMAC_MAX_RX_SIZE_OFFS        2
 359 #define      MVPP2_GMAC_MAX_RX_SIZE_MASK        0x7ffc
 360 #define      MVPP2_GMAC_MIB_CNTR_EN_MASK        BIT(15)
 361 #define MVPP2_GMAC_CTRL_1_REG                   0x4
 362 #define      MVPP2_GMAC_PERIODIC_XON_EN_MASK    BIT(1)
 363 #define      MVPP2_GMAC_GMII_LB_EN_MASK         BIT(5)
 364 #define      MVPP2_GMAC_PCS_LB_EN_BIT           6
 365 #define      MVPP2_GMAC_PCS_LB_EN_MASK          BIT(6)
 366 #define      MVPP2_GMAC_SA_LOW_OFFS             7
 367 #define MVPP2_GMAC_CTRL_2_REG                   0x8
 368 #define      MVPP2_GMAC_INBAND_AN_MASK          BIT(0)
 369 #define      MVPP2_GMAC_SGMII_MODE_MASK         BIT(0)
 370 #define      MVPP2_GMAC_PCS_ENABLE_MASK         BIT(3)
 371 #define      MVPP2_GMAC_PORT_RGMII_MASK         BIT(4)
 372 #define      MVPP2_GMAC_PORT_DIS_PADING_MASK    BIT(5)
 373 #define      MVPP2_GMAC_PORT_RESET_MASK         BIT(6)
 374 #define      MVPP2_GMAC_CLK_125_BYPS_EN_MASK    BIT(9)
 375 #define MVPP2_GMAC_AUTONEG_CONFIG               0xc
 376 #define      MVPP2_GMAC_FORCE_LINK_DOWN         BIT(0)
 377 #define      MVPP2_GMAC_FORCE_LINK_PASS         BIT(1)
 378 #define      MVPP2_GMAC_EN_PCS_AN               BIT(2)
 379 #define      MVPP2_GMAC_AN_BYPASS_EN            BIT(3)
 380 #define      MVPP2_GMAC_CONFIG_MII_SPEED        BIT(5)
 381 #define      MVPP2_GMAC_CONFIG_GMII_SPEED       BIT(6)
 382 #define      MVPP2_GMAC_AN_SPEED_EN             BIT(7)
 383 #define      MVPP2_GMAC_FC_ADV_EN               BIT(9)
 384 #define      MVPP2_GMAC_EN_FC_AN                BIT(11)
 385 #define      MVPP2_GMAC_CONFIG_FULL_DUPLEX      BIT(12)
 386 #define      MVPP2_GMAC_AN_DUPLEX_EN            BIT(13)
 387 #define      MVPP2_GMAC_CHOOSE_SAMPLE_TX_CONFIG BIT(15)
 388 #define MVPP2_GMAC_PORT_FIFO_CFG_1_REG          0x1c
 389 #define      MVPP2_GMAC_TX_FIFO_MIN_TH_OFFS     6
 390 #define      MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK 0x1fc0
 391 #define      MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(v)  (((v) << 6) & \
 392                                         MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK)
 393 #define MVPP2_GMAC_CTRL_4_REG                   0x90
 394 #define      MVPP2_GMAC_CTRL4_EXT_PIN_GMII_SEL_MASK     BIT(0)
 395 #define      MVPP2_GMAC_CTRL4_DP_CLK_SEL_MASK   BIT(5)
 396 #define      MVPP2_GMAC_CTRL4_SYNC_BYPASS_MASK  BIT(6)
 397 #define      MVPP2_GMAC_CTRL4_QSGMII_BYPASS_ACTIVE_MASK BIT(7)
 398
 399 /*
 400  * Per-port XGMAC registers. PPv2.2 only, only for GOP port 0,
 401  * relative to port->base.
 402  */
 403
 404 /* Port Mac Control0 */
 405 #define MVPP22_XLG_CTRL0_REG                    0x100
 406 #define      MVPP22_XLG_PORT_EN                 BIT(0)
 407 #define      MVPP22_XLG_MAC_RESETN              BIT(1)
 408 #define      MVPP22_XLG_RX_FC_EN                BIT(7)
 409 #define      MVPP22_XLG_MIBCNT_DIS              BIT(13)
 410 /* Port Mac Control1 */
 411 #define MVPP22_XLG_CTRL1_REG                    0x104
 412 #define      MVPP22_XLG_MAX_RX_SIZE_OFFS        0
 413 #define      MVPP22_XLG_MAX_RX_SIZE_MASK        0x1fff
 414 /* Port Interrupt Mask */
 415 #define MVPP22_XLG_INTERRUPT_MASK_REG           0x118
 416 #define      MVPP22_XLG_INTERRUPT_LINK_CHANGE   BIT(1)
 417 /* Port Mac Control3 */
 418 #define MVPP22_XLG_CTRL3_REG                    0x11c
 419 #define      MVPP22_XLG_CTRL3_MACMODESELECT_MASK        (7 << 13)
 420 #define      MVPP22_XLG_CTRL3_MACMODESELECT_GMAC        (0 << 13)
 421 #define      MVPP22_XLG_CTRL3_MACMODESELECT_10GMAC      (1 << 13)
 422 /* Port Mac Control4 */
 423 #define MVPP22_XLG_CTRL4_REG                    0x184
 424 #define      MVPP22_XLG_FORWARD_802_3X_FC_EN    BIT(5)
 425 #define      MVPP22_XLG_FORWARD_PFC_EN          BIT(6)
 426 #define      MVPP22_XLG_MODE_DMA_1G             BIT(12)
 427 #define      MVPP22_XLG_EN_IDLE_CHECK_FOR_LINK  BIT(14)
 428
 429 /* XPCS registers */
 430
 431 /* Global Configuration 0 */
 432 #define MVPP22_XPCS_GLOBAL_CFG_0_REG            0x0
 433 #define      MVPP22_XPCS_PCSRESET               BIT(0)
 434 #define      MVPP22_XPCS_PCSMODE_OFFS           3
 435 #define      MVPP22_XPCS_PCSMODE_MASK           (0x3 << \
 436                                                  MVPP22_XPCS_PCSMODE_OFFS)
 437 #define      MVPP22_XPCS_LANEACTIVE_OFFS        5
 438 #define      MVPP22_XPCS_LANEACTIVE_MASK        (0x3 << \
 439                                                  MVPP22_XPCS_LANEACTIVE_OFFS)
 440
 441 /* MPCS registers */
 442
 443 #define PCS40G_COMMON_CONTROL                   0x14
 444 #define      FORWARD_ERROR_CORRECTION_MASK      BIT(10)
 445
 446 #define PCS_CLOCK_RESET                         0x14c
 447 #define      TX_SD_CLK_RESET_MASK               BIT(0)
 448 #define      RX_SD_CLK_RESET_MASK               BIT(1)
 449 #define      MAC_CLK_RESET_MASK                 BIT(2)
 450 #define      CLK_DIVISION_RATIO_OFFS            4
 451 #define      CLK_DIVISION_RATIO_MASK            (0x7 << CLK_DIVISION_RATIO_OFFS)
 452 #define      CLK_DIV_PHASE_SET_MASK             BIT(11)
 453
 454 /* System Soft Reset 1 */
 455 #define GOP_SOFT_RESET_1_REG                    0x108
 456 #define     NETC_GOP_SOFT_RESET_OFFS            6
 457 #define     NETC_GOP_SOFT_RESET_MASK            (0x1 << \
 458                                                  NETC_GOP_SOFT_RESET_OFFS)
 459
 460 /* Ports Control 0 */
 461 #define NETCOMP_PORTS_CONTROL_0_REG             0x110
 462 #define     NETC_BUS_WIDTH_SELECT_OFFS          1
 463 #define     NETC_BUS_WIDTH_SELECT_MASK          (0x1 << \
 464                                                  NETC_BUS_WIDTH_SELECT_OFFS)
 465 #define     NETC_GIG_RX_DATA_SAMPLE_OFFS        29
 466 #define     NETC_GIG_RX_DATA_SAMPLE_MASK        (0x1 << \
 467                                                  NETC_GIG_RX_DATA_SAMPLE_OFFS)
 468 #define     NETC_CLK_DIV_PHASE_OFFS             31
 469 #define     NETC_CLK_DIV_PHASE_MASK             (0x1 << NETC_CLK_DIV_PHASE_OFFS)
 470 /* Ports Control 1 */
 471 #define NETCOMP_PORTS_CONTROL_1_REG             0x114
 472 #define     NETC_PORTS_ACTIVE_OFFSET(p)         (0 + p)
 473 #define     NETC_PORTS_ACTIVE_MASK(p)           (0x1 << \
 474                                                  NETC_PORTS_ACTIVE_OFFSET(p))
 475 #define     NETC_PORT_GIG_RF_RESET_OFFS(p)      (28 + p)
 476 #define     NETC_PORT_GIG_RF_RESET_MASK(p)      (0x1 << \
 477                                                  NETC_PORT_GIG_RF_RESET_OFFS(p))
 478 #define NETCOMP_CONTROL_0_REG                   0x120
 479 #define     NETC_GBE_PORT0_SGMII_MODE_OFFS      0
 480 #define     NETC_GBE_PORT0_SGMII_MODE_MASK      (0x1 << \
 481                                                  NETC_GBE_PORT0_SGMII_MODE_OFFS)
 482 #define     NETC_GBE_PORT1_SGMII_MODE_OFFS      1
 483 #define     NETC_GBE_PORT1_SGMII_MODE_MASK      (0x1 << \
 484                                                  NETC_GBE_PORT1_SGMII_MODE_OFFS)
 485 #define     NETC_GBE_PORT1_MII_MODE_OFFS        2
 486 #define     NETC_GBE_PORT1_MII_MODE_MASK        (0x1 << \
 487                                                  NETC_GBE_PORT1_MII_MODE_OFFS)
 488
 489 #define MVPP22_SMI_MISC_CFG_REG                 (MVPP22_SMI + 0x04)
 490 #define      MVPP22_SMI_POLLING_EN              BIT(10)
 491
 492 #define MVPP22_SMI_PHY_ADDR_REG(port)           (MVPP22_SMI + 0x04 + \
 493                                                  (0x4 * (port)))
 494
 495 #define MVPP2_CAUSE_TXQ_SENT_DESC_ALL_MASK      0xff
 496
 497 /* Descriptor ring Macros */
 498 #define MVPP2_QUEUE_NEXT_DESC(q, index) \
 499         (((index) < (q)->last_desc) ? ((index) + 1) : 0)
 500
 501 /* PP2.2: SMI: 0x12a200 -> offset 0x1200 to iface_base */
 502 #define MVPP22_SMI                              0x1200
 503
 504 /* Additional PPv2.2 offsets */
 505 #define MVPP22_MPCS                             0x007000
 506 #define MVPP22_XPCS                             0x007400
 507 #define MVPP22_PORT_BASE                        0x007e00
 508 #define MVPP22_PORT_OFFSET                      0x001000
 509 #define MVPP22_RFU1                             0x318000
 510
 511 /* Maximum number of ports */
 512 #define MVPP22_GOP_MAC_NUM                      4
 513
 514 /* Sets the field located at the specified in data */
 515 #define MVPP2_RGMII_TX_FIFO_MIN_TH              0x41
 516 #define MVPP2_SGMII_TX_FIFO_MIN_TH              0x5
 517 #define MVPP2_SGMII2_5_TX_FIFO_MIN_TH           0xb
 518
 519 /* Net Complex */
 520 enum mv_netc_topology {
 521         MV_NETC_GE_MAC2_SGMII           =       BIT(0),
 522         MV_NETC_GE_MAC3_SGMII           =       BIT(1),
 523         MV_NETC_GE_MAC3_RGMII           =       BIT(2),
 524 };
 525
 526 enum mv_netc_phase {
 527         MV_NETC_FIRST_PHASE,
 528         MV_NETC_SECOND_PHASE,
 529 };
 530
 531 enum mv_netc_sgmii_xmi_mode {
 532         MV_NETC_GBE_SGMII,
 533         MV_NETC_GBE_XMII,
 534 };
 535
 536 enum mv_netc_mii_mode {
 537         MV_NETC_GBE_RGMII,
 538         MV_NETC_GBE_MII,
 539 };
 540
 541 enum mv_netc_lanes {
 542         MV_NETC_LANE_23,
 543         MV_NETC_LANE_45,
 544 };
 545
 546 /* Various constants */
 547
 548 /* Coalescing */
 549 #define MVPP2_TXDONE_COAL_PKTS_THRESH   15
 550 #define MVPP2_TXDONE_HRTIMER_PERIOD_NS  1000000UL
 551 #define MVPP2_RX_COAL_PKTS              32
 552 #define MVPP2_RX_COAL_USEC              100
 553
 554 /* The two bytes Marvell header. Either contains a special value used
 555  * by Marvell switches when a specific hardware mode is enabled (not
 556  * supported by this driver) or is filled automatically by zeroes on
 557  * the RX side. Those two bytes being at the front of the Ethernet
 558  * header, they allow to have the IP header aligned on a 4 bytes
 559  * boundary automatically: the hardware skips those two bytes on its
 560  * own.
 561  */
 562 #define MVPP2_MH_SIZE                   2
 563 #define MVPP2_ETH_TYPE_LEN              2
 564 #define MVPP2_PPPOE_HDR_SIZE            8
 565 #define MVPP2_VLAN_TAG_LEN              4
 566
 567 /* Lbtd 802.3 type */
 568 #define MVPP2_IP_LBDT_TYPE              0xfffa
 569
 570 #define MVPP2_CPU_D_CACHE_LINE_SIZE     32
 571 #define MVPP2_TX_CSUM_MAX_SIZE          9800
 572
 573 /* Timeout constants */
 574 #define MVPP2_TX_DISABLE_TIMEOUT_MSEC   1000
 575 #define MVPP2_TX_PENDING_TIMEOUT_MSEC   1000
 576
 577 #define MVPP2_TX_MTU_MAX                0x7ffff
 578
 579 /* Maximum number of T-CONTs of PON port */
 580 #define MVPP2_MAX_TCONT                 16
 581
 582 /* Maximum number of supported ports */
 583 #define MVPP2_MAX_PORTS                 4
 584
 585 /* Maximum number of TXQs used by single port */
 586 #define MVPP2_MAX_TXQ                   8
 587
 588 /* Default number of TXQs in use */
 589 #define MVPP2_DEFAULT_TXQ               1
 590
 591 /* Default number of RXQs in use */
 592 #define MVPP2_DEFAULT_RXQ               1
 593 #define CONFIG_MV_ETH_RXQ               8       /* increment by 8 */
 594
 595 /* Max number of Rx descriptors */
 596 #define MVPP2_MAX_RXD                   16
 597
 598 /* Max number of Tx descriptors */
 599 #define MVPP2_MAX_TXD                   16
 600
 601 /* Amount of Tx descriptors that can be reserved at once by CPU */
 602 #define MVPP2_CPU_DESC_CHUNK            16
 603
 604 /* Max number of Tx descriptors in each aggregated queue */
 605 #define MVPP2_AGGR_TXQ_SIZE             16
 606
 607 /* Descriptor aligned size */
 608 #define MVPP2_DESC_ALIGNED_SIZE         32
 609
 610 /* Descriptor alignment mask */
 611 #define MVPP2_TX_DESC_ALIGN             (MVPP2_DESC_ALIGNED_SIZE - 1)
 612
 613 /* RX FIFO constants */
 614 #define MVPP21_RX_FIFO_PORT_DATA_SIZE           0x2000
 615 #define MVPP21_RX_FIFO_PORT_ATTR_SIZE           0x80
 616 #define MVPP22_RX_FIFO_10GB_PORT_DATA_SIZE      0x8000
 617 #define MVPP22_RX_FIFO_2_5GB_PORT_DATA_SIZE     0x2000
 618 #define MVPP22_RX_FIFO_1GB_PORT_DATA_SIZE       0x1000
 619 #define MVPP22_RX_FIFO_10GB_PORT_ATTR_SIZE      0x200
 620 #define MVPP22_RX_FIFO_2_5GB_PORT_ATTR_SIZE     0x80
 621 #define MVPP22_RX_FIFO_1GB_PORT_ATTR_SIZE       0x40
 622 #define MVPP2_RX_FIFO_PORT_MIN_PKT              0x80
 623
 624 /* TX general registers */
 625 #define MVPP22_TX_FIFO_SIZE_REG(eth_tx_port)    (0x8860 + ((eth_tx_port) << 2))
 626 #define MVPP22_TX_FIFO_SIZE_MASK                0xf
 627
 628 /* TX FIFO constants */
 629 #define MVPP2_TX_FIFO_DATA_SIZE_10KB            0xa
 630 #define MVPP2_TX_FIFO_DATA_SIZE_3KB             0x3
 631
 632 /* RX buffer constants */
 633 #define MVPP2_SKB_SHINFO_SIZE \
 634         0
 635
 636 #define MVPP2_RX_PKT_SIZE(mtu) \
 637         ALIGN((mtu) + MVPP2_MH_SIZE + MVPP2_VLAN_TAG_LEN + \
 638               ETH_HLEN + ETH_FCS_LEN, MVPP2_CPU_D_CACHE_LINE_SIZE)
 639
 640 #define MVPP2_RX_BUF_SIZE(pkt_size)     ((pkt_size) + NET_SKB_PAD)
 641 #define MVPP2_RX_TOTAL_SIZE(buf_size)   ((buf_size) + MVPP2_SKB_SHINFO_SIZE)
 642 #define MVPP2_RX_MAX_PKT_SIZE(total_size) \
 643         ((total_size) - NET_SKB_PAD - MVPP2_SKB_SHINFO_SIZE)
 644
 645 #define MVPP2_BIT_TO_BYTE(bit)          ((bit) / 8)
 646
 647 /* IPv6 max L3 address size */
 648 #define MVPP2_MAX_L3_ADDR_SIZE          16
 649
 650 /* Port flags */
 651 #define MVPP2_F_LOOPBACK                BIT(0)
 652
 653 /* Marvell tag types */
 654 enum mvpp2_tag_type {
 655         MVPP2_TAG_TYPE_NONE = 0,
 656         MVPP2_TAG_TYPE_MH   = 1,
 657         MVPP2_TAG_TYPE_DSA  = 2,
 658         MVPP2_TAG_TYPE_EDSA = 3,
 659         MVPP2_TAG_TYPE_VLAN = 4,
 660         MVPP2_TAG_TYPE_LAST = 5
 661 };
 662
 663 /* Parser constants */
 664 #define MVPP2_PRS_TCAM_SRAM_SIZE        256
 665 #define MVPP2_PRS_TCAM_WORDS            6
 666 #define MVPP2_PRS_SRAM_WORDS            4
 667 #define MVPP2_PRS_FLOW_ID_SIZE          64
 668 #define MVPP2_PRS_FLOW_ID_MASK          0x3f
 669 #define MVPP2_PRS_TCAM_ENTRY_INVALID    1
 670 #define MVPP2_PRS_TCAM_DSA_TAGGED_BIT   BIT(5)
 671 #define MVPP2_PRS_IPV4_HEAD             0x40
 672 #define MVPP2_PRS_IPV4_HEAD_MASK        0xf0
 673 #define MVPP2_PRS_IPV4_MC               0xe0
 674 #define MVPP2_PRS_IPV4_MC_MASK          0xf0
 675 #define MVPP2_PRS_IPV4_BC_MASK          0xff
 676 #define MVPP2_PRS_IPV4_IHL              0x5
 677 #define MVPP2_PRS_IPV4_IHL_MASK         0xf
 678 #define MVPP2_PRS_IPV6_MC               0xff
 679 #define MVPP2_PRS_IPV6_MC_MASK          0xff
 680 #define MVPP2_PRS_IPV6_HOP_MASK         0xff
 681 #define MVPP2_PRS_TCAM_PROTO_MASK       0xff
 682 #define MVPP2_PRS_TCAM_PROTO_MASK_L     0x3f
 683 #define MVPP2_PRS_DBL_VLANS_MAX         100
 684
 685 /* Tcam structure:
 686  * - lookup ID - 4 bits
 687  * - port ID - 1 byte
 688  * - additional information - 1 byte
 689  * - header data - 8 bytes
 690  * The fields are represented by MVPP2_PRS_TCAM_DATA_REG(5)->(0).
 691  */
 692 #define MVPP2_PRS_AI_BITS                       8
 693 #define MVPP2_PRS_PORT_MASK                     0xff
 694 #define MVPP2_PRS_LU_MASK                       0xf
 695 #define MVPP2_PRS_TCAM_DATA_BYTE(offs)          \
 696                                     (((offs) - ((offs) % 2)) * 2 + ((offs) % 2))
 697 #define MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)       \
 698                                               (((offs) * 2) - ((offs) % 2)  + 2)
 699 #define MVPP2_PRS_TCAM_AI_BYTE                  16
 700 #define MVPP2_PRS_TCAM_PORT_BYTE                17
 701 #define MVPP2_PRS_TCAM_LU_BYTE                  20
 702 #define MVPP2_PRS_TCAM_EN_OFFS(offs)            ((offs) + 2)
 703 #define MVPP2_PRS_TCAM_INV_WORD                 5
 704 /* Tcam entries ID */
 705 #define MVPP2_PE_DROP_ALL               0
 706 #define MVPP2_PE_FIRST_FREE_TID         1
 707 #define MVPP2_PE_LAST_FREE_TID          (MVPP2_PRS_TCAM_SRAM_SIZE - 31)
 708 #define MVPP2_PE_IP6_EXT_PROTO_UN       (MVPP2_PRS_TCAM_SRAM_SIZE - 30)
 709 #define MVPP2_PE_MAC_MC_IP6             (MVPP2_PRS_TCAM_SRAM_SIZE - 29)
 710 #define MVPP2_PE_IP6_ADDR_UN            (MVPP2_PRS_TCAM_SRAM_SIZE - 28)
 711 #define MVPP2_PE_IP4_ADDR_UN            (MVPP2_PRS_TCAM_SRAM_SIZE - 27)
 712 #define MVPP2_PE_LAST_DEFAULT_FLOW      (MVPP2_PRS_TCAM_SRAM_SIZE - 26)
 713 #define MVPP2_PE_FIRST_DEFAULT_FLOW     (MVPP2_PRS_TCAM_SRAM_SIZE - 19)
 714 #define MVPP2_PE_EDSA_TAGGED            (MVPP2_PRS_TCAM_SRAM_SIZE - 18)
 715 #define MVPP2_PE_EDSA_UNTAGGED          (MVPP2_PRS_TCAM_SRAM_SIZE - 17)
 716 #define MVPP2_PE_DSA_TAGGED             (MVPP2_PRS_TCAM_SRAM_SIZE - 16)
 717 #define MVPP2_PE_DSA_UNTAGGED           (MVPP2_PRS_TCAM_SRAM_SIZE - 15)
 718 #define MVPP2_PE_ETYPE_EDSA_TAGGED      (MVPP2_PRS_TCAM_SRAM_SIZE - 14)
 719 #define MVPP2_PE_ETYPE_EDSA_UNTAGGED    (MVPP2_PRS_TCAM_SRAM_SIZE - 13)
 720 #define MVPP2_PE_ETYPE_DSA_TAGGED       (MVPP2_PRS_TCAM_SRAM_SIZE - 12)
 721 #define MVPP2_PE_ETYPE_DSA_UNTAGGED     (MVPP2_PRS_TCAM_SRAM_SIZE - 11)
 722 #define MVPP2_PE_MH_DEFAULT             (MVPP2_PRS_TCAM_SRAM_SIZE - 10)
 723 #define MVPP2_PE_DSA_DEFAULT            (MVPP2_PRS_TCAM_SRAM_SIZE - 9)
 724 #define MVPP2_PE_IP6_PROTO_UN           (MVPP2_PRS_TCAM_SRAM_SIZE - 8)
 725 #define MVPP2_PE_IP4_PROTO_UN           (MVPP2_PRS_TCAM_SRAM_SIZE - 7)
 726 #define MVPP2_PE_ETH_TYPE_UN            (MVPP2_PRS_TCAM_SRAM_SIZE - 6)
 727 #define MVPP2_PE_VLAN_DBL               (MVPP2_PRS_TCAM_SRAM_SIZE - 5)
 728 #define MVPP2_PE_VLAN_NONE              (MVPP2_PRS_TCAM_SRAM_SIZE - 4)
 729 #define MVPP2_PE_MAC_MC_ALL             (MVPP2_PRS_TCAM_SRAM_SIZE - 3)
 730 #define MVPP2_PE_MAC_PROMISCUOUS        (MVPP2_PRS_TCAM_SRAM_SIZE - 2)
 731 #define MVPP2_PE_MAC_NON_PROMISCUOUS    (MVPP2_PRS_TCAM_SRAM_SIZE - 1)
 732
 733 /* Sram structure
 734  * The fields are represented by MVPP2_PRS_TCAM_DATA_REG(3)->(0).
 735  */
 736 #define MVPP2_PRS_SRAM_RI_OFFS                  0
 737 #define MVPP2_PRS_SRAM_RI_WORD                  0
 738 #define MVPP2_PRS_SRAM_RI_CTRL_OFFS             32
 739 #define MVPP2_PRS_SRAM_RI_CTRL_WORD             1
 740 #define MVPP2_PRS_SRAM_RI_CTRL_BITS             32
 741 #define MVPP2_PRS_SRAM_SHIFT_OFFS               64
 742 #define MVPP2_PRS_SRAM_SHIFT_SIGN_BIT           72
 743 #define MVPP2_PRS_SRAM_UDF_OFFS                 73
 744 #define MVPP2_PRS_SRAM_UDF_BITS                 8
 745 #define MVPP2_PRS_SRAM_UDF_MASK                 0xff
 746 #define MVPP2_PRS_SRAM_UDF_SIGN_BIT             81
 747 #define MVPP2_PRS_SRAM_UDF_TYPE_OFFS            82
 748 #define MVPP2_PRS_SRAM_UDF_TYPE_MASK            0x7
 749 #define MVPP2_PRS_SRAM_UDF_TYPE_L3              1
 750 #define MVPP2_PRS_SRAM_UDF_TYPE_L4              4
 751 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS        85
 752 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK        0x3
 753 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD         1
 754 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_IP4_ADD     2
 755 #define MVPP2_PRS_SRAM_OP_SEL_SHIFT_IP6_ADD     3
 756 #define MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS          87
 757 #define MVPP2_PRS_SRAM_OP_SEL_UDF_BITS          2
 758 #define MVPP2_PRS_SRAM_OP_SEL_UDF_MASK          0x3
 759 #define MVPP2_PRS_SRAM_OP_SEL_UDF_ADD           0
 760 #define MVPP2_PRS_SRAM_OP_SEL_UDF_IP4_ADD       2
 761 #define MVPP2_PRS_SRAM_OP_SEL_UDF_IP6_ADD       3
 762 #define MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS         89
 763 #define MVPP2_PRS_SRAM_AI_OFFS                  90
 764 #define MVPP2_PRS_SRAM_AI_CTRL_OFFS             98
 765 #define MVPP2_PRS_SRAM_AI_CTRL_BITS             8
 766 #define MVPP2_PRS_SRAM_AI_MASK                  0xff
 767 #define MVPP2_PRS_SRAM_NEXT_LU_OFFS             106
 768 #define MVPP2_PRS_SRAM_NEXT_LU_MASK             0xf
 769 #define MVPP2_PRS_SRAM_LU_DONE_BIT              110
 770 #define MVPP2_PRS_SRAM_LU_GEN_BIT               111
 771
 772 /* Sram result info bits assignment */
 773 #define MVPP2_PRS_RI_MAC_ME_MASK                0x1
 774 #define MVPP2_PRS_RI_DSA_MASK                   0x2
 775 #define MVPP2_PRS_RI_VLAN_MASK                  (BIT(2) | BIT(3))
 776 #define MVPP2_PRS_RI_VLAN_NONE                  0x0
 777 #define MVPP2_PRS_RI_VLAN_SINGLE                BIT(2)
 778 #define MVPP2_PRS_RI_VLAN_DOUBLE                BIT(3)
 779 #define MVPP2_PRS_RI_VLAN_TRIPLE                (BIT(2) | BIT(3))
 780 #define MVPP2_PRS_RI_CPU_CODE_MASK              0x70
 781 #define MVPP2_PRS_RI_CPU_CODE_RX_SPEC           BIT(4)
 782 #define MVPP2_PRS_RI_L2_CAST_MASK               (BIT(9) | BIT(10))
 783 #define MVPP2_PRS_RI_L2_UCAST                   0x0
 784 #define MVPP2_PRS_RI_L2_MCAST                   BIT(9)
 785 #define MVPP2_PRS_RI_L2_BCAST                   BIT(10)
 786 #define MVPP2_PRS_RI_PPPOE_MASK                 0x800
 787 #define MVPP2_PRS_RI_L3_PROTO_MASK              (BIT(12) | BIT(13) | BIT(14))
 788 #define MVPP2_PRS_RI_L3_UN                      0x0
 789 #define MVPP2_PRS_RI_L3_IP4                     BIT(12)
 790 #define MVPP2_PRS_RI_L3_IP4_OPT                 BIT(13)
 791 #define MVPP2_PRS_RI_L3_IP4_OTHER               (BIT(12) | BIT(13))
 792 #define MVPP2_PRS_RI_L3_IP6                     BIT(14)
 793 #define MVPP2_PRS_RI_L3_IP6_EXT                 (BIT(12) | BIT(14))
 794 #define MVPP2_PRS_RI_L3_ARP                     (BIT(13) | BIT(14))
 795 #define MVPP2_PRS_RI_L3_ADDR_MASK               (BIT(15) | BIT(16))
 796 #define MVPP2_PRS_RI_L3_UCAST                   0x0
 797 #define MVPP2_PRS_RI_L3_MCAST                   BIT(15)
 798 #define MVPP2_PRS_RI_L3_BCAST                   (BIT(15) | BIT(16))
 799 #define MVPP2_PRS_RI_IP_FRAG_MASK               0x20000
 800 #define MVPP2_PRS_RI_UDF3_MASK                  0x300000
 801 #define MVPP2_PRS_RI_UDF3_RX_SPECIAL            BIT(21)
 802 #define MVPP2_PRS_RI_L4_PROTO_MASK              0x1c00000
 803 #define MVPP2_PRS_RI_L4_TCP                     BIT(22)
 804 #define MVPP2_PRS_RI_L4_UDP                     BIT(23)
 805 #define MVPP2_PRS_RI_L4_OTHER                   (BIT(22) | BIT(23))
 806 #define MVPP2_PRS_RI_UDF7_MASK                  0x60000000
 807 #define MVPP2_PRS_RI_UDF7_IP6_LITE              BIT(29)
 808 #define MVPP2_PRS_RI_DROP_MASK                  0x80000000
 809
 810 /* Sram additional info bits assignment */
 811 #define MVPP2_PRS_IPV4_DIP_AI_BIT               BIT(0)
 812 #define MVPP2_PRS_IPV6_NO_EXT_AI_BIT            BIT(0)
 813 #define MVPP2_PRS_IPV6_EXT_AI_BIT               BIT(1)
 814 #define MVPP2_PRS_IPV6_EXT_AH_AI_BIT            BIT(2)
 815 #define MVPP2_PRS_IPV6_EXT_AH_LEN_AI_BIT        BIT(3)
 816 #define MVPP2_PRS_IPV6_EXT_AH_L4_AI_BIT         BIT(4)
 817 #define MVPP2_PRS_SINGLE_VLAN_AI                0
 818 #define MVPP2_PRS_DBL_VLAN_AI_BIT               BIT(7)
 819
 820 /* DSA/EDSA type */
 821 #define MVPP2_PRS_TAGGED                true
 822 #define MVPP2_PRS_UNTAGGED              false
 823 #define MVPP2_PRS_EDSA                  true
 824 #define MVPP2_PRS_DSA                   false
 825
 826 /* MAC entries, shadow udf */
 827 enum mvpp2_prs_udf {
 828         MVPP2_PRS_UDF_MAC_DEF,
 829         MVPP2_PRS_UDF_MAC_RANGE,
 830         MVPP2_PRS_UDF_L2_DEF,
 831         MVPP2_PRS_UDF_L2_DEF_COPY,
 832         MVPP2_PRS_UDF_L2_USER,
 833 };
 834
 835 /* Lookup ID */
 836 enum mvpp2_prs_lookup {
 837         MVPP2_PRS_LU_MH,
 838         MVPP2_PRS_LU_MAC,
 839         MVPP2_PRS_LU_DSA,
 840         MVPP2_PRS_LU_VLAN,
 841         MVPP2_PRS_LU_L2,
 842         MVPP2_PRS_LU_PPPOE,
 843         MVPP2_PRS_LU_IP4,
 844         MVPP2_PRS_LU_IP6,
 845         MVPP2_PRS_LU_FLOWS,
 846         MVPP2_PRS_LU_LAST,
 847 };
 848
 849 /* L3 cast enum */
 850 enum mvpp2_prs_l3_cast {
 851         MVPP2_PRS_L3_UNI_CAST,
 852         MVPP2_PRS_L3_MULTI_CAST,
 853         MVPP2_PRS_L3_BROAD_CAST
 854 };
 855
 856 /* Classifier constants */
 857 #define MVPP2_CLS_FLOWS_TBL_SIZE        512
 858 #define MVPP2_CLS_FLOWS_TBL_DATA_WORDS  3
 859 #define MVPP2_CLS_LKP_TBL_SIZE          64
 860
 861 /* BM constants */
 862 #define MVPP2_BM_POOLS_NUM              1
 863 #define MVPP2_BM_LONG_BUF_NUM           16
 864 #define MVPP2_BM_SHORT_BUF_NUM          16
 865 #define MVPP2_BM_POOL_SIZE_MAX          (16*1024 - MVPP2_BM_POOL_PTR_ALIGN/4)
 866 #define MVPP2_BM_POOL_PTR_ALIGN         128
 867 #define MVPP2_BM_SWF_LONG_POOL(port)    0
 868
 869 /* BM cookie (32 bits) definition */
 870 #define MVPP2_BM_COOKIE_POOL_OFFS       8
 871 #define MVPP2_BM_COOKIE_CPU_OFFS        24
 872
 873 /* BM short pool packet size
 874  * These value assure that for SWF the total number
 875  * of bytes allocated for each buffer will be 512
 876  */
 877 #define MVPP2_BM_SHORT_PKT_SIZE         MVPP2_RX_MAX_PKT_SIZE(512)
 878
 879 enum mvpp2_bm_type {
 880         MVPP2_BM_FREE,
 881         MVPP2_BM_SWF_LONG,
 882         MVPP2_BM_SWF_SHORT
 883 };
 884
 885 /* Definitions */
 886
 887 /* Shared Packet Processor resources */
 888 struct mvpp2 {
 889         /* Shared registers' base addresses */
 890         void __iomem *base;
 891         void __iomem *lms_base;
 892         void __iomem *iface_base;
 893
 894         void __iomem *mpcs_base;
 895         void __iomem *xpcs_base;
 896         void __iomem *rfu1_base;
 897
 898         u32 netc_config;
 899
 900         /* List of pointers to port structures */
 901         struct mvpp2_port **port_list;
 902
 903         /* Aggregated TXQs */
 904         struct mvpp2_tx_queue *aggr_txqs;
 905
 906         /* BM pools */
 907         struct mvpp2_bm_pool *bm_pools;
 908
 909         /* PRS shadow table */
 910         struct mvpp2_prs_shadow *prs_shadow;
 911         /* PRS auxiliary table for double vlan entries control */
 912         bool *prs_double_vlans;
 913
 914         /* Tclk value */
 915         u32 tclk;
 916
 917         /* HW version */
 918         enum { MVPP21, MVPP22 } hw_version;
 919
 920         /* Maximum number of RXQs per port */
 921         unsigned int max_port_rxqs;
 922
 923         int probe_done;
 924         u8 num_ports;
 925 };
 926
 927 struct mvpp2_pcpu_stats {
 928         u64     rx_packets;
 929         u64     rx_bytes;
 930         u64     tx_packets;
 931         u64     tx_bytes;
 932 };
 933
 934 struct mvpp2_port {
 935         u8 id;
 936
 937         /* Index of the port from the "group of ports" complex point
 938          * of view
 939          */
 940         int gop_id;
 941
 942         int irq;
 943
 944         struct mvpp2 *priv;
 945
 946         /* Per-port registers' base address */
 947         void __iomem *base;
 948
 949         struct mvpp2_rx_queue **rxqs;
 950         struct mvpp2_tx_queue **txqs;
 951
 952         int pkt_size;
 953
 954         u32 pending_cause_rx;
 955
 956         /* Per-CPU port control */
 957         struct mvpp2_port_pcpu __percpu *pcpu;
 958
 959         /* Flags */
 960         unsigned long flags;
 961
 962         u16 tx_ring_size;
 963         u16 rx_ring_size;
 964         struct mvpp2_pcpu_stats __percpu *stats;
 965
 966         struct phy_device *phy_dev;
 967         phy_interface_t phy_interface;
 968         int phyaddr;
 969         struct udevice *mdio_dev;
 970         struct mii_dev *bus;
 971 #if CONFIG_IS_ENABLED(DM_GPIO)
 972         struct gpio_desc phy_reset_gpio;
 973         struct gpio_desc phy_tx_disable_gpio;
 974 #endif
 975         int init;
 976         unsigned int link;
 977         unsigned int duplex;
 978         unsigned int speed;
 979
 980         unsigned int phy_speed;         /* SGMII 1Gbps vs 2.5Gbps */
 981
 982         struct mvpp2_bm_pool *pool_long;
 983         struct mvpp2_bm_pool *pool_short;
 984
 985         /* Index of first port's physical RXQ */
 986         u8 first_rxq;
 987
 988         u8 dev_addr[ETH_ALEN];
 989 };
 990
 991 /* The mvpp2_tx_desc and mvpp2_rx_desc structures describe the
 992  * layout of the transmit and reception DMA descriptors, and their
 993  * layout is therefore defined by the hardware design
 994  */
 995
 996 #define MVPP2_TXD_L3_OFF_SHIFT          0
 997 #define MVPP2_TXD_IP_HLEN_SHIFT         8
 998 #define MVPP2_TXD_L4_CSUM_FRAG          BIT(13)
 999 #define MVPP2_TXD_L4_CSUM_NOT           BIT(14)
1000 #define MVPP2_TXD_IP_CSUM_DISABLE       BIT(15)
1001 #define MVPP2_TXD_PADDING_DISABLE       BIT(23)
1002 #define MVPP2_TXD_L4_UDP                BIT(24)
1003 #define MVPP2_TXD_L3_IP6                BIT(26)
1004 #define MVPP2_TXD_L_DESC                BIT(28)
1005 #define MVPP2_TXD_F_DESC                BIT(29)
1006
1007 #define MVPP2_RXD_ERR_SUMMARY           BIT(15)
1008 #define MVPP2_RXD_ERR_CODE_MASK         (BIT(13) | BIT(14))
1009 #define MVPP2_RXD_ERR_CRC               0x0
1010 #define MVPP2_RXD_ERR_OVERRUN           BIT(13)
1011 #define MVPP2_RXD_ERR_RESOURCE          (BIT(13) | BIT(14))
1012 #define MVPP2_RXD_BM_POOL_ID_OFFS       16
1013 #define MVPP2_RXD_BM_POOL_ID_MASK       (BIT(16) | BIT(17) | BIT(18))
1014 #define MVPP2_RXD_HWF_SYNC              BIT(21)
1015 #define MVPP2_RXD_L4_CSUM_OK            BIT(22)
1016 #define MVPP2_RXD_IP4_HEADER_ERR        BIT(24)
1017 #define MVPP2_RXD_L4_TCP                BIT(25)
1018 #define MVPP2_RXD_L4_UDP                BIT(26)
1019 #define MVPP2_RXD_L3_IP4                BIT(28)
1020 #define MVPP2_RXD_L3_IP6                BIT(30)
1021 #define MVPP2_RXD_BUF_HDR               BIT(31)
1022
1023 /* HW TX descriptor for PPv2.1 */
1024 struct mvpp21_tx_desc {
1025         u32 command;            /* Options used by HW for packet transmitting.*/
1026         u8  packet_offset;      /* the offset from the buffer beginning */
1027         u8  phys_txq;           /* destination queue ID                 */
1028         u16 data_size;          /* data size of transmitted packet in bytes */
1029         u32 buf_dma_addr;       /* physical addr of transmitted buffer  */
1030         u32 buf_cookie;         /* cookie for access to TX buffer in tx path */
1031         u32 reserved1[3];       /* hw_cmd (for future use, BM, PON, PNC) */
1032         u32 reserved2;          /* reserved (for future use)            */
1033 };
1034
1035 /* HW RX descriptor for PPv2.1 */
1036 struct mvpp21_rx_desc {
1037         u32 status;             /* info about received packet           */
1038         u16 reserved1;          /* parser_info (for future use, PnC)    */
1039         u16 data_size;          /* size of received packet in bytes     */
1040         u32 buf_dma_addr;       /* physical address of the buffer       */
1041         u32 buf_cookie;         /* cookie for access to RX buffer in rx path */
1042         u16 reserved2;          /* gem_port_id (for future use, PON)    */
1043         u16 reserved3;          /* csum_l4 (for future use, PnC)        */
1044         u8  reserved4;          /* bm_qset (for future use, BM)         */
1045         u8  reserved5;
1046         u16 reserved6;          /* classify_info (for future use, PnC)  */
1047         u32 reserved7;          /* flow_id (for future use, PnC) */
1048         u32 reserved8;
1049 };
1050
1051 /* HW TX descriptor for PPv2.2 */
1052 struct mvpp22_tx_desc {
1053         u32 command;
1054         u8  packet_offset;
1055         u8  phys_txq;
1056         u16 data_size;
1057         u64 reserved1;
1058         u64 buf_dma_addr_ptp;
1059         u64 buf_cookie_misc;
1060 };
1061
1062 /* HW RX descriptor for PPv2.2 */
1063 struct mvpp22_rx_desc {
1064         u32 status;
1065         u16 reserved1;
1066         u16 data_size;
1067         u32 reserved2;
1068         u32 reserved3;
1069         u64 buf_dma_addr_key_hash;
1070         u64 buf_cookie_misc;
1071 };
1072
1073 /* Opaque type used by the driver to manipulate the HW TX and RX
1074  * descriptors
1075  */
1076 struct mvpp2_tx_desc {
1077         union {
1078                 struct mvpp21_tx_desc pp21;
1079                 struct mvpp22_tx_desc pp22;
1080         };
1081 };
1082
1083 struct mvpp2_rx_desc {
1084         union {
1085                 struct mvpp21_rx_desc pp21;
1086                 struct mvpp22_rx_desc pp22;
1087         };
1088 };
1089
1090 /* Per-CPU Tx queue control */
1091 struct mvpp2_txq_pcpu {
1092         int cpu;
1093
1094         /* Number of Tx DMA descriptors in the descriptor ring */
1095         int size;
1096
1097         /* Number of currently used Tx DMA descriptor in the
1098          * descriptor ring
1099          */
1100         int count;
1101
1102         /* Number of Tx DMA descriptors reserved for each CPU */
1103         int reserved_num;
1104
1105         /* Index of last TX DMA descriptor that was inserted */
1106         int txq_put_index;
1107
1108         /* Index of the TX DMA descriptor to be cleaned up */
1109         int txq_get_index;
1110 };
1111
1112 struct mvpp2_tx_queue {
1113         /* Physical number of this Tx queue */
1114         u8 id;
1115
1116         /* Logical number of this Tx queue */
1117         u8 log_id;
1118
1119         /* Number of Tx DMA descriptors in the descriptor ring */
1120         int size;
1121
1122         /* Number of currently used Tx DMA descriptor in the descriptor ring */
1123         int count;
1124
1125         /* Per-CPU control of physical Tx queues */
1126         struct mvpp2_txq_pcpu __percpu *pcpu;
1127
1128         u32 done_pkts_coal;
1129
1130         /* Virtual address of thex Tx DMA descriptors array */
1131         struct mvpp2_tx_desc *descs;
1132
1133         /* DMA address of the Tx DMA descriptors array */
1134         dma_addr_t descs_dma;
1135
1136         /* Index of the last Tx DMA descriptor */
1137         int last_desc;
1138
1139         /* Index of the next Tx DMA descriptor to process */
1140         int next_desc_to_proc;
1141 };
1142
1143 struct mvpp2_rx_queue {
1144         /* RX queue number, in the range 0-31 for physical RXQs */
1145         u8 id;
1146
1147         /* Num of rx descriptors in the rx descriptor ring */
1148         int size;
1149
1150         u32 pkts_coal;
1151         u32 time_coal;
1152
1153         /* Virtual address of the RX DMA descriptors array */
1154         struct mvpp2_rx_desc *descs;
1155
1156         /* DMA address of the RX DMA descriptors array */
1157         dma_addr_t descs_dma;
1158
1159         /* Index of the last RX DMA descriptor */
1160         int last_desc;
1161
1162         /* Index of the next RX DMA descriptor to process */
1163         int next_desc_to_proc;
1164
1165         /* ID of port to which physical RXQ is mapped */
1166         int port;
1167
1168         /* Port's logic RXQ number to which physical RXQ is mapped */
1169         int logic_rxq;
1170 };
1171
1172 union mvpp2_prs_tcam_entry {
1173         u32 word[MVPP2_PRS_TCAM_WORDS];
1174         u8  byte[MVPP2_PRS_TCAM_WORDS * 4];
1175 };
1176
1177 union mvpp2_prs_sram_entry {
1178         u32 word[MVPP2_PRS_SRAM_WORDS];
1179         u8  byte[MVPP2_PRS_SRAM_WORDS * 4];
1180 };
1181
1182 struct mvpp2_prs_entry {
1183         u32 index;
1184         union mvpp2_prs_tcam_entry tcam;
1185         union mvpp2_prs_sram_entry sram;
1186 };
1187
1188 struct mvpp2_prs_shadow {
1189         bool valid;
1190         bool finish;
1191
1192         /* Lookup ID */
1193         int lu;
1194
1195         /* User defined offset */
1196         int udf;
1197
1198         /* Result info */
1199         u32 ri;
1200         u32 ri_mask;
1201 };
1202
1203 struct mvpp2_cls_flow_entry {
1204         u32 index;
1205         u32 data[MVPP2_CLS_FLOWS_TBL_DATA_WORDS];
1206 };
1207
1208 struct mvpp2_cls_lookup_entry {
1209         u32 lkpid;
1210         u32 way;
1211         u32 data;
1212 };
1213
1214 struct mvpp2_bm_pool {
1215         /* Pool number in the range 0-7 */
1216         int id;
1217         enum mvpp2_bm_type type;
1218
1219         /* Buffer Pointers Pool External (BPPE) size */
1220         int size;
1221         /* Number of buffers for this pool */
1222         int buf_num;
1223         /* Pool buffer size */
1224         int buf_size;
1225         /* Packet size */
1226         int pkt_size;
1227
1228         /* BPPE virtual base address */
1229         unsigned long *virt_addr;
1230         /* BPPE DMA base address */
1231         dma_addr_t dma_addr;
1232
1233         /* Ports using BM pool */
1234         u32 port_map;
1235 };
1236
1237 /* Static declaractions */
1238
1239 /* Number of RXQs used by single port */
1240 static int rxq_number = MVPP2_DEFAULT_RXQ;
1241 /* Number of TXQs used by single port */
1242 static int txq_number = MVPP2_DEFAULT_TXQ;
1243
1244 static int base_id;
1245
1246 #define MVPP2_DRIVER_NAME "mvpp2"
1247 #define MVPP2_DRIVER_VERSION "1.0"
1248
1249 /*
1250  * U-Boot internal data, mostly uncached buffers for descriptors and data
1251  */
1252 struct buffer_location {
1253         struct mvpp2_tx_desc *aggr_tx_descs;
1254         struct mvpp2_tx_desc *tx_descs;
1255         struct mvpp2_rx_desc *rx_descs;
1256         unsigned long *bm_pool[MVPP2_BM_POOLS_NUM];
1257         unsigned long *rx_buffer[MVPP2_BM_LONG_BUF_NUM];
1258         int first_rxq;
1259 };
1260
1261 /*
1262  * All 4 interfaces use the same global buffer, since only one interface
1263  * can be enabled at once
1264  */
1265 static struct buffer_location buffer_loc;
1266 static int buffer_loc_init;
1267
1268 /*
1269  * Page table entries are set to 1MB, or multiples of 1MB
1270  * (not < 1MB). driver uses less bd's so use 1MB bdspace.
1271  */
1272 #define BD_SPACE        (1 << 20)
1273
1274 /* Utility/helper methods */
1275
1276 static void mvpp2_write(struct mvpp2 *priv, u32 offset, u32 data)
1277 {
1278         writel(data, priv->base + offset);
1279 }
1280
1281 static u32 mvpp2_read(struct mvpp2 *priv, u32 offset)
1282 {
1283         return readl(priv->base + offset);
1284 }
1285
1286 static void mvpp2_txdesc_dma_addr_set(struct mvpp2_port *port,
1287                                       struct mvpp2_tx_desc *tx_desc,
1288                                       dma_addr_t dma_addr)
1289 {
1290         if (port->priv->hw_version == MVPP21) {
1291                 tx_desc->pp21.buf_dma_addr = dma_addr;
1292         } else {
1293                 u64 val = (u64)dma_addr;
1294
1295                 tx_desc->pp22.buf_dma_addr_ptp &= ~GENMASK_ULL(40, 0);
1296                 tx_desc->pp22.buf_dma_addr_ptp |= val;
1297         }
1298 }
1299
1300 static void mvpp2_txdesc_size_set(struct mvpp2_port *port,
1301                                   struct mvpp2_tx_desc *tx_desc,
1302                                   size_t size)
1303 {
1304         if (port->priv->hw_version == MVPP21)
1305                 tx_desc->pp21.data_size = size;
1306         else
1307                 tx_desc->pp22.data_size = size;
1308 }
1309
1310 static void mvpp2_txdesc_txq_set(struct mvpp2_port *port,
1311                                  struct mvpp2_tx_desc *tx_desc,
1312                                  unsigned int txq)
1313 {
1314         if (port->priv->hw_version == MVPP21)
1315                 tx_desc->pp21.phys_txq = txq;
1316         else
1317                 tx_desc->pp22.phys_txq = txq;
1318 }
1319
1320 static void mvpp2_txdesc_cmd_set(struct mvpp2_port *port,
1321                                  struct mvpp2_tx_desc *tx_desc,
1322                                  unsigned int command)
1323 {
1324         if (port->priv->hw_version == MVPP21)
1325                 tx_desc->pp21.command = command;
1326         else
1327                 tx_desc->pp22.command = command;
1328 }
1329
1330 static void mvpp2_txdesc_offset_set(struct mvpp2_port *port,
1331                                     struct mvpp2_tx_desc *tx_desc,
1332                                     unsigned int offset)
1333 {
1334         if (port->priv->hw_version == MVPP21)
1335                 tx_desc->pp21.packet_offset = offset;
1336         else
1337                 tx_desc->pp22.packet_offset = offset;
1338 }
1339
1340 static dma_addr_t mvpp2_rxdesc_dma_addr_get(struct mvpp2_port *port,
1341                                             struct mvpp2_rx_desc *rx_desc)
1342 {
1343         if (port->priv->hw_version == MVPP21)
1344                 return rx_desc->pp21.buf_dma_addr;
1345         else
1346                 return rx_desc->pp22.buf_dma_addr_key_hash & GENMASK_ULL(40, 0);
1347 }
1348
1349 static unsigned long mvpp2_rxdesc_cookie_get(struct mvpp2_port *port,
1350                                              struct mvpp2_rx_desc *rx_desc)
1351 {
1352         if (port->priv->hw_version == MVPP21)
1353                 return rx_desc->pp21.buf_cookie;
1354         else
1355                 return rx_desc->pp22.buf_cookie_misc & GENMASK_ULL(40, 0);
1356 }
1357
1358 static size_t mvpp2_rxdesc_size_get(struct mvpp2_port *port,
1359                                     struct mvpp2_rx_desc *rx_desc)
1360 {
1361         if (port->priv->hw_version == MVPP21)
1362                 return rx_desc->pp21.data_size;
1363         else
1364                 return rx_desc->pp22.data_size;
1365 }
1366
1367 static u32 mvpp2_rxdesc_status_get(struct mvpp2_port *port,
1368                                    struct mvpp2_rx_desc *rx_desc)
1369 {
1370         if (port->priv->hw_version == MVPP21)
1371                 return rx_desc->pp21.status;
1372         else
1373                 return rx_desc->pp22.status;
1374 }
1375
1376 static void mvpp2_txq_inc_get(struct mvpp2_txq_pcpu *txq_pcpu)
1377 {
1378         txq_pcpu->txq_get_index++;
1379         if (txq_pcpu->txq_get_index == txq_pcpu->size)
1380                 txq_pcpu->txq_get_index = 0;
1381 }
1382
1383 /* Get number of physical egress port */
1384 static inline int mvpp2_egress_port(struct mvpp2_port *port)
1385 {
1386         return MVPP2_MAX_TCONT + port->id;
1387 }
1388
1389 /* Get number of physical TXQ */
1390 static inline int mvpp2_txq_phys(int port, int txq)
1391 {
1392         return (MVPP2_MAX_TCONT + port) * MVPP2_MAX_TXQ + txq;
1393 }
1394
1395 /* Parser configuration routines */
1396
1397 /* Update parser tcam and sram hw entries */
1398 static int mvpp2_prs_hw_write(struct mvpp2 *priv, struct mvpp2_prs_entry *pe)
1399 {
1400         int i;
1401
1402         if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1)
1403                 return -EINVAL;
1404
1405         /* Clear entry invalidation bit */
1406         pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] &= ~MVPP2_PRS_TCAM_INV_MASK;
1407
1408         /* Write tcam index - indirect access */
1409         mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index);
1410         for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++)
1411                 mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(i), pe->tcam.word[i]);
1412
1413         /* Write sram index - indirect access */
1414         mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index);
1415         for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++)
1416                 mvpp2_write(priv, MVPP2_PRS_SRAM_DATA_REG(i), pe->sram.word[i]);
1417
1418         return 0;
1419 }
1420
1421 /* Read tcam entry from hw */
1422 static int mvpp2_prs_hw_read(struct mvpp2 *priv, struct mvpp2_prs_entry *pe)
1423 {
1424         int i;
1425
1426         if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1)
1427                 return -EINVAL;
1428
1429         /* Write tcam index - indirect access */
1430         mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index);
1431
1432         pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] = mvpp2_read(priv,
1433                               MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD));
1434         if (pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] & MVPP2_PRS_TCAM_INV_MASK)
1435                 return MVPP2_PRS_TCAM_ENTRY_INVALID;
1436
1437         for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++)
1438                 pe->tcam.word[i] = mvpp2_read(priv, MVPP2_PRS_TCAM_DATA_REG(i));
1439
1440         /* Write sram index - indirect access */
1441         mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index);
1442         for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++)
1443                 pe->sram.word[i] = mvpp2_read(priv, MVPP2_PRS_SRAM_DATA_REG(i));
1444
1445         return 0;
1446 }
1447
1448 /* Invalidate tcam hw entry */
1449 static void mvpp2_prs_hw_inv(struct mvpp2 *priv, int index)
1450 {
1451         /* Write index - indirect access */
1452         mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, index);
1453         mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD),
1454                     MVPP2_PRS_TCAM_INV_MASK);
1455 }
1456
1457 /* Enable shadow table entry and set its lookup ID */
1458 static void mvpp2_prs_shadow_set(struct mvpp2 *priv, int index, int lu)
1459 {
1460         priv->prs_shadow[index].valid = true;
1461         priv->prs_shadow[index].lu = lu;
1462 }
1463
1464 /* Update ri fields in shadow table entry */
1465 static void mvpp2_prs_shadow_ri_set(struct mvpp2 *priv, int index,
1466                                     unsigned int ri, unsigned int ri_mask)
1467 {
1468         priv->prs_shadow[index].ri_mask = ri_mask;
1469         priv->prs_shadow[index].ri = ri;
1470 }
1471
1472 /* Update lookup field in tcam sw entry */
1473 static void mvpp2_prs_tcam_lu_set(struct mvpp2_prs_entry *pe, unsigned int lu)
1474 {
1475         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_LU_BYTE);
1476
1477         pe->tcam.byte[MVPP2_PRS_TCAM_LU_BYTE] = lu;
1478         pe->tcam.byte[enable_off] = MVPP2_PRS_LU_MASK;
1479 }
1480
1481 /* Update mask for single port in tcam sw entry */
1482 static void mvpp2_prs_tcam_port_set(struct mvpp2_prs_entry *pe,
1483                                     unsigned int port, bool add)
1484 {
1485         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE);
1486
1487         if (add)
1488                 pe->tcam.byte[enable_off] &= ~(1 << port);
1489         else
1490                 pe->tcam.byte[enable_off] |= 1 << port;
1491 }
1492
1493 /* Update port map in tcam sw entry */
1494 static void mvpp2_prs_tcam_port_map_set(struct mvpp2_prs_entry *pe,
1495                                         unsigned int ports)
1496 {
1497         unsigned char port_mask = MVPP2_PRS_PORT_MASK;
1498         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE);
1499
1500         pe->tcam.byte[MVPP2_PRS_TCAM_PORT_BYTE] = 0;
1501         pe->tcam.byte[enable_off] &= ~port_mask;
1502         pe->tcam.byte[enable_off] |= ~ports & MVPP2_PRS_PORT_MASK;
1503 }
1504
1505 /* Obtain port map from tcam sw entry */
1506 static unsigned int mvpp2_prs_tcam_port_map_get(struct mvpp2_prs_entry *pe)
1507 {
1508         int enable_off = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE);
1509
1510         return ~(pe->tcam.byte[enable_off]) & MVPP2_PRS_PORT_MASK;
1511 }
1512
1513 /* Set byte of data and its enable bits in tcam sw entry */
1514 static void mvpp2_prs_tcam_data_byte_set(struct mvpp2_prs_entry *pe,
1515                                          unsigned int offs, unsigned char byte,
1516                                          unsigned char enable)
1517 {
1518         pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(offs)] = byte;
1519         pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)] = enable;
1520 }
1521
1522 /* Get byte of data and its enable bits from tcam sw entry */
1523 static void mvpp2_prs_tcam_data_byte_get(struct mvpp2_prs_entry *pe,
1524                                          unsigned int offs, unsigned char *byte,
1525                                          unsigned char *enable)
1526 {
1527         *byte = pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(offs)];
1528         *enable = pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)];
1529 }
1530
1531 /* Set ethertype in tcam sw entry */
1532 static void mvpp2_prs_match_etype(struct mvpp2_prs_entry *pe, int offset,
1533                                   unsigned short ethertype)
1534 {
1535         mvpp2_prs_tcam_data_byte_set(pe, offset + 0, ethertype >> 8, 0xff);
1536         mvpp2_prs_tcam_data_byte_set(pe, offset + 1, ethertype & 0xff, 0xff);
1537 }
1538
1539 /* Set bits in sram sw entry */
1540 static void mvpp2_prs_sram_bits_set(struct mvpp2_prs_entry *pe, int bit_num,
1541                                     int val)
1542 {
1543         pe->sram.byte[MVPP2_BIT_TO_BYTE(bit_num)] |= (val << (bit_num % 8));
1544 }
1545
1546 /* Clear bits in sram sw entry */
1547 static void mvpp2_prs_sram_bits_clear(struct mvpp2_prs_entry *pe, int bit_num,
1548                                       int val)
1549 {
1550         pe->sram.byte[MVPP2_BIT_TO_BYTE(bit_num)] &= ~(val << (bit_num % 8));
1551 }
1552
1553 /* Update ri bits in sram sw entry */
1554 static void mvpp2_prs_sram_ri_update(struct mvpp2_prs_entry *pe,
1555                                      unsigned int bits, unsigned int mask)
1556 {
1557         unsigned int i;
1558
1559         for (i = 0; i < MVPP2_PRS_SRAM_RI_CTRL_BITS; i++) {
1560                 int ri_off = MVPP2_PRS_SRAM_RI_OFFS;
1561
1562                 if (!(mask & BIT(i)))
1563                         continue;
1564
1565                 if (bits & BIT(i))
1566                         mvpp2_prs_sram_bits_set(pe, ri_off + i, 1);
1567                 else
1568                         mvpp2_prs_sram_bits_clear(pe, ri_off + i, 1);
1569
1570                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_RI_CTRL_OFFS + i, 1);
1571         }
1572 }
1573
1574 /* Update ai bits in sram sw entry */
1575 static void mvpp2_prs_sram_ai_update(struct mvpp2_prs_entry *pe,
1576                                      unsigned int bits, unsigned int mask)
1577 {
1578         unsigned int i;
1579         int ai_off = MVPP2_PRS_SRAM_AI_OFFS;
1580
1581         for (i = 0; i < MVPP2_PRS_SRAM_AI_CTRL_BITS; i++) {
1582
1583                 if (!(mask & BIT(i)))
1584                         continue;
1585
1586                 if (bits & BIT(i))
1587                         mvpp2_prs_sram_bits_set(pe, ai_off + i, 1);
1588                 else
1589                         mvpp2_prs_sram_bits_clear(pe, ai_off + i, 1);
1590
1591                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_AI_CTRL_OFFS + i, 1);
1592         }
1593 }
1594
1595 /* Read ai bits from sram sw entry */
1596 static int mvpp2_prs_sram_ai_get(struct mvpp2_prs_entry *pe)
1597 {
1598         u8 bits;
1599         int ai_off = MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_AI_OFFS);
1600         int ai_en_off = ai_off + 1;
1601         int ai_shift = MVPP2_PRS_SRAM_AI_OFFS % 8;
1602
1603         bits = (pe->sram.byte[ai_off] >> ai_shift) |
1604                (pe->sram.byte[ai_en_off] << (8 - ai_shift));
1605
1606         return bits;
1607 }
1608
1609 /* In sram sw entry set lookup ID field of the tcam key to be used in the next
1610  * lookup interation
1611  */
1612 static void mvpp2_prs_sram_next_lu_set(struct mvpp2_prs_entry *pe,
1613                                        unsigned int lu)
1614 {
1615         int sram_next_off = MVPP2_PRS_SRAM_NEXT_LU_OFFS;
1616
1617         mvpp2_prs_sram_bits_clear(pe, sram_next_off,
1618                                   MVPP2_PRS_SRAM_NEXT_LU_MASK);
1619         mvpp2_prs_sram_bits_set(pe, sram_next_off, lu);
1620 }
1621
1622 /* In the sram sw entry set sign and value of the next lookup offset
1623  * and the offset value generated to the classifier
1624  */
1625 static void mvpp2_prs_sram_shift_set(struct mvpp2_prs_entry *pe, int shift,
1626                                      unsigned int op)
1627 {
1628         /* Set sign */
1629         if (shift < 0) {
1630                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1);
1631                 shift = 0 - shift;
1632         } else {
1633                 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1);
1634         }
1635
1636         /* Set value */
1637         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_SHIFT_OFFS)] =
1638                                                            (unsigned char)shift;
1639
1640         /* Reset and set operation */
1641         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS,
1642                                   MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK);
1643         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS, op);
1644
1645         /* Set base offset as current */
1646         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1);
1647 }
1648
1649 /* In the sram sw entry set sign and value of the user defined offset
1650  * generated to the classifier
1651  */
1652 static void mvpp2_prs_sram_offset_set(struct mvpp2_prs_entry *pe,
1653                                       unsigned int type, int offset,
1654                                       unsigned int op)
1655 {
1656         /* Set sign */
1657         if (offset < 0) {
1658                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1);
1659                 offset = 0 - offset;
1660         } else {
1661                 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1);
1662         }
1663
1664         /* Set value */
1665         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_OFFS,
1666                                   MVPP2_PRS_SRAM_UDF_MASK);
1667         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_OFFS, offset);
1668         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_UDF_OFFS +
1669                                         MVPP2_PRS_SRAM_UDF_BITS)] &=
1670               ~(MVPP2_PRS_SRAM_UDF_MASK >> (8 - (MVPP2_PRS_SRAM_UDF_OFFS % 8)));
1671         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_UDF_OFFS +
1672                                         MVPP2_PRS_SRAM_UDF_BITS)] |=
1673                                 (offset >> (8 - (MVPP2_PRS_SRAM_UDF_OFFS % 8)));
1674
1675         /* Set offset type */
1676         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS,
1677                                   MVPP2_PRS_SRAM_UDF_TYPE_MASK);
1678         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS, type);
1679
1680         /* Set offset operation */
1681         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS,
1682                                   MVPP2_PRS_SRAM_OP_SEL_UDF_MASK);
1683         mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS, op);
1684
1685         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS +
1686                                         MVPP2_PRS_SRAM_OP_SEL_UDF_BITS)] &=
1687                                              ~(MVPP2_PRS_SRAM_OP_SEL_UDF_MASK >>
1688                                     (8 - (MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS % 8)));
1689
1690         pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS +
1691                                         MVPP2_PRS_SRAM_OP_SEL_UDF_BITS)] |=
1692                              (op >> (8 - (MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS % 8)));
1693
1694         /* Set base offset as current */
1695         mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1);
1696 }
1697
1698 /* Find parser flow entry */
1699 static struct mvpp2_prs_entry *mvpp2_prs_flow_find(struct mvpp2 *priv, int flow)
1700 {
1701         struct mvpp2_prs_entry *pe;
1702         int tid;
1703
1704         pe = kzalloc(sizeof(*pe), GFP_KERNEL);
1705         if (!pe)
1706                 return NULL;
1707         mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_FLOWS);
1708
1709         /* Go through the all entires with MVPP2_PRS_LU_FLOWS */
1710         for (tid = MVPP2_PRS_TCAM_SRAM_SIZE - 1; tid >= 0; tid--) {
1711                 u8 bits;
1712
1713                 if (!priv->prs_shadow[tid].valid ||
1714                     priv->prs_shadow[tid].lu != MVPP2_PRS_LU_FLOWS)
1715                         continue;
1716
1717                 pe->index = tid;
1718                 mvpp2_prs_hw_read(priv, pe);
1719                 bits = mvpp2_prs_sram_ai_get(pe);
1720
1721                 /* Sram store classification lookup ID in AI bits [5:0] */
1722                 if ((bits & MVPP2_PRS_FLOW_ID_MASK) == flow)
1723                         return pe;
1724         }
1725         kfree(pe);
1726
1727         return NULL;
1728 }
1729
1730 /* Return first free tcam index, seeking from start to end */
1731 static int mvpp2_prs_tcam_first_free(struct mvpp2 *priv, unsigned char start,
1732                                      unsigned char end)
1733 {
1734         int tid;
1735
1736         if (start > end)
1737                 swap(start, end);
1738
1739         if (end >= MVPP2_PRS_TCAM_SRAM_SIZE)
1740                 end = MVPP2_PRS_TCAM_SRAM_SIZE - 1;
1741
1742         for (tid = start; tid <= end; tid++) {
1743                 if (!priv->prs_shadow[tid].valid)
1744                         return tid;
1745         }
1746
1747         return -EINVAL;
1748 }
1749
1750 /* Enable/disable dropping all mac da's */
1751 static void mvpp2_prs_mac_drop_all_set(struct mvpp2 *priv, int port, bool add)
1752 {
1753         struct mvpp2_prs_entry pe;
1754
1755         if (priv->prs_shadow[MVPP2_PE_DROP_ALL].valid) {
1756                 /* Entry exist - update port only */
1757                 pe.index = MVPP2_PE_DROP_ALL;
1758                 mvpp2_prs_hw_read(priv, &pe);
1759         } else {
1760                 /* Entry doesn't exist - create new */
1761                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1762                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1763                 pe.index = MVPP2_PE_DROP_ALL;
1764
1765                 /* Non-promiscuous mode for all ports - DROP unknown packets */
1766                 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK,
1767                                          MVPP2_PRS_RI_DROP_MASK);
1768
1769                 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1770                 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1771
1772                 /* Update shadow table */
1773                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1774
1775                 /* Mask all ports */
1776                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1777         }
1778
1779         /* Update port mask */
1780         mvpp2_prs_tcam_port_set(&pe, port, add);
1781
1782         mvpp2_prs_hw_write(priv, &pe);
1783 }
1784
1785 /* Set port to promiscuous mode */
1786 static void mvpp2_prs_mac_promisc_set(struct mvpp2 *priv, int port, bool add)
1787 {
1788         struct mvpp2_prs_entry pe;
1789
1790         /* Promiscuous mode - Accept unknown packets */
1791
1792         if (priv->prs_shadow[MVPP2_PE_MAC_PROMISCUOUS].valid) {
1793                 /* Entry exist - update port only */
1794                 pe.index = MVPP2_PE_MAC_PROMISCUOUS;
1795                 mvpp2_prs_hw_read(priv, &pe);
1796         } else {
1797                 /* Entry doesn't exist - create new */
1798                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1799                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1800                 pe.index = MVPP2_PE_MAC_PROMISCUOUS;
1801
1802                 /* Continue - set next lookup */
1803                 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_DSA);
1804
1805                 /* Set result info bits */
1806                 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L2_UCAST,
1807                                          MVPP2_PRS_RI_L2_CAST_MASK);
1808
1809                 /* Shift to ethertype */
1810                 mvpp2_prs_sram_shift_set(&pe, 2 * ETH_ALEN,
1811                                          MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1812
1813                 /* Mask all ports */
1814                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1815
1816                 /* Update shadow table */
1817                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1818         }
1819
1820         /* Update port mask */
1821         mvpp2_prs_tcam_port_set(&pe, port, add);
1822
1823         mvpp2_prs_hw_write(priv, &pe);
1824 }
1825
1826 /* Accept multicast */
1827 static void mvpp2_prs_mac_multi_set(struct mvpp2 *priv, int port, int index,
1828                                     bool add)
1829 {
1830         struct mvpp2_prs_entry pe;
1831         unsigned char da_mc;
1832
1833         /* Ethernet multicast address first byte is
1834          * 0x01 for IPv4 and 0x33 for IPv6
1835          */
1836         da_mc = (index == MVPP2_PE_MAC_MC_ALL) ? 0x01 : 0x33;
1837
1838         if (priv->prs_shadow[index].valid) {
1839                 /* Entry exist - update port only */
1840                 pe.index = index;
1841                 mvpp2_prs_hw_read(priv, &pe);
1842         } else {
1843                 /* Entry doesn't exist - create new */
1844                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1845                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1846                 pe.index = index;
1847
1848                 /* Continue - set next lookup */
1849                 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_DSA);
1850
1851                 /* Set result info bits */
1852                 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L2_MCAST,
1853                                          MVPP2_PRS_RI_L2_CAST_MASK);
1854
1855                 /* Update tcam entry data first byte */
1856                 mvpp2_prs_tcam_data_byte_set(&pe, 0, da_mc, 0xff);
1857
1858                 /* Shift to ethertype */
1859                 mvpp2_prs_sram_shift_set(&pe, 2 * ETH_ALEN,
1860                                          MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1861
1862                 /* Mask all ports */
1863                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1864
1865                 /* Update shadow table */
1866                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1867         }
1868
1869         /* Update port mask */
1870         mvpp2_prs_tcam_port_set(&pe, port, add);
1871
1872         mvpp2_prs_hw_write(priv, &pe);
1873 }
1874
1875 /* Parser per-port initialization */
1876 static void mvpp2_prs_hw_port_init(struct mvpp2 *priv, int port, int lu_first,
1877                                    int lu_max, int offset)
1878 {
1879         u32 val;
1880
1881         /* Set lookup ID */
1882         val = mvpp2_read(priv, MVPP2_PRS_INIT_LOOKUP_REG);
1883         val &= ~MVPP2_PRS_PORT_LU_MASK(port);
1884         val |=  MVPP2_PRS_PORT_LU_VAL(port, lu_first);
1885         mvpp2_write(priv, MVPP2_PRS_INIT_LOOKUP_REG, val);
1886
1887         /* Set maximum number of loops for packet received from port */
1888         val = mvpp2_read(priv, MVPP2_PRS_MAX_LOOP_REG(port));
1889         val &= ~MVPP2_PRS_MAX_LOOP_MASK(port);
1890         val |= MVPP2_PRS_MAX_LOOP_VAL(port, lu_max);
1891         mvpp2_write(priv, MVPP2_PRS_MAX_LOOP_REG(port), val);
1892
1893         /* Set initial offset for packet header extraction for the first
1894          * searching loop
1895          */
1896         val = mvpp2_read(priv, MVPP2_PRS_INIT_OFFS_REG(port));
1897         val &= ~MVPP2_PRS_INIT_OFF_MASK(port);
1898         val |= MVPP2_PRS_INIT_OFF_VAL(port, offset);
1899         mvpp2_write(priv, MVPP2_PRS_INIT_OFFS_REG(port), val);
1900 }
1901
1902 /* Default flow entries initialization for all ports */
1903 static void mvpp2_prs_def_flow_init(struct mvpp2 *priv)
1904 {
1905         struct mvpp2_prs_entry pe;
1906         int port;
1907
1908         for (port = 0; port < MVPP2_MAX_PORTS; port++) {
1909                 memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1910                 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1911                 pe.index = MVPP2_PE_FIRST_DEFAULT_FLOW - port;
1912
1913                 /* Mask all ports */
1914                 mvpp2_prs_tcam_port_map_set(&pe, 0);
1915
1916                 /* Set flow ID*/
1917                 mvpp2_prs_sram_ai_update(&pe, port, MVPP2_PRS_FLOW_ID_MASK);
1918                 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1);
1919
1920                 /* Update shadow table and hw entry */
1921                 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_FLOWS);
1922                 mvpp2_prs_hw_write(priv, &pe);
1923         }
1924 }
1925
1926 /* Set default entry for Marvell Header field */
1927 static void mvpp2_prs_mh_init(struct mvpp2 *priv)
1928 {
1929         struct mvpp2_prs_entry pe;
1930
1931         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1932
1933         pe.index = MVPP2_PE_MH_DEFAULT;
1934         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MH);
1935         mvpp2_prs_sram_shift_set(&pe, MVPP2_MH_SIZE,
1936                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1937         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_MAC);
1938
1939         /* Unmask all ports */
1940         mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
1941
1942         /* Update shadow table and hw entry */
1943         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MH);
1944         mvpp2_prs_hw_write(priv, &pe);
1945 }
1946
1947 /* Set default entires (place holder) for promiscuous, non-promiscuous and
1948  * multicast MAC addresses
1949  */
1950 static void mvpp2_prs_mac_init(struct mvpp2 *priv)
1951 {
1952         struct mvpp2_prs_entry pe;
1953
1954         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1955
1956         /* Non-promiscuous mode for all ports - DROP unknown packets */
1957         pe.index = MVPP2_PE_MAC_NON_PROMISCUOUS;
1958         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
1959
1960         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK,
1961                                  MVPP2_PRS_RI_DROP_MASK);
1962         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
1963         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
1964
1965         /* Unmask all ports */
1966         mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
1967
1968         /* Update shadow table and hw entry */
1969         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
1970         mvpp2_prs_hw_write(priv, &pe);
1971
1972         /* place holders only - no ports */
1973         mvpp2_prs_mac_drop_all_set(priv, 0, false);
1974         mvpp2_prs_mac_promisc_set(priv, 0, false);
1975         mvpp2_prs_mac_multi_set(priv, MVPP2_PE_MAC_MC_ALL, 0, false);
1976         mvpp2_prs_mac_multi_set(priv, MVPP2_PE_MAC_MC_IP6, 0, false);
1977 }
1978
1979 /* Match basic ethertypes */
1980 static int mvpp2_prs_etype_init(struct mvpp2 *priv)
1981 {
1982         struct mvpp2_prs_entry pe;
1983         int tid;
1984
1985         /* Ethertype: PPPoE */
1986         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
1987                                         MVPP2_PE_LAST_FREE_TID);
1988         if (tid < 0)
1989                 return tid;
1990
1991         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
1992         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
1993         pe.index = tid;
1994
1995         mvpp2_prs_match_etype(&pe, 0, PROT_PPP_SES);
1996
1997         mvpp2_prs_sram_shift_set(&pe, MVPP2_PPPOE_HDR_SIZE,
1998                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
1999         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_PPPOE);
2000         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_PPPOE_MASK,
2001                                  MVPP2_PRS_RI_PPPOE_MASK);
2002
2003         /* Update shadow table and hw entry */
2004         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2005         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2006         priv->prs_shadow[pe.index].finish = false;
2007         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_PPPOE_MASK,
2008                                 MVPP2_PRS_RI_PPPOE_MASK);
2009         mvpp2_prs_hw_write(priv, &pe);
2010
2011         /* Ethertype: ARP */
2012         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
2013                                         MVPP2_PE_LAST_FREE_TID);
2014         if (tid < 0)
2015                 return tid;
2016
2017         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
2018         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
2019         pe.index = tid;
2020
2021         mvpp2_prs_match_etype(&pe, 0, PROT_ARP);
2022
2023         /* Generate flow in the next iteration*/
2024         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
2025         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
2026         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_ARP,
2027                                  MVPP2_PRS_RI_L3_PROTO_MASK);
2028         /* Set L3 offset */
2029         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
2030                                   MVPP2_ETH_TYPE_LEN,
2031                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
2032
2033         /* Update shadow table and hw entry */
2034         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2035         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2036         priv->prs_shadow[pe.index].finish = true;
2037         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_ARP,
2038                                 MVPP2_PRS_RI_L3_PROTO_MASK);
2039         mvpp2_prs_hw_write(priv, &pe);
2040
2041         /* Ethertype: LBTD */
2042         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
2043                                         MVPP2_PE_LAST_FREE_TID);
2044         if (tid < 0)
2045                 return tid;
2046
2047         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
2048         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
2049         pe.index = tid;
2050
2051         mvpp2_prs_match_etype(&pe, 0, MVPP2_IP_LBDT_TYPE);
2052
2053         /* Generate flow in the next iteration*/
2054         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
2055         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
2056         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_CPU_CODE_RX_SPEC |
2057                                  MVPP2_PRS_RI_UDF3_RX_SPECIAL,
2058                                  MVPP2_PRS_RI_CPU_CODE_MASK |
2059                                  MVPP2_PRS_RI_UDF3_MASK);
2060         /* Set L3 offset */
2061         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
2062                                   MVPP2_ETH_TYPE_LEN,
2063                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
2064
2065         /* Update shadow table and hw entry */
2066         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2067         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2068         priv->prs_shadow[pe.index].finish = true;
2069         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_CPU_CODE_RX_SPEC |
2070                                 MVPP2_PRS_RI_UDF3_RX_SPECIAL,
2071                                 MVPP2_PRS_RI_CPU_CODE_MASK |
2072                                 MVPP2_PRS_RI_UDF3_MASK);
2073         mvpp2_prs_hw_write(priv, &pe);
2074
2075         /* Ethertype: IPv4 without options */
2076         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
2077                                         MVPP2_PE_LAST_FREE_TID);
2078         if (tid < 0)
2079                 return tid;
2080
2081         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
2082         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
2083         pe.index = tid;
2084
2085         mvpp2_prs_match_etype(&pe, 0, PROT_IP);
2086         mvpp2_prs_tcam_data_byte_set(&pe, MVPP2_ETH_TYPE_LEN,
2087                                      MVPP2_PRS_IPV4_HEAD | MVPP2_PRS_IPV4_IHL,
2088                                      MVPP2_PRS_IPV4_HEAD_MASK |
2089                                      MVPP2_PRS_IPV4_IHL_MASK);
2090
2091         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP4);
2092         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4,
2093                                  MVPP2_PRS_RI_L3_PROTO_MASK);
2094         /* Skip eth_type + 4 bytes of IP header */
2095         mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 4,
2096                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
2097         /* Set L3 offset */
2098         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
2099                                   MVPP2_ETH_TYPE_LEN,
2100                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
2101
2102         /* Update shadow table and hw entry */
2103         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2104         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2105         priv->prs_shadow[pe.index].finish = false;
2106         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP4,
2107                                 MVPP2_PRS_RI_L3_PROTO_MASK);
2108         mvpp2_prs_hw_write(priv, &pe);
2109
2110         /* Ethertype: IPv4 with options */
2111         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
2112                                         MVPP2_PE_LAST_FREE_TID);
2113         if (tid < 0)
2114                 return tid;
2115
2116         pe.index = tid;
2117
2118         /* Clear tcam data before updating */
2119         pe.tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(MVPP2_ETH_TYPE_LEN)] = 0x0;
2120         pe.tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(MVPP2_ETH_TYPE_LEN)] = 0x0;
2121
2122         mvpp2_prs_tcam_data_byte_set(&pe, MVPP2_ETH_TYPE_LEN,
2123                                      MVPP2_PRS_IPV4_HEAD,
2124                                      MVPP2_PRS_IPV4_HEAD_MASK);
2125
2126         /* Clear ri before updating */
2127         pe.sram.word[MVPP2_PRS_SRAM_RI_WORD] = 0x0;
2128         pe.sram.word[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0;
2129         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4_OPT,
2130                                  MVPP2_PRS_RI_L3_PROTO_MASK);
2131
2132         /* Update shadow table and hw entry */
2133         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2134         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2135         priv->prs_shadow[pe.index].finish = false;
2136         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP4_OPT,
2137                                 MVPP2_PRS_RI_L3_PROTO_MASK);
2138         mvpp2_prs_hw_write(priv, &pe);
2139
2140         /* Ethertype: IPv6 without options */
2141         tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
2142                                         MVPP2_PE_LAST_FREE_TID);
2143         if (tid < 0)
2144                 return tid;
2145
2146         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
2147         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
2148         pe.index = tid;
2149
2150         mvpp2_prs_match_etype(&pe, 0, PROT_IPV6);
2151
2152         /* Skip DIP of IPV6 header */
2153         mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 8 +
2154                                  MVPP2_MAX_L3_ADDR_SIZE,
2155                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
2156         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6);
2157         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP6,
2158                                  MVPP2_PRS_RI_L3_PROTO_MASK);
2159         /* Set L3 offset */
2160         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
2161                                   MVPP2_ETH_TYPE_LEN,
2162                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
2163
2164         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2165         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2166         priv->prs_shadow[pe.index].finish = false;
2167         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP6,
2168                                 MVPP2_PRS_RI_L3_PROTO_MASK);
2169         mvpp2_prs_hw_write(priv, &pe);
2170
2171         /* Default entry for MVPP2_PRS_LU_L2 - Unknown ethtype */
2172         memset(&pe, 0, sizeof(struct mvpp2_prs_entry));
2173         mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2);
2174         pe.index = MVPP2_PE_ETH_TYPE_UN;
2175
2176         /* Unmask all ports */
2177         mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
2178
2179         /* Generate flow in the next iteration*/
2180         mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
2181         mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
2182         mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UN,
2183                                  MVPP2_PRS_RI_L3_PROTO_MASK);
2184         /* Set L3 offset even it's unknown L3 */
2185         mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
2186                                   MVPP2_ETH_TYPE_LEN,
2187                                   MVPP2_PRS_SRAM_OP_SEL_UDF_ADD);
2188
2189         /* Update shadow table and hw entry */
2190         mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2);
2191         priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF;
2192         priv->prs_shadow[pe.index].finish = true;
2193         mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_UN,
2194                                 MVPP2_PRS_RI_L3_PROTO_MASK);
2195         mvpp2_prs_hw_write(priv, &pe);
2196
2197         return 0;
2198 }
2199
2200 /* Parser default initialization */
2201 static int mvpp2_prs_default_init(struct udevice *dev,
2202                                   struct mvpp2 *priv)
2203 {
2204         int err, index, i;
2205
2206         /* Enable tcam table */
2207         mvpp2_write(priv, MVPP2_PRS_TCAM_CTRL_REG, MVPP2_PRS_TCAM_EN_MASK);
2208
2209         /* Clear all tcam and sram entries */
2210         for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++) {
2211                 mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, index);
2212                 for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++)
2213                         mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(i), 0);
2214
2215                 mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, index);
2216                 for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++)
2217                         mvpp2_write(priv, MVPP2_PRS_SRAM_DATA_REG(i), 0);
2218         }
2219
2220         /* Invalidate all tcam entries */
2221         for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++)
2222                 mvpp2_prs_hw_inv(priv, index);
2223
2224         priv->prs_shadow = devm_kcalloc(dev, MVPP2_PRS_TCAM_SRAM_SIZE,
2225                                         sizeof(struct mvpp2_prs_shadow),
2226                                         GFP_KERNEL);
2227         if (!priv->prs_shadow)
2228                 return -ENOMEM;
2229
2230         /* Always start from lookup = 0 */
2231         for (index = 0; index < MVPP2_MAX_PORTS; index++)
2232                 mvpp2_prs_hw_port_init(priv, index, MVPP2_PRS_LU_MH,
2233                                        MVPP2_PRS_PORT_LU_MAX, 0);
2234
2235         mvpp2_prs_def_flow_init(priv);
2236
2237         mvpp2_prs_mh_init(priv);
2238
2239         mvpp2_prs_mac_init(priv);
2240
2241         err = mvpp2_prs_etype_init(priv);
2242         if (err)
2243                 return err;
2244
2245         return 0;
2246 }
2247
2248 /* Compare MAC DA with tcam entry data */
2249 static bool mvpp2_prs_mac_range_equals(struct mvpp2_prs_entry *pe,
2250                                        const u8 *da, unsigned char *mask)
2251 {
2252         unsigned char tcam_byte, tcam_mask;
2253         int index;
2254
2255         for (index = 0; index < ETH_ALEN; index++) {
2256                 mvpp2_prs_tcam_data_byte_get(pe, index, &tcam_byte, &tcam_mask);
2257                 if (tcam_mask != mask[index])
2258                         return false;
2259
2260                 if ((tcam_mask & tcam_byte) != (da[index] & mask[index]))
2261                         return false;
2262         }
2263
2264         return true;
2265 }
2266
2267 /* Find tcam entry with matched pair <MAC DA, port> */
2268 static struct mvpp2_prs_entry *
2269 mvpp2_prs_mac_da_range_find(struct mvpp2 *priv, int pmap, const u8 *da,
2270                             unsigned char *mask, int udf_type)
2271 {
2272         struct mvpp2_prs_entry *pe;
2273         int tid;
2274
2275         pe = kzalloc(sizeof(*pe), GFP_KERNEL);
2276         if (!pe)
2277                 return NULL;
2278         mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_MAC);
2279
2280         /* Go through the all entires with MVPP2_PRS_LU_MAC */
2281         for (tid = MVPP2_PE_FIRST_FREE_TID;
2282              tid <= MVPP2_PE_LAST_FREE_TID; tid++) {
2283                 unsigned int entry_pmap;
2284
2285                 if (!priv->prs_shadow[tid].valid ||
2286                     (priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC) ||
2287                     (priv->prs_shadow[tid].udf != udf_type))
2288                         continue;
2289
2290                 pe->index = tid;
2291                 mvpp2_prs_hw_read(priv, pe);
2292                 entry_pmap = mvpp2_prs_tcam_port_map_get(pe);
2293
2294                 if (mvpp2_prs_mac_range_equals(pe, da, mask) &&
2295                     entry_pmap == pmap)
2296                         return pe;
2297         }
2298         kfree(pe);
2299
2300         return NULL;
2301 }
2302
2303 /* Update parser's mac da entry */
2304 static int mvpp2_prs_mac_da_accept(struct mvpp2 *priv, int port,
2305                                    const u8 *da, bool add)
2306 {
2307         struct mvpp2_prs_entry *pe;
2308         unsigned int pmap, len, ri;
2309         unsigned char mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2310         int tid;
2311
2312         /* Scan TCAM and see if entry with this <MAC DA, port> already exist */
2313         pe = mvpp2_prs_mac_da_range_find(priv, (1 << port), da, mask,
2314                                          MVPP2_PRS_UDF_MAC_DEF);
2315
2316         /* No such entry */
2317         if (!pe) {
2318                 if (!add)
2319                         return 0;
2320
2321                 /* Create new TCAM entry */
2322                 /* Find first range mac entry*/
2323                 for (tid = MVPP2_PE_FIRST_FREE_TID;
2324                      tid <= MVPP2_PE_LAST_FREE_TID; tid++)
2325                         if (priv->prs_shadow[tid].valid &&
2326                             (priv->prs_shadow[tid].lu == MVPP2_PRS_LU_MAC) &&
2327                             (priv->prs_shadow[tid].udf ==
2328                                                        MVPP2_PRS_UDF_MAC_RANGE))
2329                                 break;
2330
2331                 /* Go through the all entries from first to last */
2332                 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID,
2333                                                 tid - 1);
2334                 if (tid < 0)
2335                         return tid;
2336
2337                 pe = kzalloc(sizeof(*pe), GFP_KERNEL);
2338                 if (!pe)
2339                         return -1;
2340                 mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_MAC);
2341                 pe->index = tid;
2342
2343                 /* Mask all ports */
2344                 mvpp2_prs_tcam_port_map_set(pe, 0);
2345         }
2346
2347         /* Update port mask */
2348         mvpp2_prs_tcam_port_set(pe, port, add);
2349
2350         /* Invalidate the entry if no ports are left enabled */
2351         pmap = mvpp2_prs_tcam_port_map_get(pe);
2352         if (pmap == 0) {
2353                 if (add) {
2354                         kfree(pe);
2355                         return -1;
2356                 }
2357                 mvpp2_prs_hw_inv(priv, pe->index);
2358                 priv->prs_shadow[pe->index].valid = false;
2359                 kfree(pe);
2360                 return 0;
2361         }
2362
2363         /* Continue - set next lookup */
2364         mvpp2_prs_sram_next_lu_set(pe, MVPP2_PRS_LU_DSA);
2365
2366         /* Set match on DA */
2367         len = ETH_ALEN;
2368         while (len--)
2369                 mvpp2_prs_tcam_data_byte_set(pe, len, da[len], 0xff);
2370
2371         /* Set result info bits */
2372         ri = MVPP2_PRS_RI_L2_UCAST | MVPP2_PRS_RI_MAC_ME_MASK;
2373
2374         mvpp2_prs_sram_ri_update(pe, ri, MVPP2_PRS_RI_L2_CAST_MASK |
2375                                  MVPP2_PRS_RI_MAC_ME_MASK);
2376         mvpp2_prs_shadow_ri_set(priv, pe->index, ri, MVPP2_PRS_RI_L2_CAST_MASK |
2377                                 MVPP2_PRS_RI_MAC_ME_MASK);
2378
2379         /* Shift to ethertype */
2380         mvpp2_prs_sram_shift_set(pe, 2 * ETH_ALEN,
2381                                  MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
2382
2383         /* Update shadow table and hw entry */
2384         priv->prs_shadow[pe->index].udf = MVPP2_PRS_UDF_MAC_DEF;
2385         mvpp2_prs_shadow_set(priv, pe->index, MVPP2_PRS_LU_MAC);
2386         mvpp2_prs_hw_write(priv, pe);
2387
2388         kfree(pe);
2389
2390         return 0;
2391 }
2392
2393 static int mvpp2_prs_update_mac_da(struct mvpp2_port *port, const u8 *da)
2394 {
2395         int err;
2396
2397         /* Remove old parser entry */
2398         err = mvpp2_prs_mac_da_accept(port->priv, port->id, port->dev_addr,
2399                                       false);
2400         if (err)
2401                 return err;
2402
2403         /* Add new parser entry */
2404         err = mvpp2_prs_mac_da_accept(port->priv, port->id, da, true);
2405         if (err)
2406                 return err;
2407
2408         /* Set addr in the device */
2409         memcpy(port->dev_addr, da, ETH_ALEN);
2410
2411         return 0;
2412 }
2413
2414 /* Set prs flow for the port */
2415 static int mvpp2_prs_def_flow(struct mvpp2_port *port)
2416 {
2417         struct mvpp2_prs_entry *pe;
2418         int tid;
2419
2420         pe = mvpp2_prs_flow_find(port->priv, port->id);
2421
2422         /* Such entry not exist */
2423         if (!pe) {
2424                 /* Go through the all entires from last to first */
2425                 tid = mvpp2_prs_tcam_first_free(port->priv,
2426                                                 MVPP2_PE_LAST_FREE_TID,
2427                                                MVPP2_PE_FIRST_FREE_TID);
2428                 if (tid < 0)
2429                         return tid;
2430
2431                 pe = kzalloc(sizeof(*pe), GFP_KERNEL);
2432                 if (!pe)
2433                         return -ENOMEM;
2434
2435                 mvpp2_prs_tcam_lu_set(pe, MVPP2_PRS_LU_FLOWS);
2436                 pe->index = tid;
2437
2438                 /* Set flow ID*/
2439                 mvpp2_prs_sram_ai_update(pe, port->id, MVPP2_PRS_FLOW_ID_MASK);
2440                 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1);
2441
2442                 /* Update shadow table */
2443                 mvpp2_prs_shadow_set(port->priv, pe->index, MVPP2_PRS_LU_FLOWS);
2444         }
2445
2446         mvpp2_prs_tcam_port_map_set(pe, (1 << port->id));
2447         mvpp2_prs_hw_write(port->priv, pe);
2448         kfree(pe);
2449
2450         return 0;
2451 }
2452
2453 /* Classifier configuration routines */
2454
2455 /* Update classification flow table registers */
2456 static void mvpp2_cls_flow_write(struct mvpp2 *priv,
2457                                  struct mvpp2_cls_flow_entry *fe)
2458 {
2459         mvpp2_write(priv, MVPP2_CLS_FLOW_INDEX_REG, fe->index);
2460         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL0_REG,  fe->data[0]);
2461         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL1_REG,  fe->data[1]);
2462         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL2_REG,  fe->data[2]);
2463 }
2464
2465 /* Update classification lookup table register */
2466 static void mvpp2_cls_lookup_write(struct mvpp2 *priv,
2467                                    struct mvpp2_cls_lookup_entry *le)
2468 {
2469         u32 val;
2470
2471         val = (le->way << MVPP2_CLS_LKP_INDEX_WAY_OFFS) | le->lkpid;
2472         mvpp2_write(priv, MVPP2_CLS_LKP_INDEX_REG, val);
2473         mvpp2_write(priv, MVPP2_CLS_LKP_TBL_REG, le->data);
2474 }
2475
2476 /* Classifier default initialization */
2477 static void mvpp2_cls_init(struct mvpp2 *priv)
2478 {
2479         struct mvpp2_cls_lookup_entry le;
2480         struct mvpp2_cls_flow_entry fe;
2481         int index;
2482
2483         /* Enable classifier */
2484         mvpp2_write(priv, MVPP2_CLS_MODE_REG, MVPP2_CLS_MODE_ACTIVE_MASK);
2485
2486         /* Clear classifier flow table */
2487         memset(&fe.data, 0, MVPP2_CLS_FLOWS_TBL_DATA_WORDS);
2488         for (index = 0; index < MVPP2_CLS_FLOWS_TBL_SIZE; index++) {
2489                 fe.index = index;
2490                 mvpp2_cls_flow_write(priv, &fe);
2491         }
2492
2493         /* Clear classifier lookup table */
2494         le.data = 0;
2495         for (index = 0; index < MVPP2_CLS_LKP_TBL_SIZE; index++) {
2496                 le.lkpid = index;
2497                 le.way = 0;
2498                 mvpp2_cls_lookup_write(priv, &le);
2499
2500                 le.way = 1;
2501                 mvpp2_cls_lookup_write(priv, &le);
2502         }
2503 }
2504
2505 static void mvpp2_cls_port_config(struct mvpp2_port *port)
2506 {
2507         struct mvpp2_cls_lookup_entry le;
2508         u32 val;
2509
2510         /* Set way for the port */
2511         val = mvpp2_read(port->priv, MVPP2_CLS_PORT_WAY_REG);
2512         val &= ~MVPP2_CLS_PORT_WAY_MASK(port->id);
2513         mvpp2_write(port->priv, MVPP2_CLS_PORT_WAY_REG, val);
2514
2515         /* Pick the entry to be accessed in lookup ID decoding table
2516          * according to the way and lkpid.
2517          */
2518         le.lkpid = port->id;
2519         le.way = 0;
2520         le.data = 0;
2521
2522         /* Set initial CPU queue for receiving packets */
2523         le.data &= ~MVPP2_CLS_LKP_TBL_RXQ_MASK;
2524         le.data |= port->first_rxq;
2525
2526         /* Disable classification engines */
2527         le.data &= ~MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK;
2528
2529         /* Update lookup ID table entry */
2530         mvpp2_cls_lookup_write(port->priv, &le);
2531 }
2532
2533 /* Set CPU queue number for oversize packets */
2534 static void mvpp2_cls_oversize_rxq_set(struct mvpp2_port *port)
2535 {
2536         u32 val;
2537
2538         mvpp2_write(port->priv, MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port->id),
2539                     port->first_rxq & MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK);
2540
2541         mvpp2_write(port->priv, MVPP2_CLS_SWFWD_P2HQ_REG(port->id),
2542                     (port->first_rxq >> MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS));
2543
2544         val = mvpp2_read(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG);
2545         val |= MVPP2_CLS_SWFWD_PCTRL_MASK(port->id);
2546         mvpp2_write(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG, val);
2547 }
2548
2549 /* Buffer Manager configuration routines */
2550
2551 /* Create pool */
2552 static int mvpp2_bm_pool_create(struct udevice *dev,
2553                                 struct mvpp2 *priv,
2554                                 struct mvpp2_bm_pool *bm_pool, int size)
2555 {
2556         u32 val;
2557
2558         /* Number of buffer pointers must be a multiple of 16, as per
2559          * hardware constraints
2560          */
2561         if (!IS_ALIGNED(size, 16))
2562                 return -EINVAL;
2563
2564         bm_pool->virt_addr = buffer_loc.bm_pool[bm_pool->id];
2565         bm_pool->dma_addr = (dma_addr_t)buffer_loc.bm_pool[bm_pool->id];
2566         if (!bm_pool->virt_addr)
2567                 return -ENOMEM;
2568
2569         if (!IS_ALIGNED((unsigned long)bm_pool->virt_addr,
2570                         MVPP2_BM_POOL_PTR_ALIGN)) {
2571                 dev_err(dev, "BM pool %d is not %d bytes aligned\n",
2572                         bm_pool->id, MVPP2_BM_POOL_PTR_ALIGN);
2573                 return -ENOMEM;
2574         }
2575
2576         mvpp2_write(priv, MVPP2_BM_POOL_BASE_REG(bm_pool->id),
2577                     lower_32_bits(bm_pool->dma_addr));
2578         if (priv->hw_version == MVPP22)
2579                 mvpp2_write(priv, MVPP22_BM_POOL_BASE_HIGH_REG,
2580                             (upper_32_bits(bm_pool->dma_addr) &
2581                             MVPP22_BM_POOL_BASE_HIGH_MASK));
2582         mvpp2_write(priv, MVPP2_BM_POOL_SIZE_REG(bm_pool->id), size);
2583
2584         val = mvpp2_read(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id));
2585         val |= MVPP2_BM_START_MASK;
2586         mvpp2_write(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id), val);
2587
2588         bm_pool->type = MVPP2_BM_FREE;
2589         bm_pool->size = size;
2590         bm_pool->pkt_size = 0;
2591         bm_pool->buf_num = 0;
2592
2593         return 0;
2594 }
2595
2596 /* Set pool buffer size */
2597 static void mvpp2_bm_pool_bufsize_set(struct mvpp2 *priv,
2598                                       struct mvpp2_bm_pool *bm_pool,
2599                                       int buf_size)
2600 {
2601         u32 val;
2602
2603         bm_pool->buf_size = buf_size;
2604
2605         val = ALIGN(buf_size, 1 << MVPP2_POOL_BUF_SIZE_OFFSET);
2606         mvpp2_write(priv, MVPP2_POOL_BUF_SIZE_REG(bm_pool->id), val);
2607 }
2608
2609 /* Free all buffers from the pool */
2610 static void mvpp2_bm_bufs_free(struct udevice *dev, struct mvpp2 *priv,
2611                                struct mvpp2_bm_pool *bm_pool)
2612 {
2613         int i;
2614
2615         for (i = 0; i < bm_pool->buf_num; i++) {
2616                 /* Allocate buffer back from the buffer manager */
2617                 mvpp2_read(priv, MVPP2_BM_PHY_ALLOC_REG(bm_pool->id));
2618         }
2619
2620         bm_pool->buf_num = 0;
2621 }
2622
2623 /* Cleanup pool */
2624 static int mvpp2_bm_pool_destroy(struct udevice *dev,
2625                                  struct mvpp2 *priv,
2626                                  struct mvpp2_bm_pool *bm_pool)
2627 {
2628         u32 val;
2629
2630         mvpp2_bm_bufs_free(dev, priv, bm_pool);
2631         if (bm_pool->buf_num) {
2632                 dev_err(dev, "cannot free all buffers in pool %d\n", bm_pool->id);
2633                 return 0;
2634         }
2635
2636         val = mvpp2_read(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id));
2637         val |= MVPP2_BM_STOP_MASK;
2638         mvpp2_write(priv, MVPP2_BM_POOL_CTRL_REG(bm_pool->id), val);
2639
2640         return 0;
2641 }
2642
2643 static int mvpp2_bm_pools_init(struct udevice *dev,
2644                                struct mvpp2 *priv)
2645 {
2646         int i, err, size;
2647         struct mvpp2_bm_pool *bm_pool;
2648
2649         /* Create all pools with maximum size */
2650         size = MVPP2_BM_POOL_SIZE_MAX;
2651         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
2652                 bm_pool = &priv->bm_pools[i];
2653                 bm_pool->id = i;
2654                 err = mvpp2_bm_pool_create(dev, priv, bm_pool, size);
2655                 if (err)
2656                         goto err_unroll_pools;
2657                 mvpp2_bm_pool_bufsize_set(priv, bm_pool, RX_BUFFER_SIZE);
2658         }
2659         return 0;
2660
2661 err_unroll_pools:
2662         dev_err(dev, "failed to create BM pool %d, size %d\n", i, size);
2663         for (i = i - 1; i >= 0; i--)
2664                 mvpp2_bm_pool_destroy(dev, priv, &priv->bm_pools[i]);
2665         return err;
2666 }
2667
2668 static int mvpp2_bm_init(struct udevice *dev, struct mvpp2 *priv)
2669 {
2670         int i, err;
2671
2672         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
2673                 /* Mask BM all interrupts */
2674                 mvpp2_write(priv, MVPP2_BM_INTR_MASK_REG(i), 0);
2675                 /* Clear BM cause register */
2676                 mvpp2_write(priv, MVPP2_BM_INTR_CAUSE_REG(i), 0);
2677         }
2678
2679         /* Allocate and initialize BM pools */
2680         priv->bm_pools = devm_kcalloc(dev, MVPP2_BM_POOLS_NUM,
2681                                      sizeof(struct mvpp2_bm_pool), GFP_KERNEL);
2682         if (!priv->bm_pools)
2683                 return -ENOMEM;
2684
2685         err = mvpp2_bm_pools_init(dev, priv);
2686         if (err < 0)
2687                 return err;
2688         return 0;
2689 }
2690
2691 /* Attach long pool to rxq */
2692 static void mvpp2_rxq_long_pool_set(struct mvpp2_port *port,
2693                                     int lrxq, int long_pool)
2694 {
2695         u32 val, mask;
2696         int prxq;
2697
2698         /* Get queue physical ID */
2699         prxq = port->rxqs[lrxq]->id;
2700
2701         if (port->priv->hw_version == MVPP21)
2702                 mask = MVPP21_RXQ_POOL_LONG_MASK;
2703         else
2704                 mask = MVPP22_RXQ_POOL_LONG_MASK;
2705
2706         val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq));
2707         val &= ~mask;
2708         val |= (long_pool << MVPP2_RXQ_POOL_LONG_OFFS) & mask;
2709         mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val);
2710 }
2711
2712 /* Set pool number in a BM cookie */
2713 static inline u32 mvpp2_bm_cookie_pool_set(u32 cookie, int pool)
2714 {
2715         u32 bm;
2716
2717         bm = cookie & ~(0xFF << MVPP2_BM_COOKIE_POOL_OFFS);
2718         bm |= ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS);
2719
2720         return bm;
2721 }
2722
2723 /* Get pool number from a BM cookie */
2724 static inline int mvpp2_bm_cookie_pool_get(unsigned long cookie)
2725 {
2726         return (cookie >> MVPP2_BM_COOKIE_POOL_OFFS) & 0xFF;
2727 }
2728
2729 /* Release buffer to BM */
2730 static inline void mvpp2_bm_pool_put(struct mvpp2_port *port, int pool,
2731                                      dma_addr_t buf_dma_addr,
2732                                      unsigned long buf_phys_addr)
2733 {
2734         if (port->priv->hw_version == MVPP22) {
2735                 u32 val = 0;
2736
2737                 if (sizeof(dma_addr_t) == 8)
2738                         val |= upper_32_bits(buf_dma_addr) &
2739                                 MVPP22_BM_ADDR_HIGH_PHYS_RLS_MASK;
2740
2741                 if (sizeof(phys_addr_t) == 8)
2742                         val |= (upper_32_bits(buf_phys_addr)
2743                                 << MVPP22_BM_ADDR_HIGH_VIRT_RLS_SHIFT) &
2744                                 MVPP22_BM_ADDR_HIGH_VIRT_RLS_MASK;
2745
2746                 mvpp2_write(port->priv, MVPP22_BM_ADDR_HIGH_RLS_REG, val);
2747         }
2748
2749         /* MVPP2_BM_VIRT_RLS_REG is not interpreted by HW, and simply
2750          * returned in the "cookie" field of the RX
2751          * descriptor. Instead of storing the virtual address, we
2752          * store the physical address
2753          */
2754         mvpp2_write(port->priv, MVPP2_BM_VIRT_RLS_REG, buf_phys_addr);
2755         mvpp2_write(port->priv, MVPP2_BM_PHY_RLS_REG(pool), buf_dma_addr);
2756 }
2757
2758 /* Refill BM pool */
2759 static void mvpp2_pool_refill(struct mvpp2_port *port, u32 bm,
2760                               dma_addr_t dma_addr,
2761                               phys_addr_t phys_addr)
2762 {
2763         int pool = mvpp2_bm_cookie_pool_get(bm);
2764
2765         mvpp2_bm_pool_put(port, pool, dma_addr, phys_addr);
2766 }
2767
2768 /* Allocate buffers for the pool */
2769 static int mvpp2_bm_bufs_add(struct mvpp2_port *port,
2770                              struct mvpp2_bm_pool *bm_pool, int buf_num)
2771 {
2772         int i;
2773
2774         if (buf_num < 0 ||
2775             (buf_num + bm_pool->buf_num > bm_pool->size)) {
2776                 dev_err(port->phy_dev->dev,
2777                         "cannot allocate %d buffers for pool %d\n", buf_num,
2778                         bm_pool->id);
2779                 return 0;
2780         }
2781
2782         for (i = 0; i < buf_num; i++) {
2783                 mvpp2_bm_pool_put(port, bm_pool->id,
2784                                   (dma_addr_t)buffer_loc.rx_buffer[i],
2785                                   (unsigned long)buffer_loc.rx_buffer[i]);
2786
2787         }
2788
2789         /* Update BM driver with number of buffers added to pool */
2790         bm_pool->buf_num += i;
2791
2792         return i;
2793 }
2794
2795 /* Notify the driver that BM pool is being used as specific type and return the
2796  * pool pointer on success
2797  */
2798 static struct mvpp2_bm_pool *
2799 mvpp2_bm_pool_use(struct mvpp2_port *port, int pool, enum mvpp2_bm_type type,
2800                   int pkt_size)
2801 {
2802         struct mvpp2_bm_pool *new_pool = &port->priv->bm_pools[pool];
2803         int num;
2804
2805         if (new_pool->type != MVPP2_BM_FREE && new_pool->type != type) {
2806                 dev_err(port->phy_dev->dev, "mixing pool types is forbidden\n");
2807                 return NULL;
2808         }
2809
2810         if (new_pool->type == MVPP2_BM_FREE)
2811                 new_pool->type = type;
2812
2813         /* Allocate buffers in case BM pool is used as long pool, but packet
2814          * size doesn't match MTU or BM pool hasn't being used yet
2815          */
2816         if (((type == MVPP2_BM_SWF_LONG) && (pkt_size > new_pool->pkt_size)) ||
2817             (new_pool->pkt_size == 0)) {
2818                 int pkts_num;
2819
2820                 /* Set default buffer number or free all the buffers in case
2821                  * the pool is not empty
2822                  */
2823                 pkts_num = new_pool->buf_num;
2824                 if (pkts_num == 0)
2825                         pkts_num = type == MVPP2_BM_SWF_LONG ?
2826                                    MVPP2_BM_LONG_BUF_NUM :
2827                                    MVPP2_BM_SHORT_BUF_NUM;
2828                 else
2829                         mvpp2_bm_bufs_free(NULL,
2830                                            port->priv, new_pool);
2831
2832                 new_pool->pkt_size = pkt_size;
2833
2834                 /* Allocate buffers for this pool */
2835                 num = mvpp2_bm_bufs_add(port, new_pool, pkts_num);
2836                 if (num != pkts_num) {
2837                         dev_err(port->phy_dev->dev,
2838                                 "pool %d: %d of %d allocated\n", new_pool->id,
2839                                 num, pkts_num);
2840                         return NULL;
2841                 }
2842         }
2843
2844         return new_pool;
2845 }
2846
2847 /* Initialize pools for swf */
2848 static int mvpp2_swf_bm_pool_init(struct mvpp2_port *port)
2849 {
2850         int rxq;
2851
2852         if (!port->pool_long) {
2853                 port->pool_long =
2854                        mvpp2_bm_pool_use(port, MVPP2_BM_SWF_LONG_POOL(port->id),
2855                                          MVPP2_BM_SWF_LONG,
2856                                          port->pkt_size);
2857                 if (!port->pool_long)
2858                         return -ENOMEM;
2859
2860                 port->pool_long->port_map |= (1 << port->id);
2861
2862                 for (rxq = 0; rxq < rxq_number; rxq++)
2863                         mvpp2_rxq_long_pool_set(port, rxq, port->pool_long->id);
2864         }
2865
2866         return 0;
2867 }
2868
2869 /* Port configuration routines */
2870
2871 static void mvpp2_port_mii_set(struct mvpp2_port *port)
2872 {
2873         u32 val;
2874
2875         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
2876
2877         switch (port->phy_interface) {
2878         case PHY_INTERFACE_MODE_SGMII:
2879                 val |= MVPP2_GMAC_INBAND_AN_MASK;
2880                 break;
2881         case PHY_INTERFACE_MODE_RGMII:
2882         case PHY_INTERFACE_MODE_RGMII_ID:
2883                 val |= MVPP2_GMAC_PORT_RGMII_MASK;
2884         default:
2885                 val &= ~MVPP2_GMAC_PCS_ENABLE_MASK;
2886         }
2887
2888         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2889 }
2890
2891 static void mvpp2_port_fc_adv_enable(struct mvpp2_port *port)
2892 {
2893         u32 val;
2894
2895         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
2896         val |= MVPP2_GMAC_FC_ADV_EN;
2897         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
2898 }
2899
2900 static void mvpp2_port_enable(struct mvpp2_port *port)
2901 {
2902         u32 val;
2903
2904         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2905         val |= MVPP2_GMAC_PORT_EN_MASK;
2906         val |= MVPP2_GMAC_MIB_CNTR_EN_MASK;
2907         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2908 }
2909
2910 static void mvpp2_port_disable(struct mvpp2_port *port)
2911 {
2912         u32 val;
2913
2914         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2915         val &= ~(MVPP2_GMAC_PORT_EN_MASK);
2916         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2917 }
2918
2919 /* Set IEEE 802.3x Flow Control Xon Packet Transmission Mode */
2920 static void mvpp2_port_periodic_xon_disable(struct mvpp2_port *port)
2921 {
2922         u32 val;
2923
2924         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG) &
2925                     ~MVPP2_GMAC_PERIODIC_XON_EN_MASK;
2926         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
2927 }
2928
2929 /* Configure loopback port */
2930 static void mvpp2_port_loopback_set(struct mvpp2_port *port)
2931 {
2932         u32 val;
2933
2934         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG);
2935
2936         if (port->speed == 1000)
2937                 val |= MVPP2_GMAC_GMII_LB_EN_MASK;
2938         else
2939                 val &= ~MVPP2_GMAC_GMII_LB_EN_MASK;
2940
2941         if (port->phy_interface == PHY_INTERFACE_MODE_SGMII)
2942                 val |= MVPP2_GMAC_PCS_LB_EN_MASK;
2943         else
2944                 val &= ~MVPP2_GMAC_PCS_LB_EN_MASK;
2945
2946         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
2947 }
2948
2949 static void mvpp2_port_reset(struct mvpp2_port *port)
2950 {
2951         u32 val;
2952
2953         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG) &
2954                     ~MVPP2_GMAC_PORT_RESET_MASK;
2955         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2956
2957         while (readl(port->base + MVPP2_GMAC_CTRL_2_REG) &
2958                MVPP2_GMAC_PORT_RESET_MASK)
2959                 continue;
2960 }
2961
2962 /* Change maximum receive size of the port */
2963 static inline void mvpp2_gmac_max_rx_size_set(struct mvpp2_port *port)
2964 {
2965         u32 val;
2966
2967         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
2968         val &= ~MVPP2_GMAC_MAX_RX_SIZE_MASK;
2969         val |= (((port->pkt_size - MVPP2_MH_SIZE) / 2) <<
2970                     MVPP2_GMAC_MAX_RX_SIZE_OFFS);
2971         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
2972 }
2973
2974 /* PPv2.2 GoP/GMAC config */
2975
2976 /* Set the MAC to reset or exit from reset */
2977 static int gop_gmac_reset(struct mvpp2_port *port, int reset)
2978 {
2979         u32 val;
2980
2981         /* read - modify - write */
2982         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
2983         if (reset)
2984                 val |= MVPP2_GMAC_PORT_RESET_MASK;
2985         else
2986                 val &= ~MVPP2_GMAC_PORT_RESET_MASK;
2987         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
2988
2989         return 0;
2990 }
2991
2992 /*
2993  * gop_gpcs_mode_cfg
2994  *
2995  * Configure port to working with Gig PCS or don't.
2996  */
2997 static int gop_gpcs_mode_cfg(struct mvpp2_port *port, int en)
2998 {
2999         u32 val;
3000
3001         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
3002         if (en)
3003                 val |= MVPP2_GMAC_PCS_ENABLE_MASK;
3004         else
3005                 val &= ~MVPP2_GMAC_PCS_ENABLE_MASK;
3006         /* enable / disable PCS on this port */
3007         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
3008
3009         return 0;
3010 }
3011
3012 static int gop_bypass_clk_cfg(struct mvpp2_port *port, int en)
3013 {
3014         u32 val;
3015
3016         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
3017         if (en)
3018                 val |= MVPP2_GMAC_CLK_125_BYPS_EN_MASK;
3019         else
3020                 val &= ~MVPP2_GMAC_CLK_125_BYPS_EN_MASK;
3021         /* enable / disable PCS on this port */
3022         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
3023
3024         return 0;
3025 }
3026
3027 static void gop_gmac_sgmii2_5_cfg(struct mvpp2_port *port)
3028 {
3029         u32 val, thresh;
3030
3031         /*
3032          * Configure minimal level of the Tx FIFO before the lower part
3033          * starts to read a packet
3034          */
3035         thresh = MVPP2_SGMII2_5_TX_FIFO_MIN_TH;
3036         val = readl(port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3037         val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK;
3038         val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(thresh);
3039         writel(val, port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3040
3041         /* Disable bypass of sync module */
3042         val = readl(port->base + MVPP2_GMAC_CTRL_4_REG);
3043         val |= MVPP2_GMAC_CTRL4_SYNC_BYPASS_MASK;
3044         /* configure DP clock select according to mode */
3045         val |= MVPP2_GMAC_CTRL4_DP_CLK_SEL_MASK;
3046         /* configure QSGMII bypass according to mode */
3047         val |= MVPP2_GMAC_CTRL4_QSGMII_BYPASS_ACTIVE_MASK;
3048         writel(val, port->base + MVPP2_GMAC_CTRL_4_REG);
3049
3050         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
3051         /*
3052          * Configure GIG MAC to 1000Base-X mode connected to a fiber
3053          * transceiver
3054          */
3055         val |= MVPP2_GMAC_PORT_TYPE_MASK;
3056         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
3057
3058         /* configure AN 0x9268 */
3059         val = MVPP2_GMAC_EN_PCS_AN |
3060                 MVPP2_GMAC_AN_BYPASS_EN |
3061                 MVPP2_GMAC_CONFIG_MII_SPEED  |
3062                 MVPP2_GMAC_CONFIG_GMII_SPEED     |
3063                 MVPP2_GMAC_FC_ADV_EN    |
3064                 MVPP2_GMAC_CONFIG_FULL_DUPLEX |
3065                 MVPP2_GMAC_CHOOSE_SAMPLE_TX_CONFIG;
3066         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3067 }
3068
3069 static void gop_gmac_sgmii_cfg(struct mvpp2_port *port)
3070 {
3071         u32 val, thresh;
3072
3073         /*
3074          * Configure minimal level of the Tx FIFO before the lower part
3075          * starts to read a packet
3076          */
3077         thresh = MVPP2_SGMII_TX_FIFO_MIN_TH;
3078         val = readl(port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3079         val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK;
3080         val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(thresh);
3081         writel(val, port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3082
3083         /* Disable bypass of sync module */
3084         val = readl(port->base + MVPP2_GMAC_CTRL_4_REG);
3085         val |= MVPP2_GMAC_CTRL4_SYNC_BYPASS_MASK;
3086         /* configure DP clock select according to mode */
3087         val &= ~MVPP2_GMAC_CTRL4_DP_CLK_SEL_MASK;
3088         /* configure QSGMII bypass according to mode */
3089         val |= MVPP2_GMAC_CTRL4_QSGMII_BYPASS_ACTIVE_MASK;
3090         writel(val, port->base + MVPP2_GMAC_CTRL_4_REG);
3091
3092         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
3093         /* configure GIG MAC to SGMII mode */
3094         val &= ~MVPP2_GMAC_PORT_TYPE_MASK;
3095         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
3096
3097         /* configure AN */
3098         val = MVPP2_GMAC_EN_PCS_AN |
3099                 MVPP2_GMAC_AN_BYPASS_EN |
3100                 MVPP2_GMAC_AN_SPEED_EN  |
3101                 MVPP2_GMAC_EN_FC_AN     |
3102                 MVPP2_GMAC_AN_DUPLEX_EN |
3103                 MVPP2_GMAC_CHOOSE_SAMPLE_TX_CONFIG;
3104         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3105 }
3106
3107 static void gop_gmac_rgmii_cfg(struct mvpp2_port *port)
3108 {
3109         u32 val, thresh;
3110
3111         /*
3112          * Configure minimal level of the Tx FIFO before the lower part
3113          * starts to read a packet
3114          */
3115         thresh = MVPP2_RGMII_TX_FIFO_MIN_TH;
3116         val = readl(port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3117         val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK;
3118         val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(thresh);
3119         writel(val, port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3120
3121         /* Disable bypass of sync module */
3122         val = readl(port->base + MVPP2_GMAC_CTRL_4_REG);
3123         val |= MVPP2_GMAC_CTRL4_SYNC_BYPASS_MASK;
3124         /* configure DP clock select according to mode */
3125         val &= ~MVPP2_GMAC_CTRL4_DP_CLK_SEL_MASK;
3126         val |= MVPP2_GMAC_CTRL4_QSGMII_BYPASS_ACTIVE_MASK;
3127         val |= MVPP2_GMAC_CTRL4_EXT_PIN_GMII_SEL_MASK;
3128         writel(val, port->base + MVPP2_GMAC_CTRL_4_REG);
3129
3130         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
3131         /* configure GIG MAC to SGMII mode */
3132         val &= ~MVPP2_GMAC_PORT_TYPE_MASK;
3133         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
3134
3135         /* configure AN 0xb8e8 */
3136         val = MVPP2_GMAC_AN_BYPASS_EN |
3137                 MVPP2_GMAC_AN_SPEED_EN   |
3138                 MVPP2_GMAC_EN_FC_AN      |
3139                 MVPP2_GMAC_AN_DUPLEX_EN  |
3140                 MVPP2_GMAC_CHOOSE_SAMPLE_TX_CONFIG;
3141         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
3142 }
3143
3144 /* Set the internal mux's to the required MAC in the GOP */
3145 static int gop_gmac_mode_cfg(struct mvpp2_port *port)
3146 {
3147         u32 val;
3148
3149         /* Set TX FIFO thresholds */
3150         switch (port->phy_interface) {
3151         case PHY_INTERFACE_MODE_SGMII:
3152                 if (port->phy_speed == 2500)
3153                         gop_gmac_sgmii2_5_cfg(port);
3154                 else
3155                         gop_gmac_sgmii_cfg(port);
3156                 break;
3157
3158         case PHY_INTERFACE_MODE_RGMII:
3159         case PHY_INTERFACE_MODE_RGMII_ID:
3160                 gop_gmac_rgmii_cfg(port);
3161                 break;
3162
3163         default:
3164                 return -1;
3165         }
3166
3167         /* Jumbo frame support - 0x1400*2= 0x2800 bytes */
3168         val = readl(port->base + MVPP2_GMAC_CTRL_0_REG);
3169         val &= ~MVPP2_GMAC_MAX_RX_SIZE_MASK;
3170         val |= 0x1400 << MVPP2_GMAC_MAX_RX_SIZE_OFFS;
3171         writel(val, port->base + MVPP2_GMAC_CTRL_0_REG);
3172
3173         /* PeriodicXonEn disable */
3174         val = readl(port->base + MVPP2_GMAC_CTRL_1_REG);
3175         val &= ~MVPP2_GMAC_PERIODIC_XON_EN_MASK;
3176         writel(val, port->base + MVPP2_GMAC_CTRL_1_REG);
3177
3178         return 0;
3179 }
3180
3181 static void gop_xlg_2_gig_mac_cfg(struct mvpp2_port *port)
3182 {
3183         u32 val;
3184
3185         /* relevant only for MAC0 (XLG0 and GMAC0) */
3186         if (port->gop_id > 0)
3187                 return;
3188
3189         /* configure 1Gig MAC mode */
3190         val = readl(port->base + MVPP22_XLG_CTRL3_REG);
3191         val &= ~MVPP22_XLG_CTRL3_MACMODESELECT_MASK;
3192         val |= MVPP22_XLG_CTRL3_MACMODESELECT_GMAC;
3193         writel(val, port->base + MVPP22_XLG_CTRL3_REG);
3194 }
3195
3196 static int gop_gpcs_reset(struct mvpp2_port *port, int reset)
3197 {
3198         u32 val;
3199
3200         val = readl(port->base + MVPP2_GMAC_CTRL_2_REG);
3201         if (reset)
3202                 val &= ~MVPP2_GMAC_SGMII_MODE_MASK;
3203         else
3204                 val |= MVPP2_GMAC_SGMII_MODE_MASK;
3205         writel(val, port->base + MVPP2_GMAC_CTRL_2_REG);
3206
3207         return 0;
3208 }
3209
3210 /* Set the internal mux's to the required PCS in the PI */
3211 static int gop_xpcs_mode(struct mvpp2_port *port, int num_of_lanes)
3212 {
3213         u32 val;
3214         int lane;
3215
3216         switch (num_of_lanes) {
3217         case 1:
3218                 lane = 0;
3219                 break;
3220         case 2:
3221                 lane = 1;
3222                 break;
3223         case 4:
3224                 lane = 2;
3225                 break;
3226         default:
3227                 return -1;
3228         }
3229
3230         /* configure XG MAC mode */
3231         val = readl(port->priv->xpcs_base + MVPP22_XPCS_GLOBAL_CFG_0_REG);
3232         val &= ~MVPP22_XPCS_PCSMODE_MASK;
3233         val &= ~MVPP22_XPCS_LANEACTIVE_MASK;
3234         val |= (2 * lane) << MVPP22_XPCS_LANEACTIVE_OFFS;
3235         writel(val, port->priv->xpcs_base + MVPP22_XPCS_GLOBAL_CFG_0_REG);
3236
3237         return 0;
3238 }
3239
3240 static int gop_mpcs_mode(struct mvpp2_port *port)
3241 {
3242         u32 val;
3243
3244         /* configure PCS40G COMMON CONTROL */
3245         val = readl(port->priv->mpcs_base + PCS40G_COMMON_CONTROL);
3246         val &= ~FORWARD_ERROR_CORRECTION_MASK;
3247         writel(val, port->priv->mpcs_base + PCS40G_COMMON_CONTROL);
3248
3249         /* configure PCS CLOCK RESET */
3250         val = readl(port->priv->mpcs_base + PCS_CLOCK_RESET);
3251         val &= ~CLK_DIVISION_RATIO_MASK;
3252         val |= 1 << CLK_DIVISION_RATIO_OFFS;
3253         writel(val, port->priv->mpcs_base + PCS_CLOCK_RESET);
3254
3255         val &= ~CLK_DIV_PHASE_SET_MASK;
3256         val |= MAC_CLK_RESET_MASK;
3257         val |= RX_SD_CLK_RESET_MASK;
3258         val |= TX_SD_CLK_RESET_MASK;
3259         writel(val, port->priv->mpcs_base + PCS_CLOCK_RESET);
3260
3261         return 0;
3262 }
3263
3264 /* Set the internal mux's to the required MAC in the GOP */
3265 static int gop_xlg_mac_mode_cfg(struct mvpp2_port *port, int num_of_act_lanes)
3266 {
3267         u32 val;
3268
3269         /* configure 10G MAC mode */
3270         val = readl(port->base + MVPP22_XLG_CTRL0_REG);
3271         val |= MVPP22_XLG_RX_FC_EN;
3272         writel(val, port->base + MVPP22_XLG_CTRL0_REG);
3273
3274         val = readl(port->base + MVPP22_XLG_CTRL3_REG);
3275         val &= ~MVPP22_XLG_CTRL3_MACMODESELECT_MASK;
3276         val |= MVPP22_XLG_CTRL3_MACMODESELECT_10GMAC;
3277         writel(val, port->base + MVPP22_XLG_CTRL3_REG);
3278
3279         /* read - modify - write */
3280         val = readl(port->base + MVPP22_XLG_CTRL4_REG);
3281         val &= ~MVPP22_XLG_MODE_DMA_1G;
3282         val |= MVPP22_XLG_FORWARD_PFC_EN;
3283         val |= MVPP22_XLG_FORWARD_802_3X_FC_EN;
3284         val &= ~MVPP22_XLG_EN_IDLE_CHECK_FOR_LINK;
3285         writel(val, port->base + MVPP22_XLG_CTRL4_REG);
3286
3287         /* Jumbo frame support: 0x1400 * 2 = 0x2800 bytes */
3288         val = readl(port->base + MVPP22_XLG_CTRL1_REG);
3289         val &= ~MVPP22_XLG_MAX_RX_SIZE_MASK;
3290         val |= 0x1400 << MVPP22_XLG_MAX_RX_SIZE_OFFS;
3291         writel(val, port->base + MVPP22_XLG_CTRL1_REG);
3292
3293         /* unmask link change interrupt */
3294         val = readl(port->base + MVPP22_XLG_INTERRUPT_MASK_REG);
3295         val |= MVPP22_XLG_INTERRUPT_LINK_CHANGE;
3296         val |= 1; /* unmask summary bit */
3297         writel(val, port->base + MVPP22_XLG_INTERRUPT_MASK_REG);
3298
3299         return 0;
3300 }
3301
3302 /* Set PCS to reset or exit from reset */
3303 static int gop_xpcs_reset(struct mvpp2_port *port, int reset)
3304 {
3305         u32 val;
3306
3307         /* read - modify - write */
3308         val = readl(port->priv->xpcs_base + MVPP22_XPCS_GLOBAL_CFG_0_REG);
3309         if (reset)
3310                 val &= ~MVPP22_XPCS_PCSRESET;
3311         else
3312                 val |= MVPP22_XPCS_PCSRESET;
3313         writel(val, port->priv->xpcs_base + MVPP22_XPCS_GLOBAL_CFG_0_REG);
3314
3315         return 0;
3316 }
3317
3318 /* Set the MAC to reset or exit from reset */
3319 static int gop_xlg_mac_reset(struct mvpp2_port *port, int reset)
3320 {
3321         u32 val;
3322
3323         /* read - modify - write */
3324         val = readl(port->base + MVPP22_XLG_CTRL0_REG);
3325         if (reset)
3326                 val &= ~MVPP22_XLG_MAC_RESETN;
3327         else
3328                 val |= MVPP22_XLG_MAC_RESETN;
3329         writel(val, port->base + MVPP22_XLG_CTRL0_REG);
3330
3331         return 0;
3332 }
3333
3334 /*
3335  * gop_port_init
3336  *
3337  * Init physical port. Configures the port mode and all it's elements
3338  * accordingly.
3339  * Does not verify that the selected mode/port number is valid at the
3340  * core level.
3341  */
3342 static int gop_port_init(struct mvpp2_port *port)
3343 {
3344         int mac_num = port->gop_id;
3345         int num_of_act_lanes;
3346
3347         if (mac_num >= MVPP22_GOP_MAC_NUM) {
3348                 log_err("illegal port number %d", mac_num);
3349                 return -1;
3350         }
3351
3352         switch (port->phy_interface) {
3353         case PHY_INTERFACE_MODE_RGMII:
3354         case PHY_INTERFACE_MODE_RGMII_ID:
3355                 gop_gmac_reset(port, 1);
3356
3357                 /* configure PCS */
3358                 gop_gpcs_mode_cfg(port, 0);
3359                 gop_bypass_clk_cfg(port, 1);
3360
3361                 /* configure MAC */
3362                 gop_gmac_mode_cfg(port);
3363                 /* pcs unreset */
3364                 gop_gpcs_reset(port, 0);
3365
3366                 /* mac unreset */
3367                 gop_gmac_reset(port, 0);
3368                 break;
3369
3370         case PHY_INTERFACE_MODE_SGMII:
3371                 /* configure PCS */
3372                 gop_gpcs_mode_cfg(port, 1);
3373
3374                 /* configure MAC */
3375                 gop_gmac_mode_cfg(port);
3376                 /* select proper Mac mode */
3377                 gop_xlg_2_gig_mac_cfg(port);
3378
3379                 /* pcs unreset */
3380                 gop_gpcs_reset(port, 0);
3381                 /* mac unreset */
3382                 gop_gmac_reset(port, 0);
3383                 break;
3384
3385         case PHY_INTERFACE_MODE_SFI:
3386                 num_of_act_lanes = 2;
3387                 mac_num = 0;
3388                 /* configure PCS */
3389                 gop_xpcs_mode(port, num_of_act_lanes);
3390                 gop_mpcs_mode(port);
3391                 /* configure MAC */
3392                 gop_xlg_mac_mode_cfg(port, num_of_act_lanes);
3393
3394                 /* pcs unreset */
3395                 gop_xpcs_reset(port, 0);
3396
3397                 /* mac unreset */
3398                 gop_xlg_mac_reset(port, 0);
3399                 break;
3400
3401         default:
3402                 log_err("Requested port mode (%d) not supported\n",
3403                         port->phy_interface);
3404                 return -1;
3405         }
3406
3407         return 0;
3408 }
3409
3410 static void gop_xlg_mac_port_enable(struct mvpp2_port *port, int enable)
3411 {
3412         u32 val;
3413
3414         val = readl(port->base + MVPP22_XLG_CTRL0_REG);
3415         if (enable) {
3416                 /* Enable port and MIB counters update */
3417                 val |= MVPP22_XLG_PORT_EN;
3418                 val &= ~MVPP22_XLG_MIBCNT_DIS;
3419         } else {
3420                 /* Disable port */
3421                 val &= ~MVPP22_XLG_PORT_EN;
3422         }
3423         writel(val, port->base + MVPP22_XLG_CTRL0_REG);
3424 }
3425
3426 static void gop_port_enable(struct mvpp2_port *port, int enable)
3427 {
3428         switch (port->phy_interface) {
3429         case PHY_INTERFACE_MODE_RGMII:
3430         case PHY_INTERFACE_MODE_RGMII_ID:
3431         case PHY_INTERFACE_MODE_SGMII:
3432                 if (enable)
3433                         mvpp2_port_enable(port);
3434                 else
3435                         mvpp2_port_disable(port);
3436                 break;
3437
3438         case PHY_INTERFACE_MODE_SFI:
3439                 gop_xlg_mac_port_enable(port, enable);
3440
3441                 break;
3442         default:
3443                 log_err("%s: Wrong port mode (%d)\n", __func__,
3444                         port->phy_interface);
3445                 return;
3446         }
3447 }
3448
3449 /* RFU1 functions */
3450 static inline u32 gop_rfu1_read(struct mvpp2 *priv, u32 offset)
3451 {
3452         return readl(priv->rfu1_base + offset);
3453 }
3454
3455 static inline void gop_rfu1_write(struct mvpp2 *priv, u32 offset, u32 data)
3456 {
3457         writel(data, priv->rfu1_base + offset);
3458 }
3459
3460 static u32 mvpp2_netc_cfg_create(int gop_id, phy_interface_t phy_type)
3461 {
3462         u32 val = 0;
3463
3464         if (gop_id == 2) {
3465                 if (phy_type == PHY_INTERFACE_MODE_SGMII)
3466                         val |= MV_NETC_GE_MAC2_SGMII;
3467         }
3468
3469         if (gop_id == 3) {
3470                 if (phy_type == PHY_INTERFACE_MODE_SGMII)
3471                         val |= MV_NETC_GE_MAC3_SGMII;
3472                 else if (phy_type == PHY_INTERFACE_MODE_RGMII ||
3473                          phy_type == PHY_INTERFACE_MODE_RGMII_ID)
3474                         val |= MV_NETC_GE_MAC3_RGMII;
3475         }
3476
3477         return val;
3478 }
3479
3480 static void gop_netc_active_port(struct mvpp2 *priv, int gop_id, u32 val)
3481 {
3482         u32 reg;
3483
3484         reg = gop_rfu1_read(priv, NETCOMP_PORTS_CONTROL_1_REG);
3485         reg &= ~(NETC_PORTS_ACTIVE_MASK(gop_id));
3486
3487         val <<= NETC_PORTS_ACTIVE_OFFSET(gop_id);
3488         val &= NETC_PORTS_ACTIVE_MASK(gop_id);
3489
3490         reg |= val;
3491
3492         gop_rfu1_write(priv, NETCOMP_PORTS_CONTROL_1_REG, reg);
3493 }
3494
3495 static void gop_netc_mii_mode(struct mvpp2 *priv, int gop_id, u32 val)
3496 {
3497         u32 reg;
3498
3499         reg = gop_rfu1_read(priv, NETCOMP_CONTROL_0_REG);
3500         reg &= ~NETC_GBE_PORT1_MII_MODE_MASK;
3501
3502         val <<= NETC_GBE_PORT1_MII_MODE_OFFS;
3503         val &= NETC_GBE_PORT1_MII_MODE_MASK;
3504
3505         reg |= val;
3506
3507         gop_rfu1_write(priv, NETCOMP_CONTROL_0_REG, reg);
3508 }
3509
3510 static void gop_netc_gop_reset(struct mvpp2 *priv, u32 val)
3511 {
3512         u32 reg;
3513
3514         reg = gop_rfu1_read(priv, GOP_SOFT_RESET_1_REG);
3515         reg &= ~NETC_GOP_SOFT_RESET_MASK;
3516
3517         val <<= NETC_GOP_SOFT_RESET_OFFS;
3518         val &= NETC_GOP_SOFT_RESET_MASK;
3519
3520         reg |= val;
3521
3522         gop_rfu1_write(priv, GOP_SOFT_RESET_1_REG, reg);
3523 }
3524
3525 static void gop_netc_gop_clock_logic_set(struct mvpp2 *priv, u32 val)
3526 {
3527         u32 reg;
3528
3529         reg = gop_rfu1_read(priv, NETCOMP_PORTS_CONTROL_0_REG);
3530         reg &= ~NETC_CLK_DIV_PHASE_MASK;
3531
3532         val <<= NETC_CLK_DIV_PHASE_OFFS;
3533         val &= NETC_CLK_DIV_PHASE_MASK;
3534
3535         reg |= val;
3536
3537         gop_rfu1_write(priv, NETCOMP_PORTS_CONTROL_0_REG, reg);
3538 }
3539
3540 static void gop_netc_port_rf_reset(struct mvpp2 *priv, int gop_id, u32 val)
3541 {
3542         u32 reg;
3543
3544         reg = gop_rfu1_read(priv, NETCOMP_PORTS_CONTROL_1_REG);
3545         reg &= ~(NETC_PORT_GIG_RF_RESET_MASK(gop_id));
3546
3547         val <<= NETC_PORT_GIG_RF_RESET_OFFS(gop_id);
3548         val &= NETC_PORT_GIG_RF_RESET_MASK(gop_id);
3549
3550         reg |= val;
3551
3552         gop_rfu1_write(priv, NETCOMP_PORTS_CONTROL_1_REG, reg);
3553 }
3554
3555 static void gop_netc_gbe_sgmii_mode_select(struct mvpp2 *priv, int gop_id,
3556                                            u32 val)
3557 {
3558         u32 reg, mask, offset;
3559
3560         if (gop_id == 2) {
3561                 mask = NETC_GBE_PORT0_SGMII_MODE_MASK;
3562                 offset = NETC_GBE_PORT0_SGMII_MODE_OFFS;
3563         } else {
3564                 mask = NETC_GBE_PORT1_SGMII_MODE_MASK;
3565                 offset = NETC_GBE_PORT1_SGMII_MODE_OFFS;
3566         }
3567         reg = gop_rfu1_read(priv, NETCOMP_CONTROL_0_REG);
3568         reg &= ~mask;
3569
3570         val <<= offset;
3571         val &= mask;
3572
3573         reg |= val;
3574
3575         gop_rfu1_write(priv, NETCOMP_CONTROL_0_REG, reg);
3576 }
3577
3578 static void gop_netc_bus_width_select(struct mvpp2 *priv, u32 val)
3579 {
3580         u32 reg;
3581
3582         reg = gop_rfu1_read(priv, NETCOMP_PORTS_CONTROL_0_REG);
3583         reg &= ~NETC_BUS_WIDTH_SELECT_MASK;
3584
3585         val <<= NETC_BUS_WIDTH_SELECT_OFFS;
3586         val &= NETC_BUS_WIDTH_SELECT_MASK;
3587
3588         reg |= val;
3589
3590         gop_rfu1_write(priv, NETCOMP_PORTS_CONTROL_0_REG, reg);
3591 }
3592
3593 static void gop_netc_sample_stages_timing(struct mvpp2 *priv, u32 val)
3594 {
3595         u32 reg;
3596
3597         reg = gop_rfu1_read(priv, NETCOMP_PORTS_CONTROL_0_REG);
3598         reg &= ~NETC_GIG_RX_DATA_SAMPLE_MASK;
3599
3600         val <<= NETC_GIG_RX_DATA_SAMPLE_OFFS;
3601         val &= NETC_GIG_RX_DATA_SAMPLE_MASK;
3602
3603         reg |= val;
3604
3605         gop_rfu1_write(priv, NETCOMP_PORTS_CONTROL_0_REG, reg);
3606 }
3607
3608 static void gop_netc_mac_to_xgmii(struct mvpp2 *priv, int gop_id,
3609                                   enum mv_netc_phase phase)
3610 {
3611         switch (phase) {
3612         case MV_NETC_FIRST_PHASE:
3613                 /* Set Bus Width to HB mode = 1 */
3614                 gop_netc_bus_width_select(priv, 1);
3615                 /* Select RGMII mode */
3616                 gop_netc_gbe_sgmii_mode_select(priv, gop_id, MV_NETC_GBE_XMII);
3617                 break;
3618
3619         case MV_NETC_SECOND_PHASE:
3620                 /* De-assert the relevant port HB reset */
3621                 gop_netc_port_rf_reset(priv, gop_id, 1);
3622                 break;
3623         }
3624 }
3625
3626 static void gop_netc_mac_to_sgmii(struct mvpp2 *priv, int gop_id,
3627                                   enum mv_netc_phase phase)
3628 {
3629         switch (phase) {
3630         case MV_NETC_FIRST_PHASE:
3631                 /* Set Bus Width to HB mode = 1 */
3632                 gop_netc_bus_width_select(priv, 1);
3633                 /* Select SGMII mode */
3634                 if (gop_id >= 1) {
3635                         gop_netc_gbe_sgmii_mode_select(priv, gop_id,
3636                                                        MV_NETC_GBE_SGMII);
3637                 }
3638
3639                 /* Configure the sample stages */
3640                 gop_netc_sample_stages_timing(priv, 0);
3641                 /* Configure the ComPhy Selector */
3642                 /* gop_netc_com_phy_selector_config(netComplex); */
3643                 break;
3644
3645         case MV_NETC_SECOND_PHASE:
3646                 /* De-assert the relevant port HB reset */
3647                 gop_netc_port_rf_reset(priv, gop_id, 1);
3648                 break;
3649         }
3650 }
3651
3652 static int gop_netc_init(struct mvpp2 *priv, enum mv_netc_phase phase)
3653 {
3654         u32 c = priv->netc_config;
3655
3656         if (c & MV_NETC_GE_MAC2_SGMII)
3657                 gop_netc_mac_to_sgmii(priv, 2, phase);
3658         else
3659                 gop_netc_mac_to_xgmii(priv, 2, phase);
3660
3661         if (c & MV_NETC_GE_MAC3_SGMII) {
3662                 gop_netc_mac_to_sgmii(priv, 3, phase);
3663         } else {
3664                 gop_netc_mac_to_xgmii(priv, 3, phase);
3665                 if (c & MV_NETC_GE_MAC3_RGMII)
3666                         gop_netc_mii_mode(priv, 3, MV_NETC_GBE_RGMII);
3667                 else
3668                         gop_netc_mii_mode(priv, 3, MV_NETC_GBE_MII);
3669         }
3670
3671         /* Activate gop ports 0, 2, 3 */
3672         gop_netc_active_port(priv, 0, 1);
3673         gop_netc_active_port(priv, 2, 1);
3674         gop_netc_active_port(priv, 3, 1);
3675
3676         if (phase == MV_NETC_SECOND_PHASE) {
3677                 /* Enable the GOP internal clock logic */
3678                 gop_netc_gop_clock_logic_set(priv, 1);
3679                 /* De-assert GOP unit reset */
3680                 gop_netc_gop_reset(priv, 1);
3681         }
3682
3683         return 0;
3684 }
3685
3686 /* Set defaults to the MVPP2 port */
3687 static void mvpp2_defaults_set(struct mvpp2_port *port)
3688 {
3689         int tx_port_num, val, queue, ptxq, lrxq;
3690
3691         if (port->priv->hw_version == MVPP21) {
3692                 /* Configure port to loopback if needed */
3693                 if (port->flags & MVPP2_F_LOOPBACK)
3694                         mvpp2_port_loopback_set(port);
3695
3696                 /* Update TX FIFO MIN Threshold */
3697                 val = readl(port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3698                 val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK;
3699                 /* Min. TX threshold must be less than minimal packet length */
3700                 val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(64 - 4 - 2);
3701                 writel(val, port->base + MVPP2_GMAC_PORT_FIFO_CFG_1_REG);
3702         }
3703
3704         /* Disable Legacy WRR, Disable EJP, Release from reset */
3705         tx_port_num = mvpp2_egress_port(port);
3706         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG,
3707                     tx_port_num);
3708         mvpp2_write(port->priv, MVPP2_TXP_SCHED_CMD_1_REG, 0);
3709
3710         /* Close bandwidth for all queues */
3711         for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) {
3712                 ptxq = mvpp2_txq_phys(port->id, queue);
3713                 mvpp2_write(port->priv,
3714                             MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(ptxq), 0);
3715         }
3716
3717         /* Set refill period to 1 usec, refill tokens
3718          * and bucket size to maximum
3719          */
3720         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PERIOD_REG, 0xc8);
3721         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_REFILL_REG);
3722         val &= ~MVPP2_TXP_REFILL_PERIOD_ALL_MASK;
3723         val |= MVPP2_TXP_REFILL_PERIOD_MASK(1);
3724         val |= MVPP2_TXP_REFILL_TOKENS_ALL_MASK;
3725         mvpp2_write(port->priv, MVPP2_TXP_SCHED_REFILL_REG, val);
3726         val = MVPP2_TXP_TOKEN_SIZE_MAX;
3727         mvpp2_write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val);
3728
3729         /* Set MaximumLowLatencyPacketSize value to 256 */
3730         mvpp2_write(port->priv, MVPP2_RX_CTRL_REG(port->id),
3731                     MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK |
3732                     MVPP2_RX_LOW_LATENCY_PKT_SIZE(256));
3733
3734         /* Enable Rx cache snoop */
3735         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
3736                 queue = port->rxqs[lrxq]->id;
3737                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
3738                 val |= MVPP2_SNOOP_PKT_SIZE_MASK |
3739                            MVPP2_SNOOP_BUF_HDR_MASK;
3740                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
3741         }
3742 }
3743
3744 /* Enable/disable receiving packets */
3745 static void mvpp2_ingress_enable(struct mvpp2_port *port)
3746 {
3747         u32 val;
3748         int lrxq, queue;
3749
3750         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
3751                 queue = port->rxqs[lrxq]->id;
3752                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
3753                 val &= ~MVPP2_RXQ_DISABLE_MASK;
3754                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
3755         }
3756 }
3757
3758 static void mvpp2_ingress_disable(struct mvpp2_port *port)
3759 {
3760         u32 val;
3761         int lrxq, queue;
3762
3763         for (lrxq = 0; lrxq < rxq_number; lrxq++) {
3764                 queue = port->rxqs[lrxq]->id;
3765                 val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(queue));
3766                 val |= MVPP2_RXQ_DISABLE_MASK;
3767                 mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val);
3768         }
3769 }
3770
3771 /* Enable transmit via physical egress queue
3772  * - HW starts take descriptors from DRAM
3773  */
3774 static void mvpp2_egress_enable(struct mvpp2_port *port)
3775 {
3776         u32 qmap;
3777         int queue;
3778         int tx_port_num = mvpp2_egress_port(port);
3779
3780         /* Enable all initialized TXs. */
3781         qmap = 0;
3782         for (queue = 0; queue < txq_number; queue++) {
3783                 struct mvpp2_tx_queue *txq = port->txqs[queue];
3784
3785                 if (txq->descs != NULL)
3786                         qmap |= (1 << queue);
3787         }
3788
3789         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
3790         mvpp2_write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG, qmap);
3791 }
3792
3793 /* Disable transmit via physical egress queue
3794  * - HW doesn't take descriptors from DRAM
3795  */
3796 static void mvpp2_egress_disable(struct mvpp2_port *port)
3797 {
3798         u32 reg_data;
3799         int delay;
3800         int tx_port_num = mvpp2_egress_port(port);
3801
3802         /* Issue stop command for active channels only */
3803         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
3804         reg_data = (mvpp2_read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG)) &
3805                     MVPP2_TXP_SCHED_ENQ_MASK;
3806         if (reg_data != 0)
3807                 mvpp2_write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG,
3808                             (reg_data << MVPP2_TXP_SCHED_DISQ_OFFSET));
3809
3810         /* Wait for all Tx activity to terminate. */
3811         delay = 0;
3812         do {
3813                 if (delay >= MVPP2_TX_DISABLE_TIMEOUT_MSEC) {
3814                         dev_warn(port->phy_dev->dev,
3815                                  "Tx stop timed out, status=0x%08x\n",
3816                                  reg_data);
3817                         break;
3818                 }
3819                 mdelay(1);
3820                 delay++;
3821
3822                 /* Check port TX Command register that all
3823                  * Tx queues are stopped
3824                  */
3825                 reg_data = mvpp2_read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG);
3826         } while (reg_data & MVPP2_TXP_SCHED_ENQ_MASK);
3827 }
3828
3829 /* Rx descriptors helper methods */
3830
3831 /* Get number of Rx descriptors occupied by received packets */
3832 static inline int
3833 mvpp2_rxq_received(struct mvpp2_port *port, int rxq_id)
3834 {
3835         u32 val = mvpp2_read(port->priv, MVPP2_RXQ_STATUS_REG(rxq_id));
3836
3837         return val & MVPP2_RXQ_OCCUPIED_MASK;
3838 }
3839
3840 /* Update Rx queue status with the number of occupied and available
3841  * Rx descriptor slots.
3842  */
3843 static inline void
3844 mvpp2_rxq_status_update(struct mvpp2_port *port, int rxq_id,
3845                         int used_count, int free_count)
3846 {
3847         /* Decrement the number of used descriptors and increment count
3848          * increment the number of free descriptors.
3849          */
3850         u32 val = used_count | (free_count << MVPP2_RXQ_NUM_NEW_OFFSET);
3851
3852         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_UPDATE_REG(rxq_id), val);
3853 }
3854
3855 /* Get pointer to next RX descriptor to be processed by SW */
3856 static inline struct mvpp2_rx_desc *
3857 mvpp2_rxq_next_desc_get(struct mvpp2_rx_queue *rxq)
3858 {
3859         int rx_desc = rxq->next_desc_to_proc;
3860
3861         rxq->next_desc_to_proc = MVPP2_QUEUE_NEXT_DESC(rxq, rx_desc);
3862         prefetch(rxq->descs + rxq->next_desc_to_proc);
3863         return rxq->descs + rx_desc;
3864 }
3865
3866 /* Set rx queue offset */
3867 static void mvpp2_rxq_offset_set(struct mvpp2_port *port,
3868                                  int prxq, int offset)
3869 {
3870         u32 val;
3871
3872         /* Convert offset from bytes to units of 32 bytes */
3873         offset = offset >> 5;
3874
3875         val = mvpp2_read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq));
3876         val &= ~MVPP2_RXQ_PACKET_OFFSET_MASK;
3877
3878         /* Offset is in */
3879         val |= ((offset << MVPP2_RXQ_PACKET_OFFSET_OFFS) &
3880                     MVPP2_RXQ_PACKET_OFFSET_MASK);
3881
3882         mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val);
3883 }
3884
3885 /* Obtain BM cookie information from descriptor */
3886 static u32 mvpp2_bm_cookie_build(struct mvpp2_port *port,
3887                                  struct mvpp2_rx_desc *rx_desc)
3888 {
3889         int cpu = smp_processor_id();
3890         int pool;
3891
3892         pool = (mvpp2_rxdesc_status_get(port, rx_desc) &
3893                 MVPP2_RXD_BM_POOL_ID_MASK) >>
3894                 MVPP2_RXD_BM_POOL_ID_OFFS;
3895
3896         return ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS) |
3897                ((cpu & 0xFF) << MVPP2_BM_COOKIE_CPU_OFFS);
3898 }
3899
3900 /* Tx descriptors helper methods */
3901
3902 /* Get number of Tx descriptors waiting to be transmitted by HW */
3903 static int mvpp2_txq_pend_desc_num_get(struct mvpp2_port *port,
3904                                        struct mvpp2_tx_queue *txq)
3905 {
3906         u32 val;
3907
3908         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
3909         val = mvpp2_read(port->priv, MVPP2_TXQ_PENDING_REG);
3910
3911         return val & MVPP2_TXQ_PENDING_MASK;
3912 }
3913
3914 /* Get pointer to next Tx descriptor to be processed (send) by HW */
3915 static struct mvpp2_tx_desc *
3916 mvpp2_txq_next_desc_get(struct mvpp2_tx_queue *txq)
3917 {
3918         int tx_desc = txq->next_desc_to_proc;
3919
3920         txq->next_desc_to_proc = MVPP2_QUEUE_NEXT_DESC(txq, tx_desc);
3921         return txq->descs + tx_desc;
3922 }
3923
3924 /* Update HW with number of aggregated Tx descriptors to be sent */
3925 static void mvpp2_aggr_txq_pend_desc_add(struct mvpp2_port *port, int pending)
3926 {
3927         /* aggregated access - relevant TXQ number is written in TX desc */
3928         mvpp2_write(port->priv, MVPP2_AGGR_TXQ_UPDATE_REG, pending);
3929 }
3930
3931 /* Get number of sent descriptors and decrement counter.
3932  * The number of sent descriptors is returned.
3933  * Per-CPU access
3934  */
3935 static inline int mvpp2_txq_sent_desc_proc(struct mvpp2_port *port,
3936                                            struct mvpp2_tx_queue *txq)
3937 {
3938         u32 val;
3939
3940         /* Reading status reg resets transmitted descriptor counter */
3941         val = mvpp2_read(port->priv, MVPP2_TXQ_SENT_REG(txq->id));
3942
3943         return (val & MVPP2_TRANSMITTED_COUNT_MASK) >>
3944                 MVPP2_TRANSMITTED_COUNT_OFFSET;
3945 }
3946
3947 static void mvpp2_txq_sent_counter_clear(void *arg)
3948 {
3949         struct mvpp2_port *port = arg;
3950         int queue;
3951
3952         for (queue = 0; queue < txq_number; queue++) {
3953                 int id = port->txqs[queue]->id;
3954
3955                 mvpp2_read(port->priv, MVPP2_TXQ_SENT_REG(id));
3956         }
3957 }
3958
3959 /* Set max sizes for Tx queues */
3960 static void mvpp2_txp_max_tx_size_set(struct mvpp2_port *port)
3961 {
3962         u32     val, size, mtu;
3963         int     txq, tx_port_num;
3964
3965         mtu = port->pkt_size * 8;
3966         if (mtu > MVPP2_TXP_MTU_MAX)
3967                 mtu = MVPP2_TXP_MTU_MAX;
3968
3969         /* WA for wrong Token bucket update: Set MTU value = 3*real MTU value */
3970         mtu = 3 * mtu;
3971
3972         /* Indirect access to registers */
3973         tx_port_num = mvpp2_egress_port(port);
3974         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
3975
3976         /* Set MTU */
3977         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_MTU_REG);
3978         val &= ~MVPP2_TXP_MTU_MAX;
3979         val |= mtu;
3980         mvpp2_write(port->priv, MVPP2_TXP_SCHED_MTU_REG, val);
3981
3982         /* TXP token size and all TXQs token size must be larger that MTU */
3983         val = mvpp2_read(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG);
3984         size = val & MVPP2_TXP_TOKEN_SIZE_MAX;
3985         if (size < mtu) {
3986                 size = mtu;
3987                 val &= ~MVPP2_TXP_TOKEN_SIZE_MAX;
3988                 val |= size;
3989                 mvpp2_write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val);
3990         }
3991
3992         for (txq = 0; txq < txq_number; txq++) {
3993                 val = mvpp2_read(port->priv,
3994                                  MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq));
3995                 size = val & MVPP2_TXQ_TOKEN_SIZE_MAX;
3996
3997                 if (size < mtu) {
3998                         size = mtu;
3999                         val &= ~MVPP2_TXQ_TOKEN_SIZE_MAX;
4000                         val |= size;
4001                         mvpp2_write(port->priv,
4002                                     MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq),
4003                                     val);
4004                 }
4005         }
4006 }
4007
4008 /* Free Tx queue skbuffs */
4009 static void mvpp2_txq_bufs_free(struct mvpp2_port *port,
4010                                 struct mvpp2_tx_queue *txq,
4011                                 struct mvpp2_txq_pcpu *txq_pcpu, int num)
4012 {
4013         int i;
4014
4015         for (i = 0; i < num; i++)
4016                 mvpp2_txq_inc_get(txq_pcpu);
4017 }
4018
4019 static inline struct mvpp2_rx_queue *mvpp2_get_rx_queue(struct mvpp2_port *port,
4020                                                         u32 cause)
4021 {
4022         int queue = fls(cause) - 1;
4023
4024         return port->rxqs[queue];
4025 }
4026
4027 static inline struct mvpp2_tx_queue *mvpp2_get_tx_queue(struct mvpp2_port *port,
4028                                                         u32 cause)
4029 {
4030         int queue = fls(cause) - 1;
4031
4032         return port->txqs[queue];
4033 }
4034
4035 /* Rx/Tx queue initialization/cleanup methods */
4036
4037 /* Allocate and initialize descriptors for aggr TXQ */
4038 static int mvpp2_aggr_txq_init(struct udevice *dev,
4039                                struct mvpp2_tx_queue *aggr_txq,
4040                                int desc_num, int cpu,
4041                                struct mvpp2 *priv)
4042 {
4043         u32 txq_dma;
4044
4045         /* Allocate memory for TX descriptors */
4046         aggr_txq->descs = buffer_loc.aggr_tx_descs;
4047         aggr_txq->descs_dma = (dma_addr_t)buffer_loc.aggr_tx_descs;
4048         if (!aggr_txq->descs)
4049                 return -ENOMEM;
4050
4051         /* Make sure descriptor address is cache line size aligned  */
4052         BUG_ON(aggr_txq->descs !=
4053                PTR_ALIGN(aggr_txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
4054
4055         aggr_txq->last_desc = aggr_txq->size - 1;
4056
4057         /* Aggr TXQ no reset WA */
4058         aggr_txq->next_desc_to_proc = mvpp2_read(priv,
4059                                                  MVPP2_AGGR_TXQ_INDEX_REG(cpu));
4060
4061         /* Set Tx descriptors queue starting address indirect
4062          * access
4063          */
4064         if (priv->hw_version == MVPP21)
4065                 txq_dma = aggr_txq->descs_dma;
4066         else
4067                 txq_dma = aggr_txq->descs_dma >>
4068                         MVPP22_AGGR_TXQ_DESC_ADDR_OFFS;
4069
4070         mvpp2_write(priv, MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu), txq_dma);
4071         mvpp2_write(priv, MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu), desc_num);
4072
4073         return 0;
4074 }
4075
4076 /* Create a specified Rx queue */
4077 static int mvpp2_rxq_init(struct mvpp2_port *port,
4078                           struct mvpp2_rx_queue *rxq)
4079
4080 {
4081         u32 rxq_dma;
4082
4083         rxq->size = port->rx_ring_size;
4084
4085         /* Allocate memory for RX descriptors */
4086         rxq->descs = buffer_loc.rx_descs;
4087         rxq->descs_dma = (dma_addr_t)buffer_loc.rx_descs;
4088         if (!rxq->descs)
4089                 return -ENOMEM;
4090
4091         BUG_ON(rxq->descs !=
4092                PTR_ALIGN(rxq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
4093
4094         rxq->last_desc = rxq->size - 1;
4095
4096         /* Zero occupied and non-occupied counters - direct access */
4097         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
4098
4099         /* Set Rx descriptors queue starting address - indirect access */
4100         mvpp2_write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id);
4101         if (port->priv->hw_version == MVPP21)
4102                 rxq_dma = rxq->descs_dma;
4103         else
4104                 rxq_dma = rxq->descs_dma >> MVPP22_DESC_ADDR_OFFS;
4105         mvpp2_write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, rxq_dma);
4106         mvpp2_write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, rxq->size);
4107         mvpp2_write(port->priv, MVPP2_RXQ_INDEX_REG, 0);
4108
4109         /* Set Offset */
4110         mvpp2_rxq_offset_set(port, rxq->id, NET_SKB_PAD);
4111
4112         /* Add number of descriptors ready for receiving packets */
4113         mvpp2_rxq_status_update(port, rxq->id, 0, rxq->size);
4114
4115         return 0;
4116 }
4117
4118 /* Push packets received by the RXQ to BM pool */
4119 static void mvpp2_rxq_drop_pkts(struct mvpp2_port *port,
4120                                 struct mvpp2_rx_queue *rxq)
4121 {
4122         int rx_received, i;
4123
4124         rx_received = mvpp2_rxq_received(port, rxq->id);
4125         if (!rx_received)
4126                 return;
4127
4128         for (i = 0; i < rx_received; i++) {
4129                 struct mvpp2_rx_desc *rx_desc = mvpp2_rxq_next_desc_get(rxq);
4130                 u32 bm = mvpp2_bm_cookie_build(port, rx_desc);
4131
4132                 mvpp2_pool_refill(port, bm,
4133                                   mvpp2_rxdesc_dma_addr_get(port, rx_desc),
4134                                   mvpp2_rxdesc_cookie_get(port, rx_desc));
4135         }
4136         mvpp2_rxq_status_update(port, rxq->id, rx_received, rx_received);
4137 }
4138
4139 /* Cleanup Rx queue */
4140 static void mvpp2_rxq_deinit(struct mvpp2_port *port,
4141                              struct mvpp2_rx_queue *rxq)
4142 {
4143         mvpp2_rxq_drop_pkts(port, rxq);
4144
4145         rxq->descs             = NULL;
4146         rxq->last_desc         = 0;
4147         rxq->next_desc_to_proc = 0;
4148         rxq->descs_dma         = 0;
4149
4150         /* Clear Rx descriptors queue starting address and size;
4151          * free descriptor number
4152          */
4153         mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
4154         mvpp2_write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id);
4155         mvpp2_write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, 0);
4156         mvpp2_write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, 0);
4157 }
4158
4159 /* Create and initialize a Tx queue */
4160 static int mvpp2_txq_init(struct mvpp2_port *port,
4161                           struct mvpp2_tx_queue *txq)
4162 {
4163         u32 val;
4164         int cpu, desc, desc_per_txq, tx_port_num;
4165         struct mvpp2_txq_pcpu *txq_pcpu;
4166
4167         txq->size = port->tx_ring_size;
4168
4169         /* Allocate memory for Tx descriptors */
4170         txq->descs = buffer_loc.tx_descs;
4171         txq->descs_dma = (dma_addr_t)buffer_loc.tx_descs;
4172         if (!txq->descs)
4173                 return -ENOMEM;
4174
4175         /* Make sure descriptor address is cache line size aligned  */
4176         BUG_ON(txq->descs !=
4177                PTR_ALIGN(txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
4178
4179         txq->last_desc = txq->size - 1;
4180
4181         /* Set Tx descriptors queue starting address - indirect access */
4182         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
4183         mvpp2_write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, txq->descs_dma);
4184         mvpp2_write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, txq->size &
4185                                              MVPP2_TXQ_DESC_SIZE_MASK);
4186         mvpp2_write(port->priv, MVPP2_TXQ_INDEX_REG, 0);
4187         mvpp2_write(port->priv, MVPP2_TXQ_RSVD_CLR_REG,
4188                     txq->id << MVPP2_TXQ_RSVD_CLR_OFFSET);
4189         val = mvpp2_read(port->priv, MVPP2_TXQ_PENDING_REG);
4190         val &= ~MVPP2_TXQ_PENDING_MASK;
4191         mvpp2_write(port->priv, MVPP2_TXQ_PENDING_REG, val);
4192
4193         /* Calculate base address in prefetch buffer. We reserve 16 descriptors
4194          * for each existing TXQ.
4195          * TCONTS for PON port must be continuous from 0 to MVPP2_MAX_TCONT
4196          * GBE ports assumed to be continious from 0 to MVPP2_MAX_PORTS
4197          */
4198         desc_per_txq = 16;
4199         desc = (port->id * MVPP2_MAX_TXQ * desc_per_txq) +
4200                (txq->log_id * desc_per_txq);
4201
4202         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG,
4203                     MVPP2_PREF_BUF_PTR(desc) | MVPP2_PREF_BUF_SIZE_16 |
4204                     MVPP2_PREF_BUF_THRESH(desc_per_txq / 2));
4205
4206         /* WRR / EJP configuration - indirect access */
4207         tx_port_num = mvpp2_egress_port(port);
4208         mvpp2_write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, tx_port_num);
4209
4210         val = mvpp2_read(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->log_id));
4211         val &= ~MVPP2_TXQ_REFILL_PERIOD_ALL_MASK;
4212         val |= MVPP2_TXQ_REFILL_PERIOD_MASK(1);
4213         val |= MVPP2_TXQ_REFILL_TOKENS_ALL_MASK;
4214         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->log_id), val);
4215
4216         val = MVPP2_TXQ_TOKEN_SIZE_MAX;
4217         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq->log_id),
4218                     val);
4219
4220         for_each_present_cpu(cpu) {
4221                 txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
4222                 txq_pcpu->size = txq->size;
4223         }
4224
4225         return 0;
4226 }
4227
4228 /* Free allocated TXQ resources */
4229 static void mvpp2_txq_deinit(struct mvpp2_port *port,
4230                              struct mvpp2_tx_queue *txq)
4231 {
4232         txq->descs             = NULL;
4233         txq->last_desc         = 0;
4234         txq->next_desc_to_proc = 0;
4235         txq->descs_dma         = 0;
4236
4237         /* Set minimum bandwidth for disabled TXQs */
4238         mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0);
4239
4240         /* Set Tx descriptors queue starting address and size */
4241         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
4242         mvpp2_write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, 0);
4243         mvpp2_write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, 0);
4244 }
4245
4246 /* Cleanup Tx ports */
4247 static void mvpp2_txq_clean(struct mvpp2_port *port, struct mvpp2_tx_queue *txq)
4248 {
4249         struct mvpp2_txq_pcpu *txq_pcpu;
4250         int delay, pending, cpu;
4251         u32 val;
4252
4253         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
4254         val = mvpp2_read(port->priv, MVPP2_TXQ_PREF_BUF_REG);
4255         val |= MVPP2_TXQ_DRAIN_EN_MASK;
4256         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
4257
4258         /* The napi queue has been stopped so wait for all packets
4259          * to be transmitted.
4260          */
4261         delay = 0;
4262         do {
4263                 if (delay >= MVPP2_TX_PENDING_TIMEOUT_MSEC) {
4264                         dev_warn(port->phy_dev->dev,
4265                                  "port %d: cleaning queue %d timed out\n",
4266                                  port->id, txq->log_id);
4267                         break;
4268                 }
4269                 mdelay(1);
4270                 delay++;
4271
4272                 pending = mvpp2_txq_pend_desc_num_get(port, txq);
4273         } while (pending);
4274
4275         val &= ~MVPP2_TXQ_DRAIN_EN_MASK;
4276         mvpp2_write(port->priv, MVPP2_TXQ_PREF_BUF_REG, val);
4277
4278         for_each_present_cpu(cpu) {
4279                 txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
4280
4281                 /* Release all packets */
4282                 mvpp2_txq_bufs_free(port, txq, txq_pcpu, txq_pcpu->count);
4283
4284                 /* Reset queue */
4285                 txq_pcpu->count = 0;
4286                 txq_pcpu->txq_put_index = 0;
4287                 txq_pcpu->txq_get_index = 0;
4288         }
4289 }
4290
4291 /* Cleanup all Tx queues */
4292 static void mvpp2_cleanup_txqs(struct mvpp2_port *port)
4293 {
4294         struct mvpp2_tx_queue *txq;
4295         int queue;
4296         u32 val;
4297
4298         val = mvpp2_read(port->priv, MVPP2_TX_PORT_FLUSH_REG);
4299
4300         /* Reset Tx ports and delete Tx queues */
4301         val |= MVPP2_TX_PORT_FLUSH_MASK(port->id);
4302         mvpp2_write(port->priv, MVPP2_TX_PORT_FLUSH_REG, val);
4303
4304         for (queue = 0; queue < txq_number; queue++) {
4305                 txq = port->txqs[queue];
4306                 mvpp2_txq_clean(port, txq);
4307                 mvpp2_txq_deinit(port, txq);
4308         }
4309
4310         mvpp2_txq_sent_counter_clear(port);
4311
4312         val &= ~MVPP2_TX_PORT_FLUSH_MASK(port->id);
4313         mvpp2_write(port->priv, MVPP2_TX_PORT_FLUSH_REG, val);
4314 }
4315
4316 /* Cleanup all Rx queues */
4317 static void mvpp2_cleanup_rxqs(struct mvpp2_port *port)
4318 {
4319         int queue;
4320
4321         for (queue = 0; queue < rxq_number; queue++)
4322                 mvpp2_rxq_deinit(port, port->rxqs[queue]);
4323 }
4324
4325 /* Init all Rx queues for port */
4326 static int mvpp2_setup_rxqs(struct mvpp2_port *port)
4327 {
4328         int queue, err;
4329
4330         for (queue = 0; queue < rxq_number; queue++) {
4331                 err = mvpp2_rxq_init(port, port->rxqs[queue]);
4332                 if (err)
4333                         goto err_cleanup;
4334         }
4335         return 0;
4336
4337 err_cleanup:
4338         mvpp2_cleanup_rxqs(port);
4339         return err;
4340 }
4341
4342 /* Init all tx queues for port */
4343 static int mvpp2_setup_txqs(struct mvpp2_port *port)
4344 {
4345         struct mvpp2_tx_queue *txq;
4346         int queue, err;
4347
4348         for (queue = 0; queue < txq_number; queue++) {
4349                 txq = port->txqs[queue];
4350                 err = mvpp2_txq_init(port, txq);
4351                 if (err)
4352                         goto err_cleanup;
4353         }
4354
4355         mvpp2_txq_sent_counter_clear(port);
4356         return 0;
4357
4358 err_cleanup:
4359         mvpp2_cleanup_txqs(port);
4360         return err;
4361 }
4362
4363 /* Adjust link */
4364 static void mvpp2_link_event(struct mvpp2_port *port)
4365 {
4366         struct phy_device *phydev = port->phy_dev;
4367         int status_change = 0;
4368         u32 val;
4369
4370         if (phydev->link) {
4371                 if ((port->speed != phydev->speed) ||
4372                     (port->duplex != phydev->duplex)) {
4373                         u32 val;
4374
4375                         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
4376                         val &= ~(MVPP2_GMAC_CONFIG_MII_SPEED |
4377                                  MVPP2_GMAC_CONFIG_GMII_SPEED |
4378                                  MVPP2_GMAC_CONFIG_FULL_DUPLEX |
4379                                  MVPP2_GMAC_AN_SPEED_EN |
4380                                  MVPP2_GMAC_AN_DUPLEX_EN);
4381
4382                         if (phydev->duplex)
4383                                 val |= MVPP2_GMAC_CONFIG_FULL_DUPLEX;
4384
4385                         if (phydev->speed == SPEED_1000)
4386                                 val |= MVPP2_GMAC_CONFIG_GMII_SPEED;
4387                         else if (phydev->speed == SPEED_100)
4388                                 val |= MVPP2_GMAC_CONFIG_MII_SPEED;
4389
4390                         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
4391
4392                         port->duplex = phydev->duplex;
4393                         port->speed  = phydev->speed;
4394                 }
4395         }
4396
4397         if (phydev->link != port->link) {
4398                 if (!phydev->link) {
4399                         port->duplex = -1;
4400                         port->speed = 0;
4401                 }
4402
4403                 port->link = phydev->link;
4404                 status_change = 1;
4405         }
4406
4407         if (status_change) {
4408                 if (phydev->link) {
4409                         val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
4410                         val |= (MVPP2_GMAC_FORCE_LINK_PASS |
4411                                 MVPP2_GMAC_FORCE_LINK_DOWN);
4412                         writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
4413                         mvpp2_egress_enable(port);
4414                         mvpp2_ingress_enable(port);
4415                 } else {
4416                         mvpp2_ingress_disable(port);
4417                         mvpp2_egress_disable(port);
4418                 }
4419         }
4420 }
4421
4422 /* Main RX/TX processing routines */
4423
4424 /* Display more error info */
4425 static void mvpp2_rx_error(struct mvpp2_port *port,
4426                            struct mvpp2_rx_desc *rx_desc)
4427 {
4428         u32 status = mvpp2_rxdesc_status_get(port, rx_desc);
4429         size_t sz = mvpp2_rxdesc_size_get(port, rx_desc);
4430
4431         switch (status & MVPP2_RXD_ERR_CODE_MASK) {
4432         case MVPP2_RXD_ERR_CRC:
4433                 dev_err(port->phy_dev->dev,
4434                         "bad rx status %08x (crc error), size=%zu\n", status,
4435                         sz);
4436                 break;
4437         case MVPP2_RXD_ERR_OVERRUN:
4438                 dev_err(port->phy_dev->dev,
4439                         "bad rx status %08x (overrun error), size=%zu\n",
4440                         status, sz);
4441                 break;
4442         case MVPP2_RXD_ERR_RESOURCE:
4443                 dev_err(port->phy_dev->dev,
4444                         "bad rx status %08x (resource error), size=%zu\n",
4445                         status, sz);
4446                 break;
4447         }
4448 }
4449
4450 /* Reuse skb if possible, or allocate a new skb and add it to BM pool */
4451 static int mvpp2_rx_refill(struct mvpp2_port *port,
4452                            struct mvpp2_bm_pool *bm_pool,
4453                            u32 bm, dma_addr_t dma_addr)
4454 {
4455         mvpp2_pool_refill(port, bm, dma_addr, (unsigned long)dma_addr);
4456         return 0;
4457 }
4458
4459 /* Set hw internals when starting port */
4460 static void mvpp2_start_dev(struct mvpp2_port *port)
4461 {
4462         switch (port->phy_interface) {
4463         case PHY_INTERFACE_MODE_RGMII:
4464         case PHY_INTERFACE_MODE_RGMII_ID:
4465         case PHY_INTERFACE_MODE_SGMII:
4466                 mvpp2_gmac_max_rx_size_set(port);
4467         default:
4468                 break;
4469         }
4470
4471         mvpp2_txp_max_tx_size_set(port);
4472
4473         if (port->priv->hw_version == MVPP21)
4474                 mvpp2_port_enable(port);
4475         else
4476                 gop_port_enable(port, 1);
4477 }
4478
4479 /* Set hw internals when stopping port */
4480 static void mvpp2_stop_dev(struct mvpp2_port *port)
4481 {
4482         /* Stop new packets from arriving to RXQs */
4483         mvpp2_ingress_disable(port);
4484
4485         mvpp2_egress_disable(port);
4486
4487         if (port->priv->hw_version == MVPP21)
4488                 mvpp2_port_disable(port);
4489         else
4490                 gop_port_enable(port, 0);
4491 }
4492
4493 static void mvpp2_phy_connect(struct udevice *dev, struct mvpp2_port *port)
4494 {
4495         struct phy_device *phy_dev;
4496
4497         if (!port->init || port->link == 0) {
4498                 phy_dev = dm_mdio_phy_connect(port->mdio_dev, port->phyaddr,
4499                                               dev, port->phy_interface);
4500
4501                 /*
4502                  * If the phy doesn't match with any existing u-boot drivers the
4503                  * phy framework will connect it to generic one which
4504                  * uid == 0xffffffff. In this case act as if the phy wouldn't be
4505                  * declared in dts. Otherwise in case of 3310 (for which the
4506                  * driver doesn't exist) the link will not be correctly
4507                  * detected. Removing phy entry from dts in case of 3310 is not
4508                  * an option because it is required for the phy_fw_down
4509                  * procedure.
4510                  */
4511                 if (phy_dev &&
4512                     phy_dev->drv->uid == 0xffffffff) {/* Generic phy */
4513                         dev_warn(port->phy_dev->dev,
4514                                  "Marking phy as invalid, link will not be checked\n");
4515                         /* set phy_addr to invalid value */
4516                         port->phyaddr = PHY_MAX_ADDR;
4517                         mvpp2_egress_enable(port);
4518                         mvpp2_ingress_enable(port);
4519
4520                         return;
4521                 }
4522
4523                 port->phy_dev = phy_dev;
4524                 if (!phy_dev) {
4525                         dev_err(port->phy_dev->dev, "cannot connect to phy\n");
4526                         return;
4527                 }
4528                 phy_dev->supported &= PHY_GBIT_FEATURES;
4529                 phy_dev->advertising = phy_dev->supported;
4530
4531                 port->phy_dev = phy_dev;
4532                 port->link    = 0;
4533                 port->duplex  = 0;
4534                 port->speed   = 0;
4535
4536                 phy_config(phy_dev);
4537                 phy_startup(phy_dev);
4538                 if (!phy_dev->link)
4539                         printf("%s: No link\n", phy_dev->dev->name);
4540                 else
4541                         port->init = 1;
4542         } else {
4543                 mvpp2_egress_enable(port);
4544                 mvpp2_ingress_enable(port);
4545         }
4546 }
4547
4548 static int mvpp2_open(struct udevice *dev, struct mvpp2_port *port)
4549 {
4550         unsigned char mac_bcast[ETH_ALEN] = {
4551                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
4552         int err;
4553
4554         err = mvpp2_prs_mac_da_accept(port->priv, port->id, mac_bcast, true);
4555         if (err) {
4556                 dev_err(dev, "mvpp2_prs_mac_da_accept BC failed\n");
4557                 return err;
4558         }
4559         err = mvpp2_prs_mac_da_accept(port->priv, port->id,
4560                                       port->dev_addr, true);
4561         if (err) {
4562                 dev_err(dev, "mvpp2_prs_mac_da_accept MC failed\n");
4563                 return err;
4564         }
4565         err = mvpp2_prs_def_flow(port);
4566         if (err) {
4567                 dev_err(dev, "mvpp2_prs_def_flow failed\n");
4568                 return err;
4569         }
4570
4571         /* Allocate the Rx/Tx queues */
4572         err = mvpp2_setup_rxqs(port);
4573         if (err) {
4574                 dev_err(port->phy_dev->dev, "cannot allocate Rx queues\n");
4575                 return err;
4576         }
4577
4578         err = mvpp2_setup_txqs(port);
4579         if (err) {
4580                 dev_err(port->phy_dev->dev, "cannot allocate Tx queues\n");
4581                 return err;
4582         }
4583
4584         if (port->phyaddr < PHY_MAX_ADDR) {
4585                 mvpp2_phy_connect(dev, port);
4586                 mvpp2_link_event(port);
4587         } else {
4588                 mvpp2_egress_enable(port);
4589                 mvpp2_ingress_enable(port);
4590         }
4591
4592         mvpp2_start_dev(port);
4593
4594         return 0;
4595 }
4596
4597 /* No Device ops here in U-Boot */
4598
4599 /* Driver initialization */
4600
4601 static void mvpp2_port_power_up(struct mvpp2_port *port)
4602 {
4603         struct mvpp2 *priv = port->priv;
4604
4605         /* On PPv2.2 the GoP / interface configuration has already been done */
4606         if (priv->hw_version == MVPP21)
4607                 mvpp2_port_mii_set(port);
4608         mvpp2_port_periodic_xon_disable(port);
4609         if (priv->hw_version == MVPP21)
4610                 mvpp2_port_fc_adv_enable(port);
4611         mvpp2_port_reset(port);
4612 }
4613
4614 /* Initialize port HW */
4615 static int mvpp2_port_init(struct udevice *dev, struct mvpp2_port *port)
4616 {
4617         struct mvpp2 *priv = port->priv;
4618         struct mvpp2_txq_pcpu *txq_pcpu;
4619         int queue, cpu, err;
4620
4621         if (port->first_rxq + rxq_number >
4622             MVPP2_MAX_PORTS * priv->max_port_rxqs)
4623                 return -EINVAL;
4624
4625         /* Disable port */
4626         mvpp2_egress_disable(port);
4627         if (priv->hw_version == MVPP21)
4628                 mvpp2_port_disable(port);
4629         else
4630                 gop_port_enable(port, 0);
4631
4632         port->txqs = devm_kcalloc(dev, txq_number, sizeof(*port->txqs),
4633                                   GFP_KERNEL);
4634         if (!port->txqs)
4635                 return -ENOMEM;
4636
4637         /* Associate physical Tx queues to this port and initialize.
4638          * The mapping is predefined.
4639          */
4640         for (queue = 0; queue < txq_number; queue++) {
4641                 int queue_phy_id = mvpp2_txq_phys(port->id, queue);
4642                 struct mvpp2_tx_queue *txq;
4643
4644                 txq = devm_kzalloc(dev, sizeof(*txq), GFP_KERNEL);
4645                 if (!txq)
4646                         return -ENOMEM;
4647
4648                 txq->pcpu = devm_kzalloc(dev, sizeof(struct mvpp2_txq_pcpu),
4649                                          GFP_KERNEL);
4650                 if (!txq->pcpu)
4651                         return -ENOMEM;
4652
4653                 txq->id = queue_phy_id;
4654                 txq->log_id = queue;
4655                 txq->done_pkts_coal = MVPP2_TXDONE_COAL_PKTS_THRESH;
4656                 for_each_present_cpu(cpu) {
4657                         txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
4658                         txq_pcpu->cpu = cpu;
4659                 }
4660
4661                 port->txqs[queue] = txq;
4662         }
4663
4664         port->rxqs = devm_kcalloc(dev, rxq_number, sizeof(*port->rxqs),
4665                                   GFP_KERNEL);
4666         if (!port->rxqs)
4667                 return -ENOMEM;
4668
4669         /* Allocate and initialize Rx queue for this port */
4670         for (queue = 0; queue < rxq_number; queue++) {
4671                 struct mvpp2_rx_queue *rxq;
4672
4673                 /* Map physical Rx queue to port's logical Rx queue */
4674                 rxq = devm_kzalloc(dev, sizeof(*rxq), GFP_KERNEL);
4675                 if (!rxq)
4676                         return -ENOMEM;
4677                 /* Map this Rx queue to a physical queue */
4678                 rxq->id = port->first_rxq + queue;
4679                 rxq->port = port->id;
4680                 rxq->logic_rxq = queue;
4681
4682                 port->rxqs[queue] = rxq;
4683         }
4684
4685
4686         /* Create Rx descriptor rings */
4687         for (queue = 0; queue < rxq_number; queue++) {
4688                 struct mvpp2_rx_queue *rxq = port->rxqs[queue];
4689
4690                 rxq->size = port->rx_ring_size;
4691                 rxq->pkts_coal = MVPP2_RX_COAL_PKTS;
4692                 rxq->time_coal = MVPP2_RX_COAL_USEC;
4693         }
4694
4695         mvpp2_ingress_disable(port);
4696
4697         /* Port default configuration */
4698         mvpp2_defaults_set(port);
4699
4700         /* Port's classifier configuration */
4701         mvpp2_cls_oversize_rxq_set(port);
4702         mvpp2_cls_port_config(port);
4703
4704         /* Provide an initial Rx packet size */
4705         port->pkt_size = MVPP2_RX_PKT_SIZE(PKTSIZE_ALIGN);
4706
4707         /* Initialize pools for swf */
4708         err = mvpp2_swf_bm_pool_init(port);
4709         if (err)
4710                 return err;
4711
4712         return 0;
4713 }
4714
4715 static int phy_info_parse(struct udevice *dev, struct mvpp2_port *port)
4716 {
4717         int port_node = dev_of_offset(dev);
4718         const char *phy_mode_str;
4719         int phy_node;
4720         u32 id;
4721         u32 phyaddr = 0;
4722         int phy_mode = -1;
4723         int ret;
4724
4725         phy_node = fdtdec_lookup_phandle(gd->fdt_blob, port_node, "phy");
4726
4727         if (phy_node > 0) {
4728                 int parent;
4729                 phyaddr = fdtdec_get_int(gd->fdt_blob, phy_node, "reg", 0);
4730                 if (phyaddr < 0) {
4731                         dev_err(dev, "could not find phy address\n");
4732                         return -1;
4733                 }
4734                 parent = fdt_parent_offset(gd->fdt_blob, phy_node);
4735                 ret = uclass_get_device_by_of_offset(UCLASS_MDIO, parent,
4736                                                      &port->mdio_dev);
4737                 if (ret)
4738                         return ret;
4739         } else {
4740                 /* phy_addr is set to invalid value */
4741                 phyaddr = PHY_MAX_ADDR;
4742         }
4743
4744         phy_mode_str = fdt_getprop(gd->fdt_blob, port_node, "phy-mode", NULL);
4745         if (phy_mode_str)
4746                 phy_mode = phy_get_interface_by_name(phy_mode_str);
4747         if (phy_mode == -1) {
4748                 dev_err(dev, "incorrect phy mode\n");
4749                 return -EINVAL;
4750         }
4751
4752         id = fdtdec_get_int(gd->fdt_blob, port_node, "port-id", -1);
4753         if (id == -1) {
4754                 dev_err(dev, "missing port-id value\n");
4755                 return -EINVAL;
4756         }
4757
4758 #if CONFIG_IS_ENABLED(DM_GPIO)
4759         gpio_request_by_name(dev, "phy-reset-gpios", 0,
4760                              &port->phy_reset_gpio, GPIOD_IS_OUT);
4761         gpio_request_by_name(dev, "marvell,sfp-tx-disable-gpio", 0,
4762                              &port->phy_tx_disable_gpio, GPIOD_IS_OUT);
4763 #endif
4764
4765         /*
4766          * ToDo:
4767          * Not sure if this DT property "phy-speed" will get accepted, so
4768          * this might change later
4769          */
4770         /* Get phy-speed for SGMII 2.5Gbps vs 1Gbps setup */
4771         port->phy_speed = fdtdec_get_int(gd->fdt_blob, port_node,
4772                                          "phy-speed", 1000);
4773
4774         port->id = id;
4775         if (port->priv->hw_version == MVPP21)
4776                 port->first_rxq = port->id * rxq_number;
4777         else
4778                 port->first_rxq = port->id * port->priv->max_port_rxqs;
4779         port->phy_interface = phy_mode;
4780         port->phyaddr = phyaddr;
4781
4782         return 0;
4783 }
4784
4785 #if CONFIG_IS_ENABLED(DM_GPIO)
4786 /* Port GPIO initialization */
4787 static void mvpp2_gpio_init(struct mvpp2_port *port)
4788 {
4789         if (dm_gpio_is_valid(&port->phy_reset_gpio)) {
4790                 dm_gpio_set_value(&port->phy_reset_gpio, 1);
4791                 mdelay(10);
4792                 dm_gpio_set_value(&port->phy_reset_gpio, 0);
4793         }
4794
4795         if (dm_gpio_is_valid(&port->phy_tx_disable_gpio))
4796                 dm_gpio_set_value(&port->phy_tx_disable_gpio, 0);
4797 }
4798 #endif
4799
4800 /* Ports initialization */
4801 static int mvpp2_port_probe(struct udevice *dev,
4802                             struct mvpp2_port *port,
4803                             int port_node,
4804                             struct mvpp2 *priv)
4805 {
4806         int err;
4807
4808         port->tx_ring_size = MVPP2_MAX_TXD;
4809         port->rx_ring_size = MVPP2_MAX_RXD;
4810
4811         err = mvpp2_port_init(dev, port);
4812         if (err < 0) {
4813                 dev_err(dev, "failed to init port %d\n", port->id);
4814                 return err;
4815         }
4816         mvpp2_port_power_up(port);
4817
4818 #if CONFIG_IS_ENABLED(DM_GPIO)
4819         mvpp2_gpio_init(port);
4820 #endif
4821
4822         priv->port_list[port->id] = port;
4823         priv->num_ports++;
4824         return 0;
4825 }
4826
4827 /* Initialize decoding windows */
4828 static void mvpp2_conf_mbus_windows(const struct mbus_dram_target_info *dram,
4829                                     struct mvpp2 *priv)
4830 {
4831         u32 win_enable;
4832         int i;
4833
4834         for (i = 0; i < 6; i++) {
4835                 mvpp2_write(priv, MVPP2_WIN_BASE(i), 0);
4836                 mvpp2_write(priv, MVPP2_WIN_SIZE(i), 0);
4837
4838                 if (i < 4)
4839                         mvpp2_write(priv, MVPP2_WIN_REMAP(i), 0);
4840         }
4841
4842         win_enable = 0;
4843
4844         for (i = 0; i < dram->num_cs; i++) {
4845                 const struct mbus_dram_window *cs = dram->cs + i;
4846
4847                 mvpp2_write(priv, MVPP2_WIN_BASE(i),
4848                             (cs->base & 0xffff0000) | (cs->mbus_attr << 8) |
4849                             dram->mbus_dram_target_id);
4850
4851                 mvpp2_write(priv, MVPP2_WIN_SIZE(i),
4852                             (cs->size - 1) & 0xffff0000);
4853
4854                 win_enable |= (1 << i);
4855         }
4856
4857         mvpp2_write(priv, MVPP2_BASE_ADDR_ENABLE, win_enable);
4858 }
4859
4860 /* Initialize Rx FIFO's */
4861 static void mvpp2_rx_fifo_init(struct mvpp2 *priv)
4862 {
4863         int port;
4864
4865         for (port = 0; port < MVPP2_MAX_PORTS; port++) {
4866                 if (priv->hw_version == MVPP22) {
4867                         if (port == 0) {
4868                                 mvpp2_write(priv,
4869                                             MVPP2_RX_DATA_FIFO_SIZE_REG(port),
4870                                             MVPP22_RX_FIFO_10GB_PORT_DATA_SIZE);
4871                                 mvpp2_write(priv,
4872                                             MVPP2_RX_ATTR_FIFO_SIZE_REG(port),
4873                                             MVPP22_RX_FIFO_10GB_PORT_ATTR_SIZE);
4874                         } else if (port == 1) {
4875                                 mvpp2_write(priv,
4876                                             MVPP2_RX_DATA_FIFO_SIZE_REG(port),
4877                                             MVPP22_RX_FIFO_2_5GB_PORT_DATA_SIZE);
4878                                 mvpp2_write(priv,
4879                                             MVPP2_RX_ATTR_FIFO_SIZE_REG(port),
4880                                             MVPP22_RX_FIFO_2_5GB_PORT_ATTR_SIZE);
4881                         } else {
4882                                 mvpp2_write(priv,
4883                                             MVPP2_RX_DATA_FIFO_SIZE_REG(port),
4884                                             MVPP22_RX_FIFO_1GB_PORT_DATA_SIZE);
4885                                 mvpp2_write(priv,
4886                                             MVPP2_RX_ATTR_FIFO_SIZE_REG(port),
4887                                             MVPP22_RX_FIFO_1GB_PORT_ATTR_SIZE);
4888                         }
4889                 } else {
4890                         mvpp2_write(priv, MVPP2_RX_DATA_FIFO_SIZE_REG(port),
4891                                     MVPP21_RX_FIFO_PORT_DATA_SIZE);
4892                         mvpp2_write(priv, MVPP2_RX_ATTR_FIFO_SIZE_REG(port),
4893                                     MVPP21_RX_FIFO_PORT_ATTR_SIZE);
4894                 }
4895         }
4896
4897         mvpp2_write(priv, MVPP2_RX_MIN_PKT_SIZE_REG,
4898                     MVPP2_RX_FIFO_PORT_MIN_PKT);
4899         mvpp2_write(priv, MVPP2_RX_FIFO_INIT_REG, 0x1);
4900 }
4901
4902 /* Initialize Tx FIFO's */
4903 static void mvpp2_tx_fifo_init(struct mvpp2 *priv)
4904 {
4905         int port, val;
4906
4907         for (port = 0; port < MVPP2_MAX_PORTS; port++) {
4908                 /* Port 0 supports 10KB TX FIFO */
4909                 if (port == 0) {
4910                         val = MVPP2_TX_FIFO_DATA_SIZE_10KB &
4911                                 MVPP22_TX_FIFO_SIZE_MASK;
4912                 } else {
4913                         val = MVPP2_TX_FIFO_DATA_SIZE_3KB &
4914                                 MVPP22_TX_FIFO_SIZE_MASK;
4915                 }
4916                 mvpp2_write(priv, MVPP22_TX_FIFO_SIZE_REG(port), val);
4917         }
4918 }
4919
4920 static void mvpp2_axi_init(struct mvpp2 *priv)
4921 {
4922         u32 val, rdval, wrval;
4923
4924         mvpp2_write(priv, MVPP22_BM_ADDR_HIGH_RLS_REG, 0x0);
4925
4926         /* AXI Bridge Configuration */
4927
4928         rdval = MVPP22_AXI_CODE_CACHE_RD_CACHE
4929                 << MVPP22_AXI_ATTR_CACHE_OFFS;
4930         rdval |= MVPP22_AXI_CODE_DOMAIN_OUTER_DOM
4931                 << MVPP22_AXI_ATTR_DOMAIN_OFFS;
4932
4933         wrval = MVPP22_AXI_CODE_CACHE_WR_CACHE
4934                 << MVPP22_AXI_ATTR_CACHE_OFFS;
4935         wrval |= MVPP22_AXI_CODE_DOMAIN_OUTER_DOM
4936                 << MVPP22_AXI_ATTR_DOMAIN_OFFS;
4937
4938         /* BM */
4939         mvpp2_write(priv, MVPP22_AXI_BM_WR_ATTR_REG, wrval);
4940         mvpp2_write(priv, MVPP22_AXI_BM_RD_ATTR_REG, rdval);
4941
4942         /* Descriptors */
4943         mvpp2_write(priv, MVPP22_AXI_AGGRQ_DESCR_RD_ATTR_REG, rdval);
4944         mvpp2_write(priv, MVPP22_AXI_TXQ_DESCR_WR_ATTR_REG, wrval);
4945         mvpp2_write(priv, MVPP22_AXI_TXQ_DESCR_RD_ATTR_REG, rdval);
4946         mvpp2_write(priv, MVPP22_AXI_RXQ_DESCR_WR_ATTR_REG, wrval);
4947
4948         /* Buffer Data */
4949         mvpp2_write(priv, MVPP22_AXI_TX_DATA_RD_ATTR_REG, rdval);
4950         mvpp2_write(priv, MVPP22_AXI_RX_DATA_WR_ATTR_REG, wrval);
4951
4952         val = MVPP22_AXI_CODE_CACHE_NON_CACHE
4953                 << MVPP22_AXI_CODE_CACHE_OFFS;
4954         val |= MVPP22_AXI_CODE_DOMAIN_SYSTEM
4955                 << MVPP22_AXI_CODE_DOMAIN_OFFS;
4956         mvpp2_write(priv, MVPP22_AXI_RD_NORMAL_CODE_REG, val);
4957         mvpp2_write(priv, MVPP22_AXI_WR_NORMAL_CODE_REG, val);
4958
4959         val = MVPP22_AXI_CODE_CACHE_RD_CACHE
4960                 << MVPP22_AXI_CODE_CACHE_OFFS;
4961         val |= MVPP22_AXI_CODE_DOMAIN_OUTER_DOM
4962                 << MVPP22_AXI_CODE_DOMAIN_OFFS;
4963
4964         mvpp2_write(priv, MVPP22_AXI_RD_SNOOP_CODE_REG, val);
4965
4966         val = MVPP22_AXI_CODE_CACHE_WR_CACHE
4967                 << MVPP22_AXI_CODE_CACHE_OFFS;
4968         val |= MVPP22_AXI_CODE_DOMAIN_OUTER_DOM
4969                 << MVPP22_AXI_CODE_DOMAIN_OFFS;
4970
4971         mvpp2_write(priv, MVPP22_AXI_WR_SNOOP_CODE_REG, val);
4972 }
4973
4974 /* Initialize network controller common part HW */
4975 static int mvpp2_init(struct udevice *dev, struct mvpp2 *priv)
4976 {
4977         const struct mbus_dram_target_info *dram_target_info;
4978         int err, i;
4979         u32 val;
4980
4981         /* Checks for hardware constraints (U-Boot uses only one rxq) */
4982         if ((rxq_number > priv->max_port_rxqs) ||
4983             (txq_number > MVPP2_MAX_TXQ)) {
4984                 dev_err(dev, "invalid queue size parameter\n");
4985                 return -EINVAL;
4986         }
4987
4988         if (priv->hw_version == MVPP22)
4989                 mvpp2_axi_init(priv);
4990         else {
4991                 /* MBUS windows configuration */
4992                 dram_target_info = mvebu_mbus_dram_info();
4993                 if (dram_target_info)
4994                         mvpp2_conf_mbus_windows(dram_target_info, priv);
4995         }
4996
4997         if (priv->hw_version == MVPP21) {
4998                 /* Disable HW PHY polling */
4999                 val = readl(priv->lms_base + MVPP2_PHY_AN_CFG0_REG);
5000                 val |= MVPP2_PHY_AN_STOP_SMI0_MASK;
5001                 writel(val, priv->lms_base + MVPP2_PHY_AN_CFG0_REG);
5002         } else {
5003                 /* Enable HW PHY polling */
5004                 val = readl(priv->iface_base + MVPP22_SMI_MISC_CFG_REG);
5005                 val |= MVPP22_SMI_POLLING_EN;
5006                 writel(val, priv->iface_base + MVPP22_SMI_MISC_CFG_REG);
5007         }
5008
5009         /* Allocate and initialize aggregated TXQs */
5010         priv->aggr_txqs = devm_kcalloc(dev, num_present_cpus(),
5011                                        sizeof(struct mvpp2_tx_queue),
5012                                        GFP_KERNEL);
5013         if (!priv->aggr_txqs)
5014                 return -ENOMEM;
5015
5016         for_each_present_cpu(i) {
5017                 priv->aggr_txqs[i].id = i;
5018                 priv->aggr_txqs[i].size = MVPP2_AGGR_TXQ_SIZE;
5019                 err = mvpp2_aggr_txq_init(dev, &priv->aggr_txqs[i],
5020                                           MVPP2_AGGR_TXQ_SIZE, i, priv);
5021                 if (err < 0)
5022                         return err;
5023         }
5024
5025         /* Rx Fifo Init */
5026         mvpp2_rx_fifo_init(priv);
5027
5028         /* Tx Fifo Init */
5029         if (priv->hw_version == MVPP22)
5030                 mvpp2_tx_fifo_init(priv);
5031
5032         if (priv->hw_version == MVPP21)
5033                 writel(MVPP2_EXT_GLOBAL_CTRL_DEFAULT,
5034                        priv->lms_base + MVPP2_MNG_EXTENDED_GLOBAL_CTRL_REG);
5035
5036         /* Allow cache snoop when transmiting packets */
5037         mvpp2_write(priv, MVPP2_TX_SNOOP_REG, 0x1);
5038
5039         /* Buffer Manager initialization */
5040         err = mvpp2_bm_init(dev, priv);
5041         if (err < 0)
5042                 return err;
5043
5044         /* Parser default initialization */
5045         err = mvpp2_prs_default_init(dev, priv);
5046         if (err < 0)
5047                 return err;
5048
5049         /* Classifier default initialization */
5050         mvpp2_cls_init(priv);
5051
5052         return 0;
5053 }
5054
5055 static int mvpp2_recv(struct udevice *dev, int flags, uchar **packetp)
5056 {
5057         struct mvpp2_port *port = dev_get_priv(dev);
5058         struct mvpp2_rx_desc *rx_desc;
5059         struct mvpp2_bm_pool *bm_pool;
5060         dma_addr_t dma_addr;
5061         u32 bm, rx_status;
5062         int pool, rx_bytes, err;
5063         int rx_received;
5064         struct mvpp2_rx_queue *rxq;
5065         u8 *data;
5066
5067         if (port->phyaddr < PHY_MAX_ADDR)
5068                 if (!port->phy_dev->link)
5069                         return 0;
5070
5071         /* Process RX packets */
5072         rxq = port->rxqs[0];
5073
5074         /* Get number of received packets and clamp the to-do */
5075         rx_received = mvpp2_rxq_received(port, rxq->id);
5076
5077         /* Return if no packets are received */
5078         if (!rx_received)
5079                 return 0;
5080
5081         rx_desc = mvpp2_rxq_next_desc_get(rxq);
5082         rx_status = mvpp2_rxdesc_status_get(port, rx_desc);
5083         rx_bytes = mvpp2_rxdesc_size_get(port, rx_desc);
5084         rx_bytes -= MVPP2_MH_SIZE;
5085         dma_addr = mvpp2_rxdesc_dma_addr_get(port, rx_desc);
5086
5087         bm = mvpp2_bm_cookie_build(port, rx_desc);
5088         pool = mvpp2_bm_cookie_pool_get(bm);
5089         bm_pool = &port->priv->bm_pools[pool];
5090
5091         /* In case of an error, release the requested buffer pointer
5092          * to the Buffer Manager. This request process is controlled
5093          * by the hardware, and the information about the buffer is
5094          * comprised by the RX descriptor.
5095          */
5096         if (rx_status & MVPP2_RXD_ERR_SUMMARY) {
5097                 mvpp2_rx_error(port, rx_desc);
5098                 /* Return the buffer to the pool */
5099                 mvpp2_pool_refill(port, bm, dma_addr, dma_addr);
5100                 return 0;
5101         }
5102
5103         err = mvpp2_rx_refill(port, bm_pool, bm, dma_addr);
5104         if (err) {
5105                 dev_err(port->phy_dev->dev, "failed to refill BM pools\n");
5106                 return 0;
5107         }
5108
5109         /* Update Rx queue management counters */
5110         mb();
5111         mvpp2_rxq_status_update(port, rxq->id, 1, 1);
5112
5113         /* give packet to stack - skip on first n bytes */
5114         data = (u8 *)dma_addr + 2 + 32;
5115
5116         if (rx_bytes <= 0)
5117                 return 0;
5118
5119         /*
5120          * No cache invalidation needed here, since the rx_buffer's are
5121          * located in a uncached memory region
5122          */
5123         *packetp = data;
5124
5125         return rx_bytes;
5126 }
5127
5128 static int mvpp2_send(struct udevice *dev, void *packet, int length)
5129 {
5130         struct mvpp2_port *port = dev_get_priv(dev);
5131         struct mvpp2_tx_queue *txq, *aggr_txq;
5132         struct mvpp2_tx_desc *tx_desc;
5133         int tx_done;
5134         int timeout;
5135
5136         if (port->phyaddr < PHY_MAX_ADDR)
5137                 if (!port->phy_dev->link)
5138                         return 0;
5139
5140         txq = port->txqs[0];
5141         aggr_txq = &port->priv->aggr_txqs[smp_processor_id()];
5142
5143         /* Get a descriptor for the first part of the packet */
5144         tx_desc = mvpp2_txq_next_desc_get(aggr_txq);
5145         mvpp2_txdesc_txq_set(port, tx_desc, txq->id);
5146         mvpp2_txdesc_size_set(port, tx_desc, length);
5147         mvpp2_txdesc_offset_set(port, tx_desc,
5148                                 (dma_addr_t)packet & MVPP2_TX_DESC_ALIGN);
5149         mvpp2_txdesc_dma_addr_set(port, tx_desc,
5150                                   (dma_addr_t)packet & ~MVPP2_TX_DESC_ALIGN);
5151         /* First and Last descriptor */
5152         mvpp2_txdesc_cmd_set(port, tx_desc,
5153                              MVPP2_TXD_L4_CSUM_NOT | MVPP2_TXD_IP_CSUM_DISABLE
5154                              | MVPP2_TXD_F_DESC | MVPP2_TXD_L_DESC);
5155
5156         /* Flush tx data */
5157         flush_dcache_range((unsigned long)packet,
5158                            (unsigned long)packet + ALIGN(length, PKTALIGN));
5159
5160         /* Enable transmit */
5161         mb();
5162         mvpp2_aggr_txq_pend_desc_add(port, 1);
5163
5164         mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
5165
5166         timeout = 0;
5167         do {
5168                 if (timeout++ > 10000) {
5169                         printf("timeout: packet not sent from aggregated to phys TXQ\n");
5170                         return 0;
5171                 }
5172                 tx_done = mvpp2_txq_pend_desc_num_get(port, txq);
5173         } while (tx_done);
5174
5175         timeout = 0;
5176         do {
5177                 if (timeout++ > 10000) {
5178                         printf("timeout: packet not sent\n");
5179                         return 0;
5180                 }
5181                 tx_done = mvpp2_txq_sent_desc_proc(port, txq);
5182         } while (!tx_done);
5183
5184         return 0;
5185 }
5186
5187 static int mvpp2_start(struct udevice *dev)
5188 {
5189         struct eth_pdata *pdata = dev_get_platdata(dev);
5190         struct mvpp2_port *port = dev_get_priv(dev);
5191
5192         /* Load current MAC address */
5193         memcpy(port->dev_addr, pdata->enetaddr, ETH_ALEN);
5194
5195         /* Reconfigure parser accept the original MAC address */
5196         mvpp2_prs_update_mac_da(port, port->dev_addr);
5197
5198         switch (port->phy_interface) {
5199         case PHY_INTERFACE_MODE_RGMII:
5200         case PHY_INTERFACE_MODE_RGMII_ID:
5201         case PHY_INTERFACE_MODE_SGMII:
5202                 mvpp2_port_power_up(port);
5203         default:
5204                 break;
5205         }
5206
5207         mvpp2_open(dev, port);
5208
5209         return 0;
5210 }
5211
5212 static void mvpp2_stop(struct udevice *dev)
5213 {
5214         struct mvpp2_port *port = dev_get_priv(dev);
5215
5216         mvpp2_stop_dev(port);
5217         mvpp2_cleanup_rxqs(port);
5218         mvpp2_cleanup_txqs(port);
5219 }
5220
5221 static int mvpp2_write_hwaddr(struct udevice *dev)
5222 {
5223         struct mvpp2_port *port = dev_get_priv(dev);
5224
5225         return mvpp2_prs_update_mac_da(port, port->dev_addr);
5226 }
5227
5228 static int mvpp22_smi_phy_addr_cfg(struct mvpp2_port *port)
5229 {
5230         writel(port->phyaddr, port->priv->iface_base +
5231                MVPP22_SMI_PHY_ADDR_REG(port->gop_id));
5232
5233         return 0;
5234 }
5235
5236 static int mvpp2_base_probe(struct udevice *dev)
5237 {
5238         struct mvpp2 *priv = dev_get_priv(dev);
5239         void *bd_space;
5240         u32 size = 0;
5241         int i;
5242
5243         /* Save hw-version */
5244         priv->hw_version = dev_get_driver_data(dev);
5245
5246         /*
5247          * U-Boot special buffer handling:
5248          *
5249          * Allocate buffer area for descs and rx_buffers. This is only
5250          * done once for all interfaces. As only one interface can
5251          * be active. Make this area DMA-safe by disabling the D-cache
5252          */
5253
5254         if (!buffer_loc_init) {
5255                 /* Align buffer area for descs and rx_buffers to 1MiB */
5256                 bd_space = memalign(1 << MMU_SECTION_SHIFT, BD_SPACE);
5257                 mmu_set_region_dcache_behaviour((unsigned long)bd_space,
5258                                                 BD_SPACE, DCACHE_OFF);
5259
5260                 buffer_loc.aggr_tx_descs = (struct mvpp2_tx_desc *)bd_space;
5261                 size += MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE;
5262
5263                 buffer_loc.tx_descs =
5264                         (struct mvpp2_tx_desc *)((unsigned long)bd_space + size);
5265                 size += MVPP2_MAX_TXD * MVPP2_DESC_ALIGNED_SIZE;
5266
5267                 buffer_loc.rx_descs =
5268                         (struct mvpp2_rx_desc *)((unsigned long)bd_space + size);
5269                 size += MVPP2_MAX_RXD * MVPP2_DESC_ALIGNED_SIZE;
5270
5271                 for (i = 0; i < MVPP2_BM_POOLS_NUM; i++) {
5272                         buffer_loc.bm_pool[i] =
5273                                 (unsigned long *)((unsigned long)bd_space + size);
5274                         if (priv->hw_version == MVPP21)
5275                                 size += MVPP2_BM_POOL_SIZE_MAX * 2 * sizeof(u32);
5276                         else
5277                                 size += MVPP2_BM_POOL_SIZE_MAX * 2 * sizeof(u64);
5278                 }
5279
5280                 for (i = 0; i < MVPP2_BM_LONG_BUF_NUM; i++) {
5281                         buffer_loc.rx_buffer[i] =
5282                                 (unsigned long *)((unsigned long)bd_space + size);
5283                         size += RX_BUFFER_SIZE;
5284                 }
5285
5286                 /* Clear the complete area so that all descriptors are cleared */
5287                 memset(bd_space, 0, size);
5288
5289                 buffer_loc_init = 1;
5290         }
5291
5292         /* Save base addresses for later use */
5293         priv->base = (void *)devfdt_get_addr_index(dev, 0);
5294         if (IS_ERR(priv->base))
5295                 return PTR_ERR(priv->base);
5296
5297         if (priv->hw_version == MVPP21) {
5298                 priv->lms_base = (void *)devfdt_get_addr_index(dev, 1);
5299                 if (IS_ERR(priv->lms_base))
5300                         return PTR_ERR(priv->lms_base);
5301         } else {
5302                 priv->iface_base = (void *)devfdt_get_addr_index(dev, 1);
5303                 if (IS_ERR(priv->iface_base))
5304                         return PTR_ERR(priv->iface_base);
5305
5306                 /* Store common base addresses for all ports */
5307                 priv->mpcs_base = priv->iface_base + MVPP22_MPCS;
5308                 priv->xpcs_base = priv->iface_base + MVPP22_XPCS;
5309                 priv->rfu1_base = priv->iface_base + MVPP22_RFU1;
5310         }
5311
5312         if (priv->hw_version == MVPP21)
5313                 priv->max_port_rxqs = 8;
5314         else
5315                 priv->max_port_rxqs = 32;
5316
5317         return 0;
5318 }
5319
5320 static int mvpp2_probe(struct udevice *dev)
5321 {
5322         struct mvpp2_port *port = dev_get_priv(dev);
5323         struct mvpp2 *priv = dev_get_priv(dev->parent);
5324         int err;
5325
5326         /* Only call the probe function for the parent once */
5327         if (!priv->probe_done)
5328                 err = mvpp2_base_probe(dev->parent);
5329
5330         port->priv = priv;
5331
5332         err = phy_info_parse(dev, port);
5333         if (err)
5334                 return err;
5335
5336         /*
5337          * We need the port specific io base addresses at this stage, since
5338          * gop_port_init() accesses these registers
5339          */
5340         if (priv->hw_version == MVPP21) {
5341                 int priv_common_regs_num = 2;
5342
5343                 port->base = (void __iomem *)devfdt_get_addr_index(
5344                         dev->parent, priv_common_regs_num + port->id);
5345                 if (IS_ERR(port->base))
5346                         return PTR_ERR(port->base);
5347         } else {
5348                 port->gop_id = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
5349                                               "gop-port-id", -1);
5350                 if (port->id == -1) {
5351                         dev_err(dev, "missing gop-port-id value\n");
5352                         return -EINVAL;
5353                 }
5354
5355                 port->base = priv->iface_base + MVPP22_PORT_BASE +
5356                         port->gop_id * MVPP22_PORT_OFFSET;
5357
5358                 /* Set phy address of the port */
5359                 if (port->phyaddr < PHY_MAX_ADDR)
5360                         mvpp22_smi_phy_addr_cfg(port);
5361
5362                 /* GoP Init */
5363                 gop_port_init(port);
5364         }
5365
5366         if (!priv->probe_done) {
5367                 /* Initialize network controller */
5368                 err = mvpp2_init(dev, priv);
5369                 if (err < 0) {
5370                         dev_err(dev, "failed to initialize controller\n");
5371                         return err;
5372                 }
5373                 priv->num_ports = 0;
5374                 priv->probe_done = 1;
5375         }
5376
5377         err = mvpp2_port_probe(dev, port, dev_of_offset(dev), priv);
5378         if (err)
5379                 return err;
5380
5381         if (priv->hw_version == MVPP22) {
5382                 priv->netc_config |= mvpp2_netc_cfg_create(port->gop_id,
5383                                                            port->phy_interface);
5384
5385                 /* Netcomplex configurations for all ports */
5386                 gop_netc_init(priv, MV_NETC_FIRST_PHASE);
5387                 gop_netc_init(priv, MV_NETC_SECOND_PHASE);
5388         }
5389
5390         return 0;
5391 }
5392
5393 /*
5394  * Empty BM pool and stop its activity before the OS is started
5395  */
5396 static int mvpp2_remove(struct udevice *dev)
5397 {
5398         struct mvpp2_port *port = dev_get_priv(dev);
5399         struct mvpp2 *priv = port->priv;
5400         int i;
5401
5402         priv->num_ports--;
5403
5404         if (priv->num_ports)
5405                 return 0;
5406
5407         for (i = 0; i < MVPP2_BM_POOLS_NUM; i++)
5408                 mvpp2_bm_pool_destroy(dev, priv, &priv->bm_pools[i]);
5409
5410         return 0;
5411 }
5412
5413 static const struct eth_ops mvpp2_ops = {
5414         .start          = mvpp2_start,
5415         .send           = mvpp2_send,
5416         .recv           = mvpp2_recv,
5417         .stop           = mvpp2_stop,
5418         .write_hwaddr   = mvpp2_write_hwaddr
5419 };
5420
5421 static struct driver mvpp2_driver = {
5422         .name   = "mvpp2",
5423         .id     = UCLASS_ETH,
5424         .probe  = mvpp2_probe,
5425         .remove = mvpp2_remove,
5426         .ops    = &mvpp2_ops,
5427         .priv_auto_alloc_size = sizeof(struct mvpp2_port),
5428         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
5429         .flags  = DM_FLAG_ACTIVE_DMA,
5430 };
5431
5432 /*
5433  * Use a MISC device to bind the n instances (child nodes) of the
5434  * network base controller in UCLASS_ETH.
5435  */
5436 static int mvpp2_base_bind(struct udevice *parent)
5437 {
5438         const void *blob = gd->fdt_blob;
5439         int node = dev_of_offset(parent);
5440         struct uclass_driver *drv;
5441         struct udevice *dev;
5442         struct eth_pdata *plat;
5443         char *name;
5444         int subnode;
5445         u32 id;
5446         int base_id_add;
5447
5448         /* Lookup eth driver */
5449         drv = lists_uclass_lookup(UCLASS_ETH);
5450         if (!drv) {
5451                 puts("Cannot find eth driver\n");
5452                 return -ENOENT;
5453         }
5454
5455         base_id_add = base_id;
5456
5457         fdt_for_each_subnode(subnode, blob, node) {
5458                 /* Increment base_id for all subnodes, also the disabled ones */
5459                 base_id++;
5460
5461                 /* Skip disabled ports */
5462                 if (!fdtdec_get_is_enabled(blob, subnode))
5463                         continue;
5464
5465                 plat = calloc(1, sizeof(*plat));
5466                 if (!plat)
5467                         return -ENOMEM;
5468
5469                 id = fdtdec_get_int(blob, subnode, "port-id", -1);
5470                 id += base_id_add;
5471
5472                 name = calloc(1, 16);
5473                 if (!name) {
5474                         free(plat);
5475                         return -ENOMEM;
5476                 }
5477                 sprintf(name, "mvpp2-%d", id);
5478
5479                 /* Create child device UCLASS_ETH and bind it */
5480                 device_bind(parent, &mvpp2_driver, name, plat,
5481                             offset_to_ofnode(subnode), &dev);
5482         }
5483
5484         return 0;
5485 }
5486
5487 static const struct udevice_id mvpp2_ids[] = {
5488         {
5489                 .compatible = "marvell,armada-375-pp2",
5490                 .data = MVPP21,
5491         },
5492         {
5493                 .compatible = "marvell,armada-7k-pp22",
5494                 .data = MVPP22,
5495         },
5496         { }
5497 };
5498
5499 U_BOOT_DRIVER(mvpp2_base) = {
5500         .name   = "mvpp2_base",
5501         .id     = UCLASS_MISC,
5502         .of_match = mvpp2_ids,
5503         .bind   = mvpp2_base_bind,
5504         .priv_auto_alloc_size = sizeof(struct mvpp2),
5505 };