1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Huawei HiNIC PCI Express Linux driver 3 * Copyright(c) 2017 Huawei Technologies Co., Ltd 4 */ 5 6 #include <linux/pci.h> 7 #include <linux/if_vlan.h> 8 #include <linux/interrupt.h> 9 #include <linux/etherdevice.h> 10 #include <linux/netdevice.h> 11 12 #include "hinic_hw_dev.h" 13 #include "hinic_dev.h" 14 #include "hinic_hw_mbox.h" 15 #include "hinic_hw_cmdq.h" 16 #include "hinic_port.h" 17 #include "hinic_sriov.h" 18 19 static unsigned char set_vf_link_state; 20 module_param(set_vf_link_state, byte, 0444); 21 MODULE_PARM_DESC(set_vf_link_state, "Set vf link state, 0 represents link auto, 1 represents link always up, 2 represents link always down. - default is 0."); 22 23 #define HINIC_VLAN_PRIORITY_SHIFT 13 24 #define HINIC_ADD_VLAN_IN_MAC 0x8000 25 26 static int hinic_set_mac(struct hinic_hwdev *hwdev, const u8 *mac_addr, 27 u16 vlan_id, u16 func_id) 28 { 29 struct hinic_port_mac_cmd mac_info = {0}; 30 u16 out_size = sizeof(mac_info); 31 int err; 32 33 mac_info.func_idx = func_id; 34 mac_info.vlan_id = vlan_id; 35 memcpy(mac_info.mac, mac_addr, ETH_ALEN); 36 37 err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_MAC, &mac_info, 38 sizeof(mac_info), &mac_info, &out_size); 39 if (err || out_size != sizeof(mac_info) || 40 (mac_info.status && mac_info.status != HINIC_PF_SET_VF_ALREADY && 41 mac_info.status != HINIC_MGMT_STATUS_EXIST)) { 42 dev_err(&hwdev->func_to_io.hwif->pdev->dev, "Failed to change MAC, ret = %d\n", 43 mac_info.status); 44 return -EFAULT; 45 } 46 47 return 0; 48 } 49 50 static void hinic_notify_vf_link_status(struct hinic_hwdev *hwdev, u16 vf_id, 51 u8 link_status) 52 { 53 struct vf_data_storage *vf_infos = hwdev->func_to_io.vf_infos; 54 struct hinic_port_link_status link = {0}; 55 u16 out_size = sizeof(link); 56 int err; 57 58 if (vf_infos[HW_VF_ID_TO_OS(vf_id)].registered) { 59 link.link = link_status; 60 link.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id; 61 err = hinic_mbox_to_vf(hwdev, HINIC_MOD_L2NIC, 62 vf_id, HINIC_PORT_CMD_LINK_STATUS_REPORT, 63 &link, sizeof(link), 64 &link, &out_size, 0); 65 if (err || !out_size || link.status) 66 dev_err(&hwdev->hwif->pdev->dev, 67 "Send link change event to VF %d failed, err: %d, status: 0x%x, out_size: 0x%x\n", 68 HW_VF_ID_TO_OS(vf_id), err, 69 link.status, out_size); 70 } 71 } 72 73 /* send link change event mbox msg to active vfs under the pf */ 74 void hinic_notify_all_vfs_link_changed(struct hinic_hwdev *hwdev, 75 u8 link_status) 76 { 77 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 78 u16 i; 79 80 nic_io->link_status = link_status; 81 for (i = 1; i <= nic_io->max_vfs; i++) { 82 if (!nic_io->vf_infos[HW_VF_ID_TO_OS(i)].link_forced) 83 hinic_notify_vf_link_status(hwdev, i, link_status); 84 } 85 } 86 87 static u16 hinic_vf_info_vlanprio(struct hinic_hwdev *hwdev, int vf_id) 88 { 89 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 90 u16 pf_vlan, vlanprio; 91 u8 pf_qos; 92 93 pf_vlan = nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan; 94 pf_qos = nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos; 95 vlanprio = pf_vlan | pf_qos << HINIC_VLAN_PRIORITY_SHIFT; 96 97 return vlanprio; 98 } 99 100 static int hinic_set_vf_vlan(struct hinic_hwdev *hwdev, bool add, u16 vid, 101 u8 qos, int vf_id) 102 { 103 struct hinic_vf_vlan_config vf_vlan = {0}; 104 u16 out_size = sizeof(vf_vlan); 105 int err; 106 u8 cmd; 107 108 /* VLAN 0 is a special case, don't allow it to be removed */ 109 if (!vid && !add) 110 return 0; 111 112 vf_vlan.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id; 113 vf_vlan.vlan_id = vid; 114 vf_vlan.qos = qos; 115 116 if (add) 117 cmd = HINIC_PORT_CMD_SET_VF_VLAN; 118 else 119 cmd = HINIC_PORT_CMD_CLR_VF_VLAN; 120 121 err = hinic_port_msg_cmd(hwdev, cmd, &vf_vlan, 122 sizeof(vf_vlan), &vf_vlan, &out_size); 123 if (err || !out_size || vf_vlan.status) { 124 dev_err(&hwdev->hwif->pdev->dev, "Failed to set VF %d vlan, err: %d, status: 0x%x, out size: 0x%x\n", 125 HW_VF_ID_TO_OS(vf_id), err, vf_vlan.status, out_size); 126 return -EFAULT; 127 } 128 129 return 0; 130 } 131 132 static int hinic_init_vf_config(struct hinic_hwdev *hwdev, u16 vf_id) 133 { 134 struct vf_data_storage *vf_info; 135 u16 func_id, vlan_id; 136 int err = 0; 137 138 vf_info = hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 139 if (vf_info->pf_set_mac) { 140 func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id; 141 142 vlan_id = 0; 143 144 err = hinic_set_mac(hwdev, vf_info->vf_mac_addr, vlan_id, 145 func_id); 146 if (err) { 147 dev_err(&hwdev->func_to_io.hwif->pdev->dev, "Failed to set VF %d MAC\n", 148 HW_VF_ID_TO_OS(vf_id)); 149 return err; 150 } 151 } 152 153 if (hinic_vf_info_vlanprio(hwdev, vf_id)) { 154 err = hinic_set_vf_vlan(hwdev, true, vf_info->pf_vlan, 155 vf_info->pf_qos, vf_id); 156 if (err) { 157 dev_err(&hwdev->hwif->pdev->dev, "Failed to add VF %d VLAN_QOS\n", 158 HW_VF_ID_TO_OS(vf_id)); 159 return err; 160 } 161 } 162 163 return 0; 164 } 165 166 static int hinic_register_vf_msg_handler(void *hwdev, u16 vf_id, 167 void *buf_in, u16 in_size, 168 void *buf_out, u16 *out_size) 169 { 170 struct hinic_register_vf *register_info = buf_out; 171 struct hinic_hwdev *hw_dev = hwdev; 172 struct hinic_func_to_io *nic_io; 173 int err; 174 175 nic_io = &hw_dev->func_to_io; 176 if (vf_id > nic_io->max_vfs) { 177 dev_err(&hw_dev->hwif->pdev->dev, "Register VF id %d exceed limit[0-%d]\n", 178 HW_VF_ID_TO_OS(vf_id), HW_VF_ID_TO_OS(nic_io->max_vfs)); 179 register_info->status = EFAULT; 180 return -EFAULT; 181 } 182 183 *out_size = sizeof(*register_info); 184 err = hinic_init_vf_config(hw_dev, vf_id); 185 if (err) { 186 register_info->status = EFAULT; 187 return err; 188 } 189 190 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].registered = true; 191 192 return 0; 193 } 194 195 static int hinic_unregister_vf_msg_handler(void *hwdev, u16 vf_id, 196 void *buf_in, u16 in_size, 197 void *buf_out, u16 *out_size) 198 { 199 struct hinic_hwdev *hw_dev = hwdev; 200 struct hinic_func_to_io *nic_io; 201 202 nic_io = &hw_dev->func_to_io; 203 *out_size = 0; 204 if (vf_id > nic_io->max_vfs) 205 return 0; 206 207 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].registered = false; 208 209 return 0; 210 } 211 212 static int hinic_change_vf_mtu_msg_handler(void *hwdev, u16 vf_id, 213 void *buf_in, u16 in_size, 214 void *buf_out, u16 *out_size) 215 { 216 struct hinic_hwdev *hw_dev = hwdev; 217 int err; 218 219 err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_CHANGE_MTU, buf_in, 220 in_size, buf_out, out_size); 221 if (err) { 222 dev_err(&hw_dev->hwif->pdev->dev, "Failed to set VF %u mtu\n", 223 vf_id); 224 return err; 225 } 226 227 return 0; 228 } 229 230 static int hinic_get_vf_mac_msg_handler(void *hwdev, u16 vf_id, 231 void *buf_in, u16 in_size, 232 void *buf_out, u16 *out_size) 233 { 234 struct hinic_port_mac_cmd *mac_info = buf_out; 235 struct hinic_hwdev *dev = hwdev; 236 struct hinic_func_to_io *nic_io; 237 struct vf_data_storage *vf_info; 238 239 nic_io = &dev->func_to_io; 240 vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf_id); 241 242 memcpy(mac_info->mac, vf_info->vf_mac_addr, ETH_ALEN); 243 mac_info->status = 0; 244 *out_size = sizeof(*mac_info); 245 246 return 0; 247 } 248 249 static int hinic_set_vf_mac_msg_handler(void *hwdev, u16 vf_id, 250 void *buf_in, u16 in_size, 251 void *buf_out, u16 *out_size) 252 { 253 struct hinic_port_mac_cmd *mac_out = buf_out; 254 struct hinic_port_mac_cmd *mac_in = buf_in; 255 struct hinic_hwdev *hw_dev = hwdev; 256 struct hinic_func_to_io *nic_io; 257 struct vf_data_storage *vf_info; 258 int err; 259 260 nic_io = &hw_dev->func_to_io; 261 vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf_id); 262 if (vf_info->pf_set_mac && !(vf_info->trust) && 263 is_valid_ether_addr(mac_in->mac)) { 264 dev_warn(&hw_dev->hwif->pdev->dev, "PF has already set VF %d MAC address\n", 265 HW_VF_ID_TO_OS(vf_id)); 266 mac_out->status = HINIC_PF_SET_VF_ALREADY; 267 *out_size = sizeof(*mac_out); 268 return 0; 269 } 270 271 err = hinic_port_msg_cmd(hw_dev, HINIC_PORT_CMD_SET_MAC, buf_in, 272 in_size, buf_out, out_size); 273 if ((err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) || !(*out_size)) { 274 dev_err(&hw_dev->hwif->pdev->dev, 275 "Failed to set VF %d MAC address, err: %d, status: 0x%x, out size: 0x%x\n", 276 HW_VF_ID_TO_OS(vf_id), err, mac_out->status, *out_size); 277 return -EFAULT; 278 } 279 280 return err; 281 } 282 283 static int hinic_del_vf_mac_msg_handler(void *hwdev, u16 vf_id, 284 void *buf_in, u16 in_size, 285 void *buf_out, u16 *out_size) 286 { 287 struct hinic_port_mac_cmd *mac_out = buf_out; 288 struct hinic_port_mac_cmd *mac_in = buf_in; 289 struct hinic_hwdev *hw_dev = hwdev; 290 struct hinic_func_to_io *nic_io; 291 struct vf_data_storage *vf_info; 292 int err; 293 294 nic_io = &hw_dev->func_to_io; 295 vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf_id); 296 if (vf_info->pf_set_mac && is_valid_ether_addr(mac_in->mac) && 297 !memcmp(vf_info->vf_mac_addr, mac_in->mac, ETH_ALEN)) { 298 dev_warn(&hw_dev->hwif->pdev->dev, "PF has already set VF mac.\n"); 299 mac_out->status = HINIC_PF_SET_VF_ALREADY; 300 *out_size = sizeof(*mac_out); 301 return 0; 302 } 303 304 err = hinic_port_msg_cmd(hw_dev, HINIC_PORT_CMD_DEL_MAC, buf_in, 305 in_size, buf_out, out_size); 306 if ((err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) || !(*out_size)) { 307 dev_err(&hw_dev->hwif->pdev->dev, "Failed to delete VF %d MAC, err: %d, status: 0x%x, out size: 0x%x\n", 308 HW_VF_ID_TO_OS(vf_id), err, mac_out->status, *out_size); 309 return -EFAULT; 310 } 311 312 return err; 313 } 314 315 static int hinic_get_vf_link_status_msg_handler(void *hwdev, u16 vf_id, 316 void *buf_in, u16 in_size, 317 void *buf_out, u16 *out_size) 318 { 319 struct hinic_port_link_cmd *get_link = buf_out; 320 struct hinic_hwdev *hw_dev = hwdev; 321 struct vf_data_storage *vf_infos; 322 struct hinic_func_to_io *nic_io; 323 bool link_forced, link_up; 324 325 nic_io = &hw_dev->func_to_io; 326 vf_infos = nic_io->vf_infos; 327 link_forced = vf_infos[HW_VF_ID_TO_OS(vf_id)].link_forced; 328 link_up = vf_infos[HW_VF_ID_TO_OS(vf_id)].link_up; 329 330 if (link_forced) 331 get_link->state = link_up ? 332 HINIC_LINK_STATE_UP : HINIC_LINK_STATE_DOWN; 333 else 334 get_link->state = nic_io->link_status; 335 336 get_link->status = 0; 337 *out_size = sizeof(*get_link); 338 339 return 0; 340 } 341 342 static struct vf_cmd_msg_handle nic_vf_cmd_msg_handler[] = { 343 {HINIC_PORT_CMD_VF_REGISTER, hinic_register_vf_msg_handler}, 344 {HINIC_PORT_CMD_VF_UNREGISTER, hinic_unregister_vf_msg_handler}, 345 {HINIC_PORT_CMD_CHANGE_MTU, hinic_change_vf_mtu_msg_handler}, 346 {HINIC_PORT_CMD_GET_MAC, hinic_get_vf_mac_msg_handler}, 347 {HINIC_PORT_CMD_SET_MAC, hinic_set_vf_mac_msg_handler}, 348 {HINIC_PORT_CMD_DEL_MAC, hinic_del_vf_mac_msg_handler}, 349 {HINIC_PORT_CMD_GET_LINK_STATE, hinic_get_vf_link_status_msg_handler}, 350 }; 351 352 #define CHECK_IPSU_15BIT 0X8000 353 354 static 355 struct hinic_sriov_info *hinic_get_sriov_info_by_pcidev(struct pci_dev *pdev) 356 { 357 struct net_device *netdev = pci_get_drvdata(pdev); 358 struct hinic_dev *nic_dev = netdev_priv(netdev); 359 360 return &nic_dev->sriov_info; 361 } 362 363 static int hinic_check_mac_info(u8 status, u16 vlan_id) 364 { 365 if ((status && status != HINIC_MGMT_STATUS_EXIST && 366 status != HINIC_PF_SET_VF_ALREADY) || 367 (vlan_id & CHECK_IPSU_15BIT && 368 status == HINIC_MGMT_STATUS_EXIST)) 369 return -EINVAL; 370 371 return 0; 372 } 373 374 #define HINIC_VLAN_ID_MASK 0x7FFF 375 376 static int hinic_update_mac(struct hinic_hwdev *hwdev, u8 *old_mac, 377 u8 *new_mac, u16 vlan_id, u16 func_id) 378 { 379 struct hinic_port_mac_update mac_info = {0}; 380 u16 out_size = sizeof(mac_info); 381 int err; 382 383 if (!hwdev || !old_mac || !new_mac) 384 return -EINVAL; 385 386 if ((vlan_id & HINIC_VLAN_ID_MASK) >= VLAN_N_VID) { 387 dev_err(&hwdev->hwif->pdev->dev, "Invalid VLAN number: %d\n", 388 (vlan_id & HINIC_VLAN_ID_MASK)); 389 return -EINVAL; 390 } 391 392 mac_info.func_id = func_id; 393 mac_info.vlan_id = vlan_id; 394 memcpy(mac_info.old_mac, old_mac, ETH_ALEN); 395 memcpy(mac_info.new_mac, new_mac, ETH_ALEN); 396 397 err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_UPDATE_MAC, &mac_info, 398 sizeof(mac_info), &mac_info, &out_size); 399 400 if (err || !out_size || 401 hinic_check_mac_info(mac_info.status, mac_info.vlan_id)) { 402 dev_err(&hwdev->hwif->pdev->dev, 403 "Failed to update MAC, err: %d, status: 0x%x, out size: 0x%x\n", 404 err, mac_info.status, out_size); 405 return -EINVAL; 406 } 407 408 if (mac_info.status == HINIC_PF_SET_VF_ALREADY) { 409 dev_warn(&hwdev->hwif->pdev->dev, 410 "PF has already set VF MAC. Ignore update operation\n"); 411 return HINIC_PF_SET_VF_ALREADY; 412 } 413 414 if (mac_info.status == HINIC_MGMT_STATUS_EXIST) 415 dev_warn(&hwdev->hwif->pdev->dev, "MAC is repeated. Ignore update operation\n"); 416 417 return 0; 418 } 419 420 static void hinic_get_vf_config(struct hinic_hwdev *hwdev, u16 vf_id, 421 struct ifla_vf_info *ivi) 422 { 423 struct vf_data_storage *vfinfo; 424 425 vfinfo = hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 426 427 ivi->vf = HW_VF_ID_TO_OS(vf_id); 428 memcpy(ivi->mac, vfinfo->vf_mac_addr, ETH_ALEN); 429 ivi->vlan = vfinfo->pf_vlan; 430 ivi->qos = vfinfo->pf_qos; 431 ivi->spoofchk = vfinfo->spoofchk; 432 ivi->trusted = vfinfo->trust; 433 ivi->max_tx_rate = vfinfo->max_rate; 434 ivi->min_tx_rate = vfinfo->min_rate; 435 436 if (!vfinfo->link_forced) 437 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO; 438 else if (vfinfo->link_up) 439 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE; 440 else 441 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE; 442 } 443 444 int hinic_ndo_get_vf_config(struct net_device *netdev, 445 int vf, struct ifla_vf_info *ivi) 446 { 447 struct hinic_dev *nic_dev = netdev_priv(netdev); 448 struct hinic_sriov_info *sriov_info; 449 450 sriov_info = &nic_dev->sriov_info; 451 if (vf >= sriov_info->num_vfs) 452 return -EINVAL; 453 454 hinic_get_vf_config(sriov_info->hwdev, OS_VF_ID_TO_HW(vf), ivi); 455 456 return 0; 457 } 458 459 static int hinic_set_vf_mac(struct hinic_hwdev *hwdev, int vf, 460 unsigned char *mac_addr) 461 { 462 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 463 struct vf_data_storage *vf_info; 464 u16 func_id; 465 int err; 466 467 vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf); 468 469 /* duplicate request, so just return success */ 470 if (vf_info->pf_set_mac && 471 !memcmp(vf_info->vf_mac_addr, mac_addr, ETH_ALEN)) 472 return 0; 473 474 vf_info->pf_set_mac = true; 475 476 func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf; 477 err = hinic_update_mac(hwdev, vf_info->vf_mac_addr, 478 mac_addr, 0, func_id); 479 if (err) { 480 vf_info->pf_set_mac = false; 481 return err; 482 } 483 484 memcpy(vf_info->vf_mac_addr, mac_addr, ETH_ALEN); 485 486 return 0; 487 } 488 489 int hinic_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 490 { 491 struct hinic_dev *nic_dev = netdev_priv(netdev); 492 struct hinic_sriov_info *sriov_info; 493 int err; 494 495 sriov_info = &nic_dev->sriov_info; 496 if (!is_valid_ether_addr(mac) || vf >= sriov_info->num_vfs) 497 return -EINVAL; 498 499 err = hinic_set_vf_mac(sriov_info->hwdev, OS_VF_ID_TO_HW(vf), mac); 500 if (err) 501 return err; 502 503 netif_info(nic_dev, drv, netdev, "Setting MAC %pM on VF %d\n", mac, vf); 504 netif_info(nic_dev, drv, netdev, "Reload the VF driver to make this change effective."); 505 506 return 0; 507 } 508 509 static int hinic_add_vf_vlan(struct hinic_hwdev *hwdev, int vf_id, 510 u16 vlan, u8 qos) 511 { 512 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 513 int err; 514 515 err = hinic_set_vf_vlan(hwdev, true, vlan, qos, vf_id); 516 if (err) 517 return err; 518 519 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan = vlan; 520 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos = qos; 521 522 dev_info(&hwdev->hwif->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n", 523 vlan, qos, HW_VF_ID_TO_OS(vf_id)); 524 return 0; 525 } 526 527 static int hinic_kill_vf_vlan(struct hinic_hwdev *hwdev, int vf_id) 528 { 529 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 530 int err; 531 532 err = hinic_set_vf_vlan(hwdev, false, 533 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan, 534 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos, 535 vf_id); 536 if (err) 537 return err; 538 539 dev_info(&hwdev->hwif->pdev->dev, "Remove VLAN %d on VF %d\n", 540 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan, 541 HW_VF_ID_TO_OS(vf_id)); 542 543 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan = 0; 544 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos = 0; 545 546 return 0; 547 } 548 549 static int hinic_update_mac_vlan(struct hinic_dev *nic_dev, u16 old_vlan, 550 u16 new_vlan, int vf_id) 551 { 552 struct vf_data_storage *vf_info; 553 u16 vlan_id; 554 int err; 555 556 if (!nic_dev || old_vlan >= VLAN_N_VID || new_vlan >= VLAN_N_VID) 557 return -EINVAL; 558 559 vf_info = nic_dev->hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 560 if (!vf_info->pf_set_mac) 561 return 0; 562 563 vlan_id = old_vlan; 564 if (vlan_id) 565 vlan_id |= HINIC_ADD_VLAN_IN_MAC; 566 567 err = hinic_port_del_mac(nic_dev, vf_info->vf_mac_addr, vlan_id); 568 if (err) { 569 dev_err(&nic_dev->hwdev->hwif->pdev->dev, "Failed to delete VF %d MAC %pM vlan %d\n", 570 HW_VF_ID_TO_OS(vf_id), vf_info->vf_mac_addr, old_vlan); 571 return err; 572 } 573 574 vlan_id = new_vlan; 575 if (vlan_id) 576 vlan_id |= HINIC_ADD_VLAN_IN_MAC; 577 578 err = hinic_port_add_mac(nic_dev, vf_info->vf_mac_addr, vlan_id); 579 if (err) { 580 dev_err(&nic_dev->hwdev->hwif->pdev->dev, "Failed to add VF %d MAC %pM vlan %d\n", 581 HW_VF_ID_TO_OS(vf_id), vf_info->vf_mac_addr, new_vlan); 582 goto out; 583 } 584 585 return 0; 586 587 out: 588 vlan_id = old_vlan; 589 if (vlan_id) 590 vlan_id |= HINIC_ADD_VLAN_IN_MAC; 591 hinic_port_add_mac(nic_dev, vf_info->vf_mac_addr, vlan_id); 592 593 return err; 594 } 595 596 static int set_hw_vf_vlan(struct hinic_dev *nic_dev, 597 u16 cur_vlanprio, int vf, u16 vlan, u8 qos) 598 { 599 u16 old_vlan = cur_vlanprio & VLAN_VID_MASK; 600 int err = 0; 601 602 if (vlan || qos) { 603 if (cur_vlanprio) { 604 err = hinic_kill_vf_vlan(nic_dev->hwdev, 605 OS_VF_ID_TO_HW(vf)); 606 if (err) { 607 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to delete vf %d old vlan %d\n", 608 vf, old_vlan); 609 goto out; 610 } 611 } 612 err = hinic_add_vf_vlan(nic_dev->hwdev, 613 OS_VF_ID_TO_HW(vf), vlan, qos); 614 if (err) { 615 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to add vf %d new vlan %d\n", 616 vf, vlan); 617 goto out; 618 } 619 } else { 620 err = hinic_kill_vf_vlan(nic_dev->hwdev, OS_VF_ID_TO_HW(vf)); 621 if (err) { 622 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to delete vf %d vlan %d\n", 623 vf, old_vlan); 624 goto out; 625 } 626 } 627 628 err = hinic_update_mac_vlan(nic_dev, old_vlan, vlan, 629 OS_VF_ID_TO_HW(vf)); 630 631 out: 632 return err; 633 } 634 635 int hinic_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos, 636 __be16 vlan_proto) 637 { 638 struct hinic_dev *nic_dev = netdev_priv(netdev); 639 struct hinic_sriov_info *sriov_info; 640 u16 vlanprio, cur_vlanprio; 641 642 sriov_info = &nic_dev->sriov_info; 643 if (vf >= sriov_info->num_vfs || vlan > 4095 || qos > 7) 644 return -EINVAL; 645 if (vlan_proto != htons(ETH_P_8021Q)) 646 return -EPROTONOSUPPORT; 647 vlanprio = vlan | qos << HINIC_VLAN_PRIORITY_SHIFT; 648 cur_vlanprio = hinic_vf_info_vlanprio(nic_dev->hwdev, 649 OS_VF_ID_TO_HW(vf)); 650 /* duplicate request, so just return success */ 651 if (vlanprio == cur_vlanprio) 652 return 0; 653 654 return set_hw_vf_vlan(nic_dev, cur_vlanprio, vf, vlan, qos); 655 } 656 657 static int hinic_set_vf_trust(struct hinic_hwdev *hwdev, u16 vf_id, 658 bool trust) 659 { 660 struct vf_data_storage *vf_infos; 661 struct hinic_func_to_io *nic_io; 662 663 if (!hwdev) 664 return -EINVAL; 665 666 nic_io = &hwdev->func_to_io; 667 vf_infos = nic_io->vf_infos; 668 vf_infos[vf_id].trust = trust; 669 670 return 0; 671 } 672 673 int hinic_ndo_set_vf_trust(struct net_device *netdev, int vf, bool setting) 674 { 675 struct hinic_dev *adapter = netdev_priv(netdev); 676 struct hinic_sriov_info *sriov_info; 677 struct hinic_func_to_io *nic_io; 678 bool cur_trust; 679 int err; 680 681 sriov_info = &adapter->sriov_info; 682 nic_io = &adapter->hwdev->func_to_io; 683 684 if (vf >= sriov_info->num_vfs) 685 return -EINVAL; 686 687 cur_trust = nic_io->vf_infos[vf].trust; 688 /* same request, so just return success */ 689 if ((setting && cur_trust) || (!setting && !cur_trust)) 690 return 0; 691 692 err = hinic_set_vf_trust(adapter->hwdev, vf, setting); 693 if (!err) 694 dev_info(&sriov_info->pdev->dev, "Set VF %d trusted %s succeed\n", 695 vf, setting ? "on" : "off"); 696 else 697 dev_err(&sriov_info->pdev->dev, "Failed set VF %d trusted %s\n", 698 vf, setting ? "on" : "off"); 699 700 return err; 701 } 702 703 /* pf receive message from vf */ 704 static int nic_pf_mbox_handler(void *hwdev, u16 vf_id, u8 cmd, void *buf_in, 705 u16 in_size, void *buf_out, u16 *out_size) 706 { 707 struct vf_cmd_msg_handle *vf_msg_handle; 708 struct hinic_hwdev *dev = hwdev; 709 struct hinic_func_to_io *nic_io; 710 struct hinic_pfhwdev *pfhwdev; 711 int err = 0; 712 u32 i; 713 714 if (!hwdev) 715 return -EFAULT; 716 717 pfhwdev = container_of(dev, struct hinic_pfhwdev, hwdev); 718 nic_io = &dev->func_to_io; 719 for (i = 0; i < ARRAY_SIZE(nic_vf_cmd_msg_handler); i++) { 720 vf_msg_handle = &nic_vf_cmd_msg_handler[i]; 721 if (cmd == vf_msg_handle->cmd && 722 vf_msg_handle->cmd_msg_handler) { 723 err = vf_msg_handle->cmd_msg_handler(hwdev, vf_id, 724 buf_in, in_size, 725 buf_out, 726 out_size); 727 break; 728 } 729 } 730 if (i == ARRAY_SIZE(nic_vf_cmd_msg_handler)) 731 err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_L2NIC, 732 cmd, buf_in, in_size, buf_out, 733 out_size, HINIC_MGMT_MSG_SYNC); 734 735 if (err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) 736 dev_err(&nic_io->hwif->pdev->dev, "PF receive VF L2NIC cmd: %d process error, err:%d\n", 737 cmd, err); 738 return err; 739 } 740 741 static int cfg_mbx_pf_proc_vf_msg(void *hwdev, u16 vf_id, u8 cmd, void *buf_in, 742 u16 in_size, void *buf_out, u16 *out_size) 743 { 744 struct hinic_dev_cap *dev_cap = buf_out; 745 struct hinic_hwdev *dev = hwdev; 746 struct hinic_cap *cap; 747 748 cap = &dev->nic_cap; 749 memset(dev_cap, 0, sizeof(*dev_cap)); 750 751 dev_cap->max_vf = cap->max_vf; 752 dev_cap->max_sqs = cap->max_vf_qps; 753 dev_cap->max_rqs = cap->max_vf_qps; 754 755 *out_size = sizeof(*dev_cap); 756 757 return 0; 758 } 759 760 static int hinic_init_vf_infos(struct hinic_func_to_io *nic_io, u16 vf_id) 761 { 762 struct vf_data_storage *vf_infos = nic_io->vf_infos; 763 764 if (set_vf_link_state > HINIC_IFLA_VF_LINK_STATE_DISABLE) { 765 dev_warn(&nic_io->hwif->pdev->dev, "Module Parameter set_vf_link_state value %d is out of range, resetting to %d\n", 766 set_vf_link_state, HINIC_IFLA_VF_LINK_STATE_AUTO); 767 set_vf_link_state = HINIC_IFLA_VF_LINK_STATE_AUTO; 768 } 769 770 switch (set_vf_link_state) { 771 case HINIC_IFLA_VF_LINK_STATE_AUTO: 772 vf_infos[vf_id].link_forced = false; 773 break; 774 case HINIC_IFLA_VF_LINK_STATE_ENABLE: 775 vf_infos[vf_id].link_forced = true; 776 vf_infos[vf_id].link_up = true; 777 break; 778 case HINIC_IFLA_VF_LINK_STATE_DISABLE: 779 vf_infos[vf_id].link_forced = true; 780 vf_infos[vf_id].link_up = false; 781 break; 782 default: 783 dev_err(&nic_io->hwif->pdev->dev, "Invalid input parameter set_vf_link_state: %d\n", 784 set_vf_link_state); 785 return -EINVAL; 786 } 787 788 return 0; 789 } 790 791 static void hinic_clear_vf_infos(struct hinic_dev *nic_dev, u16 vf_id) 792 { 793 struct vf_data_storage *vf_infos; 794 u16 func_id; 795 796 func_id = hinic_glb_pf_vf_offset(nic_dev->hwdev->hwif) + vf_id; 797 vf_infos = nic_dev->hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 798 if (vf_infos->pf_set_mac) 799 hinic_port_del_mac(nic_dev, vf_infos->vf_mac_addr, 0); 800 801 if (hinic_vf_info_vlanprio(nic_dev->hwdev, vf_id)) 802 hinic_kill_vf_vlan(nic_dev->hwdev, vf_id); 803 804 if (vf_infos->trust) 805 hinic_set_vf_trust(nic_dev->hwdev, vf_id, false); 806 807 memset(vf_infos, 0, sizeof(*vf_infos)); 808 /* set vf_infos to default */ 809 hinic_init_vf_infos(&nic_dev->hwdev->func_to_io, HW_VF_ID_TO_OS(vf_id)); 810 } 811 812 static int hinic_deinit_vf_hw(struct hinic_sriov_info *sriov_info, 813 u16 start_vf_id, u16 end_vf_id) 814 { 815 struct hinic_dev *nic_dev; 816 u16 func_idx, idx; 817 818 nic_dev = container_of(sriov_info, struct hinic_dev, sriov_info); 819 820 for (idx = start_vf_id; idx <= end_vf_id; idx++) { 821 func_idx = hinic_glb_pf_vf_offset(nic_dev->hwdev->hwif) + idx; 822 hinic_set_wq_page_size(nic_dev->hwdev, func_idx, 823 HINIC_HW_WQ_PAGE_SIZE); 824 hinic_clear_vf_infos(nic_dev, idx); 825 } 826 827 return 0; 828 } 829 830 int hinic_vf_func_init(struct hinic_hwdev *hwdev) 831 { 832 struct hinic_register_vf register_info = {0}; 833 u16 out_size = sizeof(register_info); 834 struct hinic_func_to_io *nic_io; 835 int err = 0; 836 u32 size, i; 837 838 nic_io = &hwdev->func_to_io; 839 840 if (HINIC_IS_VF(hwdev->hwif)) { 841 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC, 842 HINIC_PORT_CMD_VF_REGISTER, 843 ®ister_info, sizeof(register_info), 844 ®ister_info, &out_size, 0); 845 if (err || register_info.status || !out_size) { 846 dev_err(&hwdev->hwif->pdev->dev, 847 "Failed to register VF, err: %d, status: 0x%x, out size: 0x%x\n", 848 err, register_info.status, out_size); 849 hinic_unregister_vf_mbox_cb(hwdev, HINIC_MOD_L2NIC); 850 return -EIO; 851 } 852 } else { 853 err = hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_CFGM, 854 cfg_mbx_pf_proc_vf_msg); 855 if (err) { 856 dev_err(&hwdev->hwif->pdev->dev, 857 "Register PF mailbox callback failed\n"); 858 return err; 859 } 860 nic_io->max_vfs = hwdev->nic_cap.max_vf; 861 size = sizeof(*nic_io->vf_infos) * nic_io->max_vfs; 862 if (size != 0) { 863 nic_io->vf_infos = kzalloc(size, GFP_KERNEL); 864 if (!nic_io->vf_infos) { 865 err = -ENOMEM; 866 goto out_free_nic_io; 867 } 868 869 for (i = 0; i < nic_io->max_vfs; i++) { 870 err = hinic_init_vf_infos(nic_io, i); 871 if (err) 872 goto err_init_vf_infos; 873 } 874 875 err = hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_L2NIC, 876 nic_pf_mbox_handler); 877 if (err) 878 goto err_register_pf_mbox_cb; 879 } 880 } 881 882 return 0; 883 884 err_register_pf_mbox_cb: 885 err_init_vf_infos: 886 kfree(nic_io->vf_infos); 887 out_free_nic_io: 888 return err; 889 } 890 891 void hinic_vf_func_free(struct hinic_hwdev *hwdev) 892 { 893 struct hinic_register_vf unregister = {0}; 894 u16 out_size = sizeof(unregister); 895 int err; 896 897 if (HINIC_IS_VF(hwdev->hwif)) { 898 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC, 899 HINIC_PORT_CMD_VF_UNREGISTER, 900 &unregister, sizeof(unregister), 901 &unregister, &out_size, 0); 902 if (err || !out_size || unregister.status) 903 dev_err(&hwdev->hwif->pdev->dev, "Failed to unregister VF, err: %d, status: 0x%x, out_size: 0x%x\n", 904 err, unregister.status, out_size); 905 } else { 906 if (hwdev->func_to_io.vf_infos) { 907 hinic_unregister_pf_mbox_cb(hwdev, HINIC_MOD_L2NIC); 908 kfree(hwdev->func_to_io.vf_infos); 909 } 910 } 911 } 912 913 static int hinic_init_vf_hw(struct hinic_hwdev *hwdev, u16 start_vf_id, 914 u16 end_vf_id) 915 { 916 u16 i, func_idx; 917 int err; 918 919 /* vf use 256K as default wq page size, and can't change it */ 920 for (i = start_vf_id; i <= end_vf_id; i++) { 921 func_idx = hinic_glb_pf_vf_offset(hwdev->hwif) + i; 922 err = hinic_set_wq_page_size(hwdev, func_idx, 923 HINIC_DEFAULT_WQ_PAGE_SIZE); 924 if (err) 925 return err; 926 } 927 928 return 0; 929 } 930 931 int hinic_pci_sriov_disable(struct pci_dev *pdev) 932 { 933 struct hinic_sriov_info *sriov_info; 934 u16 tmp_vfs; 935 936 sriov_info = hinic_get_sriov_info_by_pcidev(pdev); 937 /* if SR-IOV is already disabled then nothing will be done */ 938 if (!sriov_info->sriov_enabled) 939 return 0; 940 941 set_bit(HINIC_SRIOV_DISABLE, &sriov_info->state); 942 943 /* If our VFs are assigned we cannot shut down SR-IOV 944 * without causing issues, so just leave the hardware 945 * available but disabled 946 */ 947 if (pci_vfs_assigned(sriov_info->pdev)) { 948 clear_bit(HINIC_SRIOV_DISABLE, &sriov_info->state); 949 dev_warn(&pdev->dev, "Unloading driver while VFs are assigned - VFs will not be deallocated\n"); 950 return -EPERM; 951 } 952 sriov_info->sriov_enabled = false; 953 954 /* disable iov and allow time for transactions to clear */ 955 pci_disable_sriov(sriov_info->pdev); 956 957 tmp_vfs = (u16)sriov_info->num_vfs; 958 sriov_info->num_vfs = 0; 959 hinic_deinit_vf_hw(sriov_info, OS_VF_ID_TO_HW(0), 960 OS_VF_ID_TO_HW(tmp_vfs - 1)); 961 962 clear_bit(HINIC_SRIOV_DISABLE, &sriov_info->state); 963 964 return 0; 965 } 966 967 int hinic_pci_sriov_enable(struct pci_dev *pdev, int num_vfs) 968 { 969 struct hinic_sriov_info *sriov_info; 970 int err; 971 972 sriov_info = hinic_get_sriov_info_by_pcidev(pdev); 973 974 if (test_and_set_bit(HINIC_SRIOV_ENABLE, &sriov_info->state)) { 975 dev_err(&pdev->dev, 976 "SR-IOV enable in process, please wait, num_vfs %d\n", 977 num_vfs); 978 return -EPERM; 979 } 980 981 err = hinic_init_vf_hw(sriov_info->hwdev, OS_VF_ID_TO_HW(0), 982 OS_VF_ID_TO_HW((u16)num_vfs - 1)); 983 if (err) { 984 dev_err(&sriov_info->pdev->dev, 985 "Failed to init vf in hardware before enable sriov, error %d\n", 986 err); 987 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state); 988 return err; 989 } 990 991 err = pci_enable_sriov(sriov_info->pdev, num_vfs); 992 if (err) { 993 dev_err(&pdev->dev, 994 "Failed to enable SR-IOV, error %d\n", err); 995 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state); 996 return err; 997 } 998 999 sriov_info->sriov_enabled = true; 1000 sriov_info->num_vfs = num_vfs; 1001 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state); 1002 1003 return num_vfs; 1004 } 1005 1006 int hinic_pci_sriov_configure(struct pci_dev *dev, int num_vfs) 1007 { 1008 struct hinic_sriov_info *sriov_info; 1009 1010 sriov_info = hinic_get_sriov_info_by_pcidev(dev); 1011 1012 if (test_bit(HINIC_FUNC_REMOVE, &sriov_info->state)) 1013 return -EBUSY; 1014 1015 if (!num_vfs) 1016 return hinic_pci_sriov_disable(dev); 1017 else 1018 return hinic_pci_sriov_enable(dev, num_vfs); 1019 } 1020