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