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