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 int hinic_set_mac(struct hinic_hwdev *hwdev, const u8 *mac_addr, u16 vlan_id, 27 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 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 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 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 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 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 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 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 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 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 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 struct hinic_sriov_info *hinic_get_sriov_info_by_pcidev(struct pci_dev *pdev) 355 { 356 struct net_device *netdev = pci_get_drvdata(pdev); 357 struct hinic_dev *nic_dev = netdev_priv(netdev); 358 359 return &nic_dev->sriov_info; 360 } 361 362 static int hinic_check_mac_info(u8 status, u16 vlan_id) 363 { 364 if ((status && status != HINIC_MGMT_STATUS_EXIST && 365 status != HINIC_PF_SET_VF_ALREADY) || 366 (vlan_id & CHECK_IPSU_15BIT && 367 status == HINIC_MGMT_STATUS_EXIST)) 368 return -EINVAL; 369 370 return 0; 371 } 372 373 #define HINIC_VLAN_ID_MASK 0x7FFF 374 375 int hinic_update_mac(struct hinic_hwdev *hwdev, u8 *old_mac, u8 *new_mac, 376 u16 vlan_id, u16 func_id) 377 { 378 struct hinic_port_mac_update mac_info = {0}; 379 u16 out_size = sizeof(mac_info); 380 int err; 381 382 if (!hwdev || !old_mac || !new_mac) 383 return -EINVAL; 384 385 if ((vlan_id & HINIC_VLAN_ID_MASK) >= VLAN_N_VID) { 386 dev_err(&hwdev->hwif->pdev->dev, "Invalid VLAN number: %d\n", 387 (vlan_id & HINIC_VLAN_ID_MASK)); 388 return -EINVAL; 389 } 390 391 mac_info.func_id = func_id; 392 mac_info.vlan_id = vlan_id; 393 memcpy(mac_info.old_mac, old_mac, ETH_ALEN); 394 memcpy(mac_info.new_mac, new_mac, ETH_ALEN); 395 396 err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_UPDATE_MAC, &mac_info, 397 sizeof(mac_info), &mac_info, &out_size); 398 399 if (err || !out_size || 400 hinic_check_mac_info(mac_info.status, mac_info.vlan_id)) { 401 dev_err(&hwdev->hwif->pdev->dev, 402 "Failed to update MAC, err: %d, status: 0x%x, out size: 0x%x\n", 403 err, mac_info.status, out_size); 404 return -EINVAL; 405 } 406 407 if (mac_info.status == HINIC_PF_SET_VF_ALREADY) { 408 dev_warn(&hwdev->hwif->pdev->dev, 409 "PF has already set VF MAC. Ignore update operation\n"); 410 return HINIC_PF_SET_VF_ALREADY; 411 } 412 413 if (mac_info.status == HINIC_MGMT_STATUS_EXIST) 414 dev_warn(&hwdev->hwif->pdev->dev, "MAC is repeated. Ignore update operation\n"); 415 416 return 0; 417 } 418 419 void hinic_get_vf_config(struct hinic_hwdev *hwdev, u16 vf_id, 420 struct ifla_vf_info *ivi) 421 { 422 struct vf_data_storage *vfinfo; 423 424 vfinfo = hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 425 426 ivi->vf = HW_VF_ID_TO_OS(vf_id); 427 memcpy(ivi->mac, vfinfo->vf_mac_addr, ETH_ALEN); 428 ivi->vlan = vfinfo->pf_vlan; 429 ivi->qos = vfinfo->pf_qos; 430 ivi->spoofchk = vfinfo->spoofchk; 431 ivi->trusted = vfinfo->trust; 432 ivi->max_tx_rate = vfinfo->max_rate; 433 ivi->min_tx_rate = vfinfo->min_rate; 434 435 if (!vfinfo->link_forced) 436 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO; 437 else if (vfinfo->link_up) 438 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE; 439 else 440 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE; 441 } 442 443 int hinic_ndo_get_vf_config(struct net_device *netdev, 444 int vf, struct ifla_vf_info *ivi) 445 { 446 struct hinic_dev *nic_dev = netdev_priv(netdev); 447 struct hinic_sriov_info *sriov_info; 448 449 sriov_info = &nic_dev->sriov_info; 450 if (vf >= sriov_info->num_vfs) 451 return -EINVAL; 452 453 hinic_get_vf_config(sriov_info->hwdev, OS_VF_ID_TO_HW(vf), ivi); 454 455 return 0; 456 } 457 458 int hinic_set_vf_mac(struct hinic_hwdev *hwdev, int vf, unsigned char *mac_addr) 459 { 460 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 461 struct vf_data_storage *vf_info; 462 u16 func_id; 463 int err; 464 465 vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf); 466 467 /* duplicate request, so just return success */ 468 if (vf_info->pf_set_mac && 469 !memcmp(vf_info->vf_mac_addr, mac_addr, ETH_ALEN)) 470 return 0; 471 472 vf_info->pf_set_mac = true; 473 474 func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf; 475 err = hinic_update_mac(hwdev, vf_info->vf_mac_addr, 476 mac_addr, 0, func_id); 477 if (err) { 478 vf_info->pf_set_mac = false; 479 return err; 480 } 481 482 memcpy(vf_info->vf_mac_addr, mac_addr, ETH_ALEN); 483 484 return 0; 485 } 486 487 int hinic_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 488 { 489 struct hinic_dev *nic_dev = netdev_priv(netdev); 490 struct hinic_sriov_info *sriov_info; 491 int err; 492 493 sriov_info = &nic_dev->sriov_info; 494 if (!is_valid_ether_addr(mac) || vf >= sriov_info->num_vfs) 495 return -EINVAL; 496 497 err = hinic_set_vf_mac(sriov_info->hwdev, OS_VF_ID_TO_HW(vf), mac); 498 if (err) 499 return err; 500 501 netif_info(nic_dev, drv, netdev, "Setting MAC %pM on VF %d\n", mac, vf); 502 netif_info(nic_dev, drv, netdev, "Reload the VF driver to make this change effective."); 503 504 return 0; 505 } 506 507 int hinic_add_vf_vlan(struct hinic_hwdev *hwdev, int vf_id, u16 vlan, u8 qos) 508 { 509 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 510 int err; 511 512 err = hinic_set_vf_vlan(hwdev, true, vlan, qos, vf_id); 513 if (err) 514 return err; 515 516 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan = vlan; 517 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos = qos; 518 519 dev_info(&hwdev->hwif->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n", 520 vlan, qos, HW_VF_ID_TO_OS(vf_id)); 521 return 0; 522 } 523 524 int hinic_kill_vf_vlan(struct hinic_hwdev *hwdev, int vf_id) 525 { 526 struct hinic_func_to_io *nic_io = &hwdev->func_to_io; 527 int err; 528 529 err = hinic_set_vf_vlan(hwdev, false, 530 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan, 531 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos, 532 vf_id); 533 if (err) 534 return err; 535 536 dev_info(&hwdev->hwif->pdev->dev, "Remove VLAN %d on VF %d\n", 537 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan, 538 HW_VF_ID_TO_OS(vf_id)); 539 540 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan = 0; 541 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos = 0; 542 543 return 0; 544 } 545 546 int hinic_update_mac_vlan(struct hinic_dev *nic_dev, u16 old_vlan, u16 new_vlan, 547 int vf_id) 548 { 549 struct vf_data_storage *vf_info; 550 u16 vlan_id; 551 int err; 552 553 if (!nic_dev || old_vlan >= VLAN_N_VID || new_vlan >= VLAN_N_VID) 554 return -EINVAL; 555 556 vf_info = nic_dev->hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 557 if (!vf_info->pf_set_mac) 558 return 0; 559 560 vlan_id = old_vlan; 561 if (vlan_id) 562 vlan_id |= HINIC_ADD_VLAN_IN_MAC; 563 564 err = hinic_port_del_mac(nic_dev, vf_info->vf_mac_addr, vlan_id); 565 if (err) { 566 dev_err(&nic_dev->hwdev->hwif->pdev->dev, "Failed to delete VF %d MAC %pM vlan %d\n", 567 HW_VF_ID_TO_OS(vf_id), vf_info->vf_mac_addr, old_vlan); 568 return err; 569 } 570 571 vlan_id = new_vlan; 572 if (vlan_id) 573 vlan_id |= HINIC_ADD_VLAN_IN_MAC; 574 575 err = hinic_port_add_mac(nic_dev, vf_info->vf_mac_addr, vlan_id); 576 if (err) { 577 dev_err(&nic_dev->hwdev->hwif->pdev->dev, "Failed to add VF %d MAC %pM vlan %d\n", 578 HW_VF_ID_TO_OS(vf_id), vf_info->vf_mac_addr, new_vlan); 579 goto out; 580 } 581 582 return 0; 583 584 out: 585 vlan_id = old_vlan; 586 if (vlan_id) 587 vlan_id |= HINIC_ADD_VLAN_IN_MAC; 588 hinic_port_add_mac(nic_dev, vf_info->vf_mac_addr, vlan_id); 589 590 return err; 591 } 592 593 static int set_hw_vf_vlan(struct hinic_dev *nic_dev, 594 u16 cur_vlanprio, int vf, u16 vlan, u8 qos) 595 { 596 u16 old_vlan = cur_vlanprio & VLAN_VID_MASK; 597 int err = 0; 598 599 if (vlan || qos) { 600 if (cur_vlanprio) { 601 err = hinic_kill_vf_vlan(nic_dev->hwdev, 602 OS_VF_ID_TO_HW(vf)); 603 if (err) { 604 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to delete vf %d old vlan %d\n", 605 vf, old_vlan); 606 goto out; 607 } 608 } 609 err = hinic_add_vf_vlan(nic_dev->hwdev, 610 OS_VF_ID_TO_HW(vf), vlan, qos); 611 if (err) { 612 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to add vf %d new vlan %d\n", 613 vf, vlan); 614 goto out; 615 } 616 } else { 617 err = hinic_kill_vf_vlan(nic_dev->hwdev, OS_VF_ID_TO_HW(vf)); 618 if (err) { 619 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to delete vf %d vlan %d\n", 620 vf, old_vlan); 621 goto out; 622 } 623 } 624 625 err = hinic_update_mac_vlan(nic_dev, old_vlan, vlan, 626 OS_VF_ID_TO_HW(vf)); 627 628 out: 629 return err; 630 } 631 632 int hinic_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos, 633 __be16 vlan_proto) 634 { 635 struct hinic_dev *nic_dev = netdev_priv(netdev); 636 struct hinic_sriov_info *sriov_info; 637 u16 vlanprio, cur_vlanprio; 638 639 sriov_info = &nic_dev->sriov_info; 640 if (vf >= sriov_info->num_vfs || vlan > 4095 || qos > 7) 641 return -EINVAL; 642 if (vlan_proto != htons(ETH_P_8021Q)) 643 return -EPROTONOSUPPORT; 644 vlanprio = vlan | qos << HINIC_VLAN_PRIORITY_SHIFT; 645 cur_vlanprio = hinic_vf_info_vlanprio(nic_dev->hwdev, 646 OS_VF_ID_TO_HW(vf)); 647 /* duplicate request, so just return success */ 648 if (vlanprio == cur_vlanprio) 649 return 0; 650 651 return set_hw_vf_vlan(nic_dev, cur_vlanprio, vf, vlan, qos); 652 } 653 654 int hinic_set_vf_trust(struct hinic_hwdev *hwdev, u16 vf_id, bool trust) 655 { 656 struct vf_data_storage *vf_infos; 657 struct hinic_func_to_io *nic_io; 658 659 if (!hwdev) 660 return -EINVAL; 661 662 nic_io = &hwdev->func_to_io; 663 vf_infos = nic_io->vf_infos; 664 vf_infos[vf_id].trust = trust; 665 666 return 0; 667 } 668 669 int hinic_ndo_set_vf_trust(struct net_device *netdev, int vf, bool setting) 670 { 671 struct hinic_dev *adapter = netdev_priv(netdev); 672 struct hinic_sriov_info *sriov_info; 673 struct hinic_func_to_io *nic_io; 674 bool cur_trust; 675 int err; 676 677 sriov_info = &adapter->sriov_info; 678 nic_io = &adapter->hwdev->func_to_io; 679 680 if (vf >= sriov_info->num_vfs) 681 return -EINVAL; 682 683 cur_trust = nic_io->vf_infos[vf].trust; 684 /* same request, so just return success */ 685 if ((setting && cur_trust) || (!setting && !cur_trust)) 686 return 0; 687 688 err = hinic_set_vf_trust(adapter->hwdev, vf, setting); 689 if (!err) 690 dev_info(&sriov_info->pdev->dev, "Set VF %d trusted %s succeed\n", 691 vf, setting ? "on" : "off"); 692 else 693 dev_err(&sriov_info->pdev->dev, "Failed set VF %d trusted %s\n", 694 vf, setting ? "on" : "off"); 695 696 return err; 697 } 698 699 /* pf receive message from vf */ 700 int nic_pf_mbox_handler(void *hwdev, u16 vf_id, u8 cmd, void *buf_in, 701 u16 in_size, void *buf_out, u16 *out_size) 702 { 703 struct vf_cmd_msg_handle *vf_msg_handle; 704 struct hinic_hwdev *dev = hwdev; 705 struct hinic_func_to_io *nic_io; 706 struct hinic_pfhwdev *pfhwdev; 707 u32 i, cmd_number; 708 int err = 0; 709 710 if (!hwdev) 711 return -EFAULT; 712 713 cmd_number = sizeof(nic_vf_cmd_msg_handler) / 714 sizeof(struct vf_cmd_msg_handle); 715 pfhwdev = container_of(dev, struct hinic_pfhwdev, hwdev); 716 nic_io = &dev->func_to_io; 717 for (i = 0; i < cmd_number; i++) { 718 vf_msg_handle = &nic_vf_cmd_msg_handler[i]; 719 if (cmd == vf_msg_handle->cmd && 720 vf_msg_handle->cmd_msg_handler) { 721 err = vf_msg_handle->cmd_msg_handler(hwdev, vf_id, 722 buf_in, in_size, 723 buf_out, 724 out_size); 725 break; 726 } 727 } 728 if (i == cmd_number) 729 err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_L2NIC, 730 cmd, buf_in, in_size, buf_out, 731 out_size, HINIC_MGMT_MSG_SYNC); 732 733 if (err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) 734 dev_err(&nic_io->hwif->pdev->dev, "PF receive VF L2NIC cmd: %d process error, err:%d\n", 735 cmd, err); 736 return err; 737 } 738 739 static int cfg_mbx_pf_proc_vf_msg(void *hwdev, u16 vf_id, u8 cmd, void *buf_in, 740 u16 in_size, void *buf_out, u16 *out_size) 741 { 742 struct hinic_dev_cap *dev_cap = buf_out; 743 struct hinic_hwdev *dev = hwdev; 744 struct hinic_cap *cap; 745 746 cap = &dev->nic_cap; 747 memset(dev_cap, 0, sizeof(*dev_cap)); 748 749 dev_cap->max_vf = cap->max_vf; 750 dev_cap->max_sqs = cap->max_vf_qps; 751 dev_cap->max_rqs = cap->max_vf_qps; 752 753 *out_size = sizeof(*dev_cap); 754 755 return 0; 756 } 757 758 static int hinic_init_vf_infos(struct hinic_func_to_io *nic_io, u16 vf_id) 759 { 760 struct vf_data_storage *vf_infos = nic_io->vf_infos; 761 762 if (set_vf_link_state > HINIC_IFLA_VF_LINK_STATE_DISABLE) { 763 dev_warn(&nic_io->hwif->pdev->dev, "Module Parameter set_vf_link_state value %d is out of range, resetting to %d\n", 764 set_vf_link_state, HINIC_IFLA_VF_LINK_STATE_AUTO); 765 set_vf_link_state = HINIC_IFLA_VF_LINK_STATE_AUTO; 766 } 767 768 switch (set_vf_link_state) { 769 case HINIC_IFLA_VF_LINK_STATE_AUTO: 770 vf_infos[vf_id].link_forced = false; 771 break; 772 case HINIC_IFLA_VF_LINK_STATE_ENABLE: 773 vf_infos[vf_id].link_forced = true; 774 vf_infos[vf_id].link_up = true; 775 break; 776 case HINIC_IFLA_VF_LINK_STATE_DISABLE: 777 vf_infos[vf_id].link_forced = true; 778 vf_infos[vf_id].link_up = false; 779 break; 780 default: 781 dev_err(&nic_io->hwif->pdev->dev, "Invalid input parameter set_vf_link_state: %d\n", 782 set_vf_link_state); 783 return -EINVAL; 784 } 785 786 return 0; 787 } 788 789 void hinic_clear_vf_infos(struct hinic_dev *nic_dev, u16 vf_id) 790 { 791 struct vf_data_storage *vf_infos; 792 u16 func_id; 793 794 func_id = hinic_glb_pf_vf_offset(nic_dev->hwdev->hwif) + vf_id; 795 vf_infos = nic_dev->hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id); 796 if (vf_infos->pf_set_mac) 797 hinic_port_del_mac(nic_dev, vf_infos->vf_mac_addr, 0); 798 799 if (hinic_vf_info_vlanprio(nic_dev->hwdev, vf_id)) 800 hinic_kill_vf_vlan(nic_dev->hwdev, vf_id); 801 802 if (vf_infos->trust) 803 hinic_set_vf_trust(nic_dev->hwdev, vf_id, false); 804 805 memset(vf_infos, 0, sizeof(*vf_infos)); 806 /* set vf_infos to default */ 807 hinic_init_vf_infos(&nic_dev->hwdev->func_to_io, HW_VF_ID_TO_OS(vf_id)); 808 } 809 810 int hinic_deinit_vf_hw(struct hinic_sriov_info *sriov_info, u16 start_vf_id, 811 u16 end_vf_id) 812 { 813 struct hinic_dev *nic_dev; 814 u16 func_idx, idx; 815 816 nic_dev = container_of(sriov_info, struct hinic_dev, sriov_info); 817 818 for (idx = start_vf_id; idx <= end_vf_id; idx++) { 819 func_idx = hinic_glb_pf_vf_offset(nic_dev->hwdev->hwif) + idx; 820 hinic_set_wq_page_size(nic_dev->hwdev, func_idx, 821 HINIC_HW_WQ_PAGE_SIZE); 822 hinic_clear_vf_infos(nic_dev, idx); 823 } 824 825 return 0; 826 } 827 828 int hinic_vf_func_init(struct hinic_hwdev *hwdev) 829 { 830 struct hinic_register_vf register_info = {0}; 831 u16 out_size = sizeof(register_info); 832 struct hinic_func_to_io *nic_io; 833 int err = 0; 834 u32 size, i; 835 836 nic_io = &hwdev->func_to_io; 837 838 if (HINIC_IS_VF(hwdev->hwif)) { 839 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC, 840 HINIC_PORT_CMD_VF_REGISTER, 841 ®ister_info, sizeof(register_info), 842 ®ister_info, &out_size, 0); 843 if (err || register_info.status || !out_size) { 844 dev_err(&hwdev->hwif->pdev->dev, 845 "Failed to register VF, err: %d, status: 0x%x, out size: 0x%x\n", 846 err, register_info.status, out_size); 847 hinic_unregister_vf_mbox_cb(hwdev, HINIC_MOD_L2NIC); 848 return -EIO; 849 } 850 } else { 851 err = hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_CFGM, 852 cfg_mbx_pf_proc_vf_msg); 853 if (err) { 854 dev_err(&hwdev->hwif->pdev->dev, 855 "Register PF mailbox callback failed\n"); 856 return err; 857 } 858 nic_io->max_vfs = hwdev->nic_cap.max_vf; 859 size = sizeof(*nic_io->vf_infos) * nic_io->max_vfs; 860 if (size != 0) { 861 nic_io->vf_infos = kzalloc(size, GFP_KERNEL); 862 if (!nic_io->vf_infos) { 863 err = -ENOMEM; 864 goto out_free_nic_io; 865 } 866 867 for (i = 0; i < nic_io->max_vfs; i++) { 868 err = hinic_init_vf_infos(nic_io, i); 869 if (err) 870 goto err_init_vf_infos; 871 } 872 873 err = hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_L2NIC, 874 nic_pf_mbox_handler); 875 if (err) 876 goto err_register_pf_mbox_cb; 877 } 878 } 879 880 return 0; 881 882 err_register_pf_mbox_cb: 883 err_init_vf_infos: 884 kfree(nic_io->vf_infos); 885 out_free_nic_io: 886 return err; 887 } 888 889 void hinic_vf_func_free(struct hinic_hwdev *hwdev) 890 { 891 struct hinic_register_vf unregister = {0}; 892 u16 out_size = sizeof(unregister); 893 int err; 894 895 if (HINIC_IS_VF(hwdev->hwif)) { 896 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC, 897 HINIC_PORT_CMD_VF_UNREGISTER, 898 &unregister, sizeof(unregister), 899 &unregister, &out_size, 0); 900 if (err || !out_size || unregister.status) 901 dev_err(&hwdev->hwif->pdev->dev, "Failed to unregister VF, err: %d, status: 0x%x, out_size: 0x%x\n", 902 err, unregister.status, out_size); 903 } else { 904 if (hwdev->func_to_io.vf_infos) { 905 hinic_unregister_pf_mbox_cb(hwdev, HINIC_MOD_L2NIC); 906 kfree(hwdev->func_to_io.vf_infos); 907 } 908 } 909 } 910 911 int hinic_init_vf_hw(struct hinic_hwdev *hwdev, u16 start_vf_id, u16 end_vf_id) 912 { 913 u16 i, func_idx; 914 int err; 915 916 /* vf use 256K as default wq page size, and can't change it */ 917 for (i = start_vf_id; i <= end_vf_id; i++) { 918 func_idx = hinic_glb_pf_vf_offset(hwdev->hwif) + i; 919 err = hinic_set_wq_page_size(hwdev, func_idx, 920 HINIC_DEFAULT_WQ_PAGE_SIZE); 921 if (err) 922 return err; 923 } 924 925 return 0; 926 } 927 928 int hinic_pci_sriov_disable(struct pci_dev *pdev) 929 { 930 struct hinic_sriov_info *sriov_info; 931 u16 tmp_vfs; 932 933 sriov_info = hinic_get_sriov_info_by_pcidev(pdev); 934 /* if SR-IOV is already disabled then nothing will be done */ 935 if (!sriov_info->sriov_enabled) 936 return 0; 937 938 set_bit(HINIC_SRIOV_DISABLE, &sriov_info->state); 939 940 /* If our VFs are assigned we cannot shut down SR-IOV 941 * without causing issues, so just leave the hardware 942 * available but disabled 943 */ 944 if (pci_vfs_assigned(sriov_info->pdev)) { 945 clear_bit(HINIC_SRIOV_DISABLE, &sriov_info->state); 946 dev_warn(&pdev->dev, "Unloading driver while VFs are assigned - VFs will not be deallocated\n"); 947 return -EPERM; 948 } 949 sriov_info->sriov_enabled = false; 950 951 /* disable iov and allow time for transactions to clear */ 952 pci_disable_sriov(sriov_info->pdev); 953 954 tmp_vfs = (u16)sriov_info->num_vfs; 955 sriov_info->num_vfs = 0; 956 hinic_deinit_vf_hw(sriov_info, OS_VF_ID_TO_HW(0), 957 OS_VF_ID_TO_HW(tmp_vfs - 1)); 958 959 clear_bit(HINIC_SRIOV_DISABLE, &sriov_info->state); 960 961 return 0; 962 } 963 964 int hinic_pci_sriov_enable(struct pci_dev *pdev, int num_vfs) 965 { 966 struct hinic_sriov_info *sriov_info; 967 int err; 968 969 sriov_info = hinic_get_sriov_info_by_pcidev(pdev); 970 971 if (test_and_set_bit(HINIC_SRIOV_ENABLE, &sriov_info->state)) { 972 dev_err(&pdev->dev, 973 "SR-IOV enable in process, please wait, num_vfs %d\n", 974 num_vfs); 975 return -EPERM; 976 } 977 978 err = hinic_init_vf_hw(sriov_info->hwdev, OS_VF_ID_TO_HW(0), 979 OS_VF_ID_TO_HW((u16)num_vfs - 1)); 980 if (err) { 981 dev_err(&sriov_info->pdev->dev, 982 "Failed to init vf in hardware before enable sriov, error %d\n", 983 err); 984 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state); 985 return err; 986 } 987 988 err = pci_enable_sriov(sriov_info->pdev, num_vfs); 989 if (err) { 990 dev_err(&pdev->dev, 991 "Failed to enable SR-IOV, error %d\n", err); 992 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state); 993 return err; 994 } 995 996 sriov_info->sriov_enabled = true; 997 sriov_info->num_vfs = num_vfs; 998 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state); 999 1000 return num_vfs; 1001 } 1002 1003 int hinic_pci_sriov_configure(struct pci_dev *dev, int num_vfs) 1004 { 1005 struct hinic_sriov_info *sriov_info; 1006 1007 sriov_info = hinic_get_sriov_info_by_pcidev(dev); 1008 1009 if (test_bit(HINIC_FUNC_REMOVE, &sriov_info->state)) 1010 return -EBUSY; 1011 1012 if (!num_vfs) 1013 return hinic_pci_sriov_disable(dev); 1014 else 1015 return hinic_pci_sriov_enable(dev, num_vfs); 1016 } 1017