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