1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Copyright (c) 2014-2015 Hisilicon Limited. 4 */ 5 6#include <linux/acpi.h> 7#include <linux/init.h> 8#include <linux/interrupt.h> 9#include <linux/kernel.h> 10#include <linux/mfd/syscon.h> 11#include <linux/module.h> 12#include <linux/netdevice.h> 13#include <linux/of.h> 14#include <linux/of_address.h> 15#include <linux/of_mdio.h> 16#include <linux/phy.h> 17#include <linux/platform_device.h> 18 19#include "hns_dsaf_main.h" 20#include "hns_dsaf_misc.h" 21#include "hns_dsaf_rcb.h" 22 23#define MAC_EN_FLAG_V 0xada0328 24 25static const u16 mac_phy_to_speed[] = { 26 [PHY_INTERFACE_MODE_MII] = MAC_SPEED_100, 27 [PHY_INTERFACE_MODE_GMII] = MAC_SPEED_1000, 28 [PHY_INTERFACE_MODE_SGMII] = MAC_SPEED_1000, 29 [PHY_INTERFACE_MODE_TBI] = MAC_SPEED_1000, 30 [PHY_INTERFACE_MODE_RMII] = MAC_SPEED_100, 31 [PHY_INTERFACE_MODE_RGMII] = MAC_SPEED_1000, 32 [PHY_INTERFACE_MODE_RGMII_ID] = MAC_SPEED_1000, 33 [PHY_INTERFACE_MODE_RGMII_RXID] = MAC_SPEED_1000, 34 [PHY_INTERFACE_MODE_RGMII_TXID] = MAC_SPEED_1000, 35 [PHY_INTERFACE_MODE_RTBI] = MAC_SPEED_1000, 36 [PHY_INTERFACE_MODE_XGMII] = MAC_SPEED_10000 37}; 38 39static const enum mac_mode g_mac_mode_100[] = { 40 [PHY_INTERFACE_MODE_MII] = MAC_MODE_MII_100, 41 [PHY_INTERFACE_MODE_RMII] = MAC_MODE_RMII_100 42}; 43 44static const enum mac_mode g_mac_mode_1000[] = { 45 [PHY_INTERFACE_MODE_GMII] = MAC_MODE_GMII_1000, 46 [PHY_INTERFACE_MODE_SGMII] = MAC_MODE_SGMII_1000, 47 [PHY_INTERFACE_MODE_TBI] = MAC_MODE_TBI_1000, 48 [PHY_INTERFACE_MODE_RGMII] = MAC_MODE_RGMII_1000, 49 [PHY_INTERFACE_MODE_RGMII_ID] = MAC_MODE_RGMII_1000, 50 [PHY_INTERFACE_MODE_RGMII_RXID] = MAC_MODE_RGMII_1000, 51 [PHY_INTERFACE_MODE_RGMII_TXID] = MAC_MODE_RGMII_1000, 52 [PHY_INTERFACE_MODE_RTBI] = MAC_MODE_RTBI_1000 53}; 54 55static enum mac_mode hns_get_enet_interface(const struct hns_mac_cb *mac_cb) 56{ 57 switch (mac_cb->max_speed) { 58 case MAC_SPEED_100: 59 return g_mac_mode_100[mac_cb->phy_if]; 60 case MAC_SPEED_1000: 61 return g_mac_mode_1000[mac_cb->phy_if]; 62 case MAC_SPEED_10000: 63 return MAC_MODE_XGMII_10000; 64 default: 65 return MAC_MODE_MII_100; 66 } 67} 68 69static u32 hns_mac_link_anti_shake(struct mac_driver *mac_ctrl_drv) 70{ 71#define HNS_MAC_LINK_WAIT_TIME 5 72#define HNS_MAC_LINK_WAIT_CNT 40 73 74 u32 link_status = 0; 75 int i; 76 77 if (!mac_ctrl_drv->get_link_status) 78 return link_status; 79 80 for (i = 0; i < HNS_MAC_LINK_WAIT_CNT; i++) { 81 msleep(HNS_MAC_LINK_WAIT_TIME); 82 mac_ctrl_drv->get_link_status(mac_ctrl_drv, &link_status); 83 if (!link_status) 84 break; 85 } 86 87 return link_status; 88} 89 90void hns_mac_get_link_status(struct hns_mac_cb *mac_cb, u32 *link_status) 91{ 92 struct mac_driver *mac_ctrl_drv; 93 int ret, sfp_prsnt; 94 95 mac_ctrl_drv = hns_mac_get_drv(mac_cb); 96 97 if (mac_ctrl_drv->get_link_status) 98 mac_ctrl_drv->get_link_status(mac_ctrl_drv, link_status); 99 else 100 *link_status = 0; 101 102 if (mac_cb->media_type == HNAE_MEDIA_TYPE_FIBER) { 103 ret = mac_cb->dsaf_dev->misc_op->get_sfp_prsnt(mac_cb, 104 &sfp_prsnt); 105 if (!ret) 106 *link_status = *link_status && sfp_prsnt; 107 108 /* for FIBER port, it may have a fake link up. 109 * when the link status changes from down to up, we need to do 110 * anti-shake. the anti-shake time is base on tests. 111 * only FIBER port need to do this. 112 */ 113 if (*link_status && !mac_cb->link) 114 *link_status = hns_mac_link_anti_shake(mac_ctrl_drv); 115 } 116 117 mac_cb->link = *link_status; 118} 119 120int hns_mac_get_port_info(struct hns_mac_cb *mac_cb, 121 u8 *auto_neg, u16 *speed, u8 *duplex) 122{ 123 struct mac_driver *mac_ctrl_drv; 124 struct mac_info info; 125 126 mac_ctrl_drv = hns_mac_get_drv(mac_cb); 127 128 if (!mac_ctrl_drv->get_info) 129 return -ENODEV; 130 131 mac_ctrl_drv->get_info(mac_ctrl_drv, &info); 132 if (auto_neg) 133 *auto_neg = info.auto_neg; 134 if (speed) 135 *speed = info.speed; 136 if (duplex) 137 *duplex = info.duplex; 138 139 return 0; 140} 141 142/** 143 *hns_mac_need_adjust_link - check is need change mac speed and duplex register 144 *@mac_cb: mac device 145 *@speed: phy device speed 146 *@duplex:phy device duplex 147 * 148 */ 149bool hns_mac_need_adjust_link(struct hns_mac_cb *mac_cb, int speed, int duplex) 150{ 151 struct mac_driver *mac_ctrl_drv; 152 153 mac_ctrl_drv = (struct mac_driver *)(mac_cb->priv.mac); 154 155 if (mac_ctrl_drv->need_adjust_link) 156 return mac_ctrl_drv->need_adjust_link(mac_ctrl_drv, 157 (enum mac_speed)speed, duplex); 158 else 159 return true; 160} 161 162void hns_mac_adjust_link(struct hns_mac_cb *mac_cb, int speed, int duplex) 163{ 164 int ret; 165 struct mac_driver *mac_ctrl_drv; 166 167 mac_ctrl_drv = (struct mac_driver *)(mac_cb->priv.mac); 168 169 mac_cb->speed = speed; 170 mac_cb->half_duplex = !duplex; 171 172 if (mac_ctrl_drv->adjust_link) { 173 ret = mac_ctrl_drv->adjust_link(mac_ctrl_drv, 174 (enum mac_speed)speed, duplex); 175 if (ret) { 176 dev_err(mac_cb->dev, 177 "adjust_link failed, %s mac%d ret = %#x!\n", 178 mac_cb->dsaf_dev->ae_dev.name, 179 mac_cb->mac_id, ret); 180 return; 181 } 182 } 183} 184 185/** 186 *hns_mac_get_inner_port_num - get mac table inner port number 187 *@mac_cb: mac device 188 *@vmid: vm id 189 *@port_num:port number 190 * 191 */ 192int hns_mac_get_inner_port_num(struct hns_mac_cb *mac_cb, u8 vmid, u8 *port_num) 193{ 194 int q_num_per_vf, vf_num_per_port; 195 int vm_queue_id; 196 u8 tmp_port; 197 198 if (mac_cb->dsaf_dev->dsaf_mode <= DSAF_MODE_ENABLE) { 199 if (mac_cb->mac_id != DSAF_MAX_PORT_NUM) { 200 dev_err(mac_cb->dev, 201 "input invalid, %s mac%d vmid%d !\n", 202 mac_cb->dsaf_dev->ae_dev.name, 203 mac_cb->mac_id, vmid); 204 return -EINVAL; 205 } 206 } else if (mac_cb->dsaf_dev->dsaf_mode < DSAF_MODE_MAX) { 207 if (mac_cb->mac_id >= DSAF_MAX_PORT_NUM) { 208 dev_err(mac_cb->dev, 209 "input invalid, %s mac%d vmid%d!\n", 210 mac_cb->dsaf_dev->ae_dev.name, 211 mac_cb->mac_id, vmid); 212 return -EINVAL; 213 } 214 } else { 215 dev_err(mac_cb->dev, "dsaf mode invalid, %s mac%d!\n", 216 mac_cb->dsaf_dev->ae_dev.name, mac_cb->mac_id); 217 return -EINVAL; 218 } 219 220 if (vmid >= mac_cb->dsaf_dev->rcb_common[0]->max_vfn) { 221 dev_err(mac_cb->dev, "input invalid, %s mac%d vmid%d !\n", 222 mac_cb->dsaf_dev->ae_dev.name, mac_cb->mac_id, vmid); 223 return -EINVAL; 224 } 225 226 q_num_per_vf = mac_cb->dsaf_dev->rcb_common[0]->max_q_per_vf; 227 vf_num_per_port = mac_cb->dsaf_dev->rcb_common[0]->max_vfn; 228 229 vm_queue_id = vmid * q_num_per_vf + 230 vf_num_per_port * q_num_per_vf * mac_cb->mac_id; 231 232 switch (mac_cb->dsaf_dev->dsaf_mode) { 233 case DSAF_MODE_ENABLE_FIX: 234 tmp_port = 0; 235 break; 236 case DSAF_MODE_DISABLE_FIX: 237 tmp_port = 0; 238 break; 239 case DSAF_MODE_ENABLE_0VM: 240 case DSAF_MODE_ENABLE_8VM: 241 case DSAF_MODE_ENABLE_16VM: 242 case DSAF_MODE_ENABLE_32VM: 243 case DSAF_MODE_ENABLE_128VM: 244 case DSAF_MODE_DISABLE_2PORT_8VM: 245 case DSAF_MODE_DISABLE_2PORT_16VM: 246 case DSAF_MODE_DISABLE_2PORT_64VM: 247 case DSAF_MODE_DISABLE_6PORT_0VM: 248 case DSAF_MODE_DISABLE_6PORT_2VM: 249 case DSAF_MODE_DISABLE_6PORT_4VM: 250 case DSAF_MODE_DISABLE_6PORT_16VM: 251 tmp_port = vm_queue_id; 252 break; 253 default: 254 dev_err(mac_cb->dev, "dsaf mode invalid, %s mac%d!\n", 255 mac_cb->dsaf_dev->ae_dev.name, mac_cb->mac_id); 256 return -EINVAL; 257 } 258 tmp_port += DSAF_BASE_INNER_PORT_NUM; 259 260 *port_num = tmp_port; 261 262 return 0; 263} 264 265/** 266 *hns_mac_change_vf_addr - change vf mac address 267 *@mac_cb: mac device 268 *@vmid: vmid 269 *@addr:mac address 270 */ 271int hns_mac_change_vf_addr(struct hns_mac_cb *mac_cb, 272 u32 vmid, const char *addr) 273{ 274 int ret; 275 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 276 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 277 struct dsaf_drv_mac_single_dest_entry mac_entry; 278 struct mac_entry_idx *old_entry; 279 280 old_entry = &mac_cb->addr_entry_idx[vmid]; 281 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) { 282 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr)); 283 mac_entry.in_vlan_id = old_entry->vlan_id; 284 mac_entry.in_port_num = mac_cb->mac_id; 285 ret = hns_mac_get_inner_port_num(mac_cb, (u8)vmid, 286 &mac_entry.port_num); 287 if (ret) 288 return ret; 289 290 if ((old_entry->valid != 0) && 291 (memcmp(old_entry->addr, 292 addr, sizeof(mac_entry.addr)) != 0)) { 293 ret = hns_dsaf_del_mac_entry(dsaf_dev, 294 old_entry->vlan_id, 295 mac_cb->mac_id, 296 old_entry->addr); 297 if (ret) 298 return ret; 299 } 300 301 ret = hns_dsaf_set_mac_uc_entry(dsaf_dev, &mac_entry); 302 if (ret) 303 return ret; 304 } 305 306 if ((mac_ctrl_drv->set_mac_addr) && (vmid == 0)) 307 mac_ctrl_drv->set_mac_addr(mac_cb->priv.mac, addr); 308 309 memcpy(old_entry->addr, addr, sizeof(old_entry->addr)); 310 old_entry->valid = 1; 311 return 0; 312} 313 314int hns_mac_add_uc_addr(struct hns_mac_cb *mac_cb, u8 vf_id, 315 const unsigned char *addr) 316{ 317 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 318 struct dsaf_drv_mac_single_dest_entry mac_entry; 319 int ret; 320 321 if (HNS_DSAF_IS_DEBUG(dsaf_dev)) 322 return -ENOSPC; 323 324 memset(&mac_entry, 0, sizeof(mac_entry)); 325 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr)); 326 mac_entry.in_port_num = mac_cb->mac_id; 327 ret = hns_mac_get_inner_port_num(mac_cb, vf_id, &mac_entry.port_num); 328 if (ret) 329 return ret; 330 331 return hns_dsaf_set_mac_uc_entry(dsaf_dev, &mac_entry); 332} 333 334int hns_mac_rm_uc_addr(struct hns_mac_cb *mac_cb, u8 vf_id, 335 const unsigned char *addr) 336{ 337 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 338 struct dsaf_drv_mac_single_dest_entry mac_entry; 339 int ret; 340 341 if (HNS_DSAF_IS_DEBUG(dsaf_dev)) 342 return -ENOSPC; 343 344 memset(&mac_entry, 0, sizeof(mac_entry)); 345 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr)); 346 mac_entry.in_port_num = mac_cb->mac_id; 347 ret = hns_mac_get_inner_port_num(mac_cb, vf_id, &mac_entry.port_num); 348 if (ret) 349 return ret; 350 351 return hns_dsaf_rm_mac_addr(dsaf_dev, &mac_entry); 352} 353 354int hns_mac_set_multi(struct hns_mac_cb *mac_cb, 355 u32 port_num, char *addr, bool enable) 356{ 357 int ret; 358 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 359 struct dsaf_drv_mac_single_dest_entry mac_entry; 360 361 if (!HNS_DSAF_IS_DEBUG(dsaf_dev) && addr) { 362 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr)); 363 mac_entry.in_vlan_id = 0;/*vlan_id;*/ 364 mac_entry.in_port_num = mac_cb->mac_id; 365 mac_entry.port_num = port_num; 366 367 if (!enable) 368 ret = hns_dsaf_del_mac_mc_port(dsaf_dev, &mac_entry); 369 else 370 ret = hns_dsaf_add_mac_mc_port(dsaf_dev, &mac_entry); 371 if (ret) { 372 dev_err(dsaf_dev->dev, 373 "set mac mc port failed, %s mac%d ret = %#x!\n", 374 mac_cb->dsaf_dev->ae_dev.name, 375 mac_cb->mac_id, ret); 376 return ret; 377 } 378 } 379 380 return 0; 381} 382 383int hns_mac_clr_multicast(struct hns_mac_cb *mac_cb, int vfn) 384{ 385 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 386 u8 port_num; 387 int ret = hns_mac_get_inner_port_num(mac_cb, vfn, &port_num); 388 389 if (ret) 390 return ret; 391 392 return hns_dsaf_clr_mac_mc_port(dsaf_dev, mac_cb->mac_id, port_num); 393} 394 395static void hns_mac_param_get(struct mac_params *param, 396 struct hns_mac_cb *mac_cb) 397{ 398 param->vaddr = mac_cb->vaddr; 399 param->mac_mode = hns_get_enet_interface(mac_cb); 400 ether_addr_copy(param->addr, mac_cb->addr_entry_idx[0].addr); 401 param->mac_id = mac_cb->mac_id; 402 param->dev = mac_cb->dev; 403} 404 405/** 406 * hns_mac_port_config_bc_en - set broadcast rx&tx enable 407 * @mac_cb: mac device 408 * @port_num: queue number 409 * @vlan_id: vlan id` 410 * @enable: enable 411 * return 0 - success , negative --fail 412 */ 413static int hns_mac_port_config_bc_en(struct hns_mac_cb *mac_cb, 414 u32 port_num, u16 vlan_id, bool enable) 415{ 416 int ret; 417 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 418 struct dsaf_drv_mac_single_dest_entry mac_entry; 419 420 /* directy return ok in debug network mode */ 421 if (mac_cb->mac_type == HNAE_PORT_DEBUG) 422 return 0; 423 424 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) { 425 eth_broadcast_addr(mac_entry.addr); 426 mac_entry.in_vlan_id = vlan_id; 427 mac_entry.in_port_num = mac_cb->mac_id; 428 mac_entry.port_num = port_num; 429 430 if (!enable) 431 ret = hns_dsaf_del_mac_mc_port(dsaf_dev, &mac_entry); 432 else 433 ret = hns_dsaf_add_mac_mc_port(dsaf_dev, &mac_entry); 434 return ret; 435 } 436 437 return 0; 438} 439 440/** 441 * hns_mac_vm_config_bc_en - set broadcast rx&tx enable 442 * @mac_cb: mac device 443 * @vmid: vm id 444 * @enable: enable 445 * return 0 - success , negative --fail 446 */ 447int hns_mac_vm_config_bc_en(struct hns_mac_cb *mac_cb, u32 vmid, bool enable) 448{ 449 int ret; 450 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev; 451 u8 port_num; 452 struct mac_entry_idx *uc_mac_entry; 453 struct dsaf_drv_mac_single_dest_entry mac_entry; 454 455 if (mac_cb->mac_type == HNAE_PORT_DEBUG) 456 return 0; 457 458 uc_mac_entry = &mac_cb->addr_entry_idx[vmid]; 459 460 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) { 461 eth_broadcast_addr(mac_entry.addr); 462 mac_entry.in_vlan_id = uc_mac_entry->vlan_id; 463 mac_entry.in_port_num = mac_cb->mac_id; 464 ret = hns_mac_get_inner_port_num(mac_cb, vmid, &port_num); 465 if (ret) 466 return ret; 467 mac_entry.port_num = port_num; 468 469 if (!enable) 470 ret = hns_dsaf_del_mac_mc_port(dsaf_dev, &mac_entry); 471 else 472 ret = hns_dsaf_add_mac_mc_port(dsaf_dev, &mac_entry); 473 return ret; 474 } 475 476 return 0; 477} 478 479int hns_mac_wait_fifo_clean(struct hns_mac_cb *mac_cb) 480{ 481 struct mac_driver *drv = hns_mac_get_drv(mac_cb); 482 483 if (drv->wait_fifo_clean) 484 return drv->wait_fifo_clean(drv); 485 486 return 0; 487} 488 489void hns_mac_reset(struct hns_mac_cb *mac_cb) 490{ 491 struct mac_driver *drv = hns_mac_get_drv(mac_cb); 492 bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver); 493 494 drv->mac_init(drv); 495 496 if (drv->config_max_frame_length) 497 drv->config_max_frame_length(drv, mac_cb->max_frm); 498 499 if (drv->set_tx_auto_pause_frames) 500 drv->set_tx_auto_pause_frames(drv, mac_cb->tx_pause_frm_time); 501 502 if (drv->set_an_mode) 503 drv->set_an_mode(drv, 1); 504 505 if (drv->mac_pausefrm_cfg) { 506 if (mac_cb->mac_type == HNAE_PORT_DEBUG) 507 drv->mac_pausefrm_cfg(drv, !is_ver1, !is_ver1); 508 else /* mac rx must disable, dsaf pfc close instead of it*/ 509 drv->mac_pausefrm_cfg(drv, 0, 1); 510 } 511} 512 513int hns_mac_set_mtu(struct hns_mac_cb *mac_cb, u32 new_mtu, u32 buf_size) 514{ 515 struct mac_driver *drv = hns_mac_get_drv(mac_cb); 516 u32 new_frm = new_mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN; 517 518 if (new_frm > HNS_RCB_RING_MAX_BD_PER_PKT * buf_size) 519 return -EINVAL; 520 521 if (!drv->config_max_frame_length) 522 return -ECHILD; 523 524 /* adjust max frame to be at least the size of a standard frame */ 525 if (new_frm < (ETH_FRAME_LEN + ETH_FCS_LEN + VLAN_HLEN)) 526 new_frm = (ETH_FRAME_LEN + ETH_FCS_LEN + VLAN_HLEN); 527 528 drv->config_max_frame_length(drv, new_frm); 529 530 mac_cb->max_frm = new_frm; 531 532 return 0; 533} 534 535void hns_mac_start(struct hns_mac_cb *mac_cb) 536{ 537 struct mac_driver *mac_drv = hns_mac_get_drv(mac_cb); 538 539 /* for virt */ 540 if (mac_drv->mac_en_flg == MAC_EN_FLAG_V) { 541 /*plus 1 when the virtual mac has been enabled */ 542 mac_drv->virt_dev_num += 1; 543 return; 544 } 545 546 if (mac_drv->mac_enable) { 547 mac_drv->mac_enable(mac_cb->priv.mac, MAC_COMM_MODE_RX_AND_TX); 548 mac_drv->mac_en_flg = MAC_EN_FLAG_V; 549 } 550} 551 552void hns_mac_stop(struct hns_mac_cb *mac_cb) 553{ 554 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 555 556 /*modified for virtualization */ 557 if (mac_ctrl_drv->virt_dev_num > 0) { 558 mac_ctrl_drv->virt_dev_num -= 1; 559 if (mac_ctrl_drv->virt_dev_num > 0) 560 return; 561 } 562 563 if (mac_ctrl_drv->mac_disable) 564 mac_ctrl_drv->mac_disable(mac_cb->priv.mac, 565 MAC_COMM_MODE_RX_AND_TX); 566 567 mac_ctrl_drv->mac_en_flg = 0; 568 mac_cb->link = 0; 569 mac_cb->dsaf_dev->misc_op->cpld_reset_led(mac_cb); 570} 571 572/** 573 * hns_mac_get_autoneg - get auto autonegotiation 574 * @mac_cb: mac control block 575 * @auto_neg: output pointer to autoneg result 576 * return 0 - success , negative --fail 577 */ 578void hns_mac_get_autoneg(struct hns_mac_cb *mac_cb, u32 *auto_neg) 579{ 580 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 581 582 if (mac_ctrl_drv->autoneg_stat) 583 mac_ctrl_drv->autoneg_stat(mac_ctrl_drv, auto_neg); 584 else 585 *auto_neg = 0; 586} 587 588/** 589 * hns_mac_get_pauseparam - set rx & tx pause parameter 590 * @mac_cb: mac control block 591 * @rx_en: rx enable status 592 * @tx_en: tx enable status 593 * return 0 - success , negative --fail 594 */ 595void hns_mac_get_pauseparam(struct hns_mac_cb *mac_cb, u32 *rx_en, u32 *tx_en) 596{ 597 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 598 599 if (mac_ctrl_drv->get_pause_enable) { 600 mac_ctrl_drv->get_pause_enable(mac_ctrl_drv, rx_en, tx_en); 601 } else { 602 *rx_en = 0; 603 *tx_en = 0; 604 } 605} 606 607/** 608 * hns_mac_set_autoneg - set auto autonegotiation 609 * @mac_cb: mac control block 610 * @enable: enable or not 611 * return 0 - success , negative --fail 612 */ 613int hns_mac_set_autoneg(struct hns_mac_cb *mac_cb, u8 enable) 614{ 615 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 616 617 if (mac_cb->phy_if == PHY_INTERFACE_MODE_XGMII && enable) { 618 dev_err(mac_cb->dev, "enabling autoneg is not allowed!\n"); 619 return -ENOTSUPP; 620 } 621 622 if (mac_ctrl_drv->set_an_mode) 623 mac_ctrl_drv->set_an_mode(mac_ctrl_drv, enable); 624 625 return 0; 626} 627 628/** 629 * hns_mac_set_pauseparam - set rx & tx pause parameter 630 * @mac_cb: mac control block 631 * @rx_en: rx enable or not 632 * @tx_en: tx enable or not 633 * return 0 - success , negative --fail 634 */ 635int hns_mac_set_pauseparam(struct hns_mac_cb *mac_cb, u32 rx_en, u32 tx_en) 636{ 637 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 638 bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver); 639 640 if (mac_cb->mac_type == HNAE_PORT_DEBUG) { 641 if (is_ver1 && (tx_en || rx_en)) { 642 dev_err(mac_cb->dev, "macv1 can't enable tx/rx_pause!\n"); 643 return -EINVAL; 644 } 645 } 646 647 if (mac_ctrl_drv->mac_pausefrm_cfg) 648 mac_ctrl_drv->mac_pausefrm_cfg(mac_ctrl_drv, rx_en, tx_en); 649 650 return 0; 651} 652 653/** 654 * hns_mac_init_ex - mac init 655 * @mac_cb: mac control block 656 * return 0 - success , negative --fail 657 */ 658static int hns_mac_init_ex(struct hns_mac_cb *mac_cb) 659{ 660 int ret; 661 struct mac_params param; 662 struct mac_driver *drv; 663 664 hns_dsaf_fix_mac_mode(mac_cb); 665 666 memset(¶m, 0, sizeof(struct mac_params)); 667 hns_mac_param_get(¶m, mac_cb); 668 669 if (MAC_SPEED_FROM_MODE(param.mac_mode) < MAC_SPEED_10000) 670 drv = (struct mac_driver *)hns_gmac_config(mac_cb, ¶m); 671 else 672 drv = (struct mac_driver *)hns_xgmac_config(mac_cb, ¶m); 673 674 if (!drv) 675 return -ENOMEM; 676 677 mac_cb->priv.mac = (void *)drv; 678 hns_mac_reset(mac_cb); 679 680 hns_mac_adjust_link(mac_cb, mac_cb->speed, !mac_cb->half_duplex); 681 682 ret = hns_mac_port_config_bc_en(mac_cb, mac_cb->mac_id, 0, true); 683 if (ret) 684 goto free_mac_drv; 685 686 return 0; 687 688free_mac_drv: 689 drv->mac_free(mac_cb->priv.mac); 690 mac_cb->priv.mac = NULL; 691 692 return ret; 693} 694 695static int 696hns_mac_phy_parse_addr(struct device *dev, struct fwnode_handle *fwnode) 697{ 698 u32 addr; 699 int ret; 700 701 ret = fwnode_property_read_u32(fwnode, "phy-addr", &addr); 702 if (ret) { 703 dev_err(dev, "has invalid PHY address ret:%d\n", ret); 704 return ret; 705 } 706 707 if (addr >= PHY_MAX_ADDR) { 708 dev_err(dev, "PHY address %i is too large\n", addr); 709 return -EINVAL; 710 } 711 712 return addr; 713} 714 715static int 716hns_mac_register_phydev(struct mii_bus *mdio, struct hns_mac_cb *mac_cb, 717 u32 addr) 718{ 719 struct phy_device *phy; 720 const char *phy_type; 721 bool is_c45; 722 int rc; 723 724 rc = fwnode_property_read_string(mac_cb->fw_port, 725 "phy-mode", &phy_type); 726 if (rc < 0) 727 return rc; 728 729 if (!strcmp(phy_type, phy_modes(PHY_INTERFACE_MODE_XGMII))) 730 is_c45 = true; 731 else if (!strcmp(phy_type, phy_modes(PHY_INTERFACE_MODE_SGMII))) 732 is_c45 = false; 733 else 734 return -ENODATA; 735 736 phy = get_phy_device(mdio, addr, is_c45); 737 if (!phy || IS_ERR(phy)) 738 return -EIO; 739 740 phy->irq = mdio->irq[addr]; 741 742 /* All data is now stored in the phy struct; 743 * register it 744 */ 745 rc = phy_device_register(phy); 746 if (rc) { 747 phy_device_free(phy); 748 dev_err(&mdio->dev, "registered phy fail at address %i\n", 749 addr); 750 return -ENODEV; 751 } 752 753 mac_cb->phy_dev = phy; 754 755 dev_dbg(&mdio->dev, "registered phy at address %i\n", addr); 756 757 return 0; 758} 759 760static int hns_mac_register_phy(struct hns_mac_cb *mac_cb) 761{ 762 struct fwnode_reference_args args; 763 struct platform_device *pdev; 764 struct mii_bus *mii_bus; 765 int rc; 766 int addr; 767 768 /* Loop over the child nodes and register a phy_device for each one */ 769 if (!to_acpi_device_node(mac_cb->fw_port)) 770 return -ENODEV; 771 772 rc = acpi_node_get_property_reference( 773 mac_cb->fw_port, "mdio-node", 0, &args); 774 if (rc) 775 return rc; 776 if (!is_acpi_device_node(args.fwnode)) 777 return -EINVAL; 778 779 addr = hns_mac_phy_parse_addr(mac_cb->dev, mac_cb->fw_port); 780 if (addr < 0) 781 return addr; 782 783 /* dev address in adev */ 784 pdev = hns_dsaf_find_platform_device(args.fwnode); 785 if (!pdev) { 786 dev_err(mac_cb->dev, "mac%d mdio pdev is NULL\n", 787 mac_cb->mac_id); 788 return -EINVAL; 789 } 790 791 mii_bus = platform_get_drvdata(pdev); 792 if (!mii_bus) { 793 dev_err(mac_cb->dev, 794 "mac%d mdio is NULL, dsaf will probe again later\n", 795 mac_cb->mac_id); 796 return -EPROBE_DEFER; 797 } 798 799 rc = hns_mac_register_phydev(mii_bus, mac_cb, addr); 800 if (!rc) 801 dev_dbg(mac_cb->dev, "mac%d register phy addr:%d\n", 802 mac_cb->mac_id, addr); 803 804 return rc; 805} 806 807static void hns_mac_remove_phydev(struct hns_mac_cb *mac_cb) 808{ 809 if (!to_acpi_device_node(mac_cb->fw_port) || !mac_cb->phy_dev) 810 return; 811 812 phy_device_remove(mac_cb->phy_dev); 813 phy_device_free(mac_cb->phy_dev); 814 815 mac_cb->phy_dev = NULL; 816} 817 818#define MAC_MEDIA_TYPE_MAX_LEN 16 819 820static const struct { 821 enum hnae_media_type value; 822 const char *name; 823} media_type_defs[] = { 824 {HNAE_MEDIA_TYPE_UNKNOWN, "unknown" }, 825 {HNAE_MEDIA_TYPE_FIBER, "fiber" }, 826 {HNAE_MEDIA_TYPE_COPPER, "copper" }, 827 {HNAE_MEDIA_TYPE_BACKPLANE, "backplane" }, 828}; 829 830/** 831 *hns_mac_get_info - get mac information from device node 832 *@mac_cb: mac device 833 * return: 0 --success, negative --fail 834 */ 835static int hns_mac_get_info(struct hns_mac_cb *mac_cb) 836{ 837 struct device_node *np; 838 struct regmap *syscon; 839 struct of_phandle_args cpld_args; 840 const char *media_type; 841 u32 i; 842 u32 ret; 843 844 mac_cb->link = false; 845 mac_cb->half_duplex = false; 846 mac_cb->media_type = HNAE_MEDIA_TYPE_UNKNOWN; 847 mac_cb->speed = mac_phy_to_speed[mac_cb->phy_if]; 848 mac_cb->max_speed = mac_cb->speed; 849 850 if (mac_cb->phy_if == PHY_INTERFACE_MODE_SGMII) { 851 mac_cb->if_support = MAC_GMAC_SUPPORTED; 852 mac_cb->if_support |= SUPPORTED_1000baseT_Full; 853 } else if (mac_cb->phy_if == PHY_INTERFACE_MODE_XGMII) { 854 mac_cb->if_support = SUPPORTED_10000baseR_FEC; 855 mac_cb->if_support |= SUPPORTED_10000baseKR_Full; 856 } 857 858 mac_cb->max_frm = MAC_DEFAULT_MTU; 859 mac_cb->tx_pause_frm_time = MAC_DEFAULT_PAUSE_TIME; 860 mac_cb->port_rst_off = mac_cb->mac_id; 861 mac_cb->port_mode_off = 0; 862 863 /* if the dsaf node doesn't contain a port subnode, get phy-handle 864 * from dsaf node 865 */ 866 if (!mac_cb->fw_port) { 867 np = of_parse_phandle(mac_cb->dev->of_node, "phy-handle", 868 mac_cb->mac_id); 869 mac_cb->phy_dev = of_phy_find_device(np); 870 if (mac_cb->phy_dev) { 871 /* refcount is held by of_phy_find_device() 872 * if the phy_dev is found 873 */ 874 put_device(&mac_cb->phy_dev->mdio.dev); 875 876 dev_dbg(mac_cb->dev, "mac%d phy_node: %pOFn\n", 877 mac_cb->mac_id, np); 878 } 879 of_node_put(np); 880 881 return 0; 882 } 883 884 if (is_of_node(mac_cb->fw_port)) { 885 /* parse property from port subnode in dsaf */ 886 np = of_parse_phandle(to_of_node(mac_cb->fw_port), 887 "phy-handle", 0); 888 mac_cb->phy_dev = of_phy_find_device(np); 889 if (mac_cb->phy_dev) { 890 /* refcount is held by of_phy_find_device() 891 * if the phy_dev is found 892 */ 893 put_device(&mac_cb->phy_dev->mdio.dev); 894 dev_dbg(mac_cb->dev, "mac%d phy_node: %pOFn\n", 895 mac_cb->mac_id, np); 896 } 897 of_node_put(np); 898 899 np = of_parse_phandle(to_of_node(mac_cb->fw_port), 900 "serdes-syscon", 0); 901 syscon = syscon_node_to_regmap(np); 902 of_node_put(np); 903 if (IS_ERR_OR_NULL(syscon)) { 904 dev_err(mac_cb->dev, "serdes-syscon is needed!\n"); 905 return -EINVAL; 906 } 907 mac_cb->serdes_ctrl = syscon; 908 909 ret = fwnode_property_read_u32(mac_cb->fw_port, 910 "port-rst-offset", 911 &mac_cb->port_rst_off); 912 if (ret) { 913 dev_dbg(mac_cb->dev, 914 "mac%d port-rst-offset not found, use default value.\n", 915 mac_cb->mac_id); 916 } 917 918 ret = fwnode_property_read_u32(mac_cb->fw_port, 919 "port-mode-offset", 920 &mac_cb->port_mode_off); 921 if (ret) { 922 dev_dbg(mac_cb->dev, 923 "mac%d port-mode-offset not found, use default value.\n", 924 mac_cb->mac_id); 925 } 926 927 ret = of_parse_phandle_with_fixed_args( 928 to_of_node(mac_cb->fw_port), "cpld-syscon", 1, 0, 929 &cpld_args); 930 if (ret) { 931 dev_dbg(mac_cb->dev, "mac%d no cpld-syscon found.\n", 932 mac_cb->mac_id); 933 mac_cb->cpld_ctrl = NULL; 934 } else { 935 syscon = syscon_node_to_regmap(cpld_args.np); 936 if (IS_ERR_OR_NULL(syscon)) { 937 dev_dbg(mac_cb->dev, "no cpld-syscon found!\n"); 938 mac_cb->cpld_ctrl = NULL; 939 } else { 940 mac_cb->cpld_ctrl = syscon; 941 mac_cb->cpld_ctrl_reg = cpld_args.args[0]; 942 } 943 } 944 } else if (is_acpi_node(mac_cb->fw_port)) { 945 ret = hns_mac_register_phy(mac_cb); 946 /* Mac can work well if there is phy or not.If the port don't 947 * connect with phy, the return value will be ignored. Only 948 * when there is phy but can't find mdio bus, the return value 949 * will be handled. 950 */ 951 if (ret == -EPROBE_DEFER) 952 return ret; 953 } else { 954 dev_err(mac_cb->dev, "mac%d cannot find phy node\n", 955 mac_cb->mac_id); 956 } 957 958 if (!fwnode_property_read_string(mac_cb->fw_port, "media-type", 959 &media_type)) { 960 for (i = 0; i < ARRAY_SIZE(media_type_defs); i++) { 961 if (!strncmp(media_type_defs[i].name, media_type, 962 MAC_MEDIA_TYPE_MAX_LEN)) { 963 mac_cb->media_type = media_type_defs[i].value; 964 break; 965 } 966 } 967 } 968 969 if (fwnode_property_read_u8_array(mac_cb->fw_port, "mc-mac-mask", 970 mac_cb->mc_mask, ETH_ALEN)) { 971 dev_warn(mac_cb->dev, 972 "no mc-mac-mask property, set to default value.\n"); 973 eth_broadcast_addr(mac_cb->mc_mask); 974 } 975 976 return 0; 977} 978 979/** 980 * hns_mac_get_mode - get mac mode 981 * @phy_if: phy interface 982 * return 0 - gmac, 1 - xgmac , negative --fail 983 */ 984static int hns_mac_get_mode(phy_interface_t phy_if) 985{ 986 switch (phy_if) { 987 case PHY_INTERFACE_MODE_SGMII: 988 return MAC_GMAC_IDX; 989 case PHY_INTERFACE_MODE_XGMII: 990 return MAC_XGMAC_IDX; 991 default: 992 return -EINVAL; 993 } 994} 995 996static u8 __iomem * 997hns_mac_get_vaddr(struct dsaf_device *dsaf_dev, 998 struct hns_mac_cb *mac_cb, u32 mac_mode_idx) 999{ 1000 u8 __iomem *base = dsaf_dev->io_base; 1001 int mac_id = mac_cb->mac_id; 1002 1003 if (mac_cb->mac_type == HNAE_PORT_SERVICE) 1004 return base + 0x40000 + mac_id * 0x4000 - 1005 mac_mode_idx * 0x20000; 1006 else 1007 return dsaf_dev->ppe_base + 0x1000; 1008} 1009 1010/** 1011 * hns_mac_get_cfg - get mac cfg from dtb or acpi table 1012 * @dsaf_dev: dsa fabric device struct pointer 1013 * @mac_cb: mac control block 1014 * return 0 - success , negative --fail 1015 */ 1016static int 1017hns_mac_get_cfg(struct dsaf_device *dsaf_dev, struct hns_mac_cb *mac_cb) 1018{ 1019 int ret; 1020 u32 mac_mode_idx; 1021 1022 mac_cb->dsaf_dev = dsaf_dev; 1023 mac_cb->dev = dsaf_dev->dev; 1024 1025 mac_cb->sys_ctl_vaddr = dsaf_dev->sc_base; 1026 mac_cb->serdes_vaddr = dsaf_dev->sds_base; 1027 1028 mac_cb->sfp_prsnt = 0; 1029 mac_cb->txpkt_for_led = 0; 1030 mac_cb->rxpkt_for_led = 0; 1031 1032 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) 1033 mac_cb->mac_type = HNAE_PORT_SERVICE; 1034 else 1035 mac_cb->mac_type = HNAE_PORT_DEBUG; 1036 1037 mac_cb->phy_if = dsaf_dev->misc_op->get_phy_if(mac_cb); 1038 1039 ret = hns_mac_get_mode(mac_cb->phy_if); 1040 if (ret < 0) { 1041 dev_err(dsaf_dev->dev, 1042 "hns_mac_get_mode failed, mac%d ret = %#x!\n", 1043 mac_cb->mac_id, ret); 1044 return ret; 1045 } 1046 mac_mode_idx = (u32)ret; 1047 1048 ret = hns_mac_get_info(mac_cb); 1049 if (ret) 1050 return ret; 1051 1052 mac_cb->dsaf_dev->misc_op->cpld_reset_led(mac_cb); 1053 mac_cb->vaddr = hns_mac_get_vaddr(dsaf_dev, mac_cb, mac_mode_idx); 1054 1055 return 0; 1056} 1057 1058static int hns_mac_get_max_port_num(struct dsaf_device *dsaf_dev) 1059{ 1060 if (HNS_DSAF_IS_DEBUG(dsaf_dev)) 1061 return 1; 1062 else 1063 return DSAF_MAX_PORT_NUM; 1064} 1065 1066void hns_mac_enable(struct hns_mac_cb *mac_cb, enum mac_commom_mode mode) 1067{ 1068 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1069 1070 mac_ctrl_drv->mac_enable(mac_cb->priv.mac, mode); 1071} 1072 1073void hns_mac_disable(struct hns_mac_cb *mac_cb, enum mac_commom_mode mode) 1074{ 1075 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1076 1077 mac_ctrl_drv->mac_disable(mac_cb->priv.mac, mode); 1078} 1079 1080/** 1081 * hns_mac_init - init mac 1082 * @dsaf_dev: dsa fabric device struct pointer 1083 * return 0 - success , negative --fail 1084 */ 1085int hns_mac_init(struct dsaf_device *dsaf_dev) 1086{ 1087 bool found = false; 1088 int ret; 1089 u32 port_id; 1090 int max_port_num = hns_mac_get_max_port_num(dsaf_dev); 1091 struct hns_mac_cb *mac_cb; 1092 struct fwnode_handle *child; 1093 1094 device_for_each_child_node(dsaf_dev->dev, child) { 1095 ret = fwnode_property_read_u32(child, "reg", &port_id); 1096 if (ret) { 1097 fwnode_handle_put(child); 1098 dev_err(dsaf_dev->dev, 1099 "get reg fail, ret=%d!\n", ret); 1100 return ret; 1101 } 1102 if (port_id >= max_port_num) { 1103 fwnode_handle_put(child); 1104 dev_err(dsaf_dev->dev, 1105 "reg(%u) out of range!\n", port_id); 1106 return -EINVAL; 1107 } 1108 mac_cb = devm_kzalloc(dsaf_dev->dev, sizeof(*mac_cb), 1109 GFP_KERNEL); 1110 if (!mac_cb) { 1111 fwnode_handle_put(child); 1112 return -ENOMEM; 1113 } 1114 mac_cb->fw_port = child; 1115 mac_cb->mac_id = (u8)port_id; 1116 dsaf_dev->mac_cb[port_id] = mac_cb; 1117 found = true; 1118 } 1119 1120 /* if don't get any port subnode from dsaf node 1121 * will init all port then, this is compatible with the old dts 1122 */ 1123 if (!found) { 1124 for (port_id = 0; port_id < max_port_num; port_id++) { 1125 mac_cb = devm_kzalloc(dsaf_dev->dev, sizeof(*mac_cb), 1126 GFP_KERNEL); 1127 if (!mac_cb) 1128 return -ENOMEM; 1129 1130 mac_cb->mac_id = port_id; 1131 dsaf_dev->mac_cb[port_id] = mac_cb; 1132 } 1133 } 1134 1135 /* init mac_cb for all port */ 1136 for (port_id = 0; port_id < max_port_num; port_id++) { 1137 mac_cb = dsaf_dev->mac_cb[port_id]; 1138 if (!mac_cb) 1139 continue; 1140 1141 ret = hns_mac_get_cfg(dsaf_dev, mac_cb); 1142 if (ret) 1143 return ret; 1144 1145 ret = hns_mac_init_ex(mac_cb); 1146 if (ret) 1147 return ret; 1148 } 1149 1150 return 0; 1151} 1152 1153void hns_mac_uninit(struct dsaf_device *dsaf_dev) 1154{ 1155 int i; 1156 int max_port_num = hns_mac_get_max_port_num(dsaf_dev); 1157 1158 for (i = 0; i < max_port_num; i++) { 1159 if (!dsaf_dev->mac_cb[i]) 1160 continue; 1161 1162 dsaf_dev->misc_op->cpld_reset_led(dsaf_dev->mac_cb[i]); 1163 hns_mac_remove_phydev(dsaf_dev->mac_cb[i]); 1164 dsaf_dev->mac_cb[i] = NULL; 1165 } 1166} 1167 1168int hns_mac_config_mac_loopback(struct hns_mac_cb *mac_cb, 1169 enum hnae_loop loop, int en) 1170{ 1171 int ret; 1172 struct mac_driver *drv = hns_mac_get_drv(mac_cb); 1173 1174 if (drv->config_loopback) 1175 ret = drv->config_loopback(drv, loop, en); 1176 else 1177 ret = -ENOTSUPP; 1178 1179 return ret; 1180} 1181 1182void hns_mac_update_stats(struct hns_mac_cb *mac_cb) 1183{ 1184 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1185 1186 mac_ctrl_drv->update_stats(mac_ctrl_drv); 1187} 1188 1189void hns_mac_get_stats(struct hns_mac_cb *mac_cb, u64 *data) 1190{ 1191 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1192 1193 mac_ctrl_drv->get_ethtool_stats(mac_ctrl_drv, data); 1194} 1195 1196void hns_mac_get_strings(struct hns_mac_cb *mac_cb, 1197 int stringset, u8 *data) 1198{ 1199 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1200 1201 mac_ctrl_drv->get_strings(stringset, data); 1202} 1203 1204int hns_mac_get_sset_count(struct hns_mac_cb *mac_cb, int stringset) 1205{ 1206 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1207 1208 return mac_ctrl_drv->get_sset_count(stringset); 1209} 1210 1211void hns_mac_set_promisc(struct hns_mac_cb *mac_cb, u8 en) 1212{ 1213 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1214 1215 hns_dsaf_set_promisc_tcam(mac_cb->dsaf_dev, mac_cb->mac_id, !!en); 1216 1217 if (mac_ctrl_drv->set_promiscuous) 1218 mac_ctrl_drv->set_promiscuous(mac_ctrl_drv, en); 1219} 1220 1221int hns_mac_get_regs_count(struct hns_mac_cb *mac_cb) 1222{ 1223 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1224 1225 return mac_ctrl_drv->get_regs_count(); 1226} 1227 1228void hns_mac_get_regs(struct hns_mac_cb *mac_cb, void *data) 1229{ 1230 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb); 1231 1232 mac_ctrl_drv->get_regs(mac_ctrl_drv, data); 1233} 1234 1235void hns_set_led_opt(struct hns_mac_cb *mac_cb) 1236{ 1237 int nic_data; 1238 int txpkts, rxpkts; 1239 1240 txpkts = mac_cb->txpkt_for_led - mac_cb->hw_stats.tx_good_pkts; 1241 rxpkts = mac_cb->rxpkt_for_led - mac_cb->hw_stats.rx_good_pkts; 1242 if (txpkts || rxpkts) 1243 nic_data = 1; 1244 else 1245 nic_data = 0; 1246 mac_cb->txpkt_for_led = mac_cb->hw_stats.tx_good_pkts; 1247 mac_cb->rxpkt_for_led = mac_cb->hw_stats.rx_good_pkts; 1248 mac_cb->dsaf_dev->misc_op->cpld_set_led(mac_cb, (int)mac_cb->link, 1249 mac_cb->speed, nic_data); 1250} 1251 1252int hns_cpld_led_set_id(struct hns_mac_cb *mac_cb, 1253 enum hnae_led_state status) 1254{ 1255 if (!mac_cb) 1256 return 0; 1257 1258 return mac_cb->dsaf_dev->misc_op->cpld_set_led_id(mac_cb, status); 1259} 1260