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