1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (c) 2014-2015 Hisilicon Limited. 4 */ 5 6 #include <linux/etherdevice.h> 7 #include <linux/netdevice.h> 8 #include <linux/spinlock.h> 9 10 #include "hnae.h" 11 #include "hns_dsaf_mac.h" 12 #include "hns_dsaf_main.h" 13 #include "hns_dsaf_ppe.h" 14 #include "hns_dsaf_rcb.h" 15 16 #define AE_NAME_PORT_ID_IDX 6 17 18 static struct hns_mac_cb *hns_get_mac_cb(struct hnae_handle *handle) 19 { 20 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 21 22 return vf_cb->mac_cb; 23 } 24 25 static struct dsaf_device *hns_ae_get_dsaf_dev(struct hnae_ae_dev *dev) 26 { 27 return container_of(dev, struct dsaf_device, ae_dev); 28 } 29 30 static struct hns_ppe_cb *hns_get_ppe_cb(struct hnae_handle *handle) 31 { 32 int ppe_index; 33 struct ppe_common_cb *ppe_comm; 34 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 35 36 ppe_comm = vf_cb->dsaf_dev->ppe_common[0]; 37 ppe_index = vf_cb->port_index; 38 39 return &ppe_comm->ppe_cb[ppe_index]; 40 } 41 42 static int hns_ae_get_q_num_per_vf( 43 struct dsaf_device *dsaf_dev, int port) 44 { 45 return dsaf_dev->rcb_common[0]->max_q_per_vf; 46 } 47 48 static int hns_ae_get_vf_num_per_port( 49 struct dsaf_device *dsaf_dev, int port) 50 { 51 return dsaf_dev->rcb_common[0]->max_vfn; 52 } 53 54 static struct ring_pair_cb *hns_ae_get_base_ring_pair( 55 struct dsaf_device *dsaf_dev, int port) 56 { 57 struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[0]; 58 int q_num = rcb_comm->max_q_per_vf; 59 int vf_num = rcb_comm->max_vfn; 60 61 return &rcb_comm->ring_pair_cb[port * q_num * vf_num]; 62 } 63 64 static struct ring_pair_cb *hns_ae_get_ring_pair(struct hnae_queue *q) 65 { 66 return container_of(q, struct ring_pair_cb, q); 67 } 68 69 static struct hnae_handle *hns_ae_get_handle(struct hnae_ae_dev *dev, 70 u32 port_id) 71 { 72 int vfnum_per_port; 73 int qnum_per_vf; 74 int i; 75 struct dsaf_device *dsaf_dev; 76 struct hnae_handle *ae_handle; 77 struct ring_pair_cb *ring_pair_cb; 78 struct hnae_vf_cb *vf_cb; 79 80 dsaf_dev = hns_ae_get_dsaf_dev(dev); 81 82 ring_pair_cb = hns_ae_get_base_ring_pair(dsaf_dev, port_id); 83 vfnum_per_port = hns_ae_get_vf_num_per_port(dsaf_dev, port_id); 84 qnum_per_vf = hns_ae_get_q_num_per_vf(dsaf_dev, port_id); 85 86 vf_cb = kzalloc(sizeof(*vf_cb) + 87 qnum_per_vf * sizeof(struct hnae_queue *), GFP_KERNEL); 88 if (unlikely(!vf_cb)) { 89 dev_err(dsaf_dev->dev, "malloc vf_cb fail!\n"); 90 ae_handle = ERR_PTR(-ENOMEM); 91 goto handle_err; 92 } 93 ae_handle = &vf_cb->ae_handle; 94 /* ae_handle Init */ 95 ae_handle->owner_dev = dsaf_dev->dev; 96 ae_handle->dev = dev; 97 ae_handle->q_num = qnum_per_vf; 98 ae_handle->coal_param = HNAE_LOWEST_LATENCY_COAL_PARAM; 99 100 /* find ring pair, and set vf id*/ 101 for (ae_handle->vf_id = 0; 102 ae_handle->vf_id < vfnum_per_port; ae_handle->vf_id++) { 103 if (!ring_pair_cb->used_by_vf) 104 break; 105 ring_pair_cb += qnum_per_vf; 106 } 107 if (ae_handle->vf_id >= vfnum_per_port) { 108 dev_err(dsaf_dev->dev, "malloc queue fail!\n"); 109 ae_handle = ERR_PTR(-EINVAL); 110 goto vf_id_err; 111 } 112 113 ae_handle->qs = (struct hnae_queue **)(&ae_handle->qs + 1); 114 for (i = 0; i < qnum_per_vf; i++) { 115 ae_handle->qs[i] = &ring_pair_cb->q; 116 ae_handle->qs[i]->rx_ring.q = ae_handle->qs[i]; 117 ae_handle->qs[i]->tx_ring.q = ae_handle->qs[i]; 118 119 ring_pair_cb->used_by_vf = 1; 120 ring_pair_cb++; 121 } 122 123 vf_cb->dsaf_dev = dsaf_dev; 124 vf_cb->port_index = port_id; 125 vf_cb->mac_cb = dsaf_dev->mac_cb[port_id]; 126 127 ae_handle->phy_if = vf_cb->mac_cb->phy_if; 128 ae_handle->phy_dev = vf_cb->mac_cb->phy_dev; 129 ae_handle->if_support = vf_cb->mac_cb->if_support; 130 ae_handle->port_type = vf_cb->mac_cb->mac_type; 131 ae_handle->media_type = vf_cb->mac_cb->media_type; 132 ae_handle->dport_id = port_id; 133 134 return ae_handle; 135 vf_id_err: 136 kfree(vf_cb); 137 handle_err: 138 return ae_handle; 139 } 140 141 static void hns_ae_put_handle(struct hnae_handle *handle) 142 { 143 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 144 int i; 145 146 for (i = 0; i < handle->q_num; i++) 147 hns_ae_get_ring_pair(handle->qs[i])->used_by_vf = 0; 148 149 kfree(vf_cb); 150 } 151 152 static int hns_ae_wait_flow_down(struct hnae_handle *handle) 153 { 154 struct dsaf_device *dsaf_dev; 155 struct hns_ppe_cb *ppe_cb; 156 struct hnae_vf_cb *vf_cb; 157 int ret; 158 int i; 159 160 for (i = 0; i < handle->q_num; i++) { 161 ret = hns_rcb_wait_tx_ring_clean(handle->qs[i]); 162 if (ret) 163 return ret; 164 } 165 166 ppe_cb = hns_get_ppe_cb(handle); 167 ret = hns_ppe_wait_tx_fifo_clean(ppe_cb); 168 if (ret) 169 return ret; 170 171 dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 172 if (!dsaf_dev) 173 return -EINVAL; 174 ret = hns_dsaf_wait_pkt_clean(dsaf_dev, handle->dport_id); 175 if (ret) 176 return ret; 177 178 vf_cb = hns_ae_get_vf_cb(handle); 179 ret = hns_mac_wait_fifo_clean(vf_cb->mac_cb); 180 if (ret) 181 return ret; 182 183 mdelay(10); 184 return 0; 185 } 186 187 static void hns_ae_ring_enable_all(struct hnae_handle *handle, int val) 188 { 189 int q_num = handle->q_num; 190 int i; 191 192 for (i = 0; i < q_num; i++) 193 hns_rcb_ring_enable_hw(handle->qs[i], val); 194 } 195 196 static void hns_ae_init_queue(struct hnae_queue *q) 197 { 198 struct ring_pair_cb *ring = 199 container_of(q, struct ring_pair_cb, q); 200 201 hns_rcb_init_hw(ring); 202 } 203 204 static void hns_ae_fini_queue(struct hnae_queue *q) 205 { 206 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(q->handle); 207 208 if (vf_cb->mac_cb->mac_type == HNAE_PORT_SERVICE) 209 hns_rcb_reset_ring_hw(q); 210 } 211 212 static int hns_ae_set_mac_address(struct hnae_handle *handle, void *p) 213 { 214 int ret; 215 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 216 217 if (!p || !is_valid_ether_addr((const u8 *)p)) { 218 dev_err(handle->owner_dev, "is not valid ether addr !\n"); 219 return -EADDRNOTAVAIL; 220 } 221 222 ret = hns_mac_change_vf_addr(mac_cb, handle->vf_id, p); 223 if (ret != 0) { 224 dev_err(handle->owner_dev, 225 "set_mac_address fail, ret=%d!\n", ret); 226 return ret; 227 } 228 229 return 0; 230 } 231 232 static int hns_ae_add_uc_address(struct hnae_handle *handle, 233 const unsigned char *addr) 234 { 235 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 236 237 if (mac_cb->mac_type != HNAE_PORT_SERVICE) 238 return -ENOSPC; 239 240 return hns_mac_add_uc_addr(mac_cb, handle->vf_id, addr); 241 } 242 243 static int hns_ae_rm_uc_address(struct hnae_handle *handle, 244 const unsigned char *addr) 245 { 246 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 247 248 if (mac_cb->mac_type != HNAE_PORT_SERVICE) 249 return -ENOSPC; 250 251 return hns_mac_rm_uc_addr(mac_cb, handle->vf_id, addr); 252 } 253 254 static int hns_ae_set_multicast_one(struct hnae_handle *handle, void *addr) 255 { 256 int ret; 257 char *mac_addr = (char *)addr; 258 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 259 u8 port_num; 260 261 assert(mac_cb); 262 263 if (mac_cb->mac_type != HNAE_PORT_SERVICE) 264 return 0; 265 266 ret = hns_mac_set_multi(mac_cb, mac_cb->mac_id, mac_addr, true); 267 if (ret) { 268 dev_err(handle->owner_dev, 269 "mac add mul_mac:%pM port%d fail, ret = %#x!\n", 270 mac_addr, mac_cb->mac_id, ret); 271 return ret; 272 } 273 274 ret = hns_mac_get_inner_port_num(mac_cb, handle->vf_id, &port_num); 275 if (ret) 276 return ret; 277 278 ret = hns_mac_set_multi(mac_cb, port_num, mac_addr, true); 279 if (ret) 280 dev_err(handle->owner_dev, 281 "mac add mul_mac:%pM port%d fail, ret = %#x!\n", 282 mac_addr, DSAF_BASE_INNER_PORT_NUM, ret); 283 284 return ret; 285 } 286 287 static int hns_ae_clr_multicast(struct hnae_handle *handle) 288 { 289 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 290 291 if (mac_cb->mac_type != HNAE_PORT_SERVICE) 292 return 0; 293 294 return hns_mac_clr_multicast(mac_cb, handle->vf_id); 295 } 296 297 static int hns_ae_set_mtu(struct hnae_handle *handle, int new_mtu) 298 { 299 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 300 struct hnae_queue *q; 301 u32 rx_buf_size; 302 int i, ret; 303 304 /* when buf_size is 2048, max mtu is 6K for rx ring max bd num is 3. */ 305 if (!AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver)) { 306 if (new_mtu <= BD_SIZE_2048_MAX_MTU) 307 rx_buf_size = 2048; 308 else 309 rx_buf_size = 4096; 310 } else { 311 rx_buf_size = mac_cb->dsaf_dev->buf_size; 312 } 313 314 ret = hns_mac_set_mtu(mac_cb, new_mtu, rx_buf_size); 315 316 if (!ret) { 317 /* reinit ring buf_size */ 318 for (i = 0; i < handle->q_num; i++) { 319 q = handle->qs[i]; 320 q->rx_ring.buf_size = rx_buf_size; 321 hns_rcb_set_rx_ring_bs(q, rx_buf_size); 322 } 323 } 324 325 return ret; 326 } 327 328 static void hns_ae_set_tso_stats(struct hnae_handle *handle, int enable) 329 { 330 struct hns_ppe_cb *ppe_cb = hns_get_ppe_cb(handle); 331 332 hns_ppe_set_tso_enable(ppe_cb, enable); 333 } 334 335 static int hns_ae_start(struct hnae_handle *handle) 336 { 337 int ret; 338 int k; 339 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 340 341 ret = hns_mac_vm_config_bc_en(mac_cb, 0, true); 342 if (ret) 343 return ret; 344 345 for (k = 0; k < handle->q_num; k++) { 346 if (AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver)) 347 hns_rcb_int_clr_hw(handle->qs[k], 348 RCB_INT_FLAG_TX | RCB_INT_FLAG_RX); 349 else 350 hns_rcbv2_int_clr_hw(handle->qs[k], 351 RCB_INT_FLAG_TX | RCB_INT_FLAG_RX); 352 } 353 hns_ae_ring_enable_all(handle, 1); 354 msleep(100); 355 356 hns_mac_start(mac_cb); 357 358 return 0; 359 } 360 361 static void hns_ae_stop(struct hnae_handle *handle) 362 { 363 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 364 365 /* just clean tx fbd, neednot rx fbd*/ 366 hns_rcb_wait_fbd_clean(handle->qs, handle->q_num, RCB_INT_FLAG_TX); 367 368 msleep(20); 369 370 hns_mac_stop(mac_cb); 371 372 usleep_range(10000, 20000); 373 374 hns_ae_ring_enable_all(handle, 0); 375 376 /* clean rx fbd. */ 377 hns_rcb_wait_fbd_clean(handle->qs, handle->q_num, RCB_INT_FLAG_RX); 378 379 (void)hns_mac_vm_config_bc_en(mac_cb, 0, false); 380 } 381 382 static void hns_ae_reset(struct hnae_handle *handle) 383 { 384 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 385 386 if (vf_cb->mac_cb->mac_type == HNAE_PORT_DEBUG) { 387 hns_mac_reset(vf_cb->mac_cb); 388 hns_ppe_reset_common(vf_cb->dsaf_dev, 0); 389 } 390 } 391 392 static void hns_ae_toggle_ring_irq(struct hnae_ring *ring, u32 mask) 393 { 394 u32 flag; 395 396 if (is_tx_ring(ring)) 397 flag = RCB_INT_FLAG_TX; 398 else 399 flag = RCB_INT_FLAG_RX; 400 401 hns_rcb_int_ctrl_hw(ring->q, flag, mask); 402 } 403 404 static void hns_aev2_toggle_ring_irq(struct hnae_ring *ring, u32 mask) 405 { 406 u32 flag; 407 408 if (is_tx_ring(ring)) 409 flag = RCB_INT_FLAG_TX; 410 else 411 flag = RCB_INT_FLAG_RX; 412 413 hns_rcbv2_int_ctrl_hw(ring->q, flag, mask); 414 } 415 416 static int hns_ae_get_link_status(struct hnae_handle *handle) 417 { 418 u32 link_status; 419 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 420 421 hns_mac_get_link_status(mac_cb, &link_status); 422 423 return !!link_status; 424 } 425 426 static int hns_ae_get_mac_info(struct hnae_handle *handle, 427 u8 *auto_neg, u16 *speed, u8 *duplex) 428 { 429 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 430 431 return hns_mac_get_port_info(mac_cb, auto_neg, speed, duplex); 432 } 433 434 static bool hns_ae_need_adjust_link(struct hnae_handle *handle, int speed, 435 int duplex) 436 { 437 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 438 439 return hns_mac_need_adjust_link(mac_cb, speed, duplex); 440 } 441 442 static void hns_ae_adjust_link(struct hnae_handle *handle, int speed, 443 int duplex) 444 { 445 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 446 447 switch (mac_cb->dsaf_dev->dsaf_ver) { 448 case AE_VERSION_1: 449 hns_mac_adjust_link(mac_cb, speed, duplex); 450 break; 451 452 case AE_VERSION_2: 453 /* chip need to clear all pkt inside */ 454 hns_mac_disable(mac_cb, MAC_COMM_MODE_RX); 455 if (hns_ae_wait_flow_down(handle)) { 456 hns_mac_enable(mac_cb, MAC_COMM_MODE_RX); 457 break; 458 } 459 460 hns_mac_adjust_link(mac_cb, speed, duplex); 461 hns_mac_enable(mac_cb, MAC_COMM_MODE_RX); 462 break; 463 464 default: 465 break; 466 } 467 468 return; 469 } 470 471 static void hns_ae_get_ring_bdnum_limit(struct hnae_queue *queue, 472 u32 *uplimit) 473 { 474 *uplimit = HNS_RCB_RING_MAX_PENDING_BD; 475 } 476 477 static void hns_ae_get_pauseparam(struct hnae_handle *handle, 478 u32 *auto_neg, u32 *rx_en, u32 *tx_en) 479 { 480 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 481 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 482 483 hns_mac_get_autoneg(mac_cb, auto_neg); 484 485 hns_mac_get_pauseparam(mac_cb, rx_en, tx_en); 486 487 /* Service port's pause feature is provided by DSAF, not mac */ 488 if (handle->port_type == HNAE_PORT_SERVICE) 489 hns_dsaf_get_rx_mac_pause_en(dsaf_dev, mac_cb->mac_id, rx_en); 490 } 491 492 static int hns_ae_set_autoneg(struct hnae_handle *handle, u8 enable) 493 { 494 assert(handle); 495 496 return hns_mac_set_autoneg(hns_get_mac_cb(handle), enable); 497 } 498 499 static void hns_ae_set_promisc_mode(struct hnae_handle *handle, u32 en) 500 { 501 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 502 503 hns_dsaf_set_promisc_mode(hns_ae_get_dsaf_dev(handle->dev), en); 504 hns_mac_set_promisc(mac_cb, (u8)!!en); 505 } 506 507 static int hns_ae_get_autoneg(struct hnae_handle *handle) 508 { 509 u32 auto_neg; 510 511 assert(handle); 512 513 hns_mac_get_autoneg(hns_get_mac_cb(handle), &auto_neg); 514 515 return auto_neg; 516 } 517 518 static int hns_ae_set_pauseparam(struct hnae_handle *handle, 519 u32 autoneg, u32 rx_en, u32 tx_en) 520 { 521 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 522 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 523 int ret; 524 525 ret = hns_mac_set_autoneg(mac_cb, autoneg); 526 if (ret) 527 return ret; 528 529 /* Service port's pause feature is provided by DSAF, not mac */ 530 if (handle->port_type == HNAE_PORT_SERVICE) { 531 ret = hns_dsaf_set_rx_mac_pause_en(dsaf_dev, 532 mac_cb->mac_id, rx_en); 533 if (ret) 534 return ret; 535 rx_en = 0; 536 } 537 return hns_mac_set_pauseparam(mac_cb, rx_en, tx_en); 538 } 539 540 static void hns_ae_get_coalesce_usecs(struct hnae_handle *handle, 541 u32 *tx_usecs, u32 *rx_usecs) 542 { 543 struct ring_pair_cb *ring_pair = 544 container_of(handle->qs[0], struct ring_pair_cb, q); 545 546 *tx_usecs = hns_rcb_get_coalesce_usecs(ring_pair->rcb_common, 547 ring_pair->port_id_in_comm); 548 *rx_usecs = hns_rcb_get_coalesce_usecs(ring_pair->rcb_common, 549 ring_pair->port_id_in_comm); 550 } 551 552 static void hns_ae_get_max_coalesced_frames(struct hnae_handle *handle, 553 u32 *tx_frames, u32 *rx_frames) 554 { 555 struct ring_pair_cb *ring_pair = 556 container_of(handle->qs[0], struct ring_pair_cb, q); 557 struct dsaf_device *dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 558 559 if (AE_IS_VER1(dsaf_dev->dsaf_ver) || 560 handle->port_type == HNAE_PORT_DEBUG) 561 *tx_frames = hns_rcb_get_rx_coalesced_frames( 562 ring_pair->rcb_common, ring_pair->port_id_in_comm); 563 else 564 *tx_frames = hns_rcb_get_tx_coalesced_frames( 565 ring_pair->rcb_common, ring_pair->port_id_in_comm); 566 *rx_frames = hns_rcb_get_rx_coalesced_frames(ring_pair->rcb_common, 567 ring_pair->port_id_in_comm); 568 } 569 570 static int hns_ae_set_coalesce_usecs(struct hnae_handle *handle, 571 u32 timeout) 572 { 573 struct ring_pair_cb *ring_pair = 574 container_of(handle->qs[0], struct ring_pair_cb, q); 575 576 return hns_rcb_set_coalesce_usecs( 577 ring_pair->rcb_common, ring_pair->port_id_in_comm, timeout); 578 } 579 580 static int hns_ae_set_coalesce_frames(struct hnae_handle *handle, 581 u32 tx_frames, u32 rx_frames) 582 { 583 int ret; 584 struct ring_pair_cb *ring_pair = 585 container_of(handle->qs[0], struct ring_pair_cb, q); 586 struct dsaf_device *dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 587 588 if (AE_IS_VER1(dsaf_dev->dsaf_ver) || 589 handle->port_type == HNAE_PORT_DEBUG) { 590 if (tx_frames != rx_frames) 591 return -EINVAL; 592 return hns_rcb_set_rx_coalesced_frames( 593 ring_pair->rcb_common, 594 ring_pair->port_id_in_comm, rx_frames); 595 } else { 596 if (tx_frames != 1) 597 return -EINVAL; 598 ret = hns_rcb_set_tx_coalesced_frames( 599 ring_pair->rcb_common, 600 ring_pair->port_id_in_comm, tx_frames); 601 if (ret) 602 return ret; 603 604 return hns_rcb_set_rx_coalesced_frames( 605 ring_pair->rcb_common, 606 ring_pair->port_id_in_comm, rx_frames); 607 } 608 } 609 610 static void hns_ae_get_coalesce_range(struct hnae_handle *handle, 611 u32 *tx_frames_low, u32 *rx_frames_low, 612 u32 *tx_frames_high, u32 *rx_frames_high, 613 u32 *tx_usecs_low, u32 *rx_usecs_low, 614 u32 *tx_usecs_high, u32 *rx_usecs_high) 615 { 616 struct dsaf_device *dsaf_dev; 617 618 assert(handle); 619 620 dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 621 622 *tx_frames_low = HNS_RCB_TX_FRAMES_LOW; 623 *rx_frames_low = HNS_RCB_RX_FRAMES_LOW; 624 625 if (AE_IS_VER1(dsaf_dev->dsaf_ver) || 626 handle->port_type == HNAE_PORT_DEBUG) 627 *tx_frames_high = 628 (dsaf_dev->desc_num - 1 > HNS_RCB_TX_FRAMES_HIGH) ? 629 HNS_RCB_TX_FRAMES_HIGH : dsaf_dev->desc_num - 1; 630 else 631 *tx_frames_high = 1; 632 633 *rx_frames_high = (dsaf_dev->desc_num - 1 > HNS_RCB_RX_FRAMES_HIGH) ? 634 HNS_RCB_RX_FRAMES_HIGH : dsaf_dev->desc_num - 1; 635 *tx_usecs_low = HNS_RCB_TX_USECS_LOW; 636 *rx_usecs_low = HNS_RCB_RX_USECS_LOW; 637 *tx_usecs_high = HNS_RCB_TX_USECS_HIGH; 638 *rx_usecs_high = HNS_RCB_RX_USECS_HIGH; 639 } 640 641 static void hns_ae_update_stats(struct hnae_handle *handle, 642 struct net_device_stats *net_stats) 643 { 644 int port; 645 int idx; 646 struct dsaf_device *dsaf_dev; 647 struct hns_mac_cb *mac_cb; 648 struct hns_ppe_cb *ppe_cb; 649 struct hnae_queue *queue; 650 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 651 u64 tx_bytes = 0, rx_bytes = 0, tx_packets = 0, rx_packets = 0; 652 u64 rx_errors = 0, tx_errors = 0, tx_dropped = 0; 653 u64 rx_missed_errors = 0; 654 655 dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 656 if (!dsaf_dev) 657 return; 658 port = vf_cb->port_index; 659 ppe_cb = hns_get_ppe_cb(handle); 660 mac_cb = hns_get_mac_cb(handle); 661 662 for (idx = 0; idx < handle->q_num; idx++) { 663 queue = handle->qs[idx]; 664 hns_rcb_update_stats(queue); 665 666 tx_bytes += queue->tx_ring.stats.tx_bytes; 667 tx_packets += queue->tx_ring.stats.tx_pkts; 668 rx_bytes += queue->rx_ring.stats.rx_bytes; 669 rx_packets += queue->rx_ring.stats.rx_pkts; 670 671 rx_errors += queue->rx_ring.stats.err_pkt_len 672 + queue->rx_ring.stats.l2_err 673 + queue->rx_ring.stats.l3l4_csum_err; 674 } 675 676 hns_ppe_update_stats(ppe_cb); 677 rx_missed_errors = ppe_cb->hw_stats.rx_drop_no_buf; 678 tx_errors += ppe_cb->hw_stats.tx_err_checksum 679 + ppe_cb->hw_stats.tx_err_fifo_empty; 680 681 if (mac_cb->mac_type == HNAE_PORT_SERVICE) { 682 hns_dsaf_update_stats(dsaf_dev, port); 683 /* for port upline direction, i.e., rx. */ 684 rx_missed_errors += dsaf_dev->hw_stats[port].bp_drop; 685 rx_missed_errors += dsaf_dev->hw_stats[port].pad_drop; 686 rx_missed_errors += dsaf_dev->hw_stats[port].crc_false; 687 688 /* for port downline direction, i.e., tx. */ 689 port = port + DSAF_PPE_INODE_BASE; 690 hns_dsaf_update_stats(dsaf_dev, port); 691 tx_dropped += dsaf_dev->hw_stats[port].bp_drop; 692 tx_dropped += dsaf_dev->hw_stats[port].pad_drop; 693 tx_dropped += dsaf_dev->hw_stats[port].crc_false; 694 tx_dropped += dsaf_dev->hw_stats[port].rslt_drop; 695 tx_dropped += dsaf_dev->hw_stats[port].vlan_drop; 696 tx_dropped += dsaf_dev->hw_stats[port].stp_drop; 697 } 698 699 hns_mac_update_stats(mac_cb); 700 rx_errors += mac_cb->hw_stats.rx_fifo_overrun_err; 701 702 tx_errors += mac_cb->hw_stats.tx_bad_pkts 703 + mac_cb->hw_stats.tx_fragment_err 704 + mac_cb->hw_stats.tx_jabber_err 705 + mac_cb->hw_stats.tx_underrun_err 706 + mac_cb->hw_stats.tx_crc_err; 707 708 net_stats->tx_bytes = tx_bytes; 709 net_stats->tx_packets = tx_packets; 710 net_stats->rx_bytes = rx_bytes; 711 net_stats->rx_dropped = 0; 712 net_stats->rx_packets = rx_packets; 713 net_stats->rx_errors = rx_errors; 714 net_stats->tx_errors = tx_errors; 715 net_stats->tx_dropped = tx_dropped; 716 net_stats->rx_missed_errors = rx_missed_errors; 717 net_stats->rx_crc_errors = mac_cb->hw_stats.rx_fcs_err; 718 net_stats->rx_frame_errors = mac_cb->hw_stats.rx_align_err; 719 net_stats->rx_fifo_errors = mac_cb->hw_stats.rx_fifo_overrun_err; 720 net_stats->rx_length_errors = mac_cb->hw_stats.rx_len_err; 721 net_stats->multicast = mac_cb->hw_stats.rx_mc_pkts; 722 } 723 724 static void hns_ae_get_stats(struct hnae_handle *handle, u64 *data) 725 { 726 int idx; 727 struct hns_mac_cb *mac_cb; 728 struct hns_ppe_cb *ppe_cb; 729 u64 *p = data; 730 struct hnae_vf_cb *vf_cb; 731 732 if (!handle || !data) { 733 pr_err("hns_ae_get_stats NULL handle or data pointer!\n"); 734 return; 735 } 736 737 vf_cb = hns_ae_get_vf_cb(handle); 738 mac_cb = hns_get_mac_cb(handle); 739 ppe_cb = hns_get_ppe_cb(handle); 740 741 for (idx = 0; idx < handle->q_num; idx++) { 742 hns_rcb_get_stats(handle->qs[idx], p); 743 p += hns_rcb_get_ring_sset_count((int)ETH_SS_STATS); 744 } 745 746 hns_ppe_get_stats(ppe_cb, p); 747 p += hns_ppe_get_sset_count((int)ETH_SS_STATS); 748 749 hns_mac_get_stats(mac_cb, p); 750 p += hns_mac_get_sset_count(mac_cb, (int)ETH_SS_STATS); 751 752 if (mac_cb->mac_type == HNAE_PORT_SERVICE) 753 hns_dsaf_get_stats(vf_cb->dsaf_dev, p, vf_cb->port_index); 754 } 755 756 static void hns_ae_get_strings(struct hnae_handle *handle, 757 u32 stringset, u8 *data) 758 { 759 int port; 760 int idx; 761 struct hns_mac_cb *mac_cb; 762 struct hns_ppe_cb *ppe_cb; 763 struct dsaf_device *dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 764 u8 *p = data; 765 struct hnae_vf_cb *vf_cb; 766 767 assert(handle); 768 769 vf_cb = hns_ae_get_vf_cb(handle); 770 port = vf_cb->port_index; 771 mac_cb = hns_get_mac_cb(handle); 772 ppe_cb = hns_get_ppe_cb(handle); 773 774 for (idx = 0; idx < handle->q_num; idx++) { 775 hns_rcb_get_strings(stringset, p, idx); 776 p += ETH_GSTRING_LEN * hns_rcb_get_ring_sset_count(stringset); 777 } 778 779 hns_ppe_get_strings(ppe_cb, stringset, p); 780 p += ETH_GSTRING_LEN * hns_ppe_get_sset_count(stringset); 781 782 hns_mac_get_strings(mac_cb, stringset, p); 783 p += ETH_GSTRING_LEN * hns_mac_get_sset_count(mac_cb, stringset); 784 785 if (mac_cb->mac_type == HNAE_PORT_SERVICE) 786 hns_dsaf_get_strings(stringset, p, port, dsaf_dev); 787 } 788 789 static int hns_ae_get_sset_count(struct hnae_handle *handle, int stringset) 790 { 791 u32 sset_count = 0; 792 struct hns_mac_cb *mac_cb; 793 struct dsaf_device *dsaf_dev = hns_ae_get_dsaf_dev(handle->dev); 794 795 assert(handle); 796 797 mac_cb = hns_get_mac_cb(handle); 798 799 sset_count += hns_rcb_get_ring_sset_count(stringset) * handle->q_num; 800 sset_count += hns_ppe_get_sset_count(stringset); 801 sset_count += hns_mac_get_sset_count(mac_cb, stringset); 802 803 if (mac_cb->mac_type == HNAE_PORT_SERVICE) 804 sset_count += hns_dsaf_get_sset_count(dsaf_dev, stringset); 805 806 return sset_count; 807 } 808 809 static int hns_ae_config_loopback(struct hnae_handle *handle, 810 enum hnae_loop loop, int en) 811 { 812 int ret; 813 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 814 struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle); 815 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 816 817 switch (loop) { 818 case MAC_INTERNALLOOP_PHY: 819 ret = 0; 820 break; 821 case MAC_INTERNALLOOP_SERDES: 822 ret = dsaf_dev->misc_op->cfg_serdes_loopback(vf_cb->mac_cb, 823 !!en); 824 break; 825 case MAC_INTERNALLOOP_MAC: 826 ret = hns_mac_config_mac_loopback(vf_cb->mac_cb, loop, en); 827 break; 828 default: 829 ret = -EINVAL; 830 } 831 832 return ret; 833 } 834 835 static void hns_ae_update_led_status(struct hnae_handle *handle) 836 { 837 struct hns_mac_cb *mac_cb; 838 839 assert(handle); 840 mac_cb = hns_get_mac_cb(handle); 841 if (mac_cb->media_type != HNAE_MEDIA_TYPE_FIBER) 842 return; 843 844 hns_set_led_opt(mac_cb); 845 } 846 847 static int hns_ae_cpld_set_led_id(struct hnae_handle *handle, 848 enum hnae_led_state status) 849 { 850 struct hns_mac_cb *mac_cb; 851 852 assert(handle); 853 854 mac_cb = hns_get_mac_cb(handle); 855 856 return hns_cpld_led_set_id(mac_cb, status); 857 } 858 859 static void hns_ae_get_regs(struct hnae_handle *handle, void *data) 860 { 861 u32 *p = data; 862 int i; 863 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 864 struct hns_ppe_cb *ppe_cb = hns_get_ppe_cb(handle); 865 866 hns_ppe_get_regs(ppe_cb, p); 867 p += hns_ppe_get_regs_count(); 868 869 hns_rcb_get_common_regs(vf_cb->dsaf_dev->rcb_common[0], p); 870 p += hns_rcb_get_common_regs_count(); 871 872 for (i = 0; i < handle->q_num; i++) { 873 hns_rcb_get_ring_regs(handle->qs[i], p); 874 p += hns_rcb_get_ring_regs_count(); 875 } 876 877 hns_mac_get_regs(vf_cb->mac_cb, p); 878 p += hns_mac_get_regs_count(vf_cb->mac_cb); 879 880 if (vf_cb->mac_cb->mac_type == HNAE_PORT_SERVICE) 881 hns_dsaf_get_regs(vf_cb->dsaf_dev, vf_cb->port_index, p); 882 } 883 884 static int hns_ae_get_regs_len(struct hnae_handle *handle) 885 { 886 u32 total_num; 887 struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle); 888 889 total_num = hns_ppe_get_regs_count(); 890 total_num += hns_rcb_get_common_regs_count(); 891 total_num += hns_rcb_get_ring_regs_count() * handle->q_num; 892 total_num += hns_mac_get_regs_count(vf_cb->mac_cb); 893 894 if (vf_cb->mac_cb->mac_type == HNAE_PORT_SERVICE) 895 total_num += hns_dsaf_get_regs_count(); 896 897 return total_num; 898 } 899 900 static u32 hns_ae_get_rss_key_size(struct hnae_handle *handle) 901 { 902 return HNS_PPEV2_RSS_KEY_SIZE; 903 } 904 905 static u32 hns_ae_get_rss_indir_size(struct hnae_handle *handle) 906 { 907 return HNS_PPEV2_RSS_IND_TBL_SIZE; 908 } 909 910 static int hns_ae_get_rss(struct hnae_handle *handle, u32 *indir, u8 *key, 911 u8 *hfunc) 912 { 913 struct hns_ppe_cb *ppe_cb = hns_get_ppe_cb(handle); 914 915 /* currently we support only one type of hash function i.e. Toep hash */ 916 if (hfunc) 917 *hfunc = ETH_RSS_HASH_TOP; 918 919 /* get the RSS Key required by the user */ 920 if (key) 921 memcpy(key, ppe_cb->rss_key, HNS_PPEV2_RSS_KEY_SIZE); 922 923 /* update the current hash->queue mappings from the shadow RSS table */ 924 if (indir) 925 memcpy(indir, ppe_cb->rss_indir_table, 926 HNS_PPEV2_RSS_IND_TBL_SIZE * sizeof(*indir)); 927 928 return 0; 929 } 930 931 static int hns_ae_set_rss(struct hnae_handle *handle, const u32 *indir, 932 const u8 *key, const u8 hfunc) 933 { 934 struct hns_ppe_cb *ppe_cb = hns_get_ppe_cb(handle); 935 936 /* set the RSS Hash Key if specififed by the user */ 937 if (key) { 938 memcpy(ppe_cb->rss_key, key, HNS_PPEV2_RSS_KEY_SIZE); 939 hns_ppe_set_rss_key(ppe_cb, ppe_cb->rss_key); 940 } 941 942 if (indir) { 943 /* update the shadow RSS table with user specified qids */ 944 memcpy(ppe_cb->rss_indir_table, indir, 945 HNS_PPEV2_RSS_IND_TBL_SIZE * sizeof(*indir)); 946 947 /* now update the hardware */ 948 hns_ppe_set_indir_table(ppe_cb, ppe_cb->rss_indir_table); 949 } 950 951 return 0; 952 } 953 954 static struct hnae_ae_ops hns_dsaf_ops = { 955 .get_handle = hns_ae_get_handle, 956 .put_handle = hns_ae_put_handle, 957 .init_queue = hns_ae_init_queue, 958 .fini_queue = hns_ae_fini_queue, 959 .start = hns_ae_start, 960 .stop = hns_ae_stop, 961 .reset = hns_ae_reset, 962 .toggle_ring_irq = hns_ae_toggle_ring_irq, 963 .get_status = hns_ae_get_link_status, 964 .get_info = hns_ae_get_mac_info, 965 .adjust_link = hns_ae_adjust_link, 966 .need_adjust_link = hns_ae_need_adjust_link, 967 .set_loopback = hns_ae_config_loopback, 968 .get_ring_bdnum_limit = hns_ae_get_ring_bdnum_limit, 969 .get_pauseparam = hns_ae_get_pauseparam, 970 .set_autoneg = hns_ae_set_autoneg, 971 .get_autoneg = hns_ae_get_autoneg, 972 .set_pauseparam = hns_ae_set_pauseparam, 973 .get_coalesce_usecs = hns_ae_get_coalesce_usecs, 974 .get_max_coalesced_frames = hns_ae_get_max_coalesced_frames, 975 .set_coalesce_usecs = hns_ae_set_coalesce_usecs, 976 .set_coalesce_frames = hns_ae_set_coalesce_frames, 977 .get_coalesce_range = hns_ae_get_coalesce_range, 978 .set_promisc_mode = hns_ae_set_promisc_mode, 979 .set_mac_addr = hns_ae_set_mac_address, 980 .add_uc_addr = hns_ae_add_uc_address, 981 .rm_uc_addr = hns_ae_rm_uc_address, 982 .set_mc_addr = hns_ae_set_multicast_one, 983 .clr_mc_addr = hns_ae_clr_multicast, 984 .set_mtu = hns_ae_set_mtu, 985 .update_stats = hns_ae_update_stats, 986 .set_tso_stats = hns_ae_set_tso_stats, 987 .get_stats = hns_ae_get_stats, 988 .get_strings = hns_ae_get_strings, 989 .get_sset_count = hns_ae_get_sset_count, 990 .update_led_status = hns_ae_update_led_status, 991 .set_led_id = hns_ae_cpld_set_led_id, 992 .get_regs = hns_ae_get_regs, 993 .get_regs_len = hns_ae_get_regs_len, 994 .get_rss_key_size = hns_ae_get_rss_key_size, 995 .get_rss_indir_size = hns_ae_get_rss_indir_size, 996 .get_rss = hns_ae_get_rss, 997 .set_rss = hns_ae_set_rss 998 }; 999 1000 int hns_dsaf_ae_init(struct dsaf_device *dsaf_dev) 1001 { 1002 struct hnae_ae_dev *ae_dev = &dsaf_dev->ae_dev; 1003 static atomic_t id = ATOMIC_INIT(-1); 1004 1005 switch (dsaf_dev->dsaf_ver) { 1006 case AE_VERSION_1: 1007 hns_dsaf_ops.toggle_ring_irq = hns_ae_toggle_ring_irq; 1008 break; 1009 case AE_VERSION_2: 1010 hns_dsaf_ops.toggle_ring_irq = hns_aev2_toggle_ring_irq; 1011 break; 1012 default: 1013 break; 1014 } 1015 1016 snprintf(ae_dev->name, AE_NAME_SIZE, "%s%d", DSAF_DEVICE_NAME, 1017 (int)atomic_inc_return(&id)); 1018 ae_dev->ops = &hns_dsaf_ops; 1019 ae_dev->dev = dsaf_dev->dev; 1020 1021 return hnae_ae_register(ae_dev, THIS_MODULE); 1022 } 1023 1024 void hns_dsaf_ae_uninit(struct dsaf_device *dsaf_dev) 1025 { 1026 hnae_ae_unregister(&dsaf_dev->ae_dev); 1027 } 1028