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/cdev.h> 11 #include <linux/module.h> 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/netdevice.h> 15 #include <linux/etherdevice.h> 16 #include <asm/cacheflush.h> 17 #include <linux/platform_device.h> 18 #include <linux/of.h> 19 #include <linux/of_address.h> 20 #include <linux/of_platform.h> 21 #include <linux/of_irq.h> 22 #include <linux/spinlock.h> 23 24 #include "hns_dsaf_main.h" 25 #include "hns_dsaf_ppe.h" 26 #include "hns_dsaf_rcb.h" 27 28 #define RCB_COMMON_REG_OFFSET 0x80000 29 #define TX_RING 0 30 #define RX_RING 1 31 32 #define RCB_RESET_WAIT_TIMES 30 33 #define RCB_RESET_TRY_TIMES 10 34 35 /* Because default mtu is 1500, rcb buffer size is set to 2048 enough */ 36 #define RCB_DEFAULT_BUFFER_SIZE 2048 37 38 /** 39 *hns_rcb_wait_fbd_clean - clean fbd 40 *@qs: ring struct pointer array 41 *@qnum: num of array 42 *@flag: tx or rx flag 43 */ 44 void hns_rcb_wait_fbd_clean(struct hnae_queue **qs, int q_num, u32 flag) 45 { 46 int i, wait_cnt; 47 u32 fbd_num; 48 49 for (wait_cnt = i = 0; i < q_num; wait_cnt++) { 50 usleep_range(200, 300); 51 fbd_num = 0; 52 if (flag & RCB_INT_FLAG_TX) 53 fbd_num += dsaf_read_dev(qs[i], 54 RCB_RING_TX_RING_FBDNUM_REG); 55 if (flag & RCB_INT_FLAG_RX) 56 fbd_num += dsaf_read_dev(qs[i], 57 RCB_RING_RX_RING_FBDNUM_REG); 58 if (!fbd_num) 59 i++; 60 if (wait_cnt >= 10000) 61 break; 62 } 63 64 if (i < q_num) 65 dev_err(qs[i]->handle->owner_dev, 66 "queue(%d) wait fbd(%d) clean fail!!\n", i, fbd_num); 67 } 68 69 /** 70 *hns_rcb_reset_ring_hw - ring reset 71 *@q: ring struct pointer 72 */ 73 void hns_rcb_reset_ring_hw(struct hnae_queue *q) 74 { 75 u32 wait_cnt; 76 u32 try_cnt = 0; 77 u32 could_ret; 78 79 u32 tx_fbd_num; 80 81 while (try_cnt++ < RCB_RESET_TRY_TIMES) { 82 usleep_range(100, 200); 83 tx_fbd_num = dsaf_read_dev(q, RCB_RING_TX_RING_FBDNUM_REG); 84 if (tx_fbd_num) 85 continue; 86 87 dsaf_write_dev(q, RCB_RING_PREFETCH_EN_REG, 0); 88 89 dsaf_write_dev(q, RCB_RING_T0_BE_RST, 1); 90 91 msleep(20); 92 could_ret = dsaf_read_dev(q, RCB_RING_COULD_BE_RST); 93 94 wait_cnt = 0; 95 while (!could_ret && (wait_cnt < RCB_RESET_WAIT_TIMES)) { 96 dsaf_write_dev(q, RCB_RING_T0_BE_RST, 0); 97 98 dsaf_write_dev(q, RCB_RING_T0_BE_RST, 1); 99 100 msleep(20); 101 could_ret = dsaf_read_dev(q, RCB_RING_COULD_BE_RST); 102 103 wait_cnt++; 104 } 105 106 dsaf_write_dev(q, RCB_RING_T0_BE_RST, 0); 107 108 if (could_ret) 109 break; 110 } 111 112 if (try_cnt >= RCB_RESET_TRY_TIMES) 113 dev_err(q->dev->dev, "port%d reset ring fail\n", 114 hns_ae_get_vf_cb(q->handle)->port_index); 115 } 116 117 /** 118 *hns_rcb_int_ctrl_hw - rcb irq enable control 119 *@q: hnae queue struct pointer 120 *@flag:ring flag tx or rx 121 *@mask:mask 122 */ 123 void hns_rcb_int_ctrl_hw(struct hnae_queue *q, u32 flag, u32 mask) 124 { 125 u32 int_mask_en = !!mask; 126 127 if (flag & RCB_INT_FLAG_TX) { 128 dsaf_write_dev(q, RCB_RING_INTMSK_TXWL_REG, int_mask_en); 129 dsaf_write_dev(q, RCB_RING_INTMSK_TX_OVERTIME_REG, 130 int_mask_en); 131 } 132 133 if (flag & RCB_INT_FLAG_RX) { 134 dsaf_write_dev(q, RCB_RING_INTMSK_RXWL_REG, int_mask_en); 135 dsaf_write_dev(q, RCB_RING_INTMSK_RX_OVERTIME_REG, 136 int_mask_en); 137 } 138 } 139 140 void hns_rcb_int_clr_hw(struct hnae_queue *q, u32 flag) 141 { 142 if (flag & RCB_INT_FLAG_TX) { 143 dsaf_write_dev(q, RCB_RING_INTSTS_TX_RING_REG, 1); 144 dsaf_write_dev(q, RCB_RING_INTSTS_TX_OVERTIME_REG, 1); 145 } 146 147 if (flag & RCB_INT_FLAG_RX) { 148 dsaf_write_dev(q, RCB_RING_INTSTS_RX_RING_REG, 1); 149 dsaf_write_dev(q, RCB_RING_INTSTS_RX_OVERTIME_REG, 1); 150 } 151 } 152 153 void hns_rcbv2_int_ctrl_hw(struct hnae_queue *q, u32 flag, u32 mask) 154 { 155 u32 int_mask_en = !!mask; 156 157 if (flag & RCB_INT_FLAG_TX) 158 dsaf_write_dev(q, RCB_RING_INTMSK_TXWL_REG, int_mask_en); 159 160 if (flag & RCB_INT_FLAG_RX) 161 dsaf_write_dev(q, RCB_RING_INTMSK_RXWL_REG, int_mask_en); 162 } 163 164 void hns_rcbv2_int_clr_hw(struct hnae_queue *q, u32 flag) 165 { 166 if (flag & RCB_INT_FLAG_TX) 167 dsaf_write_dev(q, RCBV2_TX_RING_INT_STS_REG, 1); 168 169 if (flag & RCB_INT_FLAG_RX) 170 dsaf_write_dev(q, RCBV2_RX_RING_INT_STS_REG, 1); 171 } 172 173 /** 174 *hns_rcb_ring_enable_hw - enable ring 175 *@ring: rcb ring 176 */ 177 void hns_rcb_ring_enable_hw(struct hnae_queue *q, u32 val) 178 { 179 dsaf_write_dev(q, RCB_RING_PREFETCH_EN_REG, !!val); 180 } 181 182 void hns_rcb_start(struct hnae_queue *q, u32 val) 183 { 184 hns_rcb_ring_enable_hw(q, val); 185 } 186 187 /** 188 *hns_rcb_common_init_commit_hw - make rcb common init completed 189 *@rcb_common: rcb common device 190 */ 191 void hns_rcb_common_init_commit_hw(struct rcb_common_cb *rcb_common) 192 { 193 wmb(); /* Sync point before breakpoint */ 194 dsaf_write_dev(rcb_common, RCB_COM_CFG_SYS_FSH_REG, 1); 195 wmb(); /* Sync point after breakpoint */ 196 } 197 198 /* hns_rcb_set_tx_ring_bs - init rcb ring buf size regester 199 *@q: hnae_queue 200 *@buf_size: buffer size set to hw 201 */ 202 void hns_rcb_set_tx_ring_bs(struct hnae_queue *q, u32 buf_size) 203 { 204 u32 bd_size_type = hns_rcb_buf_size2type(buf_size); 205 206 dsaf_write_dev(q, RCB_RING_TX_RING_BD_LEN_REG, 207 bd_size_type); 208 } 209 210 /* hns_rcb_set_rx_ring_bs - init rcb ring buf size regester 211 *@q: hnae_queue 212 *@buf_size: buffer size set to hw 213 */ 214 void hns_rcb_set_rx_ring_bs(struct hnae_queue *q, u32 buf_size) 215 { 216 u32 bd_size_type = hns_rcb_buf_size2type(buf_size); 217 218 dsaf_write_dev(q, RCB_RING_RX_RING_BD_LEN_REG, 219 bd_size_type); 220 } 221 222 /** 223 *hns_rcb_ring_init - init rcb ring 224 *@ring_pair: ring pair control block 225 *@ring_type: ring type, RX_RING or TX_RING 226 */ 227 static void hns_rcb_ring_init(struct ring_pair_cb *ring_pair, int ring_type) 228 { 229 struct hnae_queue *q = &ring_pair->q; 230 struct hnae_ring *ring = 231 (ring_type == RX_RING) ? &q->rx_ring : &q->tx_ring; 232 dma_addr_t dma = ring->desc_dma_addr; 233 234 if (ring_type == RX_RING) { 235 dsaf_write_dev(q, RCB_RING_RX_RING_BASEADDR_L_REG, 236 (u32)dma); 237 dsaf_write_dev(q, RCB_RING_RX_RING_BASEADDR_H_REG, 238 (u32)((dma >> 31) >> 1)); 239 240 hns_rcb_set_rx_ring_bs(q, ring->buf_size); 241 242 dsaf_write_dev(q, RCB_RING_RX_RING_BD_NUM_REG, 243 ring_pair->port_id_in_comm); 244 dsaf_write_dev(q, RCB_RING_RX_RING_PKTLINE_REG, 245 ring_pair->port_id_in_comm); 246 } else { 247 dsaf_write_dev(q, RCB_RING_TX_RING_BASEADDR_L_REG, 248 (u32)dma); 249 dsaf_write_dev(q, RCB_RING_TX_RING_BASEADDR_H_REG, 250 (u32)((dma >> 31) >> 1)); 251 252 hns_rcb_set_tx_ring_bs(q, ring->buf_size); 253 254 dsaf_write_dev(q, RCB_RING_TX_RING_BD_NUM_REG, 255 ring_pair->port_id_in_comm); 256 dsaf_write_dev(q, RCB_RING_TX_RING_PKTLINE_REG, 257 ring_pair->port_id_in_comm + HNS_RCB_TX_PKTLINE_OFFSET); 258 } 259 } 260 261 /** 262 *hns_rcb_init_hw - init rcb hardware 263 *@ring: rcb ring 264 */ 265 void hns_rcb_init_hw(struct ring_pair_cb *ring) 266 { 267 hns_rcb_ring_init(ring, RX_RING); 268 hns_rcb_ring_init(ring, TX_RING); 269 } 270 271 /** 272 *hns_rcb_set_port_desc_cnt - set rcb port description num 273 *@rcb_common: rcb_common device 274 *@port_idx:port index 275 *@desc_cnt:BD num 276 */ 277 static void hns_rcb_set_port_desc_cnt(struct rcb_common_cb *rcb_common, 278 u32 port_idx, u32 desc_cnt) 279 { 280 dsaf_write_dev(rcb_common, RCB_CFG_BD_NUM_REG + port_idx * 4, 281 desc_cnt); 282 } 283 284 static void hns_rcb_set_port_timeout( 285 struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout) 286 { 287 if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) { 288 dsaf_write_dev(rcb_common, RCB_CFG_OVERTIME_REG, 289 timeout * HNS_RCB_CLK_FREQ_MHZ); 290 } else if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) { 291 if (timeout > HNS_RCB_DEF_GAP_TIME_USECS) 292 dsaf_write_dev(rcb_common, 293 RCB_PORT_INT_GAPTIME_REG + port_idx * 4, 294 HNS_RCB_DEF_GAP_TIME_USECS); 295 else 296 dsaf_write_dev(rcb_common, 297 RCB_PORT_INT_GAPTIME_REG + port_idx * 4, 298 timeout); 299 300 dsaf_write_dev(rcb_common, 301 RCB_PORT_CFG_OVERTIME_REG + port_idx * 4, 302 timeout); 303 } else { 304 dsaf_write_dev(rcb_common, 305 RCB_PORT_CFG_OVERTIME_REG + port_idx * 4, 306 timeout); 307 } 308 } 309 310 static int hns_rcb_common_get_port_num(struct rcb_common_cb *rcb_common) 311 { 312 if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) 313 return HNS_RCB_SERVICE_NW_ENGINE_NUM; 314 else 315 return HNS_RCB_DEBUG_NW_ENGINE_NUM; 316 } 317 318 /*clr rcb comm exception irq**/ 319 static void hns_rcb_comm_exc_irq_en( 320 struct rcb_common_cb *rcb_common, int en) 321 { 322 u32 clr_vlue = 0xfffffffful; 323 u32 msk_vlue = en ? 0 : 0xfffffffful; 324 325 /* clr int*/ 326 dsaf_write_dev(rcb_common, RCB_COM_INTSTS_ECC_ERR_REG, clr_vlue); 327 328 dsaf_write_dev(rcb_common, RCB_COM_SF_CFG_RING_STS, clr_vlue); 329 330 dsaf_write_dev(rcb_common, RCB_COM_SF_CFG_BD_RINT_STS, clr_vlue); 331 332 dsaf_write_dev(rcb_common, RCB_COM_RINT_TX_PKT_REG, clr_vlue); 333 dsaf_write_dev(rcb_common, RCB_COM_AXI_ERR_STS, clr_vlue); 334 335 /*en msk*/ 336 dsaf_write_dev(rcb_common, RCB_COM_INTMASK_ECC_ERR_REG, msk_vlue); 337 338 dsaf_write_dev(rcb_common, RCB_COM_SF_CFG_INTMASK_RING, msk_vlue); 339 340 /*for tx bd neednot cacheline, so msk sf_txring_fbd_intmask (bit 1)**/ 341 dsaf_write_dev(rcb_common, RCB_COM_SF_CFG_INTMASK_BD, msk_vlue | 2); 342 343 dsaf_write_dev(rcb_common, RCB_COM_INTMSK_TX_PKT_REG, msk_vlue); 344 dsaf_write_dev(rcb_common, RCB_COM_AXI_WR_ERR_INTMASK, msk_vlue); 345 } 346 347 /** 348 *hns_rcb_common_init_hw - init rcb common hardware 349 *@rcb_common: rcb_common device 350 *retuen 0 - success , negative --fail 351 */ 352 int hns_rcb_common_init_hw(struct rcb_common_cb *rcb_common) 353 { 354 u32 reg_val; 355 int i; 356 int port_num = hns_rcb_common_get_port_num(rcb_common); 357 358 hns_rcb_comm_exc_irq_en(rcb_common, 0); 359 360 reg_val = dsaf_read_dev(rcb_common, RCB_COM_CFG_INIT_FLAG_REG); 361 if (0x1 != (reg_val & 0x1)) { 362 dev_err(rcb_common->dsaf_dev->dev, 363 "RCB_COM_CFG_INIT_FLAG_REG reg = 0x%x\n", reg_val); 364 return -EBUSY; 365 } 366 367 for (i = 0; i < port_num; i++) { 368 hns_rcb_set_port_desc_cnt(rcb_common, i, rcb_common->desc_num); 369 hns_rcb_set_rx_coalesced_frames( 370 rcb_common, i, HNS_RCB_DEF_RX_COALESCED_FRAMES); 371 if (!AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver) && 372 !HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) 373 hns_rcb_set_tx_coalesced_frames( 374 rcb_common, i, HNS_RCB_DEF_TX_COALESCED_FRAMES); 375 hns_rcb_set_port_timeout( 376 rcb_common, i, HNS_RCB_DEF_COALESCED_USECS); 377 } 378 379 dsaf_write_dev(rcb_common, RCB_COM_CFG_ENDIAN_REG, 380 HNS_RCB_COMMON_ENDIAN); 381 382 if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) { 383 dsaf_write_dev(rcb_common, RCB_COM_CFG_FNA_REG, 0x0); 384 dsaf_write_dev(rcb_common, RCB_COM_CFG_FA_REG, 0x1); 385 } else { 386 dsaf_set_dev_bit(rcb_common, RCBV2_COM_CFG_USER_REG, 387 RCB_COM_CFG_FNA_B, false); 388 dsaf_set_dev_bit(rcb_common, RCBV2_COM_CFG_USER_REG, 389 RCB_COM_CFG_FA_B, true); 390 dsaf_set_dev_bit(rcb_common, RCBV2_COM_CFG_TSO_MODE_REG, 391 RCB_COM_TSO_MODE_B, HNS_TSO_MODE_8BD_32K); 392 } 393 394 return 0; 395 } 396 397 int hns_rcb_buf_size2type(u32 buf_size) 398 { 399 int bd_size_type; 400 401 switch (buf_size) { 402 case 512: 403 bd_size_type = HNS_BD_SIZE_512_TYPE; 404 break; 405 case 1024: 406 bd_size_type = HNS_BD_SIZE_1024_TYPE; 407 break; 408 case 2048: 409 bd_size_type = HNS_BD_SIZE_2048_TYPE; 410 break; 411 case 4096: 412 bd_size_type = HNS_BD_SIZE_4096_TYPE; 413 break; 414 default: 415 bd_size_type = -EINVAL; 416 } 417 418 return bd_size_type; 419 } 420 421 static void hns_rcb_ring_get_cfg(struct hnae_queue *q, int ring_type) 422 { 423 struct hnae_ring *ring; 424 struct rcb_common_cb *rcb_common; 425 struct ring_pair_cb *ring_pair_cb; 426 u16 desc_num, mdnum_ppkt; 427 bool irq_idx, is_ver1; 428 429 ring_pair_cb = container_of(q, struct ring_pair_cb, q); 430 is_ver1 = AE_IS_VER1(ring_pair_cb->rcb_common->dsaf_dev->dsaf_ver); 431 if (ring_type == RX_RING) { 432 ring = &q->rx_ring; 433 ring->io_base = ring_pair_cb->q.io_base; 434 irq_idx = HNS_RCB_IRQ_IDX_RX; 435 mdnum_ppkt = HNS_RCB_RING_MAX_BD_PER_PKT; 436 } else { 437 ring = &q->tx_ring; 438 ring->io_base = (u8 __iomem *)ring_pair_cb->q.io_base + 439 HNS_RCB_TX_REG_OFFSET; 440 irq_idx = HNS_RCB_IRQ_IDX_TX; 441 mdnum_ppkt = is_ver1 ? HNS_RCB_RING_MAX_TXBD_PER_PKT : 442 HNS_RCBV2_RING_MAX_TXBD_PER_PKT; 443 } 444 445 rcb_common = ring_pair_cb->rcb_common; 446 desc_num = rcb_common->dsaf_dev->desc_num; 447 448 ring->desc = NULL; 449 ring->desc_cb = NULL; 450 451 ring->irq = ring_pair_cb->virq[irq_idx]; 452 ring->desc_dma_addr = 0; 453 454 ring->buf_size = RCB_DEFAULT_BUFFER_SIZE; 455 ring->desc_num = desc_num; 456 ring->max_desc_num_per_pkt = mdnum_ppkt; 457 ring->max_raw_data_sz_per_desc = HNS_RCB_MAX_PKT_SIZE; 458 ring->max_pkt_size = HNS_RCB_MAX_PKT_SIZE; 459 ring->next_to_use = 0; 460 ring->next_to_clean = 0; 461 } 462 463 static void hns_rcb_ring_pair_get_cfg(struct ring_pair_cb *ring_pair_cb) 464 { 465 ring_pair_cb->q.handle = NULL; 466 467 hns_rcb_ring_get_cfg(&ring_pair_cb->q, RX_RING); 468 hns_rcb_ring_get_cfg(&ring_pair_cb->q, TX_RING); 469 } 470 471 static int hns_rcb_get_port_in_comm( 472 struct rcb_common_cb *rcb_common, int ring_idx) 473 { 474 return ring_idx / (rcb_common->max_q_per_vf * rcb_common->max_vfn); 475 } 476 477 #define SERVICE_RING_IRQ_IDX(v1) \ 478 ((v1) ? HNS_SERVICE_RING_IRQ_IDX : HNSV2_SERVICE_RING_IRQ_IDX) 479 static int hns_rcb_get_base_irq_idx(struct rcb_common_cb *rcb_common) 480 { 481 bool is_ver1 = AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver); 482 483 if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) 484 return SERVICE_RING_IRQ_IDX(is_ver1); 485 else 486 return HNS_DEBUG_RING_IRQ_IDX; 487 } 488 489 #define RCB_COMM_BASE_TO_RING_BASE(base, ringid)\ 490 ((base) + 0x10000 + HNS_RCB_REG_OFFSET * (ringid)) 491 /** 492 *hns_rcb_get_cfg - get rcb config 493 *@rcb_common: rcb common device 494 */ 495 void hns_rcb_get_cfg(struct rcb_common_cb *rcb_common) 496 { 497 struct ring_pair_cb *ring_pair_cb; 498 u32 i; 499 u32 ring_num = rcb_common->ring_num; 500 int base_irq_idx = hns_rcb_get_base_irq_idx(rcb_common); 501 struct platform_device *pdev = 502 to_platform_device(rcb_common->dsaf_dev->dev); 503 bool is_ver1 = AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver); 504 505 for (i = 0; i < ring_num; i++) { 506 ring_pair_cb = &rcb_common->ring_pair_cb[i]; 507 ring_pair_cb->rcb_common = rcb_common; 508 ring_pair_cb->dev = rcb_common->dsaf_dev->dev; 509 ring_pair_cb->index = i; 510 ring_pair_cb->q.io_base = 511 RCB_COMM_BASE_TO_RING_BASE(rcb_common->io_base, i); 512 ring_pair_cb->port_id_in_comm = 513 hns_rcb_get_port_in_comm(rcb_common, i); 514 ring_pair_cb->virq[HNS_RCB_IRQ_IDX_TX] = 515 is_ver1 ? platform_get_irq(pdev, base_irq_idx + i * 2) : 516 platform_get_irq(pdev, base_irq_idx + i * 3 + 1); 517 ring_pair_cb->virq[HNS_RCB_IRQ_IDX_RX] = 518 is_ver1 ? platform_get_irq(pdev, base_irq_idx + i * 2 + 1) : 519 platform_get_irq(pdev, base_irq_idx + i * 3); 520 ring_pair_cb->q.phy_base = 521 RCB_COMM_BASE_TO_RING_BASE(rcb_common->phy_base, i); 522 hns_rcb_ring_pair_get_cfg(ring_pair_cb); 523 } 524 } 525 526 /** 527 *hns_rcb_get_rx_coalesced_frames - get rcb port rx coalesced frames 528 *@rcb_common: rcb_common device 529 *@port_idx:port id in comm 530 * 531 *Returns: coalesced_frames 532 */ 533 u32 hns_rcb_get_rx_coalesced_frames( 534 struct rcb_common_cb *rcb_common, u32 port_idx) 535 { 536 return dsaf_read_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4); 537 } 538 539 /** 540 *hns_rcb_get_tx_coalesced_frames - get rcb port tx coalesced frames 541 *@rcb_common: rcb_common device 542 *@port_idx:port id in comm 543 * 544 *Returns: coalesced_frames 545 */ 546 u32 hns_rcb_get_tx_coalesced_frames( 547 struct rcb_common_cb *rcb_common, u32 port_idx) 548 { 549 u64 reg; 550 551 reg = RCB_CFG_PKTLINE_REG + (port_idx + HNS_RCB_TX_PKTLINE_OFFSET) * 4; 552 return dsaf_read_dev(rcb_common, reg); 553 } 554 555 /** 556 *hns_rcb_get_coalesce_usecs - get rcb port coalesced time_out 557 *@rcb_common: rcb_common device 558 *@port_idx:port id in comm 559 * 560 *Returns: time_out 561 */ 562 u32 hns_rcb_get_coalesce_usecs( 563 struct rcb_common_cb *rcb_common, u32 port_idx) 564 { 565 if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) 566 return dsaf_read_dev(rcb_common, RCB_CFG_OVERTIME_REG) / 567 HNS_RCB_CLK_FREQ_MHZ; 568 else 569 return dsaf_read_dev(rcb_common, 570 RCB_PORT_CFG_OVERTIME_REG + port_idx * 4); 571 } 572 573 /** 574 *hns_rcb_set_coalesce_usecs - set rcb port coalesced time_out 575 *@rcb_common: rcb_common device 576 *@port_idx:port id in comm 577 *@timeout:tx/rx time for coalesced time_out 578 * 579 * Returns: 580 * Zero for success, or an error code in case of failure 581 */ 582 int hns_rcb_set_coalesce_usecs( 583 struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout) 584 { 585 u32 old_timeout = hns_rcb_get_coalesce_usecs(rcb_common, port_idx); 586 587 if (timeout == old_timeout) 588 return 0; 589 590 if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) { 591 if (!HNS_DSAF_IS_DEBUG(rcb_common->dsaf_dev)) { 592 dev_err(rcb_common->dsaf_dev->dev, 593 "error: not support coalesce_usecs setting!\n"); 594 return -EINVAL; 595 } 596 } 597 if (timeout > HNS_RCB_MAX_COALESCED_USECS || timeout == 0) { 598 dev_err(rcb_common->dsaf_dev->dev, 599 "error: coalesce_usecs setting supports 1~1023us\n"); 600 return -EINVAL; 601 } 602 hns_rcb_set_port_timeout(rcb_common, port_idx, timeout); 603 return 0; 604 } 605 606 /** 607 *hns_rcb_set_tx_coalesced_frames - set rcb coalesced frames 608 *@rcb_common: rcb_common device 609 *@port_idx:port id in comm 610 *@coalesced_frames:tx/rx BD num for coalesced frames 611 * 612 * Returns: 613 * Zero for success, or an error code in case of failure 614 */ 615 int hns_rcb_set_tx_coalesced_frames( 616 struct rcb_common_cb *rcb_common, u32 port_idx, u32 coalesced_frames) 617 { 618 u32 old_waterline = 619 hns_rcb_get_tx_coalesced_frames(rcb_common, port_idx); 620 u64 reg; 621 622 if (coalesced_frames == old_waterline) 623 return 0; 624 625 if (coalesced_frames != 1) { 626 dev_err(rcb_common->dsaf_dev->dev, 627 "error: not support tx coalesce_frames setting!\n"); 628 return -EINVAL; 629 } 630 631 reg = RCB_CFG_PKTLINE_REG + (port_idx + HNS_RCB_TX_PKTLINE_OFFSET) * 4; 632 dsaf_write_dev(rcb_common, reg, coalesced_frames); 633 return 0; 634 } 635 636 /** 637 *hns_rcb_set_rx_coalesced_frames - set rcb rx coalesced frames 638 *@rcb_common: rcb_common device 639 *@port_idx:port id in comm 640 *@coalesced_frames:tx/rx BD num for coalesced frames 641 * 642 * Returns: 643 * Zero for success, or an error code in case of failure 644 */ 645 int hns_rcb_set_rx_coalesced_frames( 646 struct rcb_common_cb *rcb_common, u32 port_idx, u32 coalesced_frames) 647 { 648 u32 old_waterline = 649 hns_rcb_get_rx_coalesced_frames(rcb_common, port_idx); 650 651 if (coalesced_frames == old_waterline) 652 return 0; 653 654 if (coalesced_frames >= rcb_common->desc_num || 655 coalesced_frames > HNS_RCB_MAX_COALESCED_FRAMES || 656 coalesced_frames < HNS_RCB_MIN_COALESCED_FRAMES) { 657 dev_err(rcb_common->dsaf_dev->dev, 658 "error: not support coalesce_frames setting!\n"); 659 return -EINVAL; 660 } 661 662 dsaf_write_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4, 663 coalesced_frames); 664 return 0; 665 } 666 667 /** 668 *hns_rcb_get_queue_mode - get max VM number and max ring number per VM 669 * accordding to dsaf mode 670 *@dsaf_mode: dsaf mode 671 *@max_vfn : max vfn number 672 *@max_q_per_vf:max ring number per vm 673 */ 674 void hns_rcb_get_queue_mode(enum dsaf_mode dsaf_mode, u16 *max_vfn, 675 u16 *max_q_per_vf) 676 { 677 switch (dsaf_mode) { 678 case DSAF_MODE_DISABLE_6PORT_0VM: 679 *max_vfn = 1; 680 *max_q_per_vf = 16; 681 break; 682 case DSAF_MODE_DISABLE_FIX: 683 case DSAF_MODE_DISABLE_SP: 684 *max_vfn = 1; 685 *max_q_per_vf = 1; 686 break; 687 case DSAF_MODE_DISABLE_2PORT_64VM: 688 *max_vfn = 64; 689 *max_q_per_vf = 1; 690 break; 691 case DSAF_MODE_DISABLE_6PORT_16VM: 692 *max_vfn = 16; 693 *max_q_per_vf = 1; 694 break; 695 default: 696 *max_vfn = 1; 697 *max_q_per_vf = 16; 698 break; 699 } 700 } 701 702 int hns_rcb_get_ring_num(struct dsaf_device *dsaf_dev) 703 { 704 switch (dsaf_dev->dsaf_mode) { 705 case DSAF_MODE_ENABLE_FIX: 706 case DSAF_MODE_DISABLE_SP: 707 return 1; 708 709 case DSAF_MODE_DISABLE_FIX: 710 return 6; 711 712 case DSAF_MODE_ENABLE_0VM: 713 return 32; 714 715 case DSAF_MODE_DISABLE_6PORT_0VM: 716 case DSAF_MODE_ENABLE_16VM: 717 case DSAF_MODE_DISABLE_6PORT_2VM: 718 case DSAF_MODE_DISABLE_6PORT_16VM: 719 case DSAF_MODE_DISABLE_6PORT_4VM: 720 case DSAF_MODE_ENABLE_8VM: 721 return 96; 722 723 case DSAF_MODE_DISABLE_2PORT_16VM: 724 case DSAF_MODE_DISABLE_2PORT_8VM: 725 case DSAF_MODE_ENABLE_32VM: 726 case DSAF_MODE_DISABLE_2PORT_64VM: 727 case DSAF_MODE_ENABLE_128VM: 728 return 128; 729 730 default: 731 dev_warn(dsaf_dev->dev, 732 "get ring num fail,use default!dsaf_mode=%d\n", 733 dsaf_dev->dsaf_mode); 734 return 128; 735 } 736 } 737 738 void __iomem *hns_rcb_common_get_vaddr(struct rcb_common_cb *rcb_common) 739 { 740 struct dsaf_device *dsaf_dev = rcb_common->dsaf_dev; 741 742 return dsaf_dev->ppe_base + RCB_COMMON_REG_OFFSET; 743 } 744 745 static phys_addr_t hns_rcb_common_get_paddr(struct rcb_common_cb *rcb_common) 746 { 747 struct dsaf_device *dsaf_dev = rcb_common->dsaf_dev; 748 749 return dsaf_dev->ppe_paddr + RCB_COMMON_REG_OFFSET; 750 } 751 752 int hns_rcb_common_get_cfg(struct dsaf_device *dsaf_dev, 753 int comm_index) 754 { 755 struct rcb_common_cb *rcb_common; 756 enum dsaf_mode dsaf_mode = dsaf_dev->dsaf_mode; 757 u16 max_vfn; 758 u16 max_q_per_vf; 759 int ring_num = hns_rcb_get_ring_num(dsaf_dev); 760 761 rcb_common = 762 devm_kzalloc(dsaf_dev->dev, sizeof(*rcb_common) + 763 ring_num * sizeof(struct ring_pair_cb), GFP_KERNEL); 764 if (!rcb_common) { 765 dev_err(dsaf_dev->dev, "rcb common devm_kzalloc fail!\n"); 766 return -ENOMEM; 767 } 768 rcb_common->comm_index = comm_index; 769 rcb_common->ring_num = ring_num; 770 rcb_common->dsaf_dev = dsaf_dev; 771 772 rcb_common->desc_num = dsaf_dev->desc_num; 773 774 hns_rcb_get_queue_mode(dsaf_mode, &max_vfn, &max_q_per_vf); 775 rcb_common->max_vfn = max_vfn; 776 rcb_common->max_q_per_vf = max_q_per_vf; 777 778 rcb_common->io_base = hns_rcb_common_get_vaddr(rcb_common); 779 rcb_common->phy_base = hns_rcb_common_get_paddr(rcb_common); 780 781 dsaf_dev->rcb_common[comm_index] = rcb_common; 782 return 0; 783 } 784 785 void hns_rcb_common_free_cfg(struct dsaf_device *dsaf_dev, 786 u32 comm_index) 787 { 788 dsaf_dev->rcb_common[comm_index] = NULL; 789 } 790 791 void hns_rcb_update_stats(struct hnae_queue *queue) 792 { 793 struct ring_pair_cb *ring = 794 container_of(queue, struct ring_pair_cb, q); 795 struct dsaf_device *dsaf_dev = ring->rcb_common->dsaf_dev; 796 struct ppe_common_cb *ppe_common 797 = dsaf_dev->ppe_common[ring->rcb_common->comm_index]; 798 struct hns_ring_hw_stats *hw_stats = &ring->hw_stats; 799 800 hw_stats->rx_pkts += dsaf_read_dev(queue, 801 RCB_RING_RX_RING_PKTNUM_RECORD_REG); 802 dsaf_write_dev(queue, RCB_RING_RX_RING_PKTNUM_RECORD_REG, 0x1); 803 804 hw_stats->ppe_rx_ok_pkts += dsaf_read_dev(ppe_common, 805 PPE_COM_HIS_RX_PKT_QID_OK_CNT_REG + 4 * ring->index); 806 hw_stats->ppe_rx_drop_pkts += dsaf_read_dev(ppe_common, 807 PPE_COM_HIS_RX_PKT_QID_DROP_CNT_REG + 4 * ring->index); 808 809 hw_stats->tx_pkts += dsaf_read_dev(queue, 810 RCB_RING_TX_RING_PKTNUM_RECORD_REG); 811 dsaf_write_dev(queue, RCB_RING_TX_RING_PKTNUM_RECORD_REG, 0x1); 812 813 hw_stats->ppe_tx_ok_pkts += dsaf_read_dev(ppe_common, 814 PPE_COM_HIS_TX_PKT_QID_OK_CNT_REG + 4 * ring->index); 815 hw_stats->ppe_tx_drop_pkts += dsaf_read_dev(ppe_common, 816 PPE_COM_HIS_TX_PKT_QID_ERR_CNT_REG + 4 * ring->index); 817 } 818 819 /** 820 *hns_rcb_get_stats - get rcb statistic 821 *@ring: rcb ring 822 *@data:statistic value 823 */ 824 void hns_rcb_get_stats(struct hnae_queue *queue, u64 *data) 825 { 826 u64 *regs_buff = data; 827 struct ring_pair_cb *ring = 828 container_of(queue, struct ring_pair_cb, q); 829 struct hns_ring_hw_stats *hw_stats = &ring->hw_stats; 830 831 regs_buff[0] = hw_stats->tx_pkts; 832 regs_buff[1] = hw_stats->ppe_tx_ok_pkts; 833 regs_buff[2] = hw_stats->ppe_tx_drop_pkts; 834 regs_buff[3] = 835 dsaf_read_dev(queue, RCB_RING_TX_RING_FBDNUM_REG); 836 837 regs_buff[4] = queue->tx_ring.stats.tx_pkts; 838 regs_buff[5] = queue->tx_ring.stats.tx_bytes; 839 regs_buff[6] = queue->tx_ring.stats.tx_err_cnt; 840 regs_buff[7] = queue->tx_ring.stats.io_err_cnt; 841 regs_buff[8] = queue->tx_ring.stats.sw_err_cnt; 842 regs_buff[9] = queue->tx_ring.stats.seg_pkt_cnt; 843 regs_buff[10] = queue->tx_ring.stats.restart_queue; 844 regs_buff[11] = queue->tx_ring.stats.tx_busy; 845 846 regs_buff[12] = hw_stats->rx_pkts; 847 regs_buff[13] = hw_stats->ppe_rx_ok_pkts; 848 regs_buff[14] = hw_stats->ppe_rx_drop_pkts; 849 regs_buff[15] = 850 dsaf_read_dev(queue, RCB_RING_RX_RING_FBDNUM_REG); 851 852 regs_buff[16] = queue->rx_ring.stats.rx_pkts; 853 regs_buff[17] = queue->rx_ring.stats.rx_bytes; 854 regs_buff[18] = queue->rx_ring.stats.rx_err_cnt; 855 regs_buff[19] = queue->rx_ring.stats.io_err_cnt; 856 regs_buff[20] = queue->rx_ring.stats.sw_err_cnt; 857 regs_buff[21] = queue->rx_ring.stats.seg_pkt_cnt; 858 regs_buff[22] = queue->rx_ring.stats.reuse_pg_cnt; 859 regs_buff[23] = queue->rx_ring.stats.err_pkt_len; 860 regs_buff[24] = queue->rx_ring.stats.non_vld_descs; 861 regs_buff[25] = queue->rx_ring.stats.err_bd_num; 862 regs_buff[26] = queue->rx_ring.stats.l2_err; 863 regs_buff[27] = queue->rx_ring.stats.l3l4_csum_err; 864 } 865 866 /** 867 *hns_rcb_get_ring_sset_count - rcb string set count 868 *@stringset:ethtool cmd 869 *return rcb ring string set count 870 */ 871 int hns_rcb_get_ring_sset_count(int stringset) 872 { 873 if (stringset == ETH_SS_STATS) 874 return HNS_RING_STATIC_REG_NUM; 875 876 return 0; 877 } 878 879 /** 880 *hns_rcb_get_common_regs_count - rcb common regs count 881 *return regs count 882 */ 883 int hns_rcb_get_common_regs_count(void) 884 { 885 return HNS_RCB_COMMON_DUMP_REG_NUM; 886 } 887 888 /** 889 *rcb_get_sset_count - rcb ring regs count 890 *return regs count 891 */ 892 int hns_rcb_get_ring_regs_count(void) 893 { 894 return HNS_RCB_RING_DUMP_REG_NUM; 895 } 896 897 /** 898 *hns_rcb_get_strings - get rcb string set 899 *@stringset:string set index 900 *@data:strings name value 901 *@index:queue index 902 */ 903 void hns_rcb_get_strings(int stringset, u8 *data, int index) 904 { 905 char *buff = (char *)data; 906 907 if (stringset != ETH_SS_STATS) 908 return; 909 910 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_rcb_pkt_num", index); 911 buff = buff + ETH_GSTRING_LEN; 912 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_ppe_tx_pkt_num", index); 913 buff = buff + ETH_GSTRING_LEN; 914 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_ppe_drop_pkt_num", index); 915 buff = buff + ETH_GSTRING_LEN; 916 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_fbd_num", index); 917 buff = buff + ETH_GSTRING_LEN; 918 919 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_pkt_num", index); 920 buff = buff + ETH_GSTRING_LEN; 921 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_bytes", index); 922 buff = buff + ETH_GSTRING_LEN; 923 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_err_cnt", index); 924 buff = buff + ETH_GSTRING_LEN; 925 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_io_err", index); 926 buff = buff + ETH_GSTRING_LEN; 927 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_sw_err", index); 928 buff = buff + ETH_GSTRING_LEN; 929 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_seg_pkt", index); 930 buff = buff + ETH_GSTRING_LEN; 931 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_restart_queue", index); 932 buff = buff + ETH_GSTRING_LEN; 933 snprintf(buff, ETH_GSTRING_LEN, "tx_ring%d_tx_busy", index); 934 buff = buff + ETH_GSTRING_LEN; 935 936 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_rcb_pkt_num", index); 937 buff = buff + ETH_GSTRING_LEN; 938 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_ppe_pkt_num", index); 939 buff = buff + ETH_GSTRING_LEN; 940 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_ppe_drop_pkt_num", index); 941 buff = buff + ETH_GSTRING_LEN; 942 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_fbd_num", index); 943 buff = buff + ETH_GSTRING_LEN; 944 945 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_pkt_num", index); 946 buff = buff + ETH_GSTRING_LEN; 947 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_bytes", index); 948 buff = buff + ETH_GSTRING_LEN; 949 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_err_cnt", index); 950 buff = buff + ETH_GSTRING_LEN; 951 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_io_err", index); 952 buff = buff + ETH_GSTRING_LEN; 953 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_sw_err", index); 954 buff = buff + ETH_GSTRING_LEN; 955 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_seg_pkt", index); 956 buff = buff + ETH_GSTRING_LEN; 957 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_reuse_pg", index); 958 buff = buff + ETH_GSTRING_LEN; 959 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_len_err", index); 960 buff = buff + ETH_GSTRING_LEN; 961 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_non_vld_desc_err", index); 962 buff = buff + ETH_GSTRING_LEN; 963 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_bd_num_err", index); 964 buff = buff + ETH_GSTRING_LEN; 965 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_l2_err", index); 966 buff = buff + ETH_GSTRING_LEN; 967 snprintf(buff, ETH_GSTRING_LEN, "rx_ring%d_l3l4csum_err", index); 968 } 969 970 void hns_rcb_get_common_regs(struct rcb_common_cb *rcb_com, void *data) 971 { 972 u32 *regs = data; 973 bool is_ver1 = AE_IS_VER1(rcb_com->dsaf_dev->dsaf_ver); 974 bool is_dbg = HNS_DSAF_IS_DEBUG(rcb_com->dsaf_dev); 975 u32 reg_tmp; 976 u32 reg_num_tmp; 977 u32 i = 0; 978 979 /*rcb common registers */ 980 regs[0] = dsaf_read_dev(rcb_com, RCB_COM_CFG_ENDIAN_REG); 981 regs[1] = dsaf_read_dev(rcb_com, RCB_COM_CFG_SYS_FSH_REG); 982 regs[2] = dsaf_read_dev(rcb_com, RCB_COM_CFG_INIT_FLAG_REG); 983 984 regs[3] = dsaf_read_dev(rcb_com, RCB_COM_CFG_PKT_REG); 985 regs[4] = dsaf_read_dev(rcb_com, RCB_COM_CFG_RINVLD_REG); 986 regs[5] = dsaf_read_dev(rcb_com, RCB_COM_CFG_FNA_REG); 987 regs[6] = dsaf_read_dev(rcb_com, RCB_COM_CFG_FA_REG); 988 regs[7] = dsaf_read_dev(rcb_com, RCB_COM_CFG_PKT_TC_BP_REG); 989 regs[8] = dsaf_read_dev(rcb_com, RCB_COM_CFG_PPE_TNL_CLKEN_REG); 990 991 regs[9] = dsaf_read_dev(rcb_com, RCB_COM_INTMSK_TX_PKT_REG); 992 regs[10] = dsaf_read_dev(rcb_com, RCB_COM_RINT_TX_PKT_REG); 993 regs[11] = dsaf_read_dev(rcb_com, RCB_COM_INTMASK_ECC_ERR_REG); 994 regs[12] = dsaf_read_dev(rcb_com, RCB_COM_INTSTS_ECC_ERR_REG); 995 regs[13] = dsaf_read_dev(rcb_com, RCB_COM_EBD_SRAM_ERR_REG); 996 regs[14] = dsaf_read_dev(rcb_com, RCB_COM_RXRING_ERR_REG); 997 regs[15] = dsaf_read_dev(rcb_com, RCB_COM_TXRING_ERR_REG); 998 regs[16] = dsaf_read_dev(rcb_com, RCB_COM_TX_FBD_ERR_REG); 999 regs[17] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK_EN_REG); 1000 regs[18] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK0_REG); 1001 regs[19] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK1_REG); 1002 regs[20] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK2_REG); 1003 regs[21] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK3_REG); 1004 regs[22] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK4_REG); 1005 regs[23] = dsaf_read_dev(rcb_com, RCB_SRAM_ECC_CHK5_REG); 1006 regs[24] = dsaf_read_dev(rcb_com, RCB_ECC_ERR_ADDR0_REG); 1007 regs[25] = dsaf_read_dev(rcb_com, RCB_ECC_ERR_ADDR3_REG); 1008 regs[26] = dsaf_read_dev(rcb_com, RCB_ECC_ERR_ADDR4_REG); 1009 regs[27] = dsaf_read_dev(rcb_com, RCB_ECC_ERR_ADDR5_REG); 1010 1011 regs[28] = dsaf_read_dev(rcb_com, RCB_COM_SF_CFG_INTMASK_RING); 1012 regs[29] = dsaf_read_dev(rcb_com, RCB_COM_SF_CFG_RING_STS); 1013 regs[30] = dsaf_read_dev(rcb_com, RCB_COM_SF_CFG_RING); 1014 regs[31] = dsaf_read_dev(rcb_com, RCB_COM_SF_CFG_INTMASK_BD); 1015 regs[32] = dsaf_read_dev(rcb_com, RCB_COM_SF_CFG_BD_RINT_STS); 1016 regs[33] = dsaf_read_dev(rcb_com, RCB_COM_RCB_RD_BD_BUSY); 1017 regs[34] = dsaf_read_dev(rcb_com, RCB_COM_RCB_FBD_CRT_EN); 1018 regs[35] = dsaf_read_dev(rcb_com, RCB_COM_AXI_WR_ERR_INTMASK); 1019 regs[36] = dsaf_read_dev(rcb_com, RCB_COM_AXI_ERR_STS); 1020 regs[37] = dsaf_read_dev(rcb_com, RCB_COM_CHK_TX_FBD_NUM_REG); 1021 1022 /* rcb common entry registers */ 1023 for (i = 0; i < 16; i++) { /* total 16 model registers */ 1024 regs[38 + i] 1025 = dsaf_read_dev(rcb_com, RCB_CFG_BD_NUM_REG + 4 * i); 1026 regs[54 + i] 1027 = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_REG + 4 * i); 1028 } 1029 1030 reg_tmp = is_ver1 ? RCB_CFG_OVERTIME_REG : RCB_PORT_CFG_OVERTIME_REG; 1031 reg_num_tmp = (is_ver1 || is_dbg) ? 1 : 6; 1032 for (i = 0; i < reg_num_tmp; i++) 1033 regs[70 + i] = dsaf_read_dev(rcb_com, reg_tmp); 1034 1035 regs[76] = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_INT_NUM_REG); 1036 regs[77] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_INT_NUM_REG); 1037 1038 /* mark end of rcb common regs */ 1039 for (i = 78; i < 80; i++) 1040 regs[i] = 0xcccccccc; 1041 } 1042 1043 void hns_rcb_get_ring_regs(struct hnae_queue *queue, void *data) 1044 { 1045 u32 *regs = data; 1046 struct ring_pair_cb *ring_pair 1047 = container_of(queue, struct ring_pair_cb, q); 1048 u32 i = 0; 1049 1050 /*rcb ring registers */ 1051 regs[0] = dsaf_read_dev(queue, RCB_RING_RX_RING_BASEADDR_L_REG); 1052 regs[1] = dsaf_read_dev(queue, RCB_RING_RX_RING_BASEADDR_H_REG); 1053 regs[2] = dsaf_read_dev(queue, RCB_RING_RX_RING_BD_NUM_REG); 1054 regs[3] = dsaf_read_dev(queue, RCB_RING_RX_RING_BD_LEN_REG); 1055 regs[4] = dsaf_read_dev(queue, RCB_RING_RX_RING_PKTLINE_REG); 1056 regs[5] = dsaf_read_dev(queue, RCB_RING_RX_RING_TAIL_REG); 1057 regs[6] = dsaf_read_dev(queue, RCB_RING_RX_RING_HEAD_REG); 1058 regs[7] = dsaf_read_dev(queue, RCB_RING_RX_RING_FBDNUM_REG); 1059 regs[8] = dsaf_read_dev(queue, RCB_RING_RX_RING_PKTNUM_RECORD_REG); 1060 1061 regs[9] = dsaf_read_dev(queue, RCB_RING_TX_RING_BASEADDR_L_REG); 1062 regs[10] = dsaf_read_dev(queue, RCB_RING_TX_RING_BASEADDR_H_REG); 1063 regs[11] = dsaf_read_dev(queue, RCB_RING_TX_RING_BD_NUM_REG); 1064 regs[12] = dsaf_read_dev(queue, RCB_RING_TX_RING_BD_LEN_REG); 1065 regs[13] = dsaf_read_dev(queue, RCB_RING_TX_RING_PKTLINE_REG); 1066 regs[15] = dsaf_read_dev(queue, RCB_RING_TX_RING_TAIL_REG); 1067 regs[16] = dsaf_read_dev(queue, RCB_RING_TX_RING_HEAD_REG); 1068 regs[17] = dsaf_read_dev(queue, RCB_RING_TX_RING_FBDNUM_REG); 1069 regs[18] = dsaf_read_dev(queue, RCB_RING_TX_RING_OFFSET_REG); 1070 regs[19] = dsaf_read_dev(queue, RCB_RING_TX_RING_PKTNUM_RECORD_REG); 1071 1072 regs[20] = dsaf_read_dev(queue, RCB_RING_PREFETCH_EN_REG); 1073 regs[21] = dsaf_read_dev(queue, RCB_RING_CFG_VF_NUM_REG); 1074 regs[22] = dsaf_read_dev(queue, RCB_RING_ASID_REG); 1075 regs[23] = dsaf_read_dev(queue, RCB_RING_RX_VM_REG); 1076 regs[24] = dsaf_read_dev(queue, RCB_RING_T0_BE_RST); 1077 regs[25] = dsaf_read_dev(queue, RCB_RING_COULD_BE_RST); 1078 regs[26] = dsaf_read_dev(queue, RCB_RING_WRR_WEIGHT_REG); 1079 1080 regs[27] = dsaf_read_dev(queue, RCB_RING_INTMSK_RXWL_REG); 1081 regs[28] = dsaf_read_dev(queue, RCB_RING_INTSTS_RX_RING_REG); 1082 regs[29] = dsaf_read_dev(queue, RCB_RING_INTMSK_TXWL_REG); 1083 regs[30] = dsaf_read_dev(queue, RCB_RING_INTSTS_TX_RING_REG); 1084 regs[31] = dsaf_read_dev(queue, RCB_RING_INTMSK_RX_OVERTIME_REG); 1085 regs[32] = dsaf_read_dev(queue, RCB_RING_INTSTS_RX_OVERTIME_REG); 1086 regs[33] = dsaf_read_dev(queue, RCB_RING_INTMSK_TX_OVERTIME_REG); 1087 regs[34] = dsaf_read_dev(queue, RCB_RING_INTSTS_TX_OVERTIME_REG); 1088 1089 /* mark end of ring regs */ 1090 for (i = 35; i < 40; i++) 1091 regs[i] = 0xcccccc00 + ring_pair->index; 1092 } 1093