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