]> git.proxmox.com Git - mirror_ubuntu-disco-kernel.git/blame - drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
projects / mirror_ubuntu-disco-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branches 'asoc/fix/amd', 'asoc/fix/arizona', 'asoc/fix/dpcm...
[mirror_ubuntu-disco-kernel.git] / drivers / net / ethernet / hisilicon / hns / hns_dsaf_main.c
CommitLineData
511e6bc0 1/*
2 * Copyright (c) 2014-2015 Hisilicon Limited.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/interrupt.h>
14#include <linux/netdevice.h>
15#include <linux/platform_device.h>
16#include <linux/of.h>
17#include <linux/of_address.h>
18#include <linux/of_irq.h>
19#include <linux/device.h>
119c7ad8
AB		 20#include <linux/vmalloc.h>
21
511e6bc0 22#include "hns_dsaf_main.h"
23#include "hns_dsaf_rcb.h"
24#include "hns_dsaf_ppe.h"
25#include "hns_dsaf_mac.h"
26
27const char *g_dsaf_mode_match[DSAF_MODE_MAX] = {
28 [DSAF_MODE_DISABLE_2PORT_64VM] = "2port-64vf",
29 [DSAF_MODE_DISABLE_6PORT_0VM] = "6port-16rss",
30 [DSAF_MODE_DISABLE_6PORT_16VM] = "6port-16vf",
31};
32
33int hns_dsaf_get_cfg(struct dsaf_device *dsaf_dev)
34{
35 int ret, i;
36 u32 desc_num;
37 u32 buf_size;
48189d6a 38 const char *mode_str;
511e6bc0 39 struct device_node *np = dsaf_dev->dev->of_node;
40
13ac695e 41 if (of_device_is_compatible(np, "hisilicon,hns-dsaf-v1"))
511e6bc0 42 dsaf_dev->dsaf_ver = AE_VERSION_1;
13ac695e
S		 43 else
44 dsaf_dev->dsaf_ver = AE_VERSION_2;
511e6bc0 45
511e6bc0 46 ret = of_property_read_string(np, "mode", &mode_str);
47 if (ret) {
48 dev_err(dsaf_dev->dev, "get dsaf mode fail, ret=%d!\n", ret);
49 return ret;
50 }
51 for (i = 0; i < DSAF_MODE_MAX; i++) {
52 if (g_dsaf_mode_match[i] &&
53 !strcmp(mode_str, g_dsaf_mode_match[i]))
54 break;
55 }
56 if (i >= DSAF_MODE_MAX ||
57 i == DSAF_MODE_INVALID || i == DSAF_MODE_ENABLE) {
58 dev_err(dsaf_dev->dev,
59 "%s prs mode str fail!\n", dsaf_dev->ae_dev.name);
60 return -EINVAL;
61 }
62 dsaf_dev->dsaf_mode = (enum dsaf_mode)i;
63
64 if (dsaf_dev->dsaf_mode > DSAF_MODE_ENABLE)
65 dsaf_dev->dsaf_en = HRD_DSAF_NO_DSAF_MODE;
66 else
67 dsaf_dev->dsaf_en = HRD_DSAF_MODE;
68
69 if ((i == DSAF_MODE_ENABLE_16VM) ||
70 (i == DSAF_MODE_DISABLE_2PORT_8VM) ||
71 (i == DSAF_MODE_DISABLE_6PORT_2VM))
72 dsaf_dev->dsaf_tc_mode = HRD_DSAF_8TC_MODE;
73 else
74 dsaf_dev->dsaf_tc_mode = HRD_DSAF_4TC_MODE;
75
76 dsaf_dev->sc_base = of_iomap(np, 0);
77 if (!dsaf_dev->sc_base) {
78 dev_err(dsaf_dev->dev,
79 "%s of_iomap 0 fail!\n", dsaf_dev->ae_dev.name);
80 ret = -ENOMEM;
81 goto unmap_base_addr;
82 }
83
84 dsaf_dev->sds_base = of_iomap(np, 1);
85 if (!dsaf_dev->sds_base) {
86 dev_err(dsaf_dev->dev,
87 "%s of_iomap 1 fail!\n", dsaf_dev->ae_dev.name);
88 ret = -ENOMEM;
89 goto unmap_base_addr;
90 }
91
92 dsaf_dev->ppe_base = of_iomap(np, 2);
93 if (!dsaf_dev->ppe_base) {
94 dev_err(dsaf_dev->dev,
95 "%s of_iomap 2 fail!\n", dsaf_dev->ae_dev.name);
96 ret = -ENOMEM;
97 goto unmap_base_addr;
98 }
99
100 dsaf_dev->io_base = of_iomap(np, 3);
101 if (!dsaf_dev->io_base) {
102 dev_err(dsaf_dev->dev,
103 "%s of_iomap 3 fail!\n", dsaf_dev->ae_dev.name);
104 ret = -ENOMEM;
105 goto unmap_base_addr;
106 }
107
108 dsaf_dev->cpld_base = of_iomap(np, 4);
109 if (!dsaf_dev->cpld_base)
110 dev_dbg(dsaf_dev->dev, "NO CPLD ADDR");
111
112 ret = of_property_read_u32(np, "desc-num", &desc_num);
113 if (ret < 0 || desc_num < HNS_DSAF_MIN_DESC_CNT ||
114 desc_num > HNS_DSAF_MAX_DESC_CNT) {
115 dev_err(dsaf_dev->dev, "get desc-num(%d) fail, ret=%d!\n",
116 desc_num, ret);
117 goto unmap_base_addr;
118 }
119 dsaf_dev->desc_num = desc_num;
120
121 ret = of_property_read_u32(np, "buf-size", &buf_size);
122 if (ret < 0) {
123 dev_err(dsaf_dev->dev,
124 "get buf-size fail, ret=%d!\r\n", ret);
125 goto unmap_base_addr;
126 }
127 dsaf_dev->buf_size = buf_size;
128
129 dsaf_dev->buf_size_type = hns_rcb_buf_size2type(buf_size);
130 if (dsaf_dev->buf_size_type < 0) {
131 dev_err(dsaf_dev->dev,
132 "buf_size(%d) is wrong!\n", buf_size);
133 goto unmap_base_addr;
134 }
135
136 if (!dma_set_mask_and_coherent(dsaf_dev->dev, DMA_BIT_MASK(64ULL)))
137 dev_dbg(dsaf_dev->dev, "set mask to 64bit\n");
138 else
139 dev_err(dsaf_dev->dev, "set mask to 64bit fail!\n");
140
141 return 0;
142
143unmap_base_addr:
144 if (dsaf_dev->io_base)
145 iounmap(dsaf_dev->io_base);
146 if (dsaf_dev->ppe_base)
147 iounmap(dsaf_dev->ppe_base);
148 if (dsaf_dev->sds_base)
149 iounmap(dsaf_dev->sds_base);
150 if (dsaf_dev->sc_base)
151 iounmap(dsaf_dev->sc_base);
152 if (dsaf_dev->cpld_base)
153 iounmap(dsaf_dev->cpld_base);
154 return ret;
155}
156
157static void hns_dsaf_free_cfg(struct dsaf_device *dsaf_dev)
158{
159 if (dsaf_dev->io_base)
160 iounmap(dsaf_dev->io_base);
161
162 if (dsaf_dev->ppe_base)
163 iounmap(dsaf_dev->ppe_base);
164
165 if (dsaf_dev->sds_base)
166 iounmap(dsaf_dev->sds_base);
167
168 if (dsaf_dev->sc_base)
169 iounmap(dsaf_dev->sc_base);
170
171 if (dsaf_dev->cpld_base)
172 iounmap(dsaf_dev->cpld_base);
173}
174
175/**
176 * hns_dsaf_sbm_link_sram_init_en - config dsaf_sbm_init_en
177 * @dsaf_id: dsa fabric id
178 */
179static void hns_dsaf_sbm_link_sram_init_en(struct dsaf_device *dsaf_dev)
180{
181 dsaf_set_dev_bit(dsaf_dev, DSAF_CFG_0_REG, DSAF_CFG_SBM_INIT_S, 1);
182}
183
184/**
185 * hns_dsaf_reg_cnt_clr_ce - config hns_dsaf_reg_cnt_clr_ce
186 * @dsaf_id: dsa fabric id
187 * @hns_dsaf_reg_cnt_clr_ce: config value
188 */
189static void
190hns_dsaf_reg_cnt_clr_ce(struct dsaf_device *dsaf_dev, u32 reg_cnt_clr_ce)
191{
192 dsaf_set_dev_bit(dsaf_dev, DSAF_DSA_REG_CNT_CLR_CE_REG,
193 DSAF_CNT_CLR_CE_S, reg_cnt_clr_ce);
194}
195
196/**
197 * hns_ppe_qid_cfg - config ppe qid
198 * @dsaf_id: dsa fabric id
199 * @pppe_qid_cfg: value array
200 */
201static void
202hns_dsaf_ppe_qid_cfg(struct dsaf_device *dsaf_dev, u32 qid_cfg)
203{
204 u32 i;
205
206 for (i = 0; i < DSAF_COMM_CHN; i++) {
207 dsaf_set_dev_field(dsaf_dev,
208 DSAF_PPE_QID_CFG_0_REG + 0x0004 * i,
209 DSAF_PPE_QID_CFG_M, DSAF_PPE_QID_CFG_S,
210 qid_cfg);
211 }
212}
213
4568637f 214static void hns_dsaf_mix_def_qid_cfg(struct dsaf_device *dsaf_dev)
215{
216 u16 max_q_per_vf, max_vfn;
217 u32 q_id, q_num_per_port;
218 u32 i;
219
220 hns_rcb_get_queue_mode(dsaf_dev->dsaf_mode,
221 HNS_DSAF_COMM_SERVICE_NW_IDX,
222 &max_vfn, &max_q_per_vf);
223 q_num_per_port = max_vfn * max_q_per_vf;
224
225 for (i = 0, q_id = 0; i < DSAF_SERVICE_NW_NUM; i++) {
226 dsaf_set_dev_field(dsaf_dev,
227 DSAF_MIX_DEF_QID_0_REG + 0x0004 * i,
228 0xff, 0, q_id);
229 q_id += q_num_per_port;
230 }
231}
232
511e6bc0 233/**
234 * hns_dsaf_sw_port_type_cfg - cfg sw type
235 * @dsaf_id: dsa fabric id
236 * @psw_port_type: array
237 */
238static void hns_dsaf_sw_port_type_cfg(struct dsaf_device *dsaf_dev,
239 enum dsaf_sw_port_type port_type)
240{
241 u32 i;
242
243 for (i = 0; i < DSAF_SW_PORT_NUM; i++) {
244 dsaf_set_dev_field(dsaf_dev,
245 DSAF_SW_PORT_TYPE_0_REG + 0x0004 * i,
246 DSAF_SW_PORT_TYPE_M, DSAF_SW_PORT_TYPE_S,
247 port_type);
248 }
249}
250
251/**
252 * hns_dsaf_stp_port_type_cfg - cfg stp type
253 * @dsaf_id: dsa fabric id
254 * @pstp_port_type: array
255 */
256static void hns_dsaf_stp_port_type_cfg(struct dsaf_device *dsaf_dev,
257 enum dsaf_stp_port_type port_type)
258{
259 u32 i;
260
261 for (i = 0; i < DSAF_COMM_CHN; i++) {
262 dsaf_set_dev_field(dsaf_dev,
263 DSAF_STP_PORT_TYPE_0_REG + 0x0004 * i,
264 DSAF_STP_PORT_TYPE_M, DSAF_STP_PORT_TYPE_S,
265 port_type);
266 }
267}
268
13ac695e
S		 269#define HNS_DSAF_SBM_NUM(dev) \
270 (AE_IS_VER1((dev)->dsaf_ver) ? DSAF_SBM_NUM : DSAFV2_SBM_NUM)
511e6bc0 271/**
272 * hns_dsaf_sbm_cfg - config sbm
273 * @dsaf_id: dsa fabric id
274 */
275static void hns_dsaf_sbm_cfg(struct dsaf_device *dsaf_dev)
276{
277 u32 o_sbm_cfg;
278 u32 i;
279
13ac695e 280 for (i = 0; i < HNS_DSAF_SBM_NUM(dsaf_dev); i++) {
511e6bc0 281 o_sbm_cfg = dsaf_read_dev(dsaf_dev,
282 DSAF_SBM_CFG_REG_0_REG + 0x80 * i);
283 dsaf_set_bit(o_sbm_cfg, DSAF_SBM_CFG_EN_S, 1);
284 dsaf_set_bit(o_sbm_cfg, DSAF_SBM_CFG_SHCUT_EN_S, 0);
285 dsaf_write_dev(dsaf_dev,
286 DSAF_SBM_CFG_REG_0_REG + 0x80 * i, o_sbm_cfg);
287 }
288}
289
290/**
291 * hns_dsaf_sbm_cfg_mib_en - config sbm
292 * @dsaf_id: dsa fabric id
293 */
294static int hns_dsaf_sbm_cfg_mib_en(struct dsaf_device *dsaf_dev)
295{
296 u32 sbm_cfg_mib_en;
297 u32 i;
298 u32 reg;
299 u32 read_cnt;
300
13ac695e
S		 301 /* validate configure by setting SBM_CFG_MIB_EN bit from 0 to 1. */
302 for (i = 0; i < HNS_DSAF_SBM_NUM(dsaf_dev); i++) {
303 reg = DSAF_SBM_CFG_REG_0_REG + 0x80 * i;
304 dsaf_set_dev_bit(dsaf_dev, reg, DSAF_SBM_CFG_MIB_EN_S, 0);
305 }
306
307 for (i = 0; i < HNS_DSAF_SBM_NUM(dsaf_dev); i++) {
511e6bc0 308 reg = DSAF_SBM_CFG_REG_0_REG + 0x80 * i;
309 dsaf_set_dev_bit(dsaf_dev, reg, DSAF_SBM_CFG_MIB_EN_S, 1);
310 }
311
312 /* waitint for all sbm enable finished */
13ac695e 313 for (i = 0; i < HNS_DSAF_SBM_NUM(dsaf_dev); i++) {
511e6bc0 314 read_cnt = 0;
315 reg = DSAF_SBM_CFG_REG_0_REG + 0x80 * i;
316 do {
317 udelay(1);
318 sbm_cfg_mib_en = dsaf_get_dev_bit(
319 dsaf_dev, reg, DSAF_SBM_CFG_MIB_EN_S);
320 read_cnt++;
321 } while (sbm_cfg_mib_en == 0 &&
322 read_cnt < DSAF_CFG_READ_CNT);
323
324 if (sbm_cfg_mib_en == 0) {
325 dev_err(dsaf_dev->dev,
326 "sbm_cfg_mib_en fail,%s,sbm_num=%d\n",
327 dsaf_dev->ae_dev.name, i);
328 return -ENODEV;
329 }
330 }
331
332 return 0;
333}
334
335/**
336 * hns_dsaf_sbm_bp_wl_cfg - config sbm
337 * @dsaf_id: dsa fabric id
338 */
339static void hns_dsaf_sbm_bp_wl_cfg(struct dsaf_device *dsaf_dev)
340{
13ac695e 341 u32 o_sbm_bp_cfg;
511e6bc0 342 u32 reg;
343 u32 i;
344
345 /* XGE */
346 for (i = 0; i < DSAF_XGE_NUM; i++) {
347 reg = DSAF_SBM_BP_CFG_0_XGE_REG_0_REG + 0x80 * i;
13ac695e
S		 348 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
349 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG0_COM_MAX_BUF_NUM_M,
511e6bc0 350 DSAF_SBM_CFG0_COM_MAX_BUF_NUM_S, 512);
13ac695e 351 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG0_VC0_MAX_BUF_NUM_M,
511e6bc0 352 DSAF_SBM_CFG0_VC0_MAX_BUF_NUM_S, 0);
13ac695e 353 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG0_VC1_MAX_BUF_NUM_M,
511e6bc0 354 DSAF_SBM_CFG0_VC1_MAX_BUF_NUM_S, 0);
13ac695e 355 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 356
357 reg = DSAF_SBM_BP_CFG_1_REG_0_REG + 0x80 * i;
13ac695e
S		 358 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
359 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG1_TC4_MAX_BUF_NUM_M,
511e6bc0 360 DSAF_SBM_CFG1_TC4_MAX_BUF_NUM_S, 0);
13ac695e 361 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG1_TC0_MAX_BUF_NUM_M,
511e6bc0 362 DSAF_SBM_CFG1_TC0_MAX_BUF_NUM_S, 0);
13ac695e 363 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 364
365 reg = DSAF_SBM_BP_CFG_2_XGE_REG_0_REG + 0x80 * i;
13ac695e
S		 366 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
367 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG2_SET_BUF_NUM_M,
511e6bc0 368 DSAF_SBM_CFG2_SET_BUF_NUM_S, 104);
13ac695e 369 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG2_RESET_BUF_NUM_M,
511e6bc0 370 DSAF_SBM_CFG2_RESET_BUF_NUM_S, 128);
13ac695e 371 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 372
373 reg = DSAF_SBM_BP_CFG_3_REG_0_REG + 0x80 * i;
13ac695e
S		 374 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
375 dsaf_set_field(o_sbm_bp_cfg,
511e6bc0 376 DSAF_SBM_CFG3_SET_BUF_NUM_NO_PFC_M,
377 DSAF_SBM_CFG3_SET_BUF_NUM_NO_PFC_S, 110);
13ac695e 378 dsaf_set_field(o_sbm_bp_cfg,
511e6bc0 379 DSAF_SBM_CFG3_RESET_BUF_NUM_NO_PFC_M,
380 DSAF_SBM_CFG3_RESET_BUF_NUM_NO_PFC_S, 160);
13ac695e 381 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 382
383 /* for no enable pfc mode */
384 reg = DSAF_SBM_BP_CFG_4_REG_0_REG + 0x80 * i;
13ac695e
S		 385 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
386 dsaf_set_field(o_sbm_bp_cfg,
511e6bc0 387 DSAF_SBM_CFG3_SET_BUF_NUM_NO_PFC_M,
388 DSAF_SBM_CFG3_SET_BUF_NUM_NO_PFC_S, 128);
13ac695e 389 dsaf_set_field(o_sbm_bp_cfg,
511e6bc0 390 DSAF_SBM_CFG3_RESET_BUF_NUM_NO_PFC_M,
391 DSAF_SBM_CFG3_RESET_BUF_NUM_NO_PFC_S, 192);
13ac695e 392 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 393 }
394
395 /* PPE */
396 for (i = 0; i < DSAF_COMM_CHN; i++) {
397 reg = DSAF_SBM_BP_CFG_2_PPE_REG_0_REG + 0x80 * i;
13ac695e
S		 398 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
399 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG2_SET_BUF_NUM_M,
511e6bc0 400 DSAF_SBM_CFG2_SET_BUF_NUM_S, 10);
13ac695e 401 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG2_RESET_BUF_NUM_M,
511e6bc0 402 DSAF_SBM_CFG2_RESET_BUF_NUM_S, 12);
13ac695e 403 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 404 }
405
406 /* RoCEE */
407 for (i = 0; i < DSAF_COMM_CHN; i++) {
408 reg = DSAF_SBM_BP_CFG_2_ROCEE_REG_0_REG + 0x80 * i;
13ac695e
S		 409 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
410 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG2_SET_BUF_NUM_M,
511e6bc0 411 DSAF_SBM_CFG2_SET_BUF_NUM_S, 2);
13ac695e 412 dsaf_set_field(o_sbm_bp_cfg, DSAF_SBM_CFG2_RESET_BUF_NUM_M,
511e6bc0 413 DSAF_SBM_CFG2_RESET_BUF_NUM_S, 4);
13ac695e
S		 414 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
415 }
416}
417
418static void hns_dsafv2_sbm_bp_wl_cfg(struct dsaf_device *dsaf_dev)
419{
420 u32 o_sbm_bp_cfg;
421 u32 reg;
422 u32 i;
423
424 /* XGE */
425 for (i = 0; i < DSAFV2_SBM_XGE_CHN; i++) {
426 reg = DSAF_SBM_BP_CFG_0_XGE_REG_0_REG + 0x80 * i;
427 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
428 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG0_COM_MAX_BUF_NUM_M,
429 DSAFV2_SBM_CFG0_COM_MAX_BUF_NUM_S, 256);
430 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG0_VC0_MAX_BUF_NUM_M,
431 DSAFV2_SBM_CFG0_VC0_MAX_BUF_NUM_S, 0);
432 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG0_VC1_MAX_BUF_NUM_M,
433 DSAFV2_SBM_CFG0_VC1_MAX_BUF_NUM_S, 0);
434 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
435
436 reg = DSAF_SBM_BP_CFG_1_REG_0_REG + 0x80 * i;
437 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
438 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG1_TC4_MAX_BUF_NUM_M,
439 DSAFV2_SBM_CFG1_TC4_MAX_BUF_NUM_S, 0);
440 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG1_TC0_MAX_BUF_NUM_M,
441 DSAFV2_SBM_CFG1_TC0_MAX_BUF_NUM_S, 0);
442 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
443
444 reg = DSAF_SBM_BP_CFG_2_XGE_REG_0_REG + 0x80 * i;
445 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
446 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG2_SET_BUF_NUM_M,
447 DSAFV2_SBM_CFG2_SET_BUF_NUM_S, 104);
448 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG2_RESET_BUF_NUM_M,
449 DSAFV2_SBM_CFG2_RESET_BUF_NUM_S, 128);
450 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
451
452 reg = DSAF_SBM_BP_CFG_3_REG_0_REG + 0x80 * i;
453 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
454 dsaf_set_field(o_sbm_bp_cfg,
455 DSAFV2_SBM_CFG3_SET_BUF_NUM_NO_PFC_M,
456 DSAFV2_SBM_CFG3_SET_BUF_NUM_NO_PFC_S, 110);
457 dsaf_set_field(o_sbm_bp_cfg,
458 DSAFV2_SBM_CFG3_RESET_BUF_NUM_NO_PFC_M,
459 DSAFV2_SBM_CFG3_RESET_BUF_NUM_NO_PFC_S, 160);
460 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
461
462 /* for no enable pfc mode */
463 reg = DSAF_SBM_BP_CFG_4_REG_0_REG + 0x80 * i;
464 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
465 dsaf_set_field(o_sbm_bp_cfg,
466 DSAFV2_SBM_CFG4_SET_BUF_NUM_NO_PFC_M,
467 DSAFV2_SBM_CFG4_SET_BUF_NUM_NO_PFC_S, 128);
468 dsaf_set_field(o_sbm_bp_cfg,
469 DSAFV2_SBM_CFG4_RESET_BUF_NUM_NO_PFC_M,
470 DSAFV2_SBM_CFG4_RESET_BUF_NUM_NO_PFC_S, 192);
471 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
472 }
473
474 /* PPE */
475 reg = DSAF_SBM_BP_CFG_2_PPE_REG_0_REG + 0x80 * i;
476 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
477 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG2_SET_BUF_NUM_M,
478 DSAFV2_SBM_CFG2_SET_BUF_NUM_S, 10);
479 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG2_RESET_BUF_NUM_M,
480 DSAFV2_SBM_CFG2_RESET_BUF_NUM_S, 12);
481 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
482 /* RoCEE */
483 for (i = 0; i < DASFV2_ROCEE_CRD_NUM; i++) {
484 reg = DSAFV2_SBM_BP_CFG_2_ROCEE_REG_0_REG + 0x80 * i;
485 o_sbm_bp_cfg = dsaf_read_dev(dsaf_dev, reg);
486 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG2_SET_BUF_NUM_M,
487 DSAFV2_SBM_CFG2_SET_BUF_NUM_S, 2);
488 dsaf_set_field(o_sbm_bp_cfg, DSAFV2_SBM_CFG2_RESET_BUF_NUM_M,
489 DSAFV2_SBM_CFG2_RESET_BUF_NUM_S, 4);
490 dsaf_write_dev(dsaf_dev, reg, o_sbm_bp_cfg);
511e6bc0 491 }
492}
493
494/**
495 * hns_dsaf_voq_bp_all_thrd_cfg - voq
496 * @dsaf_id: dsa fabric id
497 */
498static void hns_dsaf_voq_bp_all_thrd_cfg(struct dsaf_device *dsaf_dev)
499{
500 u32 voq_bp_all_thrd;
501 u32 i;
502
503 for (i = 0; i < DSAF_VOQ_NUM; i++) {
504 voq_bp_all_thrd = dsaf_read_dev(
505 dsaf_dev, DSAF_VOQ_BP_ALL_THRD_0_REG + 0x40 * i);
506 if (i < DSAF_XGE_NUM) {
507 dsaf_set_field(voq_bp_all_thrd,
508 DSAF_VOQ_BP_ALL_DOWNTHRD_M,
509 DSAF_VOQ_BP_ALL_DOWNTHRD_S, 930);
510 dsaf_set_field(voq_bp_all_thrd,
511 DSAF_VOQ_BP_ALL_UPTHRD_M,
512 DSAF_VOQ_BP_ALL_UPTHRD_S, 950);
513 } else {
514 dsaf_set_field(voq_bp_all_thrd,
515 DSAF_VOQ_BP_ALL_DOWNTHRD_M,
516 DSAF_VOQ_BP_ALL_DOWNTHRD_S, 220);
517 dsaf_set_field(voq_bp_all_thrd,
518 DSAF_VOQ_BP_ALL_UPTHRD_M,
519 DSAF_VOQ_BP_ALL_UPTHRD_S, 230);
520 }
521 dsaf_write_dev(
522 dsaf_dev, DSAF_VOQ_BP_ALL_THRD_0_REG + 0x40 * i,
523 voq_bp_all_thrd);
524 }
525}
526
527/**
528 * hns_dsaf_tbl_tcam_data_cfg - tbl
529 * @dsaf_id: dsa fabric id
530 * @ptbl_tcam_data: addr
531 */
532static void hns_dsaf_tbl_tcam_data_cfg(
533 struct dsaf_device *dsaf_dev,
534 struct dsaf_tbl_tcam_data *ptbl_tcam_data)
535{
536 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_LOW_0_REG,
537 ptbl_tcam_data->tbl_tcam_data_low);
538 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_HIGH_0_REG,
539 ptbl_tcam_data->tbl_tcam_data_high);
540}
541
542/**
543 * dsaf_tbl_tcam_mcast_cfg - tbl
544 * @dsaf_id: dsa fabric id
545 * @ptbl_tcam_mcast: addr
546 */
547static void hns_dsaf_tbl_tcam_mcast_cfg(
548 struct dsaf_device *dsaf_dev,
549 struct dsaf_tbl_tcam_mcast_cfg *mcast)
550{
551 u32 mcast_cfg4;
552
553 mcast_cfg4 = dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_4_0_REG);
554 dsaf_set_bit(mcast_cfg4, DSAF_TBL_MCAST_CFG4_ITEM_VLD_S,
555 mcast->tbl_mcast_item_vld);
556 dsaf_set_bit(mcast_cfg4, DSAF_TBL_MCAST_CFG4_OLD_EN_S,
557 mcast->tbl_mcast_old_en);
558 dsaf_set_field(mcast_cfg4, DSAF_TBL_MCAST_CFG4_VM128_112_M,
559 DSAF_TBL_MCAST_CFG4_VM128_112_S,
560 mcast->tbl_mcast_port_msk[4]);
561 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_4_0_REG, mcast_cfg4);
562
563 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_3_0_REG,
564 mcast->tbl_mcast_port_msk[3]);
565
566 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_2_0_REG,
567 mcast->tbl_mcast_port_msk[2]);
568
569 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_1_0_REG,
570 mcast->tbl_mcast_port_msk[1]);
571
572 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_0_0_REG,
573 mcast->tbl_mcast_port_msk[0]);
574}
575
576/**
577 * hns_dsaf_tbl_tcam_ucast_cfg - tbl
578 * @dsaf_id: dsa fabric id
579 * @ptbl_tcam_ucast: addr
580 */
581static void hns_dsaf_tbl_tcam_ucast_cfg(
582 struct dsaf_device *dsaf_dev,
583 struct dsaf_tbl_tcam_ucast_cfg *tbl_tcam_ucast)
584{
585 u32 ucast_cfg1;
586
587 ucast_cfg1 = dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_UCAST_CFG_0_REG);
588 dsaf_set_bit(ucast_cfg1, DSAF_TBL_UCAST_CFG1_MAC_DISCARD_S,
589 tbl_tcam_ucast->tbl_ucast_mac_discard);
590 dsaf_set_bit(ucast_cfg1, DSAF_TBL_UCAST_CFG1_ITEM_VLD_S,
591 tbl_tcam_ucast->tbl_ucast_item_vld);
592 dsaf_set_bit(ucast_cfg1, DSAF_TBL_UCAST_CFG1_OLD_EN_S,
593 tbl_tcam_ucast->tbl_ucast_old_en);
594 dsaf_set_bit(ucast_cfg1, DSAF_TBL_UCAST_CFG1_DVC_S,
595 tbl_tcam_ucast->tbl_ucast_dvc);
596 dsaf_set_field(ucast_cfg1, DSAF_TBL_UCAST_CFG1_OUT_PORT_M,
597 DSAF_TBL_UCAST_CFG1_OUT_PORT_S,
598 tbl_tcam_ucast->tbl_ucast_out_port);
599 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_UCAST_CFG_0_REG, ucast_cfg1);
600}
601
602/**
603 * hns_dsaf_tbl_line_cfg - tbl
604 * @dsaf_id: dsa fabric id
605 * @ptbl_lin: addr
606 */
607static void hns_dsaf_tbl_line_cfg(struct dsaf_device *dsaf_dev,
608 struct dsaf_tbl_line_cfg *tbl_lin)
609{
610 u32 tbl_line;
611
612 tbl_line = dsaf_read_dev(dsaf_dev, DSAF_TBL_LIN_CFG_0_REG);
613 dsaf_set_bit(tbl_line, DSAF_TBL_LINE_CFG_MAC_DISCARD_S,
614 tbl_lin->tbl_line_mac_discard);
615 dsaf_set_bit(tbl_line, DSAF_TBL_LINE_CFG_DVC_S,
616 tbl_lin->tbl_line_dvc);
617 dsaf_set_field(tbl_line, DSAF_TBL_LINE_CFG_OUT_PORT_M,
618 DSAF_TBL_LINE_CFG_OUT_PORT_S,
619 tbl_lin->tbl_line_out_port);
620 dsaf_write_dev(dsaf_dev, DSAF_TBL_LIN_CFG_0_REG, tbl_line);
621}
622
623/**
624 * hns_dsaf_tbl_tcam_mcast_pul - tbl
625 * @dsaf_id: dsa fabric id
626 */
627static void hns_dsaf_tbl_tcam_mcast_pul(struct dsaf_device *dsaf_dev)
628{
629 u32 o_tbl_pul;
630
631 o_tbl_pul = dsaf_read_dev(dsaf_dev, DSAF_TBL_PUL_0_REG);
632 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_MCAST_VLD_S, 1);
633 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, o_tbl_pul);
634 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_MCAST_VLD_S, 0);
635 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, o_tbl_pul);
636}
637
638/**
639 * hns_dsaf_tbl_line_pul - tbl
640 * @dsaf_id: dsa fabric id
641 */
642static void hns_dsaf_tbl_line_pul(struct dsaf_device *dsaf_dev)
643{
644 u32 tbl_pul;
645
646 tbl_pul = dsaf_read_dev(dsaf_dev, DSAF_TBL_PUL_0_REG);
647 dsaf_set_bit(tbl_pul, DSAF_TBL_PUL_LINE_VLD_S, 1);
648 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, tbl_pul);
649 dsaf_set_bit(tbl_pul, DSAF_TBL_PUL_LINE_VLD_S, 0);
650 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, tbl_pul);
651}
652
653/**
654 * hns_dsaf_tbl_tcam_data_mcast_pul - tbl
655 * @dsaf_id: dsa fabric id
656 */
657static void hns_dsaf_tbl_tcam_data_mcast_pul(
658 struct dsaf_device *dsaf_dev)
659{
660 u32 o_tbl_pul;
661
662 o_tbl_pul = dsaf_read_dev(dsaf_dev, DSAF_TBL_PUL_0_REG);
663 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_TCAM_DATA_VLD_S, 1);
664 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_MCAST_VLD_S, 1);
665 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, o_tbl_pul);
666 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_TCAM_DATA_VLD_S, 0);
667 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_MCAST_VLD_S, 0);
668 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, o_tbl_pul);
669}
670
671/**
672 * hns_dsaf_tbl_tcam_data_ucast_pul - tbl
673 * @dsaf_id: dsa fabric id
674 */
675static void hns_dsaf_tbl_tcam_data_ucast_pul(
676 struct dsaf_device *dsaf_dev)
677{
678 u32 o_tbl_pul;
679
680 o_tbl_pul = dsaf_read_dev(dsaf_dev, DSAF_TBL_PUL_0_REG);
681 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_TCAM_DATA_VLD_S, 1);
682 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_UCAST_VLD_S, 1);
683 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, o_tbl_pul);
684 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_TCAM_DATA_VLD_S, 0);
685 dsaf_set_bit(o_tbl_pul, DSAF_TBL_PUL_UCAST_VLD_S, 0);
686 dsaf_write_dev(dsaf_dev, DSAF_TBL_PUL_0_REG, o_tbl_pul);
687}
688
4568637f 689void hns_dsaf_set_promisc_mode(struct dsaf_device *dsaf_dev, u32 en)
690{
691 dsaf_set_dev_bit(dsaf_dev, DSAF_CFG_0_REG, DSAF_CFG_MIX_MODE_S, !!en);
692}
693
511e6bc0 694/**
695 * hns_dsaf_tbl_stat_en - tbl
696 * @dsaf_id: dsa fabric id
697 * @ptbl_stat_en: addr
698 */
699static void hns_dsaf_tbl_stat_en(struct dsaf_device *dsaf_dev)
700{
701 u32 o_tbl_ctrl;
702
703 o_tbl_ctrl = dsaf_read_dev(dsaf_dev, DSAF_TBL_DFX_CTRL_0_REG);
704 dsaf_set_bit(o_tbl_ctrl, DSAF_TBL_DFX_LINE_LKUP_NUM_EN_S, 1);
705 dsaf_set_bit(o_tbl_ctrl, DSAF_TBL_DFX_UC_LKUP_NUM_EN_S, 1);
706 dsaf_set_bit(o_tbl_ctrl, DSAF_TBL_DFX_MC_LKUP_NUM_EN_S, 1);
707 dsaf_set_bit(o_tbl_ctrl, DSAF_TBL_DFX_BC_LKUP_NUM_EN_S, 1);
708 dsaf_write_dev(dsaf_dev, DSAF_TBL_DFX_CTRL_0_REG, o_tbl_ctrl);
709}
710
711/**
712 * hns_dsaf_rocee_bp_en - rocee back press enable
713 * @dsaf_id: dsa fabric id
714 */
715static void hns_dsaf_rocee_bp_en(struct dsaf_device *dsaf_dev)
716{
717 dsaf_set_dev_bit(dsaf_dev, DSAF_XGE_CTRL_SIG_CFG_0_REG,
718 DSAF_FC_XGE_TX_PAUSE_S, 1);
719}
720
721/* set msk for dsaf exception irq*/
722static void hns_dsaf_int_xge_msk_set(struct dsaf_device *dsaf_dev,
723 u32 chnn_num, u32 mask_set)
724{
725 dsaf_write_dev(dsaf_dev,
726 DSAF_XGE_INT_MSK_0_REG + 0x4 * chnn_num, mask_set);
727}
728
729static void hns_dsaf_int_ppe_msk_set(struct dsaf_device *dsaf_dev,
730 u32 chnn_num, u32 msk_set)
731{
732 dsaf_write_dev(dsaf_dev,
733 DSAF_PPE_INT_MSK_0_REG + 0x4 * chnn_num, msk_set);
734}
735
736static void hns_dsaf_int_rocee_msk_set(struct dsaf_device *dsaf_dev,
737 u32 chnn, u32 msk_set)
738{
739 dsaf_write_dev(dsaf_dev,
740 DSAF_ROCEE_INT_MSK_0_REG + 0x4 * chnn, msk_set);
741}
742
743static void
744hns_dsaf_int_tbl_msk_set(struct dsaf_device *dsaf_dev, u32 msk_set)
745{
746 dsaf_write_dev(dsaf_dev, DSAF_TBL_INT_MSK_0_REG, msk_set);
747}
748
749/* clr dsaf exception irq*/
750static void hns_dsaf_int_xge_src_clr(struct dsaf_device *dsaf_dev,
751 u32 chnn_num, u32 int_src)
752{
753 dsaf_write_dev(dsaf_dev,
754 DSAF_XGE_INT_SRC_0_REG + 0x4 * chnn_num, int_src);
755}
756
757static void hns_dsaf_int_ppe_src_clr(struct dsaf_device *dsaf_dev,
758 u32 chnn, u32 int_src)
759{
760 dsaf_write_dev(dsaf_dev,
761 DSAF_PPE_INT_SRC_0_REG + 0x4 * chnn, int_src);
762}
763
764static void hns_dsaf_int_rocee_src_clr(struct dsaf_device *dsaf_dev,
765 u32 chnn, u32 int_src)
766{
767 dsaf_write_dev(dsaf_dev,
768 DSAF_ROCEE_INT_SRC_0_REG + 0x4 * chnn, int_src);
769}
770
771static void hns_dsaf_int_tbl_src_clr(struct dsaf_device *dsaf_dev,
772 u32 int_src)
773{
774 dsaf_write_dev(dsaf_dev, DSAF_TBL_INT_SRC_0_REG, int_src);
775}
776
777/**
778 * hns_dsaf_single_line_tbl_cfg - INT
779 * @dsaf_id: dsa fabric id
780 * @address:
781 * @ptbl_line:
782 */
783static void hns_dsaf_single_line_tbl_cfg(
784 struct dsaf_device *dsaf_dev,
785 u32 address, struct dsaf_tbl_line_cfg *ptbl_line)
786{
787 /*Write Addr*/
788 hns_dsaf_tbl_line_addr_cfg(dsaf_dev, address);
789
790 /*Write Line*/
791 hns_dsaf_tbl_line_cfg(dsaf_dev, ptbl_line);
792
793 /*Write Plus*/
794 hns_dsaf_tbl_line_pul(dsaf_dev);
795}
796
797/**
798 * hns_dsaf_tcam_uc_cfg - INT
799 * @dsaf_id: dsa fabric id
800 * @address,
801 * @ptbl_tcam_data,
802 */
803static void hns_dsaf_tcam_uc_cfg(
804 struct dsaf_device *dsaf_dev, u32 address,
805 struct dsaf_tbl_tcam_data *ptbl_tcam_data,
806 struct dsaf_tbl_tcam_ucast_cfg *ptbl_tcam_ucast)
807{
808 /*Write Addr*/
809 hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
810 /*Write Tcam Data*/
811 hns_dsaf_tbl_tcam_data_cfg(dsaf_dev, ptbl_tcam_data);
812 /*Write Tcam Ucast*/
813 hns_dsaf_tbl_tcam_ucast_cfg(dsaf_dev, ptbl_tcam_ucast);
814 /*Write Plus*/
815 hns_dsaf_tbl_tcam_data_ucast_pul(dsaf_dev);
816}
817
818/**
819 * hns_dsaf_tcam_mc_cfg - INT
820 * @dsaf_id: dsa fabric id
821 * @address,
822 * @ptbl_tcam_data,
823 * @ptbl_tcam_mcast,
824 */
825static void hns_dsaf_tcam_mc_cfg(
826 struct dsaf_device *dsaf_dev, u32 address,
827 struct dsaf_tbl_tcam_data *ptbl_tcam_data,
828 struct dsaf_tbl_tcam_mcast_cfg *ptbl_tcam_mcast)
829{
830 /*Write Addr*/
831 hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
832 /*Write Tcam Data*/
833 hns_dsaf_tbl_tcam_data_cfg(dsaf_dev, ptbl_tcam_data);
834 /*Write Tcam Mcast*/
835 hns_dsaf_tbl_tcam_mcast_cfg(dsaf_dev, ptbl_tcam_mcast);
836 /*Write Plus*/
837 hns_dsaf_tbl_tcam_data_mcast_pul(dsaf_dev);
838}
839
840/**
841 * hns_dsaf_tcam_mc_invld - INT
842 * @dsaf_id: dsa fabric id
843 * @address
844 */
845static void hns_dsaf_tcam_mc_invld(struct dsaf_device *dsaf_dev, u32 address)
846{
847 /*Write Addr*/
848 hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
849
850 /*write tcam mcast*/
851 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_0_0_REG, 0);
852 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_1_0_REG, 0);
853 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_2_0_REG, 0);
854 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_3_0_REG, 0);
855 dsaf_write_dev(dsaf_dev, DSAF_TBL_TCAM_MCAST_CFG_4_0_REG, 0);
856
857 /*Write Plus*/
858 hns_dsaf_tbl_tcam_mcast_pul(dsaf_dev);
859}
860
861/**
862 * hns_dsaf_tcam_uc_get - INT
863 * @dsaf_id: dsa fabric id
864 * @address
865 * @ptbl_tcam_data
866 * @ptbl_tcam_ucast
867 */
868static void hns_dsaf_tcam_uc_get(
869 struct dsaf_device *dsaf_dev, u32 address,
870 struct dsaf_tbl_tcam_data *ptbl_tcam_data,
871 struct dsaf_tbl_tcam_ucast_cfg *ptbl_tcam_ucast)
872{
873 u32 tcam_read_data0;
874 u32 tcam_read_data4;
875
876 /*Write Addr*/
877 hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
878
879 /*read tcam item puls*/
880 hns_dsaf_tbl_tcam_load_pul(dsaf_dev);
881
882 /*read tcam data*/
883 ptbl_tcam_data->tbl_tcam_data_high
884 = dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RDATA_LOW_0_REG);
885 ptbl_tcam_data->tbl_tcam_data_low
886 = dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RDATA_HIGH_0_REG);
887
888 /*read tcam mcast*/
889 tcam_read_data0 = dsaf_read_dev(dsaf_dev,
890 DSAF_TBL_TCAM_RAM_RDATA0_0_REG);
891 tcam_read_data4 = dsaf_read_dev(dsaf_dev,
892 DSAF_TBL_TCAM_RAM_RDATA4_0_REG);
893
894 ptbl_tcam_ucast->tbl_ucast_item_vld
895 = dsaf_get_bit(tcam_read_data4,
896 DSAF_TBL_MCAST_CFG4_ITEM_VLD_S);
897 ptbl_tcam_ucast->tbl_ucast_old_en
898 = dsaf_get_bit(tcam_read_data4, DSAF_TBL_MCAST_CFG4_OLD_EN_S);
899 ptbl_tcam_ucast->tbl_ucast_mac_discard
900 = dsaf_get_bit(tcam_read_data0,
901 DSAF_TBL_UCAST_CFG1_MAC_DISCARD_S);
902 ptbl_tcam_ucast->tbl_ucast_out_port
903 = dsaf_get_field(tcam_read_data0,
904 DSAF_TBL_UCAST_CFG1_OUT_PORT_M,
905 DSAF_TBL_UCAST_CFG1_OUT_PORT_S);
906 ptbl_tcam_ucast->tbl_ucast_dvc
907 = dsaf_get_bit(tcam_read_data0, DSAF_TBL_UCAST_CFG1_DVC_S);
908}
909
910/**
911 * hns_dsaf_tcam_mc_get - INT
912 * @dsaf_id: dsa fabric id
913 * @address
914 * @ptbl_tcam_data
915 * @ptbl_tcam_ucast
916 */
917static void hns_dsaf_tcam_mc_get(
918 struct dsaf_device *dsaf_dev, u32 address,
919 struct dsaf_tbl_tcam_data *ptbl_tcam_data,
920 struct dsaf_tbl_tcam_mcast_cfg *ptbl_tcam_mcast)
921{
922 u32 data_tmp;
923
924 /*Write Addr*/
925 hns_dsaf_tbl_tcam_addr_cfg(dsaf_dev, address);
926
927 /*read tcam item puls*/
928 hns_dsaf_tbl_tcam_load_pul(dsaf_dev);
929
930 /*read tcam data*/
931 ptbl_tcam_data->tbl_tcam_data_high =
932 dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RDATA_LOW_0_REG);
933 ptbl_tcam_data->tbl_tcam_data_low =
934 dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RDATA_HIGH_0_REG);
935
936 /*read tcam mcast*/
937 ptbl_tcam_mcast->tbl_mcast_port_msk[0] =
938 dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RAM_RDATA0_0_REG);
939 ptbl_tcam_mcast->tbl_mcast_port_msk[1] =
940 dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RAM_RDATA1_0_REG);
941 ptbl_tcam_mcast->tbl_mcast_port_msk[2] =
942 dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RAM_RDATA2_0_REG);
943 ptbl_tcam_mcast->tbl_mcast_port_msk[3] =
944 dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RAM_RDATA3_0_REG);
945
946 data_tmp = dsaf_read_dev(dsaf_dev, DSAF_TBL_TCAM_RAM_RDATA4_0_REG);
947 ptbl_tcam_mcast->tbl_mcast_item_vld =
948 dsaf_get_bit(data_tmp, DSAF_TBL_MCAST_CFG4_ITEM_VLD_S);
949 ptbl_tcam_mcast->tbl_mcast_old_en =
950 dsaf_get_bit(data_tmp, DSAF_TBL_MCAST_CFG4_OLD_EN_S);
951 ptbl_tcam_mcast->tbl_mcast_port_msk[4] =
952 dsaf_get_field(data_tmp, DSAF_TBL_MCAST_CFG4_VM128_112_M,
953 DSAF_TBL_MCAST_CFG4_VM128_112_S);
954}
955
956/**
957 * hns_dsaf_tbl_line_init - INT
958 * @dsaf_id: dsa fabric id
959 */
960static void hns_dsaf_tbl_line_init(struct dsaf_device *dsaf_dev)
961{
962 u32 i;
963 /* defaultly set all lineal mac table entry resulting discard */
964 struct dsaf_tbl_line_cfg tbl_line[] = {{1, 0, 0} };
965
966 for (i = 0; i < DSAF_LINE_SUM; i++)
967 hns_dsaf_single_line_tbl_cfg(dsaf_dev, i, tbl_line);
968}
969
970/**
971 * hns_dsaf_tbl_tcam_init - INT
972 * @dsaf_id: dsa fabric id
973 */
974static void hns_dsaf_tbl_tcam_init(struct dsaf_device *dsaf_dev)
975{
976 u32 i;
977 struct dsaf_tbl_tcam_data tcam_data[] = {{0, 0} };
978 struct dsaf_tbl_tcam_ucast_cfg tcam_ucast[] = {{0, 0, 0, 0, 0} };
979
980 /*tcam tbl*/
981 for (i = 0; i < DSAF_TCAM_SUM; i++)
982 hns_dsaf_tcam_uc_cfg(dsaf_dev, i, tcam_data, tcam_ucast);
983}
984
985/**
986 * hns_dsaf_pfc_en_cfg - dsaf pfc pause cfg
987 * @mac_cb: mac contrl block
988 */
989static void hns_dsaf_pfc_en_cfg(struct dsaf_device *dsaf_dev,
990 int mac_id, int en)
991{
992 if (!en)
993 dsaf_write_dev(dsaf_dev, DSAF_PFC_EN_0_REG + mac_id * 4, 0);
994 else
995 dsaf_write_dev(dsaf_dev, DSAF_PFC_EN_0_REG + mac_id * 4, 0xff);
996}
997
998/**
999 * hns_dsaf_tbl_tcam_init - INT
1000 * @dsaf_id: dsa fabric id
1001 * @dsaf_mode
1002 */
1003static void hns_dsaf_comm_init(struct dsaf_device *dsaf_dev)
1004{
1005 u32 i;
1006 u32 o_dsaf_cfg;
1007
1008 o_dsaf_cfg = dsaf_read_dev(dsaf_dev, DSAF_CFG_0_REG);
1009 dsaf_set_bit(o_dsaf_cfg, DSAF_CFG_EN_S, dsaf_dev->dsaf_en);
1010 dsaf_set_bit(o_dsaf_cfg, DSAF_CFG_TC_MODE_S, dsaf_dev->dsaf_tc_mode);
1011 dsaf_set_bit(o_dsaf_cfg, DSAF_CFG_CRC_EN_S, 0);
1012 dsaf_set_bit(o_dsaf_cfg, DSAF_CFG_MIX_MODE_S, 0);
1013 dsaf_set_bit(o_dsaf_cfg, DSAF_CFG_LOCA_ADDR_EN_S, 0);
1014 dsaf_write_dev(dsaf_dev, DSAF_CFG_0_REG, o_dsaf_cfg);
1015
1016 hns_dsaf_reg_cnt_clr_ce(dsaf_dev, 1);
1017 hns_dsaf_stp_port_type_cfg(dsaf_dev, DSAF_STP_PORT_TYPE_FORWARD);
1018
1019 /* set 22 queue per tx ppe engine, only used in switch mode */
1020 hns_dsaf_ppe_qid_cfg(dsaf_dev, DSAF_DEFAUTL_QUEUE_NUM_PER_PPE);
1021
4568637f 1022 /* set promisc def queue id */
1023 hns_dsaf_mix_def_qid_cfg(dsaf_dev);
1024
511e6bc0 1025 /* in non switch mode, set all port to access mode */
1026 hns_dsaf_sw_port_type_cfg(dsaf_dev, DSAF_SW_PORT_TYPE_NON_VLAN);
1027
1028 /*set dsaf pfc to 0 for parseing rx pause*/
1029 for (i = 0; i < DSAF_COMM_CHN; i++)
1030 hns_dsaf_pfc_en_cfg(dsaf_dev, i, 0);
1031
1032 /*msk and clr exception irqs */
1033 for (i = 0; i < DSAF_COMM_CHN; i++) {
1034 hns_dsaf_int_xge_src_clr(dsaf_dev, i, 0xfffffffful);
1035 hns_dsaf_int_ppe_src_clr(dsaf_dev, i, 0xfffffffful);
1036 hns_dsaf_int_rocee_src_clr(dsaf_dev, i, 0xfffffffful);
1037
1038 hns_dsaf_int_xge_msk_set(dsaf_dev, i, 0xfffffffful);
1039 hns_dsaf_int_ppe_msk_set(dsaf_dev, i, 0xfffffffful);
1040 hns_dsaf_int_rocee_msk_set(dsaf_dev, i, 0xfffffffful);
1041 }
1042 hns_dsaf_int_tbl_src_clr(dsaf_dev, 0xfffffffful);
1043 hns_dsaf_int_tbl_msk_set(dsaf_dev, 0xfffffffful);
1044}
1045
1046/**
1047 * hns_dsaf_inode_init - INT
1048 * @dsaf_id: dsa fabric id
1049 */
1050static void hns_dsaf_inode_init(struct dsaf_device *dsaf_dev)
1051{
1052 u32 reg;
1053 u32 tc_cfg;
1054 u32 i;
1055
1056 if (dsaf_dev->dsaf_tc_mode == HRD_DSAF_4TC_MODE)
1057 tc_cfg = HNS_DSAF_I4TC_CFG;
1058 else
1059 tc_cfg = HNS_DSAF_I8TC_CFG;
1060
13ac695e
S		 1061 if (AE_IS_VER1(dsaf_dev->dsaf_ver)) {
1062 for (i = 0; i < DSAF_INODE_NUM; i++) {
1063 reg = DSAF_INODE_IN_PORT_NUM_0_REG + 0x80 * i;
1064 dsaf_set_dev_field(dsaf_dev, reg,
1065 DSAF_INODE_IN_PORT_NUM_M,
1066 DSAF_INODE_IN_PORT_NUM_S,
1067 i % DSAF_XGE_NUM);
1068 }
1069 } else {
1070 for (i = 0; i < DSAF_PORT_TYPE_NUM; i++) {
1071 reg = DSAF_INODE_IN_PORT_NUM_0_REG + 0x80 * i;
1072 dsaf_set_dev_field(dsaf_dev, reg,
1073 DSAF_INODE_IN_PORT_NUM_M,
1074 DSAF_INODE_IN_PORT_NUM_S, 0);
1075 dsaf_set_dev_field(dsaf_dev, reg,
1076 DSAFV2_INODE_IN_PORT1_NUM_M,
1077 DSAFV2_INODE_IN_PORT1_NUM_S, 1);
1078 dsaf_set_dev_field(dsaf_dev, reg,
1079 DSAFV2_INODE_IN_PORT2_NUM_M,
1080 DSAFV2_INODE_IN_PORT2_NUM_S, 2);
1081 dsaf_set_dev_field(dsaf_dev, reg,
1082 DSAFV2_INODE_IN_PORT3_NUM_M,
1083 DSAFV2_INODE_IN_PORT3_NUM_S, 3);
1084 dsaf_set_dev_field(dsaf_dev, reg,
1085 DSAFV2_INODE_IN_PORT4_NUM_M,
1086 DSAFV2_INODE_IN_PORT4_NUM_S, 4);
1087 dsaf_set_dev_field(dsaf_dev, reg,
1088 DSAFV2_INODE_IN_PORT5_NUM_M,
1089 DSAFV2_INODE_IN_PORT5_NUM_S, 5);
1090 }
1091 }
511e6bc0 1092 for (i = 0; i < DSAF_INODE_NUM; i++) {
511e6bc0 1093 reg = DSAF_INODE_PRI_TC_CFG_0_REG + 0x80 * i;
1094 dsaf_write_dev(dsaf_dev, reg, tc_cfg);
1095 }
1096}
1097
1098/**
1099 * hns_dsaf_sbm_init - INT
1100 * @dsaf_id: dsa fabric id
1101 */
1102static int hns_dsaf_sbm_init(struct dsaf_device *dsaf_dev)
1103{
1104 u32 flag;
13ac695e 1105 u32 finish_msk;
511e6bc0 1106 u32 cnt = 0;
1107 int ret;
1108
13ac695e
S		 1109 if (AE_IS_VER1(dsaf_dev->dsaf_ver)) {
1110 hns_dsaf_sbm_bp_wl_cfg(dsaf_dev);
1111 finish_msk = DSAF_SRAM_INIT_OVER_M;
1112 } else {
1113 hns_dsafv2_sbm_bp_wl_cfg(dsaf_dev);
1114 finish_msk = DSAFV2_SRAM_INIT_OVER_M;
1115 }
511e6bc0 1116
1117 /* enable sbm chanel, disable sbm chanel shcut function*/
1118 hns_dsaf_sbm_cfg(dsaf_dev);
1119
1120 /* enable sbm mib */
1121 ret = hns_dsaf_sbm_cfg_mib_en(dsaf_dev);
1122 if (ret) {
1123 dev_err(dsaf_dev->dev,
1124 "hns_dsaf_sbm_cfg_mib_en fail,%s, ret=%d\n",
1125 dsaf_dev->ae_dev.name, ret);
1126 return ret;
1127 }
1128
1129 /* enable sbm initial link sram */
1130 hns_dsaf_sbm_link_sram_init_en(dsaf_dev);
1131
1132 do {
1133 usleep_range(200, 210);/*udelay(200);*/
13ac695e
S		 1134 flag = dsaf_get_dev_field(dsaf_dev, DSAF_SRAM_INIT_OVER_0_REG,
1135 finish_msk, DSAF_SRAM_INIT_OVER_S);
511e6bc0 1136 cnt++;
13ac695e
S		 1137 } while (flag != (finish_msk >> DSAF_SRAM_INIT_OVER_S) &&
1138 cnt < DSAF_CFG_READ_CNT);
511e6bc0 1139
13ac695e 1140 if (flag != (finish_msk >> DSAF_SRAM_INIT_OVER_S)) {
511e6bc0 1141 dev_err(dsaf_dev->dev,
1142 "hns_dsaf_sbm_init fail %s, flag=%d, cnt=%d\n",
1143 dsaf_dev->ae_dev.name, flag, cnt);
1144 return -ENODEV;
1145 }
1146
1147 hns_dsaf_rocee_bp_en(dsaf_dev);
1148
1149 return 0;
1150}
1151
1152/**
1153 * hns_dsaf_tbl_init - INT
1154 * @dsaf_id: dsa fabric id
1155 */
1156static void hns_dsaf_tbl_init(struct dsaf_device *dsaf_dev)
1157{
1158 hns_dsaf_tbl_stat_en(dsaf_dev);
1159
1160 hns_dsaf_tbl_tcam_init(dsaf_dev);
1161 hns_dsaf_tbl_line_init(dsaf_dev);
1162}
1163
1164/**
1165 * hns_dsaf_voq_init - INT
1166 * @dsaf_id: dsa fabric id
1167 */
1168static void hns_dsaf_voq_init(struct dsaf_device *dsaf_dev)
1169{
1170 hns_dsaf_voq_bp_all_thrd_cfg(dsaf_dev);
1171}
1172
1173/**
1174 * hns_dsaf_init_hw - init dsa fabric hardware
1175 * @dsaf_dev: dsa fabric device struct pointer
1176 */
1177static int hns_dsaf_init_hw(struct dsaf_device *dsaf_dev)
1178{
1179 int ret;
1180
1181 dev_dbg(dsaf_dev->dev,
1182 "hns_dsaf_init_hw begin %s !\n", dsaf_dev->ae_dev.name);
1183
1184 hns_dsaf_rst(dsaf_dev, 0);
1185 mdelay(10);
1186 hns_dsaf_rst(dsaf_dev, 1);
1187
1188 hns_dsaf_comm_init(dsaf_dev);
1189
1190 /*init XBAR_INODE*/
1191 hns_dsaf_inode_init(dsaf_dev);
1192
1193 /*init SBM*/
1194 ret = hns_dsaf_sbm_init(dsaf_dev);
1195 if (ret)
1196 return ret;
1197
1198 /*init TBL*/
1199 hns_dsaf_tbl_init(dsaf_dev);
1200
1201 /*init VOQ*/
1202 hns_dsaf_voq_init(dsaf_dev);
1203
1204 return 0;
1205}
1206
1207/**
1208 * hns_dsaf_remove_hw - uninit dsa fabric hardware
1209 * @dsaf_dev: dsa fabric device struct pointer
1210 */
1211static void hns_dsaf_remove_hw(struct dsaf_device *dsaf_dev)
1212{
1213 /*reset*/
1214 hns_dsaf_rst(dsaf_dev, 0);
1215}
1216
1217/**
1218 * hns_dsaf_init - init dsa fabric
1219 * @dsaf_dev: dsa fabric device struct pointer
1220 * retuen 0 - success , negative --fail
1221 */
1222static int hns_dsaf_init(struct dsaf_device *dsaf_dev)
1223{
1224 struct dsaf_drv_priv *priv =
1225 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1226 u32 i;
1227 int ret;
1228
1229 ret = hns_dsaf_init_hw(dsaf_dev);
1230 if (ret)
1231 return ret;
1232
1233 /* malloc mem for tcam mac key(vlan+mac) */
1234 priv->soft_mac_tbl = vzalloc(sizeof(*priv->soft_mac_tbl)
1235 * DSAF_TCAM_SUM);
1236 if (!priv->soft_mac_tbl) {
1237 ret = -ENOMEM;
1238 goto remove_hw;
1239 }
1240
1241 /*all entry invall */
1242 for (i = 0; i < DSAF_TCAM_SUM; i++)
1243 (priv->soft_mac_tbl + i)->index = DSAF_INVALID_ENTRY_IDX;
1244
1245 return 0;
1246
1247remove_hw:
1248 hns_dsaf_remove_hw(dsaf_dev);
1249 return ret;
1250}
1251
1252/**
1253 * hns_dsaf_free - free dsa fabric
1254 * @dsaf_dev: dsa fabric device struct pointer
1255 */
1256static void hns_dsaf_free(struct dsaf_device *dsaf_dev)
1257{
1258 struct dsaf_drv_priv *priv =
1259 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1260
1261 hns_dsaf_remove_hw(dsaf_dev);
1262
1263 /* free all mac mem */
1264 vfree(priv->soft_mac_tbl);
1265 priv->soft_mac_tbl = NULL;
1266}
1267
1268/**
1269 * hns_dsaf_find_soft_mac_entry - find dsa fabric soft entry
1270 * @dsaf_dev: dsa fabric device struct pointer
1271 * @mac_key: mac entry struct pointer
1272 */
1273static u16 hns_dsaf_find_soft_mac_entry(
1274 struct dsaf_device *dsaf_dev,
1275 struct dsaf_drv_tbl_tcam_key *mac_key)
1276{
1277 struct dsaf_drv_priv *priv =
1278 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1279 struct dsaf_drv_soft_mac_tbl *soft_mac_entry;
1280 u32 i;
1281
1282 soft_mac_entry = priv->soft_mac_tbl;
1283 for (i = 0; i < DSAF_TCAM_SUM; i++) {
1284 /* invall tab entry */
1285 if ((soft_mac_entry->index != DSAF_INVALID_ENTRY_IDX) &&
1286 (soft_mac_entry->tcam_key.high.val == mac_key->high.val) &&
1287 (soft_mac_entry->tcam_key.low.val == mac_key->low.val))
1288 /* return find result --soft index */
1289 return soft_mac_entry->index;
1290
1291 soft_mac_entry++;
1292 }
1293 return DSAF_INVALID_ENTRY_IDX;
1294}
1295
1296/**
1297 * hns_dsaf_find_empty_mac_entry - search dsa fabric soft empty-entry
1298 * @dsaf_dev: dsa fabric device struct pointer
1299 */
1300static u16 hns_dsaf_find_empty_mac_entry(struct dsaf_device *dsaf_dev)
1301{
1302 struct dsaf_drv_priv *priv =
1303 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1304 struct dsaf_drv_soft_mac_tbl *soft_mac_entry;
1305 u32 i;
1306
1307 soft_mac_entry = priv->soft_mac_tbl;
1308 for (i = 0; i < DSAF_TCAM_SUM; i++) {
1309 /* inv all entry */
1310 if (soft_mac_entry->index == DSAF_INVALID_ENTRY_IDX)
1311 /* return find result --soft index */
1312 return i;
1313
1314 soft_mac_entry++;
1315 }
1316 return DSAF_INVALID_ENTRY_IDX;
1317}
1318
1319/**
1320 * hns_dsaf_set_mac_key - set mac key
1321 * @dsaf_dev: dsa fabric device struct pointer
1322 * @mac_key: tcam key pointer
1323 * @vlan_id: vlan id
1324 * @in_port_num: input port num
1325 * @addr: mac addr
1326 */
1327static void hns_dsaf_set_mac_key(
1328 struct dsaf_device *dsaf_dev,
1329 struct dsaf_drv_tbl_tcam_key *mac_key, u16 vlan_id, u8 in_port_num,
1330 u8 *addr)
1331{
1332 u8 port;
1333
1334 if (dsaf_dev->dsaf_mode <= DSAF_MODE_ENABLE)
1335 /*DSAF mode : in port id fixed 0*/
1336 port = 0;
1337 else
1338 /*non-dsaf mode*/
1339 port = in_port_num;
1340
1341 mac_key->high.bits.mac_0 = addr[0];
1342 mac_key->high.bits.mac_1 = addr[1];
1343 mac_key->high.bits.mac_2 = addr[2];
1344 mac_key->high.bits.mac_3 = addr[3];
1345 mac_key->low.bits.mac_4 = addr[4];
1346 mac_key->low.bits.mac_5 = addr[5];
1347 mac_key->low.bits.vlan = vlan_id;
1348 mac_key->low.bits.port = port;
1349}
1350
1351/**
1352 * hns_dsaf_set_mac_uc_entry - set mac uc-entry
1353 * @dsaf_dev: dsa fabric device struct pointer
1354 * @mac_entry: uc-mac entry
1355 */
1356int hns_dsaf_set_mac_uc_entry(
1357 struct dsaf_device *dsaf_dev,
1358 struct dsaf_drv_mac_single_dest_entry *mac_entry)
1359{
1360 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1361 struct dsaf_drv_tbl_tcam_key mac_key;
1362 struct dsaf_tbl_tcam_ucast_cfg mac_data;
1363 struct dsaf_drv_priv *priv =
1364 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1365 struct dsaf_drv_soft_mac_tbl *soft_mac_entry = priv->soft_mac_tbl;
1366
1367 /* mac addr check */
1368 if (MAC_IS_ALL_ZEROS(mac_entry->addr) ||
1369 MAC_IS_BROADCAST(mac_entry->addr) ||
1370 MAC_IS_MULTICAST(mac_entry->addr)) {
98900a80
AS		 1371 dev_err(dsaf_dev->dev, "set_uc %s Mac %pM err!\n",
1372 dsaf_dev->ae_dev.name, mac_entry->addr);
511e6bc0 1373 return -EINVAL;
1374 }
1375
1376 /* config key */
1377 hns_dsaf_set_mac_key(dsaf_dev, &mac_key, mac_entry->in_vlan_id,
1378 mac_entry->in_port_num, mac_entry->addr);
1379
1380 /* entry ie exist? */
1381 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1382 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1383 /*if has not inv entry,find a empty entry */
1384 entry_index = hns_dsaf_find_empty_mac_entry(dsaf_dev);
1385 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1386 /* has not empty,return error */
1387 dev_err(dsaf_dev->dev,
1388 "set_uc_entry failed, %s Mac key(%#x:%#x)\n",
1389 dsaf_dev->ae_dev.name,
1390 mac_key.high.val, mac_key.low.val);
1391 return -EINVAL;
1392 }
1393 }
1394
1395 dev_dbg(dsaf_dev->dev,
1396 "set_uc_entry, %s Mac key(%#x:%#x) entry_index%d\n",
1397 dsaf_dev->ae_dev.name, mac_key.high.val,
1398 mac_key.low.val, entry_index);
1399
1400 /* config hardware entry */
1401 mac_data.tbl_ucast_item_vld = 1;
1402 mac_data.tbl_ucast_mac_discard = 0;
1403 mac_data.tbl_ucast_old_en = 0;
1404 /* default config dvc to 0 */
1405 mac_data.tbl_ucast_dvc = 0;
1406 mac_data.tbl_ucast_out_port = mac_entry->port_num;
1407 hns_dsaf_tcam_uc_cfg(
1408 dsaf_dev, entry_index,
1409 (struct dsaf_tbl_tcam_data *)(&mac_key), &mac_data);
1410
1411 /* config software entry */
1412 soft_mac_entry += entry_index;
1413 soft_mac_entry->index = entry_index;
1414 soft_mac_entry->tcam_key.high.val = mac_key.high.val;
1415 soft_mac_entry->tcam_key.low.val = mac_key.low.val;
1416
1417 return 0;
1418}
1419
1420/**
1421 * hns_dsaf_set_mac_mc_entry - set mac mc-entry
1422 * @dsaf_dev: dsa fabric device struct pointer
1423 * @mac_entry: mc-mac entry
1424 */
1425int hns_dsaf_set_mac_mc_entry(
1426 struct dsaf_device *dsaf_dev,
1427 struct dsaf_drv_mac_multi_dest_entry *mac_entry)
1428{
1429 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1430 struct dsaf_drv_tbl_tcam_key mac_key;
1431 struct dsaf_tbl_tcam_mcast_cfg mac_data;
1432 struct dsaf_drv_priv *priv =
1433 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1434 struct dsaf_drv_soft_mac_tbl *soft_mac_entry = priv->soft_mac_tbl;
1435 struct dsaf_drv_tbl_tcam_key tmp_mac_key;
1436
1437 /* mac addr check */
1438 if (MAC_IS_ALL_ZEROS(mac_entry->addr)) {
98900a80
AS		 1439 dev_err(dsaf_dev->dev, "set uc %s Mac %pM err!\n",
1440 dsaf_dev->ae_dev.name, mac_entry->addr);
511e6bc0 1441 return -EINVAL;
1442 }
1443
1444 /*config key */
1445 hns_dsaf_set_mac_key(dsaf_dev, &mac_key,
1446 mac_entry->in_vlan_id,
1447 mac_entry->in_port_num, mac_entry->addr);
1448
1449 /* entry ie exist? */
1450 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1451 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1452 /*if hasnot, find enpty entry*/
1453 entry_index = hns_dsaf_find_empty_mac_entry(dsaf_dev);
1454 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1455 /*if hasnot empty, error*/
1456 dev_err(dsaf_dev->dev,
1457 "set_uc_entry failed, %s Mac key(%#x:%#x)\n",
1458 dsaf_dev->ae_dev.name,
1459 mac_key.high.val, mac_key.low.val);
1460 return -EINVAL;
1461 }
1462
1463 /* config hardware entry */
1464 memset(mac_data.tbl_mcast_port_msk,
1465 0, sizeof(mac_data.tbl_mcast_port_msk));
1466 } else {
1467 /* config hardware entry */
1468 hns_dsaf_tcam_mc_get(
1469 dsaf_dev, entry_index,
1470 (struct dsaf_tbl_tcam_data *)(&tmp_mac_key), &mac_data);
1471 }
1472 mac_data.tbl_mcast_old_en = 0;
1473 mac_data.tbl_mcast_item_vld = 1;
1474 dsaf_set_field(mac_data.tbl_mcast_port_msk[0],
1475 0x3F, 0, mac_entry->port_mask[0]);
1476
1477 dev_dbg(dsaf_dev->dev,
1478 "set_uc_entry, %s key(%#x:%#x) entry_index%d\n",
1479 dsaf_dev->ae_dev.name, mac_key.high.val,
1480 mac_key.low.val, entry_index);
1481
1482 hns_dsaf_tcam_mc_cfg(
1483 dsaf_dev, entry_index,
1484 (struct dsaf_tbl_tcam_data *)(&mac_key), &mac_data);
1485
1486 /* config software entry */
1487 soft_mac_entry += entry_index;
1488 soft_mac_entry->index = entry_index;
1489 soft_mac_entry->tcam_key.high.val = mac_key.high.val;
1490 soft_mac_entry->tcam_key.low.val = mac_key.low.val;
1491
1492 return 0;
1493}
1494
1495/**
1496 * hns_dsaf_add_mac_mc_port - add mac mc-port
1497 * @dsaf_dev: dsa fabric device struct pointer
1498 * @mac_entry: mc-mac entry
1499 */
1500int hns_dsaf_add_mac_mc_port(struct dsaf_device *dsaf_dev,
1501 struct dsaf_drv_mac_single_dest_entry *mac_entry)
1502{
1503 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1504 struct dsaf_drv_tbl_tcam_key mac_key;
1505 struct dsaf_tbl_tcam_mcast_cfg mac_data;
1506 struct dsaf_drv_priv *priv =
1507 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1508 struct dsaf_drv_soft_mac_tbl *soft_mac_entry = priv->soft_mac_tbl;
1509 struct dsaf_drv_tbl_tcam_key tmp_mac_key;
1510 int mskid;
1511
1512 /*chechk mac addr */
1513 if (MAC_IS_ALL_ZEROS(mac_entry->addr)) {
98900a80
AS		 1514 dev_err(dsaf_dev->dev, "set_entry failed,addr %pM!\n",
1515 mac_entry->addr);
511e6bc0 1516 return -EINVAL;
1517 }
1518
1519 /*config key */
1520 hns_dsaf_set_mac_key(
1521 dsaf_dev, &mac_key, mac_entry->in_vlan_id,
1522 mac_entry->in_port_num, mac_entry->addr);
1523
1524 memset(&mac_data, 0, sizeof(struct dsaf_tbl_tcam_mcast_cfg));
1525
1526 /*check exist? */
1527 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1528 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1529 /*if hasnot , find a empty*/
1530 entry_index = hns_dsaf_find_empty_mac_entry(dsaf_dev);
1531 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1532 /*if hasnot empty, error*/
1533 dev_err(dsaf_dev->dev,
1534 "set_uc_entry failed, %s Mac key(%#x:%#x)\n",
1535 dsaf_dev->ae_dev.name, mac_key.high.val,
1536 mac_key.low.val);
1537 return -EINVAL;
1538 }
1539 } else {
1540 /*if exist, add in */
1541 hns_dsaf_tcam_mc_get(
1542 dsaf_dev, entry_index,
1543 (struct dsaf_tbl_tcam_data *)(&tmp_mac_key), &mac_data);
1544 }
1545 /* config hardware entry */
1546 if (mac_entry->port_num < DSAF_SERVICE_NW_NUM) {
1547 mskid = mac_entry->port_num;
1548 } else if (mac_entry->port_num >= DSAF_BASE_INNER_PORT_NUM) {
1549 mskid = mac_entry->port_num -
1550 DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM;
1551 } else {
1552 dev_err(dsaf_dev->dev,
1553 "%s,pnum(%d)error,key(%#x:%#x)\n",
1554 dsaf_dev->ae_dev.name, mac_entry->port_num,
1555 mac_key.high.val, mac_key.low.val);
1556 return -EINVAL;
1557 }
1558 dsaf_set_bit(mac_data.tbl_mcast_port_msk[mskid / 32], mskid % 32, 1);
1559 mac_data.tbl_mcast_old_en = 0;
1560 mac_data.tbl_mcast_item_vld = 1;
1561
1562 dev_dbg(dsaf_dev->dev,
1563 "set_uc_entry, %s Mac key(%#x:%#x) entry_index%d\n",
1564 dsaf_dev->ae_dev.name, mac_key.high.val,
1565 mac_key.low.val, entry_index);
1566
1567 hns_dsaf_tcam_mc_cfg(
1568 dsaf_dev, entry_index,
1569 (struct dsaf_tbl_tcam_data *)(&mac_key), &mac_data);
1570
1571 /*config software entry */
1572 soft_mac_entry += entry_index;
1573 soft_mac_entry->index = entry_index;
1574 soft_mac_entry->tcam_key.high.val = mac_key.high.val;
1575 soft_mac_entry->tcam_key.low.val = mac_key.low.val;
1576
1577 return 0;
1578}
1579
1580/**
1581 * hns_dsaf_del_mac_entry - del mac mc-port
1582 * @dsaf_dev: dsa fabric device struct pointer
1583 * @vlan_id: vlian id
1584 * @in_port_num: input port num
1585 * @addr : mac addr
1586 */
1587int hns_dsaf_del_mac_entry(struct dsaf_device *dsaf_dev, u16 vlan_id,
1588 u8 in_port_num, u8 *addr)
1589{
1590 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1591 struct dsaf_drv_tbl_tcam_key mac_key;
1592 struct dsaf_drv_priv *priv =
1593 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1594 struct dsaf_drv_soft_mac_tbl *soft_mac_entry = priv->soft_mac_tbl;
1595
1596 /*check mac addr */
1597 if (MAC_IS_ALL_ZEROS(addr) || MAC_IS_BROADCAST(addr)) {
98900a80
AS		 1598 dev_err(dsaf_dev->dev, "del_entry failed,addr %pM!\n",
1599 addr);
511e6bc0 1600 return -EINVAL;
1601 }
1602
1603 /*config key */
1604 hns_dsaf_set_mac_key(dsaf_dev, &mac_key, vlan_id, in_port_num, addr);
1605
1606 /*exist ?*/
1607 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1608 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1609 /*not exist, error */
1610 dev_err(dsaf_dev->dev,
1611 "del_mac_entry failed, %s Mac key(%#x:%#x)\n",
1612 dsaf_dev->ae_dev.name,
1613 mac_key.high.val, mac_key.low.val);
1614 return -EINVAL;
1615 }
1616 dev_dbg(dsaf_dev->dev,
1617 "del_mac_entry, %s Mac key(%#x:%#x) entry_index%d\n",
1618 dsaf_dev->ae_dev.name, mac_key.high.val,
1619 mac_key.low.val, entry_index);
1620
1621 /*do del opt*/
1622 hns_dsaf_tcam_mc_invld(dsaf_dev, entry_index);
1623
1624 /*del soft emtry */
1625 soft_mac_entry += entry_index;
1626 soft_mac_entry->index = DSAF_INVALID_ENTRY_IDX;
1627
1628 return 0;
1629}
1630
1631/**
1632 * hns_dsaf_del_mac_mc_port - del mac mc- port
1633 * @dsaf_dev: dsa fabric device struct pointer
1634 * @mac_entry: mac entry
1635 */
1636int hns_dsaf_del_mac_mc_port(struct dsaf_device *dsaf_dev,
1637 struct dsaf_drv_mac_single_dest_entry *mac_entry)
1638{
1639 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1640 struct dsaf_drv_tbl_tcam_key mac_key;
1641 struct dsaf_drv_priv *priv =
1642 (struct dsaf_drv_priv *)hns_dsaf_dev_priv(dsaf_dev);
1643 struct dsaf_drv_soft_mac_tbl *soft_mac_entry = priv->soft_mac_tbl;
1644 u16 vlan_id;
1645 u8 in_port_num;
1646 struct dsaf_tbl_tcam_mcast_cfg mac_data;
1647 struct dsaf_drv_tbl_tcam_key tmp_mac_key;
1648 int mskid;
1649 const u8 empty_msk[sizeof(mac_data.tbl_mcast_port_msk)] = {0};
1650
1651 if (!(void *)mac_entry) {
1652 dev_err(dsaf_dev->dev,
1653 "hns_dsaf_del_mac_mc_port mac_entry is NULL\n");
1654 return -EINVAL;
1655 }
1656
1657 /*get key info*/
1658 vlan_id = mac_entry->in_vlan_id;
1659 in_port_num = mac_entry->in_port_num;
1660
1661 /*check mac addr */
1662 if (MAC_IS_ALL_ZEROS(mac_entry->addr)) {
98900a80
AS		 1663 dev_err(dsaf_dev->dev, "del_port failed, addr %pM!\n",
1664 mac_entry->addr);
511e6bc0 1665 return -EINVAL;
1666 }
1667
1668 /*config key */
1669 hns_dsaf_set_mac_key(dsaf_dev, &mac_key, vlan_id, in_port_num,
1670 mac_entry->addr);
1671
1672 /*check is exist? */
1673 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1674 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1675 /*find none */
1676 dev_err(dsaf_dev->dev,
1677 "find_soft_mac_entry failed, %s Mac key(%#x:%#x)\n",
1678 dsaf_dev->ae_dev.name,
1679 mac_key.high.val, mac_key.low.val);
1680 return -EINVAL;
1681 }
1682
1683 dev_dbg(dsaf_dev->dev,
1684 "del_mac_mc_port, %s key(%#x:%#x) index%d\n",
1685 dsaf_dev->ae_dev.name, mac_key.high.val,
1686 mac_key.low.val, entry_index);
1687
1688 /*read entry*/
1689 hns_dsaf_tcam_mc_get(
1690 dsaf_dev, entry_index,
1691 (struct dsaf_tbl_tcam_data *)(&tmp_mac_key), &mac_data);
1692
1693 /*del the port*/
1694 if (mac_entry->port_num < DSAF_SERVICE_NW_NUM) {
1695 mskid = mac_entry->port_num;
1696 } else if (mac_entry->port_num >= DSAF_BASE_INNER_PORT_NUM) {
1697 mskid = mac_entry->port_num -
1698 DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM;
1699 } else {
1700 dev_err(dsaf_dev->dev,
1701 "%s,pnum(%d)error,key(%#x:%#x)\n",
1702 dsaf_dev->ae_dev.name, mac_entry->port_num,
1703 mac_key.high.val, mac_key.low.val);
1704 return -EINVAL;
1705 }
1706 dsaf_set_bit(mac_data.tbl_mcast_port_msk[mskid / 32], mskid % 32, 0);
1707
1708 /*check non port, do del entry */
1709 if (!memcmp(mac_data.tbl_mcast_port_msk, empty_msk,
1710 sizeof(mac_data.tbl_mcast_port_msk))) {
1711 hns_dsaf_tcam_mc_invld(dsaf_dev, entry_index);
1712
1713 /* del soft entry */
1714 soft_mac_entry += entry_index;
1715 soft_mac_entry->index = DSAF_INVALID_ENTRY_IDX;
1716 } else { /* not zer, just del port, updata*/
1717 hns_dsaf_tcam_mc_cfg(
1718 dsaf_dev, entry_index,
1719 (struct dsaf_tbl_tcam_data *)(&mac_key), &mac_data);
1720 }
1721
1722 return 0;
1723}
1724
1725/**
1726 * hns_dsaf_get_mac_uc_entry - get mac uc entry
1727 * @dsaf_dev: dsa fabric device struct pointer
1728 * @mac_entry: mac entry
1729 */
1730int hns_dsaf_get_mac_uc_entry(struct dsaf_device *dsaf_dev,
1731 struct dsaf_drv_mac_single_dest_entry *mac_entry)
1732{
1733 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1734 struct dsaf_drv_tbl_tcam_key mac_key;
1735
1736 struct dsaf_tbl_tcam_ucast_cfg mac_data;
1737
1738 /* check macaddr */
1739 if (MAC_IS_ALL_ZEROS(mac_entry->addr) ||
1740 MAC_IS_BROADCAST(mac_entry->addr)) {
98900a80
AS		 1741 dev_err(dsaf_dev->dev, "get_entry failed,addr %pM\n",
1742 mac_entry->addr);
511e6bc0 1743 return -EINVAL;
1744 }
1745
1746 /*config key */
1747 hns_dsaf_set_mac_key(dsaf_dev, &mac_key, mac_entry->in_vlan_id,
1748 mac_entry->in_port_num, mac_entry->addr);
1749
1750 /*check exist? */
1751 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1752 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1753 /*find none, error */
1754 dev_err(dsaf_dev->dev,
1755 "get_uc_entry failed, %s Mac key(%#x:%#x)\n",
1756 dsaf_dev->ae_dev.name,
1757 mac_key.high.val, mac_key.low.val);
1758 return -EINVAL;
1759 }
1760 dev_dbg(dsaf_dev->dev,
1761 "get_uc_entry, %s Mac key(%#x:%#x) entry_index%d\n",
1762 dsaf_dev->ae_dev.name, mac_key.high.val,
1763 mac_key.low.val, entry_index);
1764
1765 /*read entry*/
1766 hns_dsaf_tcam_uc_get(dsaf_dev, entry_index,
1767 (struct dsaf_tbl_tcam_data *)&mac_key, &mac_data);
1768 mac_entry->port_num = mac_data.tbl_ucast_out_port;
1769
1770 return 0;
1771}
1772
1773/**
1774 * hns_dsaf_get_mac_mc_entry - get mac mc entry
1775 * @dsaf_dev: dsa fabric device struct pointer
1776 * @mac_entry: mac entry
1777 */
1778int hns_dsaf_get_mac_mc_entry(struct dsaf_device *dsaf_dev,
1779 struct dsaf_drv_mac_multi_dest_entry *mac_entry)
1780{
1781 u16 entry_index = DSAF_INVALID_ENTRY_IDX;
1782 struct dsaf_drv_tbl_tcam_key mac_key;
1783
1784 struct dsaf_tbl_tcam_mcast_cfg mac_data;
1785
1786 /*check mac addr */
1787 if (MAC_IS_ALL_ZEROS(mac_entry->addr) ||
1788 MAC_IS_BROADCAST(mac_entry->addr)) {
98900a80
AS		 1789 dev_err(dsaf_dev->dev, "get_entry failed,addr %pM\n",
1790 mac_entry->addr);
511e6bc0 1791 return -EINVAL;
1792 }
1793
1794 /*config key */
1795 hns_dsaf_set_mac_key(dsaf_dev, &mac_key, mac_entry->in_vlan_id,
1796 mac_entry->in_port_num, mac_entry->addr);
1797
1798 /*check exist? */
1799 entry_index = hns_dsaf_find_soft_mac_entry(dsaf_dev, &mac_key);
1800 if (entry_index == DSAF_INVALID_ENTRY_IDX) {
1801 /* find none, error */
1802 dev_err(dsaf_dev->dev,
1803 "get_mac_uc_entry failed, %s Mac key(%#x:%#x)\n",
1804 dsaf_dev->ae_dev.name, mac_key.high.val,
1805 mac_key.low.val);
1806 return -EINVAL;
1807 }
1808 dev_dbg(dsaf_dev->dev,
1809 "get_mac_uc_entry, %s Mac key(%#x:%#x) entry_index%d\n",
1810 dsaf_dev->ae_dev.name, mac_key.high.val,
1811 mac_key.low.val, entry_index);
1812
1813 /*read entry */
1814 hns_dsaf_tcam_mc_get(dsaf_dev, entry_index,
1815 (struct dsaf_tbl_tcam_data *)&mac_key, &mac_data);
1816
1817 mac_entry->port_mask[0] = mac_data.tbl_mcast_port_msk[0] & 0x3F;
1818 return 0;
1819}
1820
1821/**
1822 * hns_dsaf_get_mac_entry_by_index - get mac entry by tab index
1823 * @dsaf_dev: dsa fabric device struct pointer
1824 * @entry_index: tab entry index
1825 * @mac_entry: mac entry
1826 */
1827int hns_dsaf_get_mac_entry_by_index(
1828 struct dsaf_device *dsaf_dev,
1829 u16 entry_index, struct dsaf_drv_mac_multi_dest_entry *mac_entry)
1830{
1831 struct dsaf_drv_tbl_tcam_key mac_key;
1832
1833 struct dsaf_tbl_tcam_mcast_cfg mac_data;
1834 struct dsaf_tbl_tcam_ucast_cfg mac_uc_data;
1835 char mac_addr[MAC_NUM_OCTETS_PER_ADDR] = {0};
1836
1837 if (entry_index >= DSAF_TCAM_SUM) {
1838 /* find none, del error */
1839 dev_err(dsaf_dev->dev, "get_uc_entry failed, %s\n",
1840 dsaf_dev->ae_dev.name);
1841 return -EINVAL;
1842 }
1843
1844 /* mc entry, do read opt */
1845 hns_dsaf_tcam_mc_get(dsaf_dev, entry_index,
1846 (struct dsaf_tbl_tcam_data *)&mac_key, &mac_data);
1847
1848 mac_entry->port_mask[0] = mac_data.tbl_mcast_port_msk[0] & 0x3F;
1849
1850 /***get mac addr*/
1851 mac_addr[0] = mac_key.high.bits.mac_0;
1852 mac_addr[1] = mac_key.high.bits.mac_1;
1853 mac_addr[2] = mac_key.high.bits.mac_2;
1854 mac_addr[3] = mac_key.high.bits.mac_3;
1855 mac_addr[4] = mac_key.low.bits.mac_4;
1856 mac_addr[5] = mac_key.low.bits.mac_5;
1857 /**is mc or uc*/
1858 if (MAC_IS_MULTICAST((u8 *)mac_addr) ||
1859 MAC_IS_L3_MULTICAST((u8 *)mac_addr)) {
1860 /**mc donot do*/
1861 } else {
1862 /*is not mc, just uc... */
1863 hns_dsaf_tcam_uc_get(dsaf_dev, entry_index,
1864 (struct dsaf_tbl_tcam_data *)&mac_key,
1865 &mac_uc_data);
1866 mac_entry->port_mask[0] = (1 << mac_uc_data.tbl_ucast_out_port);
1867 }
1868
1869 return 0;
1870}
1871
1872static struct dsaf_device *hns_dsaf_alloc_dev(struct device *dev,
1873 size_t sizeof_priv)
1874{
1875 struct dsaf_device *dsaf_dev;
1876
1877 dsaf_dev = devm_kzalloc(dev,
1878 sizeof(*dsaf_dev) + sizeof_priv, GFP_KERNEL);
1879 if (unlikely(!dsaf_dev)) {
1880 dsaf_dev = ERR_PTR(-ENOMEM);
1881 } else {
1882 dsaf_dev->dev = dev;
1883 dev_set_drvdata(dev, dsaf_dev);
1884 }
1885
1886 return dsaf_dev;
1887}
1888
1889/**
1890 * hns_dsaf_free_dev - free dev mem
1891 * @dev: struct device pointer
1892 */
1893static void hns_dsaf_free_dev(struct dsaf_device *dsaf_dev)
1894{
1895 (void)dev_set_drvdata(dsaf_dev->dev, NULL);
1896}
1897
1898/**
1899 * dsaf_pfc_unit_cnt - set pfc unit count
1900 * @dsaf_id: dsa fabric id
1901 * @pport_rate: value array
1902 * @pdsaf_pfc_unit_cnt: value array
1903 */
1904static void hns_dsaf_pfc_unit_cnt(struct dsaf_device *dsaf_dev, int mac_id,
1905 enum dsaf_port_rate_mode rate)
1906{
1907 u32 unit_cnt;
1908
1909 switch (rate) {
1910 case DSAF_PORT_RATE_10000:
1911 unit_cnt = HNS_DSAF_PFC_UNIT_CNT_FOR_XGE;
1912 break;
1913 case DSAF_PORT_RATE_1000:
1914 unit_cnt = HNS_DSAF_PFC_UNIT_CNT_FOR_GE_1000;
1915 break;
1916 case DSAF_PORT_RATE_2500:
1917 unit_cnt = HNS_DSAF_PFC_UNIT_CNT_FOR_GE_1000;
1918 break;
1919 default:
1920 unit_cnt = HNS_DSAF_PFC_UNIT_CNT_FOR_XGE;
1921 }
1922
1923 dsaf_set_dev_field(dsaf_dev,
1924 (DSAF_PFC_UNIT_CNT_0_REG + 0x4 * (u64)mac_id),
1925 DSAF_PFC_UNINT_CNT_M, DSAF_PFC_UNINT_CNT_S,
1926 unit_cnt);
1927}
1928
1929/**
1930 * dsaf_port_work_rate_cfg - fifo
1931 * @dsaf_id: dsa fabric id
1932 * @xge_ge_work_mode
1933 */
1934void hns_dsaf_port_work_rate_cfg(struct dsaf_device *dsaf_dev, int mac_id,
1935 enum dsaf_port_rate_mode rate_mode)
1936{
1937 u32 port_work_mode;
1938
1939 port_work_mode = dsaf_read_dev(
1940 dsaf_dev, DSAF_XGE_GE_WORK_MODE_0_REG + 0x4 * (u64)mac_id);
1941
1942 if (rate_mode == DSAF_PORT_RATE_10000)
1943 dsaf_set_bit(port_work_mode, DSAF_XGE_GE_WORK_MODE_S, 1);
1944 else
1945 dsaf_set_bit(port_work_mode, DSAF_XGE_GE_WORK_MODE_S, 0);
1946
1947 dsaf_write_dev(dsaf_dev,
1948 DSAF_XGE_GE_WORK_MODE_0_REG + 0x4 * (u64)mac_id,
1949 port_work_mode);
1950
1951 hns_dsaf_pfc_unit_cnt(dsaf_dev, mac_id, rate_mode);
1952}
1953
1954/**
1955 * hns_dsaf_fix_mac_mode - dsaf modify mac mode
1956 * @mac_cb: mac contrl block
1957 */
1958void hns_dsaf_fix_mac_mode(struct hns_mac_cb *mac_cb)
1959{
1960 enum dsaf_port_rate_mode mode;
1961 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
1962 int mac_id = mac_cb->mac_id;
1963
1964 if (mac_cb->mac_type != HNAE_PORT_SERVICE)
1965 return;
1966 if (mac_cb->phy_if == PHY_INTERFACE_MODE_XGMII)
1967 mode = DSAF_PORT_RATE_10000;
1968 else
1969 mode = DSAF_PORT_RATE_1000;
1970
1971 hns_dsaf_port_work_rate_cfg(dsaf_dev, mac_id, mode);
1972}
1973
1974void hns_dsaf_update_stats(struct dsaf_device *dsaf_dev, u32 node_num)
1975{
1976 struct dsaf_hw_stats *hw_stats
1977 = &dsaf_dev->hw_stats[node_num];
1978
1979 hw_stats->pad_drop += dsaf_read_dev(dsaf_dev,
1980 DSAF_INODE_PAD_DISCARD_NUM_0_REG + 0x80 * (u64)node_num);
1981 hw_stats->man_pkts += dsaf_read_dev(dsaf_dev,
1982 DSAF_INODE_FINAL_IN_MAN_NUM_0_REG + 0x80 * (u64)node_num);
1983 hw_stats->rx_pkts += dsaf_read_dev(dsaf_dev,
1984 DSAF_INODE_FINAL_IN_PKT_NUM_0_REG + 0x80 * (u64)node_num);
1985 hw_stats->rx_pkt_id += dsaf_read_dev(dsaf_dev,
1986 DSAF_INODE_SBM_PID_NUM_0_REG + 0x80 * (u64)node_num);
1987 hw_stats->rx_pause_frame += dsaf_read_dev(dsaf_dev,
1988 DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG + 0x80 * (u64)node_num);
1989 hw_stats->release_buf_num += dsaf_read_dev(dsaf_dev,
1990 DSAF_INODE_SBM_RELS_NUM_0_REG + 0x80 * (u64)node_num);
1991 hw_stats->sbm_drop += dsaf_read_dev(dsaf_dev,
1992 DSAF_INODE_SBM_DROP_NUM_0_REG + 0x80 * (u64)node_num);
1993 hw_stats->crc_false += dsaf_read_dev(dsaf_dev,
1994 DSAF_INODE_CRC_FALSE_NUM_0_REG + 0x80 * (u64)node_num);
1995 hw_stats->bp_drop += dsaf_read_dev(dsaf_dev,
1996 DSAF_INODE_BP_DISCARD_NUM_0_REG + 0x80 * (u64)node_num);
1997 hw_stats->rslt_drop += dsaf_read_dev(dsaf_dev,
1998 DSAF_INODE_RSLT_DISCARD_NUM_0_REG + 0x80 * (u64)node_num);
1999 hw_stats->local_addr_false += dsaf_read_dev(dsaf_dev,
2000 DSAF_INODE_LOCAL_ADDR_FALSE_NUM_0_REG + 0x80 * (u64)node_num);
2001
2002 hw_stats->vlan_drop += dsaf_read_dev(dsaf_dev,
2003 DSAF_INODE_SW_VLAN_TAG_DISC_0_REG + 0x80 * (u64)node_num);
2004 hw_stats->stp_drop += dsaf_read_dev(dsaf_dev,
2005 DSAF_INODE_IN_DATA_STP_DISC_0_REG + 0x80 * (u64)node_num);
2006
2007 hw_stats->tx_pkts += dsaf_read_dev(dsaf_dev,
2008 DSAF_XOD_RCVPKT_CNT_0_REG + 0x90 * (u64)node_num);
2009}
2010
2011/**
2012 *hns_dsaf_get_regs - dump dsaf regs
2013 *@dsaf_dev: dsaf device
2014 *@data:data for value of regs
2015 */
2016void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data)
2017{
2018 u32 i = 0;
2019 u32 j;
2020 u32 *p = data;
2021
2022 /* dsaf common registers */
2023 p[0] = dsaf_read_dev(ddev, DSAF_SRAM_INIT_OVER_0_REG);
2024 p[1] = dsaf_read_dev(ddev, DSAF_CFG_0_REG);
2025 p[2] = dsaf_read_dev(ddev, DSAF_ECC_ERR_INVERT_0_REG);
2026 p[3] = dsaf_read_dev(ddev, DSAF_ABNORMAL_TIMEOUT_0_REG);
2027 p[4] = dsaf_read_dev(ddev, DSAF_FSM_TIMEOUT_0_REG);
2028 p[5] = dsaf_read_dev(ddev, DSAF_DSA_REG_CNT_CLR_CE_REG);
2029 p[6] = dsaf_read_dev(ddev, DSAF_DSA_SBM_INF_FIFO_THRD_REG);
2030 p[7] = dsaf_read_dev(ddev, DSAF_DSA_SRAM_1BIT_ECC_SEL_REG);
2031 p[8] = dsaf_read_dev(ddev, DSAF_DSA_SRAM_1BIT_ECC_CNT_REG);
2032
2033 p[9] = dsaf_read_dev(ddev, DSAF_PFC_EN_0_REG + port * 4);
2034 p[10] = dsaf_read_dev(ddev, DSAF_PFC_UNIT_CNT_0_REG + port * 4);
2035 p[11] = dsaf_read_dev(ddev, DSAF_XGE_INT_MSK_0_REG + port * 4);
2036 p[12] = dsaf_read_dev(ddev, DSAF_XGE_INT_SRC_0_REG + port * 4);
2037 p[13] = dsaf_read_dev(ddev, DSAF_XGE_INT_STS_0_REG + port * 4);
2038 p[14] = dsaf_read_dev(ddev, DSAF_XGE_INT_MSK_0_REG + port * 4);
2039 p[15] = dsaf_read_dev(ddev, DSAF_PPE_INT_MSK_0_REG + port * 4);
2040 p[16] = dsaf_read_dev(ddev, DSAF_ROCEE_INT_MSK_0_REG + port * 4);
2041 p[17] = dsaf_read_dev(ddev, DSAF_XGE_INT_SRC_0_REG + port * 4);
2042 p[18] = dsaf_read_dev(ddev, DSAF_PPE_INT_SRC_0_REG + port * 4);
2043 p[19] = dsaf_read_dev(ddev, DSAF_ROCEE_INT_SRC_0_REG + port * 4);
2044 p[20] = dsaf_read_dev(ddev, DSAF_XGE_INT_STS_0_REG + port * 4);
2045 p[21] = dsaf_read_dev(ddev, DSAF_PPE_INT_STS_0_REG + port * 4);
2046 p[22] = dsaf_read_dev(ddev, DSAF_ROCEE_INT_STS_0_REG + port * 4);
2047 p[23] = dsaf_read_dev(ddev, DSAF_PPE_QID_CFG_0_REG + port * 4);
2048
2049 for (i = 0; i < DSAF_SW_PORT_NUM; i++)
2050 p[24 + i] = dsaf_read_dev(ddev,
2051 DSAF_SW_PORT_TYPE_0_REG + i * 4);
2052
2053 p[32] = dsaf_read_dev(ddev, DSAF_MIX_DEF_QID_0_REG + port * 4);
2054
2055 for (i = 0; i < DSAF_SW_PORT_NUM; i++)
2056 p[33 + i] = dsaf_read_dev(ddev,
2057 DSAF_PORT_DEF_VLAN_0_REG + i * 4);
2058
2059 for (i = 0; i < DSAF_TOTAL_QUEUE_NUM; i++)
2060 p[41 + i] = dsaf_read_dev(ddev,
2061 DSAF_VM_DEF_VLAN_0_REG + i * 4);
2062
2063 /* dsaf inode registers */
2064 p[170] = dsaf_read_dev(ddev, DSAF_INODE_CUT_THROUGH_CFG_0_REG);
2065
2066 p[171] = dsaf_read_dev(ddev,
2067 DSAF_INODE_ECC_ERR_ADDR_0_REG + port * 0x80);
2068
2069 for (i = 0; i < DSAF_INODE_NUM / DSAF_COMM_CHN; i++) {
2070 j = i * DSAF_COMM_CHN + port;
2071 p[172 + i] = dsaf_read_dev(ddev,
2072 DSAF_INODE_IN_PORT_NUM_0_REG + j * 0x80);
2073 p[175 + i] = dsaf_read_dev(ddev,
2074 DSAF_INODE_PRI_TC_CFG_0_REG + j * 0x80);
2075 p[178 + i] = dsaf_read_dev(ddev,
2076 DSAF_INODE_BP_STATUS_0_REG + j * 0x80);
2077 p[181 + i] = dsaf_read_dev(ddev,
2078 DSAF_INODE_PAD_DISCARD_NUM_0_REG + j * 0x80);
2079 p[184 + i] = dsaf_read_dev(ddev,
2080 DSAF_INODE_FINAL_IN_MAN_NUM_0_REG + j * 0x80);
2081 p[187 + i] = dsaf_read_dev(ddev,
2082 DSAF_INODE_FINAL_IN_PKT_NUM_0_REG + j * 0x80);
2083 p[190 + i] = dsaf_read_dev(ddev,
2084 DSAF_INODE_SBM_PID_NUM_0_REG + j * 0x80);
2085 p[193 + i] = dsaf_read_dev(ddev,
2086 DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG + j * 0x80);
2087 p[196 + i] = dsaf_read_dev(ddev,
2088 DSAF_INODE_SBM_RELS_NUM_0_REG + j * 0x80);
2089 p[199 + i] = dsaf_read_dev(ddev,
2090 DSAF_INODE_SBM_DROP_NUM_0_REG + j * 0x80);
2091 p[202 + i] = dsaf_read_dev(ddev,
2092 DSAF_INODE_CRC_FALSE_NUM_0_REG + j * 0x80);
2093 p[205 + i] = dsaf_read_dev(ddev,
2094 DSAF_INODE_BP_DISCARD_NUM_0_REG + j * 0x80);
2095 p[208 + i] = dsaf_read_dev(ddev,
2096 DSAF_INODE_RSLT_DISCARD_NUM_0_REG + j * 0x80);
2097 p[211 + i] = dsaf_read_dev(ddev,
2098 DSAF_INODE_LOCAL_ADDR_FALSE_NUM_0_REG + j * 0x80);
2099 p[214 + i] = dsaf_read_dev(ddev,
2100 DSAF_INODE_VOQ_OVER_NUM_0_REG + j * 0x80);
2101 p[217 + i] = dsaf_read_dev(ddev,
2102 DSAF_INODE_BD_SAVE_STATUS_0_REG + j * 4);
2103 p[220 + i] = dsaf_read_dev(ddev,
2104 DSAF_INODE_BD_ORDER_STATUS_0_REG + j * 4);
2105 p[223 + i] = dsaf_read_dev(ddev,
2106 DSAF_INODE_SW_VLAN_TAG_DISC_0_REG + j * 4);
2107 p[224 + i] = dsaf_read_dev(ddev,
2108 DSAF_INODE_IN_DATA_STP_DISC_0_REG + j * 4);
2109 }
2110
2111 p[227] = dsaf_read_dev(ddev, DSAF_INODE_GE_FC_EN_0_REG + port * 4);
2112
2113 for (i = 0; i < DSAF_INODE_NUM / DSAF_COMM_CHN; i++) {
2114 j = i * DSAF_COMM_CHN + port;
2115 p[228 + i] = dsaf_read_dev(ddev,
2116 DSAF_INODE_VC0_IN_PKT_NUM_0_REG + j * 4);
2117 }
2118
2119 p[231] = dsaf_read_dev(ddev,
2120 DSAF_INODE_VC1_IN_PKT_NUM_0_REG + port * 4);
2121
2122 /* dsaf inode registers */
13ac695e 2123 for (i = 0; i < HNS_DSAF_SBM_NUM(ddev) / DSAF_COMM_CHN; i++) {
511e6bc0 2124 j = i * DSAF_COMM_CHN + port;
2125 p[232 + i] = dsaf_read_dev(ddev,
2126 DSAF_SBM_CFG_REG_0_REG + j * 0x80);
2127 p[235 + i] = dsaf_read_dev(ddev,
2128 DSAF_SBM_BP_CFG_0_XGE_REG_0_REG + j * 0x80);
2129 p[238 + i] = dsaf_read_dev(ddev,
2130 DSAF_SBM_BP_CFG_1_REG_0_REG + j * 0x80);
2131 p[241 + i] = dsaf_read_dev(ddev,
2132 DSAF_SBM_BP_CFG_2_XGE_REG_0_REG + j * 0x80);
2133 p[244 + i] = dsaf_read_dev(ddev,
2134 DSAF_SBM_FREE_CNT_0_0_REG + j * 0x80);
2135 p[245 + i] = dsaf_read_dev(ddev,
2136 DSAF_SBM_FREE_CNT_1_0_REG + j * 0x80);
2137 p[248 + i] = dsaf_read_dev(ddev,
2138 DSAF_SBM_BP_CNT_0_0_REG + j * 0x80);
2139 p[251 + i] = dsaf_read_dev(ddev,
2140 DSAF_SBM_BP_CNT_1_0_REG + j * 0x80);
2141 p[254 + i] = dsaf_read_dev(ddev,
2142 DSAF_SBM_BP_CNT_2_0_REG + j * 0x80);
2143 p[257 + i] = dsaf_read_dev(ddev,
2144 DSAF_SBM_BP_CNT_3_0_REG + j * 0x80);
2145 p[260 + i] = dsaf_read_dev(ddev,
2146 DSAF_SBM_INER_ST_0_REG + j * 0x80);
2147 p[263 + i] = dsaf_read_dev(ddev,
2148 DSAF_SBM_MIB_REQ_FAILED_TC_0_REG + j * 0x80);
2149 p[266 + i] = dsaf_read_dev(ddev,
2150 DSAF_SBM_LNK_INPORT_CNT_0_REG + j * 0x80);
2151 p[269 + i] = dsaf_read_dev(ddev,
2152 DSAF_SBM_LNK_DROP_CNT_0_REG + j * 0x80);
2153 p[272 + i] = dsaf_read_dev(ddev,
2154 DSAF_SBM_INF_OUTPORT_CNT_0_REG + j * 0x80);
2155 p[275 + i] = dsaf_read_dev(ddev,
2156 DSAF_SBM_LNK_INPORT_TC0_CNT_0_REG + j * 0x80);
2157 p[278 + i] = dsaf_read_dev(ddev,
2158 DSAF_SBM_LNK_INPORT_TC1_CNT_0_REG + j * 0x80);
2159 p[281 + i] = dsaf_read_dev(ddev,
2160 DSAF_SBM_LNK_INPORT_TC2_CNT_0_REG + j * 0x80);
2161 p[284 + i] = dsaf_read_dev(ddev,
2162 DSAF_SBM_LNK_INPORT_TC3_CNT_0_REG + j * 0x80);
2163 p[287 + i] = dsaf_read_dev(ddev,
2164 DSAF_SBM_LNK_INPORT_TC4_CNT_0_REG + j * 0x80);
2165 p[290 + i] = dsaf_read_dev(ddev,
2166 DSAF_SBM_LNK_INPORT_TC5_CNT_0_REG + j * 0x80);
2167 p[293 + i] = dsaf_read_dev(ddev,
2168 DSAF_SBM_LNK_INPORT_TC6_CNT_0_REG + j * 0x80);
2169 p[296 + i] = dsaf_read_dev(ddev,
2170 DSAF_SBM_LNK_INPORT_TC7_CNT_0_REG + j * 0x80);
2171 p[299 + i] = dsaf_read_dev(ddev,
2172 DSAF_SBM_LNK_REQ_CNT_0_REG + j * 0x80);
2173 p[302 + i] = dsaf_read_dev(ddev,
2174 DSAF_SBM_LNK_RELS_CNT_0_REG + j * 0x80);
2175 p[305 + i] = dsaf_read_dev(ddev,
2176 DSAF_SBM_BP_CFG_3_REG_0_REG + j * 0x80);
2177 p[308 + i] = dsaf_read_dev(ddev,
2178 DSAF_SBM_BP_CFG_4_REG_0_REG + j * 0x80);
2179 }
2180
2181 /* dsaf onode registers */
2182 for (i = 0; i < DSAF_XOD_NUM; i++) {
2183 p[311 + i] = dsaf_read_dev(ddev,
2184 DSAF_XOD_ETS_TSA_TC0_TC3_CFG_0_REG + j * 0x90);
2185 p[319 + i] = dsaf_read_dev(ddev,
2186 DSAF_XOD_ETS_TSA_TC4_TC7_CFG_0_REG + j * 0x90);
2187 p[327 + i] = dsaf_read_dev(ddev,
2188 DSAF_XOD_ETS_BW_TC0_TC3_CFG_0_REG + j * 0x90);
2189 p[335 + i] = dsaf_read_dev(ddev,
2190 DSAF_XOD_ETS_BW_TC4_TC7_CFG_0_REG + j * 0x90);
2191 p[343 + i] = dsaf_read_dev(ddev,
2192 DSAF_XOD_ETS_BW_OFFSET_CFG_0_REG + j * 0x90);
2193 p[351 + i] = dsaf_read_dev(ddev,
2194 DSAF_XOD_ETS_TOKEN_CFG_0_REG + j * 0x90);
2195 }
2196
2197 p[359] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_0_0_REG + port * 0x90);
2198 p[360] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_1_0_REG + port * 0x90);
2199 p[361] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_2_0_REG + port * 0x90);
2200
2201 for (i = 0; i < DSAF_XOD_BIG_NUM / DSAF_COMM_CHN; i++) {
2202 j = i * DSAF_COMM_CHN + port;
2203 p[362 + i] = dsaf_read_dev(ddev,
2204 DSAF_XOD_GNT_L_0_REG + j * 0x90);
2205 p[365 + i] = dsaf_read_dev(ddev,
2206 DSAF_XOD_GNT_H_0_REG + j * 0x90);
2207 p[368 + i] = dsaf_read_dev(ddev,
2208 DSAF_XOD_CONNECT_STATE_0_REG + j * 0x90);
2209 p[371 + i] = dsaf_read_dev(ddev,
2210 DSAF_XOD_RCVPKT_CNT_0_REG + j * 0x90);
2211 p[374 + i] = dsaf_read_dev(ddev,
2212 DSAF_XOD_RCVTC0_CNT_0_REG + j * 0x90);
2213 p[377 + i] = dsaf_read_dev(ddev,
2214 DSAF_XOD_RCVTC1_CNT_0_REG + j * 0x90);
2215 p[380 + i] = dsaf_read_dev(ddev,
2216 DSAF_XOD_RCVTC2_CNT_0_REG + j * 0x90);
2217 p[383 + i] = dsaf_read_dev(ddev,
2218 DSAF_XOD_RCVTC3_CNT_0_REG + j * 0x90);
2219 p[386 + i] = dsaf_read_dev(ddev,
2220 DSAF_XOD_RCVVC0_CNT_0_REG + j * 0x90);
2221 p[389 + i] = dsaf_read_dev(ddev,
2222 DSAF_XOD_RCVVC1_CNT_0_REG + j * 0x90);
2223 }
2224
2225 p[392] = dsaf_read_dev(ddev,
2226 DSAF_XOD_XGE_RCVIN0_CNT_0_REG + port * 0x90);
2227 p[393] = dsaf_read_dev(ddev,
2228 DSAF_XOD_XGE_RCVIN1_CNT_0_REG + port * 0x90);
2229 p[394] = dsaf_read_dev(ddev,
2230 DSAF_XOD_XGE_RCVIN2_CNT_0_REG + port * 0x90);
2231 p[395] = dsaf_read_dev(ddev,
2232 DSAF_XOD_XGE_RCVIN3_CNT_0_REG + port * 0x90);
2233 p[396] = dsaf_read_dev(ddev,
2234 DSAF_XOD_XGE_RCVIN4_CNT_0_REG + port * 0x90);
2235 p[397] = dsaf_read_dev(ddev,
2236 DSAF_XOD_XGE_RCVIN5_CNT_0_REG + port * 0x90);
2237 p[398] = dsaf_read_dev(ddev,
2238 DSAF_XOD_XGE_RCVIN6_CNT_0_REG + port * 0x90);
2239 p[399] = dsaf_read_dev(ddev,
2240 DSAF_XOD_XGE_RCVIN7_CNT_0_REG + port * 0x90);
2241 p[400] = dsaf_read_dev(ddev,
2242 DSAF_XOD_PPE_RCVIN0_CNT_0_REG + port * 0x90);
2243 p[401] = dsaf_read_dev(ddev,
2244 DSAF_XOD_PPE_RCVIN1_CNT_0_REG + port * 0x90);
2245 p[402] = dsaf_read_dev(ddev,
2246 DSAF_XOD_ROCEE_RCVIN0_CNT_0_REG + port * 0x90);
2247 p[403] = dsaf_read_dev(ddev,
2248 DSAF_XOD_ROCEE_RCVIN1_CNT_0_REG + port * 0x90);
2249 p[404] = dsaf_read_dev(ddev,
2250 DSAF_XOD_FIFO_STATUS_0_REG + port * 0x90);
2251
2252 /* dsaf voq registers */
2253 for (i = 0; i < DSAF_VOQ_NUM / DSAF_COMM_CHN; i++) {
2254 j = (i * DSAF_COMM_CHN + port) * 0x90;
2255 p[405 + i] = dsaf_read_dev(ddev,
2256 DSAF_VOQ_ECC_INVERT_EN_0_REG + j);
2257 p[408 + i] = dsaf_read_dev(ddev,
2258 DSAF_VOQ_SRAM_PKT_NUM_0_REG + j);
2259 p[411 + i] = dsaf_read_dev(ddev, DSAF_VOQ_IN_PKT_NUM_0_REG + j);
2260 p[414 + i] = dsaf_read_dev(ddev,
2261 DSAF_VOQ_OUT_PKT_NUM_0_REG + j);
2262 p[417 + i] = dsaf_read_dev(ddev,
2263 DSAF_VOQ_ECC_ERR_ADDR_0_REG + j);
2264 p[420 + i] = dsaf_read_dev(ddev, DSAF_VOQ_BP_STATUS_0_REG + j);
2265 p[423 + i] = dsaf_read_dev(ddev, DSAF_VOQ_SPUP_IDLE_0_REG + j);
2266 p[426 + i] = dsaf_read_dev(ddev,
2267 DSAF_VOQ_XGE_XOD_REQ_0_0_REG + j);
2268 p[429 + i] = dsaf_read_dev(ddev,
2269 DSAF_VOQ_XGE_XOD_REQ_1_0_REG + j);
2270 p[432 + i] = dsaf_read_dev(ddev,
2271 DSAF_VOQ_PPE_XOD_REQ_0_REG + j);
2272 p[435 + i] = dsaf_read_dev(ddev,
2273 DSAF_VOQ_ROCEE_XOD_REQ_0_REG + j);
2274 p[438 + i] = dsaf_read_dev(ddev,
2275 DSAF_VOQ_BP_ALL_THRD_0_REG + j);
2276 }
2277
2278 /* dsaf tbl registers */
2279 p[441] = dsaf_read_dev(ddev, DSAF_TBL_CTRL_0_REG);
2280 p[442] = dsaf_read_dev(ddev, DSAF_TBL_INT_MSK_0_REG);
2281 p[443] = dsaf_read_dev(ddev, DSAF_TBL_INT_SRC_0_REG);
2282 p[444] = dsaf_read_dev(ddev, DSAF_TBL_INT_STS_0_REG);
2283 p[445] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_ADDR_0_REG);
2284 p[446] = dsaf_read_dev(ddev, DSAF_TBL_LINE_ADDR_0_REG);
2285 p[447] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_HIGH_0_REG);
2286 p[448] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_LOW_0_REG);
2287 p[449] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_4_0_REG);
2288 p[450] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_3_0_REG);
2289 p[451] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_2_0_REG);
2290 p[452] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_1_0_REG);
2291 p[453] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_MCAST_CFG_0_0_REG);
2292 p[454] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_UCAST_CFG_0_REG);
2293 p[455] = dsaf_read_dev(ddev, DSAF_TBL_LIN_CFG_0_REG);
2294 p[456] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RDATA_HIGH_0_REG);
2295 p[457] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RDATA_LOW_0_REG);
2296 p[458] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA4_0_REG);
2297 p[459] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA3_0_REG);
2298 p[460] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA2_0_REG);
2299 p[461] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA1_0_REG);
2300 p[462] = dsaf_read_dev(ddev, DSAF_TBL_TCAM_RAM_RDATA0_0_REG);
2301 p[463] = dsaf_read_dev(ddev, DSAF_TBL_LIN_RDATA_0_REG);
2302
2303 for (i = 0; i < DSAF_SW_PORT_NUM; i++) {
2304 j = i * 0x8;
2305 p[464 + 2 * i] = dsaf_read_dev(ddev,
2306 DSAF_TBL_DA0_MIS_INFO1_0_REG + j);
2307 p[465 + 2 * i] = dsaf_read_dev(ddev,
2308 DSAF_TBL_DA0_MIS_INFO0_0_REG + j);
2309 }
2310
2311 p[480] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO2_0_REG);
2312 p[481] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO1_0_REG);
2313 p[482] = dsaf_read_dev(ddev, DSAF_TBL_SA_MIS_INFO0_0_REG);
2314 p[483] = dsaf_read_dev(ddev, DSAF_TBL_PUL_0_REG);
2315 p[484] = dsaf_read_dev(ddev, DSAF_TBL_OLD_RSLT_0_REG);
2316 p[485] = dsaf_read_dev(ddev, DSAF_TBL_OLD_SCAN_VAL_0_REG);
2317 p[486] = dsaf_read_dev(ddev, DSAF_TBL_DFX_CTRL_0_REG);
2318 p[487] = dsaf_read_dev(ddev, DSAF_TBL_DFX_STAT_0_REG);
2319 p[488] = dsaf_read_dev(ddev, DSAF_TBL_DFX_STAT_2_0_REG);
2320 p[489] = dsaf_read_dev(ddev, DSAF_TBL_LKUP_NUM_I_0_REG);
2321 p[490] = dsaf_read_dev(ddev, DSAF_TBL_LKUP_NUM_O_0_REG);
2322 p[491] = dsaf_read_dev(ddev, DSAF_TBL_UCAST_BCAST_MIS_INFO_0_0_REG);
2323
2324 /* dsaf other registers */
2325 p[492] = dsaf_read_dev(ddev, DSAF_INODE_FIFO_WL_0_REG + port * 0x4);
2326 p[493] = dsaf_read_dev(ddev, DSAF_ONODE_FIFO_WL_0_REG + port * 0x4);
2327 p[494] = dsaf_read_dev(ddev, DSAF_XGE_GE_WORK_MODE_0_REG + port * 0x4);
2328 p[495] = dsaf_read_dev(ddev,
2329 DSAF_XGE_APP_RX_LINK_UP_0_REG + port * 0x4);
2330 p[496] = dsaf_read_dev(ddev, DSAF_NETPORT_CTRL_SIG_0_REG + port * 0x4);
2331 p[497] = dsaf_read_dev(ddev, DSAF_XGE_CTRL_SIG_CFG_0_REG + port * 0x4);
2332
2333 /* mark end of dsaf regs */
2334 for (i = 498; i < 504; i++)
2335 p[i] = 0xdddddddd;
2336}
2337
2338static char *hns_dsaf_get_node_stats_strings(char *data, int node)
2339{
2340 char *buff = data;
2341
2342 snprintf(buff, ETH_GSTRING_LEN, "innod%d_pad_drop_pkts", node);
2343 buff = buff + ETH_GSTRING_LEN;
2344 snprintf(buff, ETH_GSTRING_LEN, "innod%d_manage_pkts", node);
2345 buff = buff + ETH_GSTRING_LEN;
2346 snprintf(buff, ETH_GSTRING_LEN, "innod%d_rx_pkts", node);
2347 buff = buff + ETH_GSTRING_LEN;
2348 snprintf(buff, ETH_GSTRING_LEN, "innod%d_rx_pkt_id", node);
2349 buff = buff + ETH_GSTRING_LEN;
2350 snprintf(buff, ETH_GSTRING_LEN, "innod%d_rx_pause_frame", node);
2351 buff = buff + ETH_GSTRING_LEN;
2352 snprintf(buff, ETH_GSTRING_LEN, "innod%d_release_buf_num", node);
2353 buff = buff + ETH_GSTRING_LEN;
2354 snprintf(buff, ETH_GSTRING_LEN, "innod%d_sbm_drop_pkts", node);
2355 buff = buff + ETH_GSTRING_LEN;
2356 snprintf(buff, ETH_GSTRING_LEN, "innod%d_crc_false_pkts", node);
2357 buff = buff + ETH_GSTRING_LEN;
2358 snprintf(buff, ETH_GSTRING_LEN, "innod%d_bp_drop_pkts", node);
2359 buff = buff + ETH_GSTRING_LEN;
2360 snprintf(buff, ETH_GSTRING_LEN, "innod%d_lookup_rslt_drop_pkts", node);
2361 buff = buff + ETH_GSTRING_LEN;
2362 snprintf(buff, ETH_GSTRING_LEN, "innod%d_local_rslt_fail_pkts", node);
2363 buff = buff + ETH_GSTRING_LEN;
2364 snprintf(buff, ETH_GSTRING_LEN, "innod%d_vlan_drop_pkts", node);
2365 buff = buff + ETH_GSTRING_LEN;
2366 snprintf(buff, ETH_GSTRING_LEN, "innod%d_stp_drop_pkts", node);
2367 buff = buff + ETH_GSTRING_LEN;
2368 snprintf(buff, ETH_GSTRING_LEN, "onnod%d_tx_pkts", node);
2369 buff = buff + ETH_GSTRING_LEN;
2370
2371 return buff;
2372}
2373
2374static u64 *hns_dsaf_get_node_stats(struct dsaf_device *ddev, u64 *data,
2375 int node_num)
2376{
2377 u64 *p = data;
2378 struct dsaf_hw_stats *hw_stats = &ddev->hw_stats[node_num];
2379
2380 p[0] = hw_stats->pad_drop;
2381 p[1] = hw_stats->man_pkts;
2382 p[2] = hw_stats->rx_pkts;
2383 p[3] = hw_stats->rx_pkt_id;
2384 p[4] = hw_stats->rx_pause_frame;
2385 p[5] = hw_stats->release_buf_num;
2386 p[6] = hw_stats->sbm_drop;
2387 p[7] = hw_stats->crc_false;
2388 p[8] = hw_stats->bp_drop;
2389 p[9] = hw_stats->rslt_drop;
2390 p[10] = hw_stats->local_addr_false;
2391 p[11] = hw_stats->vlan_drop;
2392 p[12] = hw_stats->stp_drop;
2393 p[13] = hw_stats->tx_pkts;
2394
2395 return &p[14];
2396}
2397
2398/**
2399 *hns_dsaf_get_stats - get dsaf statistic
2400 *@ddev: dsaf device
2401 *@data:statistic value
2402 *@port: port num
2403 */
2404void hns_dsaf_get_stats(struct dsaf_device *ddev, u64 *data, int port)
2405{
2406 u64 *p = data;
2407 int node_num = port;
2408
2409 /* for ge/xge node info */
2410 p = hns_dsaf_get_node_stats(ddev, p, node_num);
2411
2412 /* for ppe node info */
2413 node_num = port + DSAF_PPE_INODE_BASE;
2414 (void)hns_dsaf_get_node_stats(ddev, p, node_num);
2415}
2416
2417/**
2418 *hns_dsaf_get_sset_count - get dsaf string set count
2419 *@stringset: type of values in data
2420 *return dsaf string name count
2421 */
2422int hns_dsaf_get_sset_count(int stringset)
2423{
2424 if (stringset == ETH_SS_STATS)
2425 return DSAF_STATIC_NUM;
2426
2427 return 0;
2428}
2429
2430/**
2431 *hns_dsaf_get_strings - get dsaf string set
2432 *@stringset:srting set index
2433 *@data:strings name value
2434 *@port:port index
2435 */
2436void hns_dsaf_get_strings(int stringset, u8 *data, int port)
2437{
2438 char *buff = (char *)data;
2439 int node = port;
2440
2441 if (stringset != ETH_SS_STATS)
2442 return;
2443
2444 /* for ge/xge node info */
2445 buff = hns_dsaf_get_node_stats_strings(buff, node);
2446
2447 /* for ppe node info */
2448 node = port + DSAF_PPE_INODE_BASE;
2449 (void)hns_dsaf_get_node_stats_strings(buff, node);
2450}
2451
2452/**
2453 *hns_dsaf_get_sset_count - get dsaf regs count
2454 *return dsaf regs count
2455 */
2456int hns_dsaf_get_regs_count(void)
2457{
2458 return DSAF_DUMP_REGS_NUM;
2459}
2460
2461/**
2462 * dsaf_probe - probo dsaf dev
2463 * @pdev: dasf platform device
2464 * retuen 0 - success , negative --fail
2465 */
2466static int hns_dsaf_probe(struct platform_device *pdev)
2467{
2468 struct dsaf_device *dsaf_dev;
2469 int ret;
2470
2471 dsaf_dev = hns_dsaf_alloc_dev(&pdev->dev, sizeof(struct dsaf_drv_priv));
2472 if (IS_ERR(dsaf_dev)) {
2473 ret = PTR_ERR(dsaf_dev);
2474 dev_err(&pdev->dev,
2475 "dsaf_probe dsaf_alloc_dev failed, ret = %#x!\n", ret);
2476 return ret;
2477 }
2478
2479 ret = hns_dsaf_get_cfg(dsaf_dev);
2480 if (ret)
2481 goto free_dev;
2482
2483 ret = hns_dsaf_init(dsaf_dev);
2484 if (ret)
2485 goto free_cfg;
2486
2487 ret = hns_mac_init(dsaf_dev);
2488 if (ret)
2489 goto uninit_dsaf;
2490
2491 ret = hns_ppe_init(dsaf_dev);
2492 if (ret)
2493 goto uninit_mac;
2494
2495 ret = hns_dsaf_ae_init(dsaf_dev);
2496 if (ret)
2497 goto uninit_ppe;
2498
2499 return 0;
2500
2501uninit_ppe:
2502 hns_ppe_uninit(dsaf_dev);
2503
2504uninit_mac:
2505 hns_mac_uninit(dsaf_dev);
2506
2507uninit_dsaf:
2508 hns_dsaf_free(dsaf_dev);
2509
2510free_cfg:
2511 hns_dsaf_free_cfg(dsaf_dev);
2512
2513free_dev:
2514 hns_dsaf_free_dev(dsaf_dev);
2515
2516 return ret;
2517}
2518
2519/**
2520 * dsaf_remove - remove dsaf dev
2521 * @pdev: dasf platform device
2522 */
2523static int hns_dsaf_remove(struct platform_device *pdev)
2524{
2525 struct dsaf_device *dsaf_dev = dev_get_drvdata(&pdev->dev);
2526
2527 hns_dsaf_ae_uninit(dsaf_dev);
2528
2529 hns_ppe_uninit(dsaf_dev);
2530
2531 hns_mac_uninit(dsaf_dev);
2532
2533 hns_dsaf_free(dsaf_dev);
2534
2535 hns_dsaf_free_cfg(dsaf_dev);
2536
2537 hns_dsaf_free_dev(dsaf_dev);
2538
2539 return 0;
2540}
2541
2542static const struct of_device_id g_dsaf_match[] = {
2543 {.compatible = "hisilicon,hns-dsaf-v1"},
2544 {.compatible = "hisilicon,hns-dsaf-v2"},
2545 {}
2546};
2547
2548static struct platform_driver g_dsaf_driver = {
2549 .probe = hns_dsaf_probe,
2550 .remove = hns_dsaf_remove,
2551 .driver = {
2552 .name = DSAF_DRV_NAME,
2553 .of_match_table = g_dsaf_match,
2554 },
2555};
2556
2557module_platform_driver(g_dsaf_driver);
2558
2559MODULE_LICENSE("GPL");
2560MODULE_AUTHOR("Huawei Tech. Co., Ltd.");
2561MODULE_DESCRIPTION("HNS DSAF driver");
2562MODULE_VERSION(DSAF_MOD_VERSION);
Ubuntu Disco kernel mirror for Proxmox VE and PMG