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

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