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