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