drivers/net/mvpp2.c

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