drivers/net/ethernet/huawei/hinic/hinic_sriov.c

   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 #include <linux/module.h>
  12
  13 #include "hinic_hw_dev.h"
  14 #include "hinic_dev.h"
  15 #include "hinic_hw_mbox.h"
  16 #include "hinic_hw_cmdq.h"
  17 #include "hinic_port.h"
  18 #include "hinic_sriov.h"
  19
  20 static unsigned char set_vf_link_state;
  21 module_param(set_vf_link_state, byte, 0444);
  22 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.");
  23
  24 #define HINIC_VLAN_PRIORITY_SHIFT 13
  25 #define HINIC_ADD_VLAN_IN_MAC 0x8000
  26 #define HINIC_TX_RATE_TABLE_FULL 12
  27 #define HINIC_MAX_QOS 7
  28
  29 static int hinic_set_mac(struct hinic_hwdev *hwdev, const u8 *mac_addr,
  30                          u16 vlan_id, u16 func_id)
  31 {
  32         struct hinic_port_mac_cmd mac_info = {0};
  33         u16 out_size = sizeof(mac_info);
  34         int err;
  35
  36         mac_info.func_idx = func_id;
  37         mac_info.vlan_id = vlan_id;
  38         memcpy(mac_info.mac, mac_addr, ETH_ALEN);
  39
  40         err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_MAC, &mac_info,
  41                                  sizeof(mac_info), &mac_info, &out_size);
  42         if (err || out_size != sizeof(mac_info) ||
  43             (mac_info.status && mac_info.status != HINIC_MGMT_STATUS_EXIST)) {
  44                 dev_err(&hwdev->func_to_io.hwif->pdev->dev, "Failed to set MAC, err: %d, status: 0x%x, out size: 0x%x\n",
  45                         err, mac_info.status, out_size);
  46                 return -EIO;
  47         }
  48
  49         return 0;
  50 }
  51
  52 static void hinic_notify_vf_link_status(struct hinic_hwdev *hwdev, u16 vf_id,
  53                                         u8 link_status)
  54 {
  55         struct vf_data_storage *vf_infos = hwdev->func_to_io.vf_infos;
  56         struct hinic_port_link_status link = {0};
  57         u16 out_size = sizeof(link);
  58         int err;
  59
  60         if (vf_infos[HW_VF_ID_TO_OS(vf_id)].registered) {
  61                 link.link = link_status;
  62                 link.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
  63                 err = hinic_mbox_to_vf(hwdev, HINIC_MOD_L2NIC,
  64                                        vf_id, HINIC_PORT_CMD_LINK_STATUS_REPORT,
  65                                        &link, sizeof(link),
  66                                        &link, &out_size, 0);
  67                 if (err || !out_size || link.status)
  68                         dev_err(&hwdev->hwif->pdev->dev,
  69                                 "Send link change event to VF %d failed, err: %d, status: 0x%x, out_size: 0x%x\n",
  70                                 HW_VF_ID_TO_OS(vf_id), err,
  71                                 link.status, out_size);
  72         }
  73 }
  74
  75 /* send link change event mbox msg to active vfs under the pf */
  76 void hinic_notify_all_vfs_link_changed(struct hinic_hwdev *hwdev,
  77                                        u8 link_status)
  78 {
  79         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
  80         u16 i;
  81
  82         nic_io->link_status = link_status;
  83         for (i = 1; i <= nic_io->max_vfs; i++) {
  84                 if (!nic_io->vf_infos[HW_VF_ID_TO_OS(i)].link_forced)
  85                         hinic_notify_vf_link_status(hwdev, i,  link_status);
  86         }
  87 }
  88
  89 static u16 hinic_vf_info_vlanprio(struct hinic_hwdev *hwdev, int vf_id)
  90 {
  91         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
  92         u16 pf_vlan, vlanprio;
  93         u8 pf_qos;
  94
  95         pf_vlan = nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan;
  96         pf_qos = nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos;
  97         vlanprio = pf_vlan | pf_qos << HINIC_VLAN_PRIORITY_SHIFT;
  98
  99         return vlanprio;
 100 }
 101
 102 static int hinic_set_vf_vlan(struct hinic_hwdev *hwdev, bool add, u16 vid,
 103                              u8 qos, int vf_id)
 104 {
 105         struct hinic_vf_vlan_config vf_vlan = {0};
 106         u16 out_size = sizeof(vf_vlan);
 107         int err;
 108         u8 cmd;
 109
 110         /* VLAN 0 is a special case, don't allow it to be removed */
 111         if (!vid && !add)
 112                 return 0;
 113
 114         vf_vlan.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
 115         vf_vlan.vlan_id = vid;
 116         vf_vlan.qos = qos;
 117
 118         if (add)
 119                 cmd = HINIC_PORT_CMD_SET_VF_VLAN;
 120         else
 121                 cmd = HINIC_PORT_CMD_CLR_VF_VLAN;
 122
 123         err = hinic_port_msg_cmd(hwdev, cmd, &vf_vlan,
 124                                  sizeof(vf_vlan), &vf_vlan, &out_size);
 125         if (err || !out_size || vf_vlan.status) {
 126                 dev_err(&hwdev->hwif->pdev->dev, "Failed to set VF %d vlan, err: %d, status: 0x%x, out size: 0x%x\n",
 127                         HW_VF_ID_TO_OS(vf_id), err, vf_vlan.status, out_size);
 128                 return -EFAULT;
 129         }
 130
 131         return 0;
 132 }
 133
 134 static int hinic_set_vf_tx_rate_max_min(struct hinic_hwdev *hwdev, u16 vf_id,
 135                                         u32 max_rate, u32 min_rate)
 136 {
 137         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
 138         struct hinic_tx_rate_cfg_max_min rate_cfg = {0};
 139         u16 out_size = sizeof(rate_cfg);
 140         int err;
 141
 142         rate_cfg.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
 143         rate_cfg.max_rate = max_rate;
 144         rate_cfg.min_rate = min_rate;
 145         err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_VF_MAX_MIN_RATE,
 146                                  &rate_cfg, sizeof(rate_cfg), &rate_cfg,
 147                                  &out_size);
 148         if ((rate_cfg.status != HINIC_MGMT_CMD_UNSUPPORTED &&
 149              rate_cfg.status) || err || !out_size) {
 150                 dev_err(&hwdev->hwif->pdev->dev, "Failed to set VF(%d) max rate(%d), min rate(%d), err: %d, status: 0x%x, out size: 0x%x\n",
 151                         HW_VF_ID_TO_OS(vf_id), max_rate, min_rate, err,
 152                         rate_cfg.status, out_size);
 153                 return -EIO;
 154         }
 155
 156         if (!rate_cfg.status) {
 157                 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].max_rate = max_rate;
 158                 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].min_rate = min_rate;
 159         }
 160
 161         return rate_cfg.status;
 162 }
 163
 164 static int hinic_set_vf_rate_limit(struct hinic_hwdev *hwdev, u16 vf_id,
 165                                    u32 tx_rate)
 166 {
 167         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
 168         struct hinic_tx_rate_cfg rate_cfg = {0};
 169         u16 out_size = sizeof(rate_cfg);
 170         int err;
 171
 172         rate_cfg.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
 173         rate_cfg.tx_rate = tx_rate;
 174         err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_VF_RATE,
 175                                  &rate_cfg, sizeof(rate_cfg), &rate_cfg,
 176                                  &out_size);
 177         if (err || !out_size || rate_cfg.status) {
 178                 dev_err(&hwdev->hwif->pdev->dev, "Failed to set VF(%d) rate(%d), err: %d, status: 0x%x, out size: 0x%x\n",
 179                         HW_VF_ID_TO_OS(vf_id), tx_rate, err, rate_cfg.status,
 180                         out_size);
 181                 if (rate_cfg.status)
 182                         return rate_cfg.status;
 183
 184                 return -EIO;
 185         }
 186
 187         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].max_rate = tx_rate;
 188         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].min_rate = 0;
 189
 190         return 0;
 191 }
 192
 193 static int hinic_set_vf_tx_rate(struct hinic_hwdev *hwdev, u16 vf_id,
 194                                 u32 max_rate, u32 min_rate)
 195 {
 196         int err;
 197
 198         err = hinic_set_vf_tx_rate_max_min(hwdev, vf_id, max_rate, min_rate);
 199         if (err != HINIC_MGMT_CMD_UNSUPPORTED)
 200                 return err;
 201
 202         if (min_rate) {
 203                 dev_err(&hwdev->hwif->pdev->dev, "Current firmware doesn't support to set min tx rate\n");
 204                 return -EOPNOTSUPP;
 205         }
 206
 207         dev_info(&hwdev->hwif->pdev->dev, "Current firmware doesn't support to set min tx rate, force min_tx_rate = max_tx_rate\n");
 208
 209         return hinic_set_vf_rate_limit(hwdev, vf_id, max_rate);
 210 }
 211
 212 static int hinic_init_vf_config(struct hinic_hwdev *hwdev, u16 vf_id)
 213 {
 214         struct vf_data_storage *vf_info;
 215         u16 func_id, vlan_id;
 216         int err = 0;
 217
 218         vf_info = hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id);
 219         if (vf_info->pf_set_mac) {
 220                 func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
 221
 222                 vlan_id = 0;
 223
 224                 err = hinic_set_mac(hwdev, vf_info->vf_mac_addr, vlan_id,
 225                                     func_id);
 226                 if (err) {
 227                         dev_err(&hwdev->func_to_io.hwif->pdev->dev, "Failed to set VF %d MAC\n",
 228                                 HW_VF_ID_TO_OS(vf_id));
 229                         return err;
 230                 }
 231         }
 232
 233         if (hinic_vf_info_vlanprio(hwdev, vf_id)) {
 234                 err = hinic_set_vf_vlan(hwdev, true, vf_info->pf_vlan,
 235                                         vf_info->pf_qos, vf_id);
 236                 if (err) {
 237                         dev_err(&hwdev->hwif->pdev->dev, "Failed to add VF %d VLAN_QOS\n",
 238                                 HW_VF_ID_TO_OS(vf_id));
 239                         return err;
 240                 }
 241         }
 242
 243         if (vf_info->max_rate) {
 244                 err = hinic_set_vf_tx_rate(hwdev, vf_id, vf_info->max_rate,
 245                                            vf_info->min_rate);
 246                 if (err) {
 247                         dev_err(&hwdev->hwif->pdev->dev, "Failed to set VF %d max rate: %d, min rate: %d\n",
 248                                 HW_VF_ID_TO_OS(vf_id), vf_info->max_rate,
 249                                 vf_info->min_rate);
 250                         return err;
 251                 }
 252         }
 253
 254         return 0;
 255 }
 256
 257 static int hinic_register_vf_msg_handler(void *hwdev, u16 vf_id,
 258                                          void *buf_in, u16 in_size,
 259                                          void *buf_out, u16 *out_size)
 260 {
 261         struct hinic_register_vf *register_info = buf_out;
 262         struct hinic_hwdev *hw_dev = hwdev;
 263         struct hinic_func_to_io *nic_io;
 264         int err;
 265
 266         nic_io = &hw_dev->func_to_io;
 267         if (vf_id > nic_io->max_vfs) {
 268                 dev_err(&hw_dev->hwif->pdev->dev, "Register VF id %d exceed limit[0-%d]\n",
 269                         HW_VF_ID_TO_OS(vf_id), HW_VF_ID_TO_OS(nic_io->max_vfs));
 270                 register_info->status = EFAULT;
 271                 return -EFAULT;
 272         }
 273
 274         *out_size = sizeof(*register_info);
 275         err = hinic_init_vf_config(hw_dev, vf_id);
 276         if (err) {
 277                 register_info->status = EFAULT;
 278                 return err;
 279         }
 280
 281         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].registered = true;
 282
 283         return 0;
 284 }
 285
 286 static int hinic_unregister_vf_msg_handler(void *hwdev, u16 vf_id,
 287                                            void *buf_in, u16 in_size,
 288                                            void *buf_out, u16 *out_size)
 289 {
 290         struct hinic_hwdev *hw_dev = hwdev;
 291         struct hinic_func_to_io *nic_io;
 292
 293         nic_io = &hw_dev->func_to_io;
 294         *out_size = 0;
 295         if (vf_id > nic_io->max_vfs)
 296                 return 0;
 297
 298         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].registered = false;
 299
 300         return 0;
 301 }
 302
 303 static int hinic_change_vf_mtu_msg_handler(void *hwdev, u16 vf_id,
 304                                            void *buf_in, u16 in_size,
 305                                            void *buf_out, u16 *out_size)
 306 {
 307         struct hinic_hwdev *hw_dev = hwdev;
 308         int err;
 309
 310         err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_CHANGE_MTU, buf_in,
 311                                  in_size, buf_out, out_size);
 312         if (err) {
 313                 dev_err(&hw_dev->hwif->pdev->dev, "Failed to set VF %u mtu\n",
 314                         vf_id);
 315                 return err;
 316         }
 317
 318         return 0;
 319 }
 320
 321 static int hinic_get_vf_mac_msg_handler(void *hwdev, u16 vf_id,
 322                                         void *buf_in, u16 in_size,
 323                                         void *buf_out, u16 *out_size)
 324 {
 325         struct hinic_port_mac_cmd *mac_info = buf_out;
 326         struct hinic_hwdev *dev = hwdev;
 327         struct hinic_func_to_io *nic_io;
 328         struct vf_data_storage *vf_info;
 329
 330         nic_io = &dev->func_to_io;
 331         vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf_id);
 332
 333         memcpy(mac_info->mac, vf_info->vf_mac_addr, ETH_ALEN);
 334         mac_info->status = 0;
 335         *out_size = sizeof(*mac_info);
 336
 337         return 0;
 338 }
 339
 340 static int hinic_set_vf_mac_msg_handler(void *hwdev, u16 vf_id,
 341                                         void *buf_in, u16 in_size,
 342                                         void *buf_out, u16 *out_size)
 343 {
 344         struct hinic_port_mac_cmd *mac_out = buf_out;
 345         struct hinic_port_mac_cmd *mac_in = buf_in;
 346         struct hinic_hwdev *hw_dev = hwdev;
 347         struct hinic_func_to_io *nic_io;
 348         struct vf_data_storage *vf_info;
 349         int err;
 350
 351         nic_io =  &hw_dev->func_to_io;
 352         vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf_id);
 353         if (vf_info->pf_set_mac && !(vf_info->trust) &&
 354             is_valid_ether_addr(mac_in->mac)) {
 355                 dev_warn(&hw_dev->hwif->pdev->dev, "PF has already set VF %d MAC address\n",
 356                          HW_VF_ID_TO_OS(vf_id));
 357                 mac_out->status = HINIC_PF_SET_VF_ALREADY;
 358                 *out_size = sizeof(*mac_out);
 359                 return 0;
 360         }
 361
 362         err = hinic_port_msg_cmd(hw_dev, HINIC_PORT_CMD_SET_MAC, buf_in,
 363                                  in_size, buf_out, out_size);
 364         if ((err &&  err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) || !(*out_size)) {
 365                 dev_err(&hw_dev->hwif->pdev->dev,
 366                         "Failed to set VF %d MAC address, err: %d, status: 0x%x, out size: 0x%x\n",
 367                         HW_VF_ID_TO_OS(vf_id), err, mac_out->status, *out_size);
 368                 return -EFAULT;
 369         }
 370
 371         return err;
 372 }
 373
 374 static int hinic_del_vf_mac_msg_handler(void *hwdev, u16 vf_id,
 375                                         void *buf_in, u16 in_size,
 376                                         void *buf_out, u16 *out_size)
 377 {
 378         struct hinic_port_mac_cmd *mac_out = buf_out;
 379         struct hinic_port_mac_cmd *mac_in = buf_in;
 380         struct hinic_hwdev *hw_dev = hwdev;
 381         struct hinic_func_to_io *nic_io;
 382         struct vf_data_storage *vf_info;
 383         int err;
 384
 385         nic_io = &hw_dev->func_to_io;
 386         vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf_id);
 387         if (vf_info->pf_set_mac && is_valid_ether_addr(mac_in->mac) &&
 388             !memcmp(vf_info->vf_mac_addr, mac_in->mac, ETH_ALEN)) {
 389                 dev_warn(&hw_dev->hwif->pdev->dev, "PF has already set VF mac.\n");
 390                 mac_out->status = HINIC_PF_SET_VF_ALREADY;
 391                 *out_size = sizeof(*mac_out);
 392                 return 0;
 393         }
 394
 395         err = hinic_port_msg_cmd(hw_dev, HINIC_PORT_CMD_DEL_MAC, buf_in,
 396                                  in_size, buf_out, out_size);
 397         if ((err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) || !(*out_size)) {
 398                 dev_err(&hw_dev->hwif->pdev->dev, "Failed to delete VF %d MAC, err: %d, status: 0x%x, out size: 0x%x\n",
 399                         HW_VF_ID_TO_OS(vf_id), err, mac_out->status, *out_size);
 400                 return -EFAULT;
 401         }
 402
 403         return err;
 404 }
 405
 406 static int hinic_get_vf_link_status_msg_handler(void *hwdev, u16 vf_id,
 407                                                 void *buf_in, u16 in_size,
 408                                                 void *buf_out, u16 *out_size)
 409 {
 410         struct hinic_port_link_cmd *get_link = buf_out;
 411         struct hinic_hwdev *hw_dev = hwdev;
 412         struct vf_data_storage *vf_infos;
 413         struct hinic_func_to_io *nic_io;
 414         bool link_forced, link_up;
 415
 416         nic_io = &hw_dev->func_to_io;
 417         vf_infos = nic_io->vf_infos;
 418         link_forced = vf_infos[HW_VF_ID_TO_OS(vf_id)].link_forced;
 419         link_up = vf_infos[HW_VF_ID_TO_OS(vf_id)].link_up;
 420
 421         if (link_forced)
 422                 get_link->state = link_up ?
 423                         HINIC_LINK_STATE_UP : HINIC_LINK_STATE_DOWN;
 424         else
 425                 get_link->state = nic_io->link_status;
 426
 427         get_link->status = 0;
 428         *out_size = sizeof(*get_link);
 429
 430         return 0;
 431 }
 432
 433 static bool check_func_table(struct hinic_hwdev *hwdev, u16 func_idx,
 434                              void *buf_in, u16 in_size)
 435 {
 436         struct hinic_cmd_fw_ctxt *function_table = buf_in;
 437
 438         if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size) ||
 439             !function_table->rx_buf_sz)
 440                 return false;
 441
 442         return true;
 443 }
 444
 445 static struct vf_cmd_msg_handle nic_vf_cmd_msg_handler[] = {
 446         {HINIC_PORT_CMD_VF_REGISTER, hinic_register_vf_msg_handler},
 447         {HINIC_PORT_CMD_VF_UNREGISTER, hinic_unregister_vf_msg_handler},
 448         {HINIC_PORT_CMD_CHANGE_MTU, hinic_change_vf_mtu_msg_handler},
 449         {HINIC_PORT_CMD_GET_MAC, hinic_get_vf_mac_msg_handler},
 450         {HINIC_PORT_CMD_SET_MAC, hinic_set_vf_mac_msg_handler},
 451         {HINIC_PORT_CMD_DEL_MAC, hinic_del_vf_mac_msg_handler},
 452         {HINIC_PORT_CMD_GET_LINK_STATE, hinic_get_vf_link_status_msg_handler},
 453 };
 454
 455 static struct vf_cmd_check_handle nic_cmd_support_vf[] = {
 456         {HINIC_PORT_CMD_VF_REGISTER, NULL},
 457         {HINIC_PORT_CMD_VF_UNREGISTER, NULL},
 458         {HINIC_PORT_CMD_CHANGE_MTU, hinic_mbox_check_func_id_8B},
 459         {HINIC_PORT_CMD_ADD_VLAN, hinic_mbox_check_func_id_8B},
 460         {HINIC_PORT_CMD_DEL_VLAN, hinic_mbox_check_func_id_8B},
 461         {HINIC_PORT_CMD_SET_MAC, hinic_mbox_check_func_id_8B},
 462         {HINIC_PORT_CMD_GET_MAC, hinic_mbox_check_func_id_8B},
 463         {HINIC_PORT_CMD_DEL_MAC, hinic_mbox_check_func_id_8B},
 464         {HINIC_PORT_CMD_SET_RX_MODE, hinic_mbox_check_func_id_8B},
 465         {HINIC_PORT_CMD_GET_PAUSE_INFO, hinic_mbox_check_func_id_8B},
 466         {HINIC_PORT_CMD_GET_LINK_STATE, hinic_mbox_check_func_id_8B},
 467         {HINIC_PORT_CMD_SET_LRO, hinic_mbox_check_func_id_8B},
 468         {HINIC_PORT_CMD_SET_RX_CSUM, hinic_mbox_check_func_id_8B},
 469         {HINIC_PORT_CMD_SET_RX_VLAN_OFFLOAD, hinic_mbox_check_func_id_8B},
 470         {HINIC_PORT_CMD_GET_VPORT_STAT, hinic_mbox_check_func_id_8B},
 471         {HINIC_PORT_CMD_CLEAN_VPORT_STAT, hinic_mbox_check_func_id_8B},
 472         {HINIC_PORT_CMD_GET_RSS_TEMPLATE_INDIR_TBL,
 473          hinic_mbox_check_func_id_8B},
 474         {HINIC_PORT_CMD_SET_RSS_TEMPLATE_TBL, hinic_mbox_check_func_id_8B},
 475         {HINIC_PORT_CMD_GET_RSS_TEMPLATE_TBL, hinic_mbox_check_func_id_8B},
 476         {HINIC_PORT_CMD_SET_RSS_HASH_ENGINE, hinic_mbox_check_func_id_8B},
 477         {HINIC_PORT_CMD_GET_RSS_HASH_ENGINE, hinic_mbox_check_func_id_8B},
 478         {HINIC_PORT_CMD_GET_RSS_CTX_TBL, hinic_mbox_check_func_id_8B},
 479         {HINIC_PORT_CMD_SET_RSS_CTX_TBL, hinic_mbox_check_func_id_8B},
 480         {HINIC_PORT_CMD_RSS_TEMP_MGR, hinic_mbox_check_func_id_8B},
 481         {HINIC_PORT_CMD_RSS_CFG, hinic_mbox_check_func_id_8B},
 482         {HINIC_PORT_CMD_FWCTXT_INIT, check_func_table},
 483         {HINIC_PORT_CMD_GET_MGMT_VERSION, NULL},
 484         {HINIC_PORT_CMD_SET_FUNC_STATE, hinic_mbox_check_func_id_8B},
 485         {HINIC_PORT_CMD_GET_GLOBAL_QPN, hinic_mbox_check_func_id_8B},
 486         {HINIC_PORT_CMD_SET_TSO, hinic_mbox_check_func_id_8B},
 487         {HINIC_PORT_CMD_SET_RQ_IQ_MAP, hinic_mbox_check_func_id_8B},
 488         {HINIC_PORT_CMD_LINK_STATUS_REPORT, hinic_mbox_check_func_id_8B},
 489         {HINIC_PORT_CMD_UPDATE_MAC, hinic_mbox_check_func_id_8B},
 490         {HINIC_PORT_CMD_GET_CAP, hinic_mbox_check_func_id_8B},
 491         {HINIC_PORT_CMD_GET_LINK_MODE, hinic_mbox_check_func_id_8B},
 492         {HINIC_PORT_CMD_GET_VF_COS, NULL},
 493         {HINIC_PORT_CMD_SET_VHD_CFG, hinic_mbox_check_func_id_8B},
 494         {HINIC_PORT_CMD_SET_VLAN_FILTER, hinic_mbox_check_func_id_8B},
 495         {HINIC_PORT_CMD_Q_FILTER, hinic_mbox_check_func_id_8B},
 496         {HINIC_PORT_CMD_TCAM_FILTER, NULL},
 497         {HINIC_PORT_CMD_UP_TC_ADD_FLOW, NULL},
 498         {HINIC_PORT_CMD_UP_TC_DEL_FLOW, NULL},
 499         {HINIC_PORT_CMD_UP_TC_FLUSH_TCAM, hinic_mbox_check_func_id_8B},
 500         {HINIC_PORT_CMD_UP_TC_CTRL_TCAM_BLOCK, hinic_mbox_check_func_id_8B},
 501         {HINIC_PORT_CMD_UP_TC_ENABLE, hinic_mbox_check_func_id_8B},
 502         {HINIC_PORT_CMD_CABLE_PLUG_EVENT, NULL},
 503         {HINIC_PORT_CMD_LINK_ERR_EVENT, NULL},
 504         {HINIC_PORT_CMD_SET_PORT_STATE, hinic_mbox_check_func_id_8B},
 505         {HINIC_PORT_CMD_SET_ETS, NULL},
 506         {HINIC_PORT_CMD_SET_ANTI_ATTACK_RATE, NULL},
 507         {HINIC_PORT_CMD_RESET_LINK_CFG, hinic_mbox_check_func_id_8B},
 508         {HINIC_PORT_CMD_SET_LINK_FOLLOW, NULL},
 509         {HINIC_PORT_CMD_CLEAR_QP_RES, NULL},
 510 };
 511
 512 #define CHECK_IPSU_15BIT        0X8000
 513
 514 static
 515 struct hinic_sriov_info *hinic_get_sriov_info_by_pcidev(struct pci_dev *pdev)
 516 {
 517         struct net_device *netdev = pci_get_drvdata(pdev);
 518         struct hinic_dev *nic_dev = netdev_priv(netdev);
 519
 520         return &nic_dev->sriov_info;
 521 }
 522
 523 static int hinic_check_mac_info(u8 status, u16 vlan_id)
 524 {
 525         if ((status && status != HINIC_MGMT_STATUS_EXIST) ||
 526             (vlan_id & CHECK_IPSU_15BIT &&
 527              status == HINIC_MGMT_STATUS_EXIST))
 528                 return -EINVAL;
 529
 530         return 0;
 531 }
 532
 533 #define HINIC_VLAN_ID_MASK      0x7FFF
 534
 535 static int hinic_update_mac(struct hinic_hwdev *hwdev, u8 *old_mac,
 536                             u8 *new_mac, u16 vlan_id, u16 func_id)
 537 {
 538         struct hinic_port_mac_update mac_info = {0};
 539         u16 out_size = sizeof(mac_info);
 540         int err;
 541
 542         if (!hwdev || !old_mac || !new_mac)
 543                 return -EINVAL;
 544
 545         if ((vlan_id & HINIC_VLAN_ID_MASK) >= VLAN_N_VID) {
 546                 dev_err(&hwdev->hwif->pdev->dev, "Invalid VLAN number: %d\n",
 547                         (vlan_id & HINIC_VLAN_ID_MASK));
 548                 return -EINVAL;
 549         }
 550
 551         mac_info.func_id = func_id;
 552         mac_info.vlan_id = vlan_id;
 553         memcpy(mac_info.old_mac, old_mac, ETH_ALEN);
 554         memcpy(mac_info.new_mac, new_mac, ETH_ALEN);
 555
 556         err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_UPDATE_MAC, &mac_info,
 557                                  sizeof(mac_info), &mac_info, &out_size);
 558
 559         if (err || !out_size ||
 560             hinic_check_mac_info(mac_info.status, mac_info.vlan_id)) {
 561                 dev_err(&hwdev->hwif->pdev->dev,
 562                         "Failed to update MAC, err: %d, status: 0x%x, out size: 0x%x\n",
 563                         err, mac_info.status, out_size);
 564                 return -EINVAL;
 565         }
 566
 567         if (mac_info.status == HINIC_MGMT_STATUS_EXIST)
 568                 dev_warn(&hwdev->hwif->pdev->dev, "MAC is repeated. Ignore update operation\n");
 569
 570         return 0;
 571 }
 572
 573 static void hinic_get_vf_config(struct hinic_hwdev *hwdev, u16 vf_id,
 574                                 struct ifla_vf_info *ivi)
 575 {
 576         struct vf_data_storage *vfinfo;
 577
 578         vfinfo = hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id);
 579
 580         ivi->vf = HW_VF_ID_TO_OS(vf_id);
 581         memcpy(ivi->mac, vfinfo->vf_mac_addr, ETH_ALEN);
 582         ivi->vlan = vfinfo->pf_vlan;
 583         ivi->qos = vfinfo->pf_qos;
 584         ivi->spoofchk = vfinfo->spoofchk;
 585         ivi->trusted = vfinfo->trust;
 586         ivi->max_tx_rate = vfinfo->max_rate;
 587         ivi->min_tx_rate = vfinfo->min_rate;
 588
 589         if (!vfinfo->link_forced)
 590                 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO;
 591         else if (vfinfo->link_up)
 592                 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE;
 593         else
 594                 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE;
 595 }
 596
 597 int hinic_ndo_get_vf_config(struct net_device *netdev,
 598                             int vf, struct ifla_vf_info *ivi)
 599 {
 600         struct hinic_dev *nic_dev = netdev_priv(netdev);
 601         struct hinic_sriov_info *sriov_info;
 602
 603         sriov_info = &nic_dev->sriov_info;
 604         if (vf >= sriov_info->num_vfs)
 605                 return -EINVAL;
 606
 607         hinic_get_vf_config(sriov_info->hwdev, OS_VF_ID_TO_HW(vf), ivi);
 608
 609         return 0;
 610 }
 611
 612 static int hinic_set_vf_mac(struct hinic_hwdev *hwdev, int vf,
 613                             unsigned char *mac_addr)
 614 {
 615         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
 616         struct vf_data_storage *vf_info;
 617         u16 func_id;
 618         int err;
 619
 620         vf_info = nic_io->vf_infos + HW_VF_ID_TO_OS(vf);
 621
 622         /* duplicate request, so just return success */
 623         if (vf_info->pf_set_mac &&
 624             !memcmp(vf_info->vf_mac_addr, mac_addr, ETH_ALEN))
 625                 return 0;
 626
 627         vf_info->pf_set_mac = true;
 628
 629         func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf;
 630         err = hinic_update_mac(hwdev, vf_info->vf_mac_addr,
 631                                mac_addr, 0, func_id);
 632         if (err) {
 633                 vf_info->pf_set_mac = false;
 634                 return err;
 635         }
 636
 637         memcpy(vf_info->vf_mac_addr, mac_addr, ETH_ALEN);
 638
 639         return 0;
 640 }
 641
 642 int hinic_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
 643 {
 644         struct hinic_dev *nic_dev = netdev_priv(netdev);
 645         struct hinic_sriov_info *sriov_info;
 646         int err;
 647
 648         sriov_info = &nic_dev->sriov_info;
 649         if (!is_valid_ether_addr(mac) || vf >= sriov_info->num_vfs)
 650                 return -EINVAL;
 651
 652         err = hinic_set_vf_mac(sriov_info->hwdev, OS_VF_ID_TO_HW(vf), mac);
 653         if (err)
 654                 return err;
 655
 656         netif_info(nic_dev, drv, netdev, "Setting MAC %pM on VF %d\n", mac, vf);
 657         netif_info(nic_dev, drv, netdev, "Reload the VF driver to make this change effective.");
 658
 659         return 0;
 660 }
 661
 662 static int hinic_add_vf_vlan(struct hinic_hwdev *hwdev, int vf_id,
 663                              u16 vlan, u8 qos)
 664 {
 665         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
 666         int err;
 667
 668         err = hinic_set_vf_vlan(hwdev, true, vlan, qos, vf_id);
 669         if (err)
 670                 return err;
 671
 672         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan = vlan;
 673         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos = qos;
 674
 675         dev_info(&hwdev->hwif->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n",
 676                  vlan, qos, HW_VF_ID_TO_OS(vf_id));
 677         return 0;
 678 }
 679
 680 static int hinic_kill_vf_vlan(struct hinic_hwdev *hwdev, int vf_id)
 681 {
 682         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
 683         int err;
 684
 685         err = hinic_set_vf_vlan(hwdev, false,
 686                                 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan,
 687                                 nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos,
 688                                 vf_id);
 689         if (err)
 690                 return err;
 691
 692         dev_info(&hwdev->hwif->pdev->dev, "Remove VLAN %d on VF %d\n",
 693                  nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan,
 694                  HW_VF_ID_TO_OS(vf_id));
 695
 696         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_vlan = 0;
 697         nic_io->vf_infos[HW_VF_ID_TO_OS(vf_id)].pf_qos = 0;
 698
 699         return 0;
 700 }
 701
 702 static int hinic_update_mac_vlan(struct hinic_dev *nic_dev, u16 old_vlan,
 703                                  u16 new_vlan, int vf_id)
 704 {
 705         struct vf_data_storage *vf_info;
 706         u16 vlan_id;
 707         int err;
 708
 709         if (!nic_dev || old_vlan >= VLAN_N_VID || new_vlan >= VLAN_N_VID)
 710                 return -EINVAL;
 711
 712         vf_info = nic_dev->hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id);
 713         if (!vf_info->pf_set_mac)
 714                 return 0;
 715
 716         vlan_id = old_vlan;
 717         if (vlan_id)
 718                 vlan_id |= HINIC_ADD_VLAN_IN_MAC;
 719
 720         err = hinic_port_del_mac(nic_dev, vf_info->vf_mac_addr, vlan_id);
 721         if (err) {
 722                 dev_err(&nic_dev->hwdev->hwif->pdev->dev, "Failed to delete VF %d MAC %pM vlan %d\n",
 723                         HW_VF_ID_TO_OS(vf_id), vf_info->vf_mac_addr, old_vlan);
 724                 return err;
 725         }
 726
 727         vlan_id = new_vlan;
 728         if (vlan_id)
 729                 vlan_id |= HINIC_ADD_VLAN_IN_MAC;
 730
 731         err = hinic_port_add_mac(nic_dev, vf_info->vf_mac_addr, vlan_id);
 732         if (err) {
 733                 dev_err(&nic_dev->hwdev->hwif->pdev->dev, "Failed to add VF %d MAC %pM vlan %d\n",
 734                         HW_VF_ID_TO_OS(vf_id), vf_info->vf_mac_addr, new_vlan);
 735                 goto out;
 736         }
 737
 738         return 0;
 739
 740 out:
 741         vlan_id = old_vlan;
 742         if (vlan_id)
 743                 vlan_id |= HINIC_ADD_VLAN_IN_MAC;
 744         hinic_port_add_mac(nic_dev, vf_info->vf_mac_addr, vlan_id);
 745
 746         return err;
 747 }
 748
 749 static int set_hw_vf_vlan(struct hinic_dev *nic_dev,
 750                           u16 cur_vlanprio, int vf, u16 vlan, u8 qos)
 751 {
 752         u16 old_vlan = cur_vlanprio & VLAN_VID_MASK;
 753         int err = 0;
 754
 755         if (vlan || qos) {
 756                 if (cur_vlanprio) {
 757                         err = hinic_kill_vf_vlan(nic_dev->hwdev,
 758                                                  OS_VF_ID_TO_HW(vf));
 759                         if (err) {
 760                                 dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to delete vf %d old vlan %d\n",
 761                                         vf, old_vlan);
 762                                 goto out;
 763                         }
 764                 }
 765                 err = hinic_add_vf_vlan(nic_dev->hwdev,
 766                                         OS_VF_ID_TO_HW(vf), vlan, qos);
 767                 if (err) {
 768                         dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to add vf %d new vlan %d\n",
 769                                 vf, vlan);
 770                         goto out;
 771                 }
 772         } else {
 773                 err = hinic_kill_vf_vlan(nic_dev->hwdev, OS_VF_ID_TO_HW(vf));
 774                 if (err) {
 775                         dev_err(&nic_dev->sriov_info.pdev->dev, "Failed to delete vf %d vlan %d\n",
 776                                 vf, old_vlan);
 777                         goto out;
 778                 }
 779         }
 780
 781         err = hinic_update_mac_vlan(nic_dev, old_vlan, vlan,
 782                                     OS_VF_ID_TO_HW(vf));
 783
 784 out:
 785         return err;
 786 }
 787
 788 int hinic_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos,
 789                           __be16 vlan_proto)
 790 {
 791         struct hinic_dev *nic_dev = netdev_priv(netdev);
 792         struct hinic_sriov_info *sriov_info;
 793         u16 vlanprio, cur_vlanprio;
 794
 795         sriov_info = &nic_dev->sriov_info;
 796         if (vf >= sriov_info->num_vfs || vlan >= VLAN_N_VID || qos > HINIC_MAX_QOS)
 797                 return -EINVAL;
 798         if (vlan_proto != htons(ETH_P_8021Q))
 799                 return -EPROTONOSUPPORT;
 800         vlanprio = vlan | qos << HINIC_VLAN_PRIORITY_SHIFT;
 801         cur_vlanprio = hinic_vf_info_vlanprio(nic_dev->hwdev,
 802                                               OS_VF_ID_TO_HW(vf));
 803         /* duplicate request, so just return success */
 804         if (vlanprio == cur_vlanprio)
 805                 return 0;
 806
 807         return set_hw_vf_vlan(nic_dev, cur_vlanprio, vf, vlan, qos);
 808 }
 809
 810 static int hinic_set_vf_trust(struct hinic_hwdev *hwdev, u16 vf_id,
 811                               bool trust)
 812 {
 813         struct vf_data_storage *vf_infos;
 814         struct hinic_func_to_io *nic_io;
 815
 816         if (!hwdev)
 817                 return -EINVAL;
 818
 819         nic_io = &hwdev->func_to_io;
 820         vf_infos = nic_io->vf_infos;
 821         vf_infos[vf_id].trust = trust;
 822
 823         return 0;
 824 }
 825
 826 int hinic_ndo_set_vf_trust(struct net_device *netdev, int vf, bool setting)
 827 {
 828         struct hinic_dev *adapter = netdev_priv(netdev);
 829         struct hinic_sriov_info *sriov_info;
 830         struct hinic_func_to_io *nic_io;
 831         bool cur_trust;
 832         int err;
 833
 834         sriov_info = &adapter->sriov_info;
 835         nic_io = &adapter->hwdev->func_to_io;
 836
 837         if (vf >= sriov_info->num_vfs)
 838                 return -EINVAL;
 839
 840         cur_trust = nic_io->vf_infos[vf].trust;
 841         /* same request, so just return success */
 842         if (setting == cur_trust)
 843                 return 0;
 844
 845         err = hinic_set_vf_trust(adapter->hwdev, vf, setting);
 846         if (!err)
 847                 dev_info(&sriov_info->pdev->dev, "Set VF %d trusted %s succeed\n",
 848                          vf, setting ? "on" : "off");
 849         else
 850                 dev_err(&sriov_info->pdev->dev, "Failed set VF %d trusted %s\n",
 851                         vf, setting ? "on" : "off");
 852
 853         return err;
 854 }
 855
 856 int hinic_ndo_set_vf_bw(struct net_device *netdev,
 857                         int vf, int min_tx_rate, int max_tx_rate)
 858 {
 859         static const u32 speeds[] = {
 860                 SPEED_10, SPEED_100, SPEED_1000, SPEED_10000,
 861                 SPEED_25000, SPEED_40000, SPEED_100000
 862         };
 863         struct hinic_dev *nic_dev = netdev_priv(netdev);
 864         struct hinic_port_cap port_cap = { 0 };
 865         enum hinic_port_link_state link_state;
 866         int err;
 867
 868         if (vf >= nic_dev->sriov_info.num_vfs) {
 869                 netif_err(nic_dev, drv, netdev, "VF number must be less than %d\n",
 870                           nic_dev->sriov_info.num_vfs);
 871                 return -EINVAL;
 872         }
 873
 874         err = hinic_port_link_state(nic_dev, &link_state);
 875         if (err) {
 876                 netif_err(nic_dev, drv, netdev,
 877                           "Get link status failed when setting vf tx rate\n");
 878                 return -EIO;
 879         }
 880
 881         if (link_state == HINIC_LINK_STATE_DOWN) {
 882                 netif_err(nic_dev, drv, netdev,
 883                           "Link status must be up when setting vf tx rate\n");
 884                 return -EPERM;
 885         }
 886
 887         err = hinic_port_get_cap(nic_dev, &port_cap);
 888         if (err || port_cap.speed > LINK_SPEED_100GB)
 889                 return -EIO;
 890
 891         /* rate limit cannot be less than 0 and greater than link speed */
 892         if (max_tx_rate < 0 || max_tx_rate > speeds[port_cap.speed]) {
 893                 netif_err(nic_dev, drv, netdev, "Max tx rate must be in [0 - %d]\n",
 894                           speeds[port_cap.speed]);
 895                 return -EINVAL;
 896         }
 897
 898         err = hinic_set_vf_tx_rate(nic_dev->hwdev, OS_VF_ID_TO_HW(vf),
 899                                    max_tx_rate, min_tx_rate);
 900         if (err) {
 901                 netif_err(nic_dev, drv, netdev,
 902                           "Unable to set VF %d max rate %d min rate %d%s\n",
 903                           vf, max_tx_rate, min_tx_rate,
 904                           err == HINIC_TX_RATE_TABLE_FULL ?
 905                           ", tx rate profile is full" : "");
 906                 return -EIO;
 907         }
 908
 909         netif_info(nic_dev, drv, netdev,
 910                    "Set VF %d max tx rate %d min tx rate %d successfully\n",
 911                    vf, max_tx_rate, min_tx_rate);
 912
 913         return 0;
 914 }
 915
 916 static int hinic_set_vf_spoofchk(struct hinic_hwdev *hwdev, u16 vf_id,
 917                                  bool spoofchk)
 918 {
 919         struct hinic_spoofchk_set spoofchk_cfg = {0};
 920         struct vf_data_storage *vf_infos = NULL;
 921         u16 out_size = sizeof(spoofchk_cfg);
 922         int err;
 923
 924         if (!hwdev)
 925                 return -EINVAL;
 926
 927         vf_infos = hwdev->func_to_io.vf_infos;
 928
 929         spoofchk_cfg.func_id = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
 930         spoofchk_cfg.state = spoofchk ? 1 : 0;
 931         err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_ENABLE_SPOOFCHK,
 932                                  &spoofchk_cfg, sizeof(spoofchk_cfg),
 933                                  &spoofchk_cfg, &out_size);
 934         if (spoofchk_cfg.status == HINIC_MGMT_CMD_UNSUPPORTED) {
 935                 err = HINIC_MGMT_CMD_UNSUPPORTED;
 936         } else if (err || !out_size || spoofchk_cfg.status) {
 937                 dev_err(&hwdev->hwif->pdev->dev, "Failed to set VF(%d) spoofchk, err: %d, status: 0x%x, out size: 0x%x\n",
 938                         HW_VF_ID_TO_OS(vf_id), err, spoofchk_cfg.status,
 939                         out_size);
 940                 err = -EIO;
 941         }
 942
 943         vf_infos[HW_VF_ID_TO_OS(vf_id)].spoofchk = spoofchk;
 944
 945         return err;
 946 }
 947
 948 int hinic_ndo_set_vf_spoofchk(struct net_device *netdev, int vf, bool setting)
 949 {
 950         struct hinic_dev *nic_dev = netdev_priv(netdev);
 951         struct hinic_sriov_info *sriov_info;
 952         bool cur_spoofchk;
 953         int err;
 954
 955         sriov_info = &nic_dev->sriov_info;
 956         if (vf >= sriov_info->num_vfs)
 957                 return -EINVAL;
 958
 959         cur_spoofchk = nic_dev->hwdev->func_to_io.vf_infos[vf].spoofchk;
 960
 961         /* same request, so just return success */
 962         if (setting == cur_spoofchk)
 963                 return 0;
 964
 965         err = hinic_set_vf_spoofchk(sriov_info->hwdev,
 966                                     OS_VF_ID_TO_HW(vf), setting);
 967         if (!err) {
 968                 netif_info(nic_dev, drv, netdev, "Set VF %d spoofchk %s successfully\n",
 969                            vf, setting ? "on" : "off");
 970         } else if (err == HINIC_MGMT_CMD_UNSUPPORTED) {
 971                 netif_err(nic_dev, drv, netdev,
 972                           "Current firmware doesn't support to set vf spoofchk, need to upgrade latest firmware version\n");
 973                 err = -EOPNOTSUPP;
 974         }
 975
 976         return err;
 977 }
 978
 979 static int hinic_set_vf_link_state(struct hinic_hwdev *hwdev, u16 vf_id,
 980                                    int link)
 981 {
 982         struct hinic_func_to_io *nic_io = &hwdev->func_to_io;
 983         struct vf_data_storage *vf_infos = nic_io->vf_infos;
 984         u8 link_status = 0;
 985
 986         switch (link) {
 987         case HINIC_IFLA_VF_LINK_STATE_AUTO:
 988                 vf_infos[HW_VF_ID_TO_OS(vf_id)].link_forced = false;
 989                 vf_infos[HW_VF_ID_TO_OS(vf_id)].link_up = nic_io->link_status ?
 990                         true : false;
 991                 link_status = nic_io->link_status;
 992                 break;
 993         case HINIC_IFLA_VF_LINK_STATE_ENABLE:
 994                 vf_infos[HW_VF_ID_TO_OS(vf_id)].link_forced = true;
 995                 vf_infos[HW_VF_ID_TO_OS(vf_id)].link_up = true;
 996                 link_status = HINIC_LINK_UP;
 997                 break;
 998         case HINIC_IFLA_VF_LINK_STATE_DISABLE:
 999                 vf_infos[HW_VF_ID_TO_OS(vf_id)].link_forced = true;
1000                 vf_infos[HW_VF_ID_TO_OS(vf_id)].link_up = false;
1001                 link_status = HINIC_LINK_DOWN;
1002                 break;
1003         default:
1004                 return -EINVAL;
1005         }
1006
1007         /* Notify the VF of its new link state */
1008         hinic_notify_vf_link_status(hwdev, vf_id, link_status);
1009
1010         return 0;
1011 }
1012
1013 int hinic_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link)
1014 {
1015         struct hinic_dev *nic_dev = netdev_priv(netdev);
1016         struct hinic_sriov_info *sriov_info;
1017
1018         sriov_info = &nic_dev->sriov_info;
1019
1020         if (vf_id >= sriov_info->num_vfs) {
1021                 netif_err(nic_dev, drv, netdev,
1022                           "Invalid VF Identifier %d\n", vf_id);
1023                 return -EINVAL;
1024         }
1025
1026         return hinic_set_vf_link_state(sriov_info->hwdev,
1027                                       OS_VF_ID_TO_HW(vf_id), link);
1028 }
1029
1030 /* pf receive message from vf */
1031 static int nic_pf_mbox_handler(void *hwdev, u16 vf_id, u8 cmd, void *buf_in,
1032                                u16 in_size, void *buf_out, u16 *out_size)
1033 {
1034         u8 size = ARRAY_SIZE(nic_cmd_support_vf);
1035         struct vf_cmd_msg_handle *vf_msg_handle;
1036         struct hinic_hwdev *dev = hwdev;
1037         struct hinic_func_to_io *nic_io;
1038         struct hinic_pfhwdev *pfhwdev;
1039         int err = 0;
1040         u32 i;
1041
1042         if (!hwdev)
1043                 return -EINVAL;
1044
1045         if (!hinic_mbox_check_cmd_valid(hwdev, nic_cmd_support_vf, vf_id, cmd,
1046                                         buf_in, in_size, size)) {
1047                 dev_err(&dev->hwif->pdev->dev,
1048                         "PF Receive VF nic cmd: 0x%x, mbox len: 0x%x is invalid\n",
1049                         cmd, in_size);
1050                 return HINIC_MBOX_VF_CMD_ERROR;
1051         }
1052
1053         pfhwdev = container_of(dev, struct hinic_pfhwdev, hwdev);
1054         nic_io = &dev->func_to_io;
1055         for (i = 0; i < ARRAY_SIZE(nic_vf_cmd_msg_handler); i++) {
1056                 vf_msg_handle = &nic_vf_cmd_msg_handler[i];
1057                 if (cmd == vf_msg_handle->cmd &&
1058                     vf_msg_handle->cmd_msg_handler) {
1059                         err = vf_msg_handle->cmd_msg_handler(hwdev, vf_id,
1060                                                              buf_in, in_size,
1061                                                              buf_out,
1062                                                              out_size);
1063                         break;
1064                 }
1065         }
1066         if (i == ARRAY_SIZE(nic_vf_cmd_msg_handler))
1067                 err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_L2NIC,
1068                                         cmd, buf_in, in_size, buf_out,
1069                                         out_size, HINIC_MGMT_MSG_SYNC);
1070
1071         if (err &&  err != HINIC_MBOX_PF_BUSY_ACTIVE_FW)
1072                 dev_err(&nic_io->hwif->pdev->dev, "PF receive VF L2NIC cmd: %d process error, err:%d\n",
1073                         cmd, err);
1074         return err;
1075 }
1076
1077 static int cfg_mbx_pf_proc_vf_msg(void *hwdev, u16 vf_id, u8 cmd, void *buf_in,
1078                                   u16 in_size, void *buf_out, u16 *out_size)
1079 {
1080         struct hinic_dev_cap *dev_cap = buf_out;
1081         struct hinic_hwdev *dev = hwdev;
1082         struct hinic_cap *cap;
1083
1084         cap = &dev->nic_cap;
1085         memset(dev_cap, 0, sizeof(*dev_cap));
1086
1087         dev_cap->max_vf = cap->max_vf;
1088         dev_cap->max_sqs = cap->max_vf_qps;
1089         dev_cap->max_rqs = cap->max_vf_qps;
1090         dev_cap->port_id = dev->port_id;
1091
1092         *out_size = sizeof(*dev_cap);
1093
1094         return 0;
1095 }
1096
1097 static int hinic_init_vf_infos(struct hinic_func_to_io *nic_io, u16 vf_id)
1098 {
1099         struct vf_data_storage *vf_infos = nic_io->vf_infos;
1100
1101         if (set_vf_link_state > HINIC_IFLA_VF_LINK_STATE_DISABLE) {
1102                 dev_warn(&nic_io->hwif->pdev->dev, "Module Parameter set_vf_link_state value %d is out of range, resetting to %d\n",
1103                          set_vf_link_state, HINIC_IFLA_VF_LINK_STATE_AUTO);
1104                 set_vf_link_state = HINIC_IFLA_VF_LINK_STATE_AUTO;
1105         }
1106
1107         switch (set_vf_link_state) {
1108         case HINIC_IFLA_VF_LINK_STATE_AUTO:
1109                 vf_infos[vf_id].link_forced = false;
1110                 break;
1111         case HINIC_IFLA_VF_LINK_STATE_ENABLE:
1112                 vf_infos[vf_id].link_forced = true;
1113                 vf_infos[vf_id].link_up = true;
1114                 break;
1115         case HINIC_IFLA_VF_LINK_STATE_DISABLE:
1116                 vf_infos[vf_id].link_forced = true;
1117                 vf_infos[vf_id].link_up = false;
1118                 break;
1119         default:
1120                 dev_err(&nic_io->hwif->pdev->dev, "Invalid input parameter set_vf_link_state: %d\n",
1121                         set_vf_link_state);
1122                 return -EINVAL;
1123         }
1124
1125         return 0;
1126 }
1127
1128 static void hinic_clear_vf_infos(struct hinic_dev *nic_dev, u16 vf_id)
1129 {
1130         struct vf_data_storage *vf_infos;
1131
1132         vf_infos = nic_dev->hwdev->func_to_io.vf_infos + HW_VF_ID_TO_OS(vf_id);
1133         if (vf_infos->pf_set_mac)
1134                 hinic_port_del_mac(nic_dev, vf_infos->vf_mac_addr, 0);
1135
1136         if (hinic_vf_info_vlanprio(nic_dev->hwdev, vf_id))
1137                 hinic_kill_vf_vlan(nic_dev->hwdev, vf_id);
1138
1139         if (vf_infos->max_rate)
1140                 hinic_set_vf_tx_rate(nic_dev->hwdev, vf_id, 0, 0);
1141
1142         if (vf_infos->spoofchk)
1143                 hinic_set_vf_spoofchk(nic_dev->hwdev, vf_id, false);
1144
1145         if (vf_infos->trust)
1146                 hinic_set_vf_trust(nic_dev->hwdev, vf_id, false);
1147
1148         memset(vf_infos, 0, sizeof(*vf_infos));
1149         /* set vf_infos to default */
1150         hinic_init_vf_infos(&nic_dev->hwdev->func_to_io, HW_VF_ID_TO_OS(vf_id));
1151 }
1152
1153 static void hinic_deinit_vf_hw(struct hinic_sriov_info *sriov_info,
1154                                u16 start_vf_id, u16 end_vf_id)
1155 {
1156         struct hinic_dev *nic_dev;
1157         u16 func_idx, idx;
1158
1159         nic_dev = container_of(sriov_info, struct hinic_dev, sriov_info);
1160
1161         for (idx = start_vf_id; idx <= end_vf_id; idx++) {
1162                 func_idx = hinic_glb_pf_vf_offset(nic_dev->hwdev->hwif) + idx;
1163                 hinic_set_wq_page_size(nic_dev->hwdev, func_idx,
1164                                        HINIC_HW_WQ_PAGE_SIZE);
1165                 hinic_clear_vf_infos(nic_dev, idx);
1166         }
1167 }
1168
1169 int hinic_vf_func_init(struct hinic_hwdev *hwdev)
1170 {
1171         struct hinic_register_vf register_info = {0};
1172         u16 out_size = sizeof(register_info);
1173         struct hinic_func_to_io *nic_io;
1174         int err = 0;
1175         u32 size, i;
1176
1177         err = hinic_vf_mbox_random_id_init(hwdev);
1178         if (err) {
1179                 dev_err(&hwdev->hwif->pdev->dev, "Failed to init vf mbox random id, err: %d\n",
1180                         err);
1181                 return err;
1182         }
1183
1184         nic_io = &hwdev->func_to_io;
1185
1186         if (HINIC_IS_VF(hwdev->hwif)) {
1187                 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC,
1188                                        HINIC_PORT_CMD_VF_REGISTER,
1189                                        &register_info, sizeof(register_info),
1190                                        &register_info, &out_size, 0);
1191                 if (err || register_info.status || !out_size) {
1192                         dev_err(&hwdev->hwif->pdev->dev,
1193                                 "Failed to register VF, err: %d, status: 0x%x, out size: 0x%x\n",
1194                                 err, register_info.status, out_size);
1195                         return -EIO;
1196                 }
1197         } else {
1198                 err = hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_CFGM,
1199                                                 cfg_mbx_pf_proc_vf_msg);
1200                 if (err) {
1201                         dev_err(&hwdev->hwif->pdev->dev,
1202                                 "Register PF mailbox callback failed\n");
1203                         return err;
1204                 }
1205                 nic_io->max_vfs = hwdev->nic_cap.max_vf;
1206                 size = sizeof(*nic_io->vf_infos) * nic_io->max_vfs;
1207                 if (size != 0) {
1208                         nic_io->vf_infos = kzalloc(size, GFP_KERNEL);
1209                         if (!nic_io->vf_infos) {
1210                                 err = -ENOMEM;
1211                                 goto out_free_nic_io;
1212                         }
1213
1214                         for (i = 0; i < nic_io->max_vfs; i++) {
1215                                 err = hinic_init_vf_infos(nic_io, i);
1216                                 if (err)
1217                                         goto err_init_vf_infos;
1218                         }
1219
1220                         err = hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_L2NIC,
1221                                                         nic_pf_mbox_handler);
1222                         if (err)
1223                                 goto err_register_pf_mbox_cb;
1224                 }
1225         }
1226
1227         return 0;
1228
1229 err_register_pf_mbox_cb:
1230 err_init_vf_infos:
1231         kfree(nic_io->vf_infos);
1232 out_free_nic_io:
1233         return err;
1234 }
1235
1236 void hinic_vf_func_free(struct hinic_hwdev *hwdev)
1237 {
1238         struct hinic_register_vf unregister = {0};
1239         u16 out_size = sizeof(unregister);
1240         int err;
1241
1242         if (HINIC_IS_VF(hwdev->hwif)) {
1243                 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC,
1244                                        HINIC_PORT_CMD_VF_UNREGISTER,
1245                                        &unregister, sizeof(unregister),
1246                                        &unregister, &out_size, 0);
1247                 if (err || !out_size || unregister.status)
1248                         dev_err(&hwdev->hwif->pdev->dev, "Failed to unregister VF, err: %d, status: 0x%x, out_size: 0x%x\n",
1249                                 err, unregister.status, out_size);
1250         } else {
1251                 if (hwdev->func_to_io.vf_infos) {
1252                         hinic_unregister_pf_mbox_cb(hwdev, HINIC_MOD_L2NIC);
1253                         kfree(hwdev->func_to_io.vf_infos);
1254                 }
1255         }
1256 }
1257
1258 static int hinic_init_vf_hw(struct hinic_hwdev *hwdev, u16 start_vf_id,
1259                             u16 end_vf_id)
1260 {
1261         u16 i, func_idx;
1262         int err;
1263
1264         /* vf use 256K as default wq page size, and can't change it */
1265         for (i = start_vf_id; i <= end_vf_id; i++) {
1266                 func_idx = hinic_glb_pf_vf_offset(hwdev->hwif) + i;
1267                 err = hinic_set_wq_page_size(hwdev, func_idx,
1268                                              HINIC_DEFAULT_WQ_PAGE_SIZE);
1269                 if (err)
1270                         return err;
1271         }
1272
1273         return 0;
1274 }
1275
1276 int hinic_pci_sriov_disable(struct pci_dev *pdev)
1277 {
1278         struct hinic_sriov_info *sriov_info;
1279         u16 tmp_vfs;
1280
1281         sriov_info = hinic_get_sriov_info_by_pcidev(pdev);
1282         /* if SR-IOV is already disabled then nothing will be done */
1283         if (!sriov_info->sriov_enabled)
1284                 return 0;
1285
1286         set_bit(HINIC_SRIOV_DISABLE, &sriov_info->state);
1287
1288         /* If our VFs are assigned we cannot shut down SR-IOV
1289          * without causing issues, so just leave the hardware
1290          * available but disabled
1291          */
1292         if (pci_vfs_assigned(sriov_info->pdev)) {
1293                 clear_bit(HINIC_SRIOV_DISABLE, &sriov_info->state);
1294                 dev_warn(&pdev->dev, "Unloading driver while VFs are assigned - VFs will not be deallocated\n");
1295                 return -EPERM;
1296         }
1297         sriov_info->sriov_enabled = false;
1298
1299         /* disable iov and allow time for transactions to clear */
1300         pci_disable_sriov(sriov_info->pdev);
1301
1302         tmp_vfs = (u16)sriov_info->num_vfs;
1303         sriov_info->num_vfs = 0;
1304         hinic_deinit_vf_hw(sriov_info, OS_VF_ID_TO_HW(0),
1305                            OS_VF_ID_TO_HW(tmp_vfs - 1));
1306
1307         clear_bit(HINIC_SRIOV_DISABLE, &sriov_info->state);
1308
1309         return 0;
1310 }
1311
1312 static int hinic_pci_sriov_enable(struct pci_dev *pdev, int num_vfs)
1313 {
1314         struct hinic_sriov_info *sriov_info;
1315         int err;
1316
1317         sriov_info = hinic_get_sriov_info_by_pcidev(pdev);
1318
1319         if (test_and_set_bit(HINIC_SRIOV_ENABLE, &sriov_info->state)) {
1320                 dev_err(&pdev->dev,
1321                         "SR-IOV enable in process, please wait, num_vfs %d\n",
1322                         num_vfs);
1323                 return -EPERM;
1324         }
1325
1326         err = hinic_init_vf_hw(sriov_info->hwdev, OS_VF_ID_TO_HW(0),
1327                                OS_VF_ID_TO_HW((u16)num_vfs - 1));
1328         if (err) {
1329                 dev_err(&sriov_info->pdev->dev,
1330                         "Failed to init vf in hardware before enable sriov, error %d\n",
1331                         err);
1332                 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state);
1333                 return err;
1334         }
1335
1336         err = pci_enable_sriov(sriov_info->pdev, num_vfs);
1337         if (err) {
1338                 dev_err(&pdev->dev,
1339                         "Failed to enable SR-IOV, error %d\n", err);
1340                 clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state);
1341                 return err;
1342         }
1343
1344         sriov_info->sriov_enabled = true;
1345         sriov_info->num_vfs = num_vfs;
1346         clear_bit(HINIC_SRIOV_ENABLE, &sriov_info->state);
1347
1348         return num_vfs;
1349 }
1350
1351 int hinic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
1352 {
1353         struct hinic_sriov_info *sriov_info;
1354
1355         sriov_info = hinic_get_sriov_info_by_pcidev(dev);
1356
1357         if (test_bit(HINIC_FUNC_REMOVE, &sriov_info->state))
1358                 return -EBUSY;
1359
1360         if (!num_vfs)
1361                 return hinic_pci_sriov_disable(dev);
1362         else
1363                 return hinic_pci_sriov_enable(dev, num_vfs);
1364 }