drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c

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