drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_pf.c

   1 /*
   2  * QLogic qlcnic NIC Driver
   3  * Copyright (c) 2009-2013 QLogic Corporation
   4  *
   5  * See LICENSE.qlcnic for copyright and licensing details.
   6  */
   7
   8 #include "qlcnic_sriov.h"
   9 #include "qlcnic.h"
  10 #include <linux/types.h>
  11
  12 #define QLCNIC_SRIOV_VF_MAX_MAC 1
  13 #define QLC_VF_MIN_TX_RATE      100
  14 #define QLC_VF_MAX_TX_RATE      9999
  15
  16 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
  17
  18 struct qlcnic_sriov_cmd_handler {
  19         int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
  20 };
  21
  22 struct qlcnic_sriov_fw_cmd_handler {
  23         u32 cmd;
  24         int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
  25 };
  26
  27 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
  28                                           struct qlcnic_info *npar_info,
  29                                           u16 vport_id)
  30 {
  31         struct qlcnic_cmd_args cmd;
  32         int err;
  33
  34         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
  35                 return -ENOMEM;
  36
  37         cmd.req.arg[1] = (vport_id << 16) | 0x1;
  38         cmd.req.arg[2] = npar_info->bit_offsets;
  39         cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
  40         cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
  41         cmd.req.arg[4] = npar_info->max_tx_mac_filters;
  42         cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
  43         cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
  44                          (npar_info->max_rx_ip_addr << 16);
  45         cmd.req.arg[6] = npar_info->max_rx_lro_flow |
  46                          (npar_info->max_rx_status_rings << 16);
  47         cmd.req.arg[7] = npar_info->max_rx_buf_rings |
  48                          (npar_info->max_rx_ques << 16);
  49         cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
  50         cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
  51         cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
  52
  53         err = qlcnic_issue_cmd(adapter, &cmd);
  54         if (err)
  55                 dev_err(&adapter->pdev->dev,
  56                         "Failed to set vport info, err=%d\n", err);
  57
  58         qlcnic_free_mbx_args(&cmd);
  59         return err;
  60 }
  61
  62 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
  63                                          struct qlcnic_info *info, u16 func)
  64 {
  65         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
  66         struct qlcnic_resources *res = &sriov->ff_max;
  67         u32 temp, num_vf_macs, num_vfs, max;
  68         int ret = -EIO, vpid, id;
  69         struct qlcnic_vport *vp;
  70
  71         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
  72         if (vpid < 0)
  73                 return -EINVAL;
  74
  75         num_vfs = sriov->num_vfs;
  76         max = num_vfs + 1;
  77         info->bit_offsets = 0xffff;
  78         info->max_tx_ques = res->num_tx_queues / max;
  79         info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
  80         num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC;
  81
  82         if (adapter->ahw->pci_func == func) {
  83                 temp = res->num_rx_mcast_mac_filters - (num_vfs * num_vf_macs);
  84                 info->max_rx_ucast_mac_filters = temp;
  85                 temp = res->num_tx_mac_filters - (num_vfs * num_vf_macs);
  86                 info->max_tx_mac_filters = temp;
  87                 info->min_tx_bw = 0;
  88                 info->max_tx_bw = MAX_BW;
  89         } else {
  90                 id = qlcnic_sriov_func_to_index(adapter, func);
  91                 if (id < 0)
  92                         return id;
  93                 vp = sriov->vf_info[id].vp;
  94                 info->min_tx_bw = vp->min_tx_bw;
  95                 info->max_tx_bw = vp->max_tx_bw;
  96                 info->max_rx_ucast_mac_filters = num_vf_macs;
  97                 info->max_tx_mac_filters = num_vf_macs;
  98         }
  99
 100         info->max_rx_ip_addr = res->num_destip / max;
 101         info->max_rx_status_rings = res->num_rx_status_rings / max;
 102         info->max_rx_buf_rings = res->num_rx_buf_rings / max;
 103         info->max_rx_ques = res->num_rx_queues / max;
 104         info->max_rx_lro_flow = res->num_lro_flows_supported / max;
 105         info->max_tx_vlan_keys = res->num_txvlan_keys;
 106         info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
 107         info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
 108
 109         ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
 110         if (ret)
 111                 return ret;
 112
 113         return 0;
 114 }
 115
 116 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
 117                                            struct qlcnic_info *info)
 118 {
 119         struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
 120
 121         ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
 122         ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
 123         ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
 124         ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
 125         ff_max->num_rx_queues = info->max_rx_ques;
 126         ff_max->num_tx_queues = info->max_tx_ques;
 127         ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
 128         ff_max->num_destip = info->max_rx_ip_addr;
 129         ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
 130         ff_max->num_rx_status_rings = info->max_rx_status_rings;
 131         ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
 132         ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
 133 }
 134
 135 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
 136                                     struct qlcnic_info *npar_info)
 137 {
 138         int err;
 139         struct qlcnic_cmd_args cmd;
 140
 141         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
 142                 return -ENOMEM;
 143
 144         cmd.req.arg[1] = 0x2;
 145         err = qlcnic_issue_cmd(adapter, &cmd);
 146         if (err) {
 147                 dev_err(&adapter->pdev->dev,
 148                         "Failed to get PF info, err=%d\n", err);
 149                 goto out;
 150         }
 151
 152         npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
 153         npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
 154         npar_info->max_vports = MSW(cmd.rsp.arg[2]);
 155         npar_info->max_tx_ques =  LSW(cmd.rsp.arg[3]);
 156         npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
 157         npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
 158         npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
 159         npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
 160         npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
 161         npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
 162         npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
 163         npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
 164         npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
 165         npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
 166         npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
 167
 168         qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
 169         dev_info(&adapter->pdev->dev,
 170                  "\n\ttotal_pf: %d,\n"
 171                  "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
 172                  "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
 173                  "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
 174                  "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
 175                  "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
 176                  "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
 177                  npar_info->total_pf, npar_info->total_rss_engines,
 178                  npar_info->max_vports, npar_info->max_tx_ques,
 179                  npar_info->max_tx_mac_filters,
 180                  npar_info->max_rx_mcast_mac_filters,
 181                  npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
 182                  npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
 183                  npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
 184                  npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
 185                  npar_info->max_remote_ipv6_addrs);
 186
 187 out:
 188         qlcnic_free_mbx_args(&cmd);
 189         return err;
 190 }
 191
 192 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
 193                                                u8 func)
 194 {
 195         struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
 196         struct qlcnic_vport *vp;
 197         int index;
 198
 199         if (adapter->ahw->pci_func == func) {
 200                 sriov->vp_handle = 0;
 201         } else {
 202                 index = qlcnic_sriov_func_to_index(adapter, func);
 203                 if (index < 0)
 204                         return;
 205                 vp = sriov->vf_info[index].vp;
 206                 vp->handle = 0;
 207         }
 208 }
 209
 210 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
 211                                              u16 vport_handle, u8 func)
 212 {
 213         struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
 214         struct qlcnic_vport *vp;
 215         int index;
 216
 217         if (adapter->ahw->pci_func == func) {
 218                 sriov->vp_handle = vport_handle;
 219         } else {
 220                 index = qlcnic_sriov_func_to_index(adapter, func);
 221                 if (index < 0)
 222                         return;
 223                 vp = sriov->vf_info[index].vp;
 224                 vp->handle = vport_handle;
 225         }
 226 }
 227
 228 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
 229                                             u8 func)
 230 {
 231         struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
 232         struct qlcnic_vf_info *vf_info;
 233         int index;
 234
 235         if (adapter->ahw->pci_func == func) {
 236                 return sriov->vp_handle;
 237         } else {
 238                 index = qlcnic_sriov_func_to_index(adapter, func);
 239                 if (index >= 0) {
 240                         vf_info = &sriov->vf_info[index];
 241                         return vf_info->vp->handle;
 242                 }
 243         }
 244
 245         return -EINVAL;
 246 }
 247
 248 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
 249                                         u8 flag, u16 func)
 250 {
 251         struct qlcnic_cmd_args cmd;
 252         int ret;
 253         int vpid;
 254
 255         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
 256                 return -ENOMEM;
 257
 258         if (flag) {
 259                 cmd.req.arg[3] = func << 8;
 260         } else {
 261                 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
 262                 if (vpid < 0) {
 263                         ret = -EINVAL;
 264                         goto out;
 265                 }
 266                 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
 267         }
 268
 269         ret = qlcnic_issue_cmd(adapter, &cmd);
 270         if (ret) {
 271                 dev_err(&adapter->pdev->dev,
 272                         "Failed %s vport, err %d for func 0x%x\n",
 273                         (flag ? "enable" : "disable"), ret, func);
 274                 goto out;
 275         }
 276
 277         if (flag) {
 278                 vpid = cmd.rsp.arg[2] & 0xffff;
 279                 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
 280         } else {
 281                 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
 282         }
 283
 284 out:
 285         qlcnic_free_mbx_args(&cmd);
 286         return ret;
 287 }
 288
 289 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
 290                                               u8 enable)
 291 {
 292         struct qlcnic_cmd_args cmd;
 293         int err;
 294
 295         err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
 296         if (err)
 297                 return err;
 298
 299         cmd.req.arg[1] = 0x4;
 300         if (enable)
 301                 cmd.req.arg[1] |= BIT_16;
 302
 303         err = qlcnic_issue_cmd(adapter, &cmd);
 304         if (err)
 305                 dev_err(&adapter->pdev->dev,
 306                         "Failed to configure VLAN filtering, err=%d\n", err);
 307
 308         qlcnic_free_mbx_args(&cmd);
 309         return err;
 310 }
 311
 312 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
 313                                        u8 func, u8 enable)
 314 {
 315         struct qlcnic_cmd_args cmd;
 316         int err = -EIO;
 317
 318         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
 319                 return -ENOMEM;
 320
 321         cmd.req.arg[0] |= (3 << 29);
 322         cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
 323         if (enable)
 324                 cmd.req.arg[1] |= BIT_0;
 325
 326         err = qlcnic_issue_cmd(adapter, &cmd);
 327
 328         if (err != QLCNIC_RCODE_SUCCESS) {
 329                 dev_err(&adapter->pdev->dev,
 330                         "Failed to enable sriov eswitch%d\n", err);
 331                 err = -EIO;
 332         }
 333
 334         qlcnic_free_mbx_args(&cmd);
 335         return err;
 336 }
 337
 338 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
 339 {
 340         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
 341         struct qlcnic_back_channel *bc = &sriov->bc;
 342         int i;
 343
 344         for (i = 0; i < sriov->num_vfs; i++)
 345                 cancel_work_sync(&sriov->vf_info[i].flr_work);
 346
 347         destroy_workqueue(bc->bc_flr_wq);
 348 }
 349
 350 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
 351 {
 352         struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
 353         struct workqueue_struct *wq;
 354
 355         wq = create_singlethread_workqueue("qlcnic-flr");
 356         if (wq == NULL) {
 357                 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
 358                 return -ENOMEM;
 359         }
 360
 361         bc->bc_flr_wq =  wq;
 362         return 0;
 363 }
 364
 365 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
 366 {
 367         u8 func = adapter->ahw->pci_func;
 368
 369         if (!qlcnic_sriov_enable_check(adapter))
 370                 return;
 371
 372         qlcnic_sriov_pf_del_flr_queue(adapter);
 373         qlcnic_sriov_cfg_bc_intr(adapter, 0);
 374         qlcnic_sriov_pf_config_vport(adapter, 0, func);
 375         qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
 376         qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
 377         __qlcnic_sriov_cleanup(adapter);
 378         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
 379         clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 380 }
 381
 382 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
 383 {
 384         if (!qlcnic_sriov_pf_check(adapter))
 385                 return;
 386
 387         if (!qlcnic_sriov_enable_check(adapter))
 388                 return;
 389
 390         pci_disable_sriov(adapter->pdev);
 391         netdev_info(adapter->netdev,
 392                     "SR-IOV is disabled successfully on port %d\n",
 393                     adapter->portnum);
 394 }
 395
 396 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
 397 {
 398         struct net_device *netdev = adapter->netdev;
 399
 400         if (netif_running(netdev))
 401                 __qlcnic_down(adapter, netdev);
 402
 403         qlcnic_sriov_pf_disable(adapter);
 404
 405         qlcnic_sriov_pf_cleanup(adapter);
 406
 407         /* After disabling SRIOV re-init the driver in default mode
 408            configure opmode based on op_mode of function
 409          */
 410         if (qlcnic_83xx_configure_opmode(adapter))
 411                 return -EIO;
 412
 413         if (netif_running(netdev))
 414                 __qlcnic_up(adapter, netdev);
 415
 416         return 0;
 417 }
 418
 419 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
 420 {
 421         struct qlcnic_hardware_context *ahw = adapter->ahw;
 422         struct qlcnic_info nic_info, pf_info, vp_info;
 423         int err;
 424         u8 func = ahw->pci_func;
 425
 426         if (!qlcnic_sriov_enable_check(adapter))
 427                 return 0;
 428
 429         err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
 430         if (err)
 431                 return err;
 432
 433         err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
 434         if (err)
 435                 goto disable_vlan_filtering;
 436
 437         err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 438         if (err)
 439                 goto disable_eswitch;
 440
 441         err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
 442         if (err)
 443                 goto delete_vport;
 444
 445         err = qlcnic_get_nic_info(adapter, &nic_info, func);
 446         if (err)
 447                 goto delete_vport;
 448
 449         err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
 450         if (err)
 451                 goto delete_vport;
 452
 453         err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
 454         if (err)
 455                 goto delete_vport;
 456
 457         ahw->physical_port = (u8) nic_info.phys_port;
 458         ahw->switch_mode = nic_info.switch_mode;
 459         ahw->max_mtu = nic_info.max_mtu;
 460         ahw->capabilities = nic_info.capabilities;
 461         ahw->nic_mode = QLC_83XX_SRIOV_MODE;
 462         return err;
 463
 464 delete_vport:
 465         qlcnic_sriov_pf_config_vport(adapter, 0, func);
 466
 467 disable_eswitch:
 468         qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
 469
 470 disable_vlan_filtering:
 471         qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
 472
 473         return err;
 474 }
 475
 476 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
 477 {
 478         int err;
 479
 480         if (!qlcnic_sriov_enable_check(adapter))
 481                 return 0;
 482
 483         err = pci_enable_sriov(adapter->pdev, num_vfs);
 484         if (err)
 485                 qlcnic_sriov_pf_cleanup(adapter);
 486
 487         return err;
 488 }
 489
 490 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
 491                                      int num_vfs)
 492 {
 493         int err = 0;
 494
 495         set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 496         adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
 497
 498         err = qlcnic_sriov_init(adapter, num_vfs);
 499         if (err)
 500                 goto clear_op_mode;
 501
 502         err = qlcnic_sriov_pf_create_flr_queue(adapter);
 503         if (err)
 504                 goto sriov_cleanup;
 505
 506         err = qlcnic_sriov_pf_init(adapter);
 507         if (err)
 508                 goto del_flr_queue;
 509
 510         err = qlcnic_sriov_pf_enable(adapter, num_vfs);
 511         return err;
 512
 513 del_flr_queue:
 514         qlcnic_sriov_pf_del_flr_queue(adapter);
 515
 516 sriov_cleanup:
 517         __qlcnic_sriov_cleanup(adapter);
 518
 519 clear_op_mode:
 520         clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 521         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
 522         return err;
 523 }
 524
 525 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
 526 {
 527         struct net_device *netdev = adapter->netdev;
 528         int err;
 529
 530         if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
 531                 netdev_err(netdev,
 532                            "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
 533                 return -EIO;
 534         }
 535
 536         if (netif_running(netdev))
 537                 __qlcnic_down(adapter, netdev);
 538
 539         err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
 540         if (err) {
 541                 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
 542                             adapter->portnum);
 543
 544                 err = -EIO;
 545                 if (qlcnic_83xx_configure_opmode(adapter))
 546                         goto error;
 547         } else {
 548                 netdev_info(netdev,
 549                             "SR-IOV is enabled successfully on port %d\n",
 550                             adapter->portnum);
 551                 /* Return number of vfs enabled */
 552                 err = num_vfs;
 553         }
 554         if (netif_running(netdev))
 555                 __qlcnic_up(adapter, netdev);
 556
 557 error:
 558         return err;
 559 }
 560
 561 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
 562 {
 563         struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
 564         int err;
 565
 566         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 567                 return -EBUSY;
 568
 569         if (num_vfs == 0)
 570                 err = qlcnic_pci_sriov_disable(adapter);
 571         else
 572                 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
 573
 574         clear_bit(__QLCNIC_RESETTING, &adapter->state);
 575         return err;
 576 }
 577
 578 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
 579 {
 580         struct qlcnic_cmd_args cmd;
 581         struct qlcnic_vport *vp;
 582         int err, id;
 583         u8 *mac;
 584
 585         id = qlcnic_sriov_func_to_index(adapter, func);
 586         if (id < 0)
 587                 return id;
 588
 589         vp = adapter->ahw->sriov->vf_info[id].vp;
 590         err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
 591         if (err)
 592                 return err;
 593
 594         cmd.req.arg[1] = 0x3 | func << 16;
 595         if (vp->spoofchk == true) {
 596                 mac = vp->mac;
 597                 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
 598                 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
 599                                  mac[2] << 24;
 600                 cmd.req.arg[5] = mac[1] | mac[0] << 8;
 601         }
 602
 603         if (vp->vlan_mode == QLC_PVID_MODE) {
 604                 cmd.req.arg[2] |= BIT_6;
 605                 cmd.req.arg[3] |= vp->vlan << 8;
 606         }
 607
 608         err = qlcnic_issue_cmd(adapter, &cmd);
 609         if (err)
 610                 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
 611                         err);
 612
 613         qlcnic_free_mbx_args(&cmd);
 614         return err;
 615 }
 616
 617 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
 618                                           u16 func)
 619 {
 620         struct qlcnic_info defvp_info;
 621         int err;
 622
 623         err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
 624         if (err)
 625                 return -EIO;
 626
 627         err = qlcnic_sriov_set_vf_acl(adapter, func);
 628         if (err)
 629                 return err;
 630
 631         return 0;
 632 }
 633
 634 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
 635                                            struct qlcnic_cmd_args *cmd)
 636 {
 637         struct qlcnic_vf_info *vf = trans->vf;
 638         struct qlcnic_vport *vp = vf->vp;
 639         struct qlcnic_adapter *adapter;
 640         u16 func = vf->pci_func;
 641         int err;
 642
 643         adapter = vf->adapter;
 644
 645         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
 646                 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 647                 if (!err) {
 648                         err = qlcnic_sriov_set_vf_vport_info(adapter, func);
 649                         if (err)
 650                                 qlcnic_sriov_pf_config_vport(adapter, 0, func);
 651                 }
 652         } else {
 653                 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
 654                         vp->vlan = 0;
 655                 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
 656         }
 657
 658         if (err)
 659                 goto err_out;
 660
 661         cmd->rsp.arg[0] |= (1 << 25);
 662
 663         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
 664                 set_bit(QLC_BC_VF_STATE, &vf->state);
 665         else
 666                 clear_bit(QLC_BC_VF_STATE, &vf->state);
 667
 668         return err;
 669
 670 err_out:
 671         cmd->rsp.arg[0] |= (2 << 25);
 672         return err;
 673 }
 674
 675 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
 676                                        struct qlcnic_vport *vp,
 677                                        u16 func, u16 vlan, u8 op)
 678 {
 679         struct qlcnic_cmd_args cmd;
 680         struct qlcnic_macvlan_mbx mv;
 681         u8 *addr;
 682         int err;
 683         u32 *buf;
 684         int vpid;
 685
 686         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
 687                 return -ENOMEM;
 688
 689         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
 690         if (vpid < 0) {
 691                 err = -EINVAL;
 692                 goto out;
 693         }
 694
 695         if (vlan)
 696                 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
 697                       QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
 698
 699         cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
 700         cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
 701
 702         addr = vp->mac;
 703         mv.vlan = vlan;
 704         mv.mac_addr0 = addr[0];
 705         mv.mac_addr1 = addr[1];
 706         mv.mac_addr2 = addr[2];
 707         mv.mac_addr3 = addr[3];
 708         mv.mac_addr4 = addr[4];
 709         mv.mac_addr5 = addr[5];
 710         buf = &cmd.req.arg[2];
 711         memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
 712
 713         err = qlcnic_issue_cmd(adapter, &cmd);
 714
 715         if (err)
 716                 dev_err(&adapter->pdev->dev,
 717                         "MAC-VLAN %s to CAM failed, err=%d.\n",
 718                         ((op == 1) ? "add " : "delete "), err);
 719
 720 out:
 721         qlcnic_free_mbx_args(&cmd);
 722         return err;
 723 }
 724
 725 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
 726 {
 727         if ((cmd->req.arg[0] >> 29) != 0x3)
 728                 return -EINVAL;
 729
 730         return 0;
 731 }
 732
 733 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
 734                                              struct qlcnic_cmd_args *cmd)
 735 {
 736         struct qlcnic_vf_info *vf = tran->vf;
 737         struct qlcnic_adapter *adapter = vf->adapter;
 738         struct qlcnic_rcv_mbx_out *mbx_out;
 739         int err;
 740         u16 vlan;
 741
 742         err = qlcnic_sriov_validate_create_rx_ctx(cmd);
 743         if (err) {
 744                 cmd->rsp.arg[0] |= (0x6 << 25);
 745                 return err;
 746         }
 747
 748         cmd->req.arg[6] = vf->vp->handle;
 749         err = qlcnic_issue_cmd(adapter, cmd);
 750
 751         vlan = vf->vp->vlan;
 752         if (!err) {
 753                 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
 754                 vf->rx_ctx_id = mbx_out->ctx_id;
 755                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
 756                                             vlan, QLCNIC_MAC_ADD);
 757         } else {
 758                 vf->rx_ctx_id = 0;
 759         }
 760
 761         return err;
 762 }
 763
 764 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
 765                                            struct qlcnic_cmd_args *cmd)
 766 {
 767         struct qlcnic_vf_info *vf = trans->vf;
 768         u8 type, *mac;
 769
 770         type = cmd->req.arg[1];
 771         switch (type) {
 772         case QLCNIC_SET_STATION_MAC:
 773         case QLCNIC_SET_FAC_DEF_MAC:
 774                 cmd->rsp.arg[0] = (2 << 25);
 775                 break;
 776         case QLCNIC_GET_CURRENT_MAC:
 777                 cmd->rsp.arg[0] = (1 << 25);
 778                 mac = vf->vp->mac;
 779                 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
 780                 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
 781                                   ((mac[3]) << 16 & 0xff0000) |
 782                                   ((mac[2]) << 24 & 0xff000000);
 783         }
 784
 785         return 0;
 786 }
 787
 788 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
 789 {
 790         if ((cmd->req.arg[0] >> 29) != 0x3)
 791                 return -EINVAL;
 792
 793         return 0;
 794 }
 795
 796 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 797                                              struct qlcnic_cmd_args *cmd)
 798 {
 799         struct qlcnic_vf_info *vf = trans->vf;
 800         struct qlcnic_adapter *adapter = vf->adapter;
 801         struct qlcnic_tx_mbx_out *mbx_out;
 802         int err;
 803
 804         err = qlcnic_sriov_validate_create_tx_ctx(cmd);
 805         if (err) {
 806                 cmd->rsp.arg[0] |= (0x6 << 25);
 807                 return err;
 808         }
 809
 810         cmd->req.arg[5] |= vf->vp->handle << 16;
 811         err = qlcnic_issue_cmd(adapter, cmd);
 812         if (!err) {
 813                 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
 814                 vf->tx_ctx_id = mbx_out->ctx_id;
 815         } else {
 816                 vf->tx_ctx_id = 0;
 817         }
 818
 819         return err;
 820 }
 821
 822 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
 823                                             struct qlcnic_cmd_args *cmd)
 824 {
 825         if ((cmd->req.arg[0] >> 29) != 0x3)
 826                 return -EINVAL;
 827
 828         if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
 829                 return -EINVAL;
 830
 831         return 0;
 832 }
 833
 834 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
 835                                           struct qlcnic_cmd_args *cmd)
 836 {
 837         struct qlcnic_vf_info *vf = trans->vf;
 838         struct qlcnic_adapter *adapter = vf->adapter;
 839         int err;
 840         u16 vlan;
 841
 842         err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
 843         if (err) {
 844                 cmd->rsp.arg[0] |= (0x6 << 25);
 845                 return err;
 846         }
 847
 848         vlan = vf->vp->vlan;
 849         qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
 850                                     vlan, QLCNIC_MAC_DEL);
 851         cmd->req.arg[1] |= vf->vp->handle << 16;
 852         err = qlcnic_issue_cmd(adapter, cmd);
 853
 854         if (!err)
 855                 vf->rx_ctx_id = 0;
 856
 857         return err;
 858 }
 859
 860 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
 861                                             struct qlcnic_cmd_args *cmd)
 862 {
 863         if ((cmd->req.arg[0] >> 29) != 0x3)
 864                 return -EINVAL;
 865
 866         if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
 867                 return -EINVAL;
 868
 869         return 0;
 870 }
 871
 872 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 873                                           struct qlcnic_cmd_args *cmd)
 874 {
 875         struct qlcnic_vf_info *vf = trans->vf;
 876         struct qlcnic_adapter *adapter = vf->adapter;
 877         int err;
 878
 879         err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
 880         if (err) {
 881                 cmd->rsp.arg[0] |= (0x6 << 25);
 882                 return err;
 883         }
 884
 885         cmd->req.arg[1] |= vf->vp->handle << 16;
 886         err = qlcnic_issue_cmd(adapter, cmd);
 887
 888         if (!err)
 889                 vf->tx_ctx_id = 0;
 890
 891         return err;
 892 }
 893
 894 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
 895                                          struct qlcnic_cmd_args *cmd)
 896 {
 897         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
 898                 return -EINVAL;
 899
 900         return 0;
 901 }
 902
 903 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
 904                                        struct qlcnic_cmd_args *cmd)
 905 {
 906         struct qlcnic_vf_info *vf = trans->vf;
 907         struct qlcnic_adapter *adapter = vf->adapter;
 908         int err;
 909
 910         err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
 911         if (err) {
 912                 cmd->rsp.arg[0] |= (0x6 << 25);
 913                 return err;
 914         }
 915
 916         err = qlcnic_issue_cmd(adapter, cmd);
 917         return err;
 918 }
 919
 920 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
 921                                       struct qlcnic_cmd_args *cmd)
 922 {
 923         struct qlcnic_vf_info *vf = trans->vf;
 924         struct qlcnic_adapter *adapter = vf->adapter;
 925         int err = -EIO;
 926         u8 op;
 927
 928         op =  cmd->req.arg[1] & 0xff;
 929
 930         cmd->req.arg[1] |= vf->vp->handle << 16;
 931         cmd->req.arg[1] |= BIT_31;
 932
 933         err = qlcnic_issue_cmd(adapter, cmd);
 934         return err;
 935 }
 936
 937 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
 938                                             struct qlcnic_cmd_args *cmd)
 939 {
 940         if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
 941                 return -EINVAL;
 942
 943         if (!(cmd->req.arg[1] & BIT_16))
 944                 return -EINVAL;
 945
 946         if ((cmd->req.arg[1] & 0xff) != 0x1)
 947                 return -EINVAL;
 948
 949         return 0;
 950 }
 951
 952 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
 953                                           struct qlcnic_cmd_args *cmd)
 954 {
 955         struct qlcnic_vf_info *vf = trans->vf;
 956         struct qlcnic_adapter *adapter = vf->adapter;
 957         int err;
 958
 959         err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
 960         if (err)
 961                 cmd->rsp.arg[0] |= (0x6 << 25);
 962         else
 963                 err = qlcnic_issue_cmd(adapter, cmd);
 964
 965         return err;
 966 }
 967
 968 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
 969                                      struct qlcnic_vf_info *vf,
 970                                      struct qlcnic_cmd_args *cmd)
 971 {
 972         if (cmd->req.arg[1] != vf->rx_ctx_id)
 973                 return -EINVAL;
 974
 975         if (cmd->req.arg[2] > adapter->ahw->max_mtu)
 976                 return -EINVAL;
 977
 978         return 0;
 979 }
 980
 981 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
 982                                        struct qlcnic_cmd_args *cmd)
 983 {
 984         struct qlcnic_vf_info *vf = trans->vf;
 985         struct qlcnic_adapter *adapter = vf->adapter;
 986         int err;
 987
 988         err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
 989         if (err)
 990                 cmd->rsp.arg[0] |= (0x6 << 25);
 991         else
 992                 err = qlcnic_issue_cmd(adapter, cmd);
 993
 994         return err;
 995 }
 996
 997 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
 998                                               struct qlcnic_cmd_args *cmd)
 999 {
1000         if (cmd->req.arg[1] & BIT_31) {
1001                 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1002                         return -EINVAL;
1003         } else {
1004                 cmd->req.arg[1] |= vf->vp->handle << 16;
1005         }
1006
1007         return 0;
1008 }
1009
1010 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1011                                             struct qlcnic_cmd_args *cmd)
1012 {
1013         struct qlcnic_vf_info *vf = trans->vf;
1014         struct qlcnic_adapter *adapter = vf->adapter;
1015         int err;
1016
1017         err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1018         if (err) {
1019                 cmd->rsp.arg[0] |= (0x6 << 25);
1020                 return err;
1021         }
1022
1023         err = qlcnic_issue_cmd(adapter, cmd);
1024         return err;
1025 }
1026
1027 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1028                                          struct qlcnic_cmd_args *cmd)
1029 {
1030         if (cmd->req.arg[1] != vf->rx_ctx_id)
1031                 return -EINVAL;
1032
1033         return 0;
1034 }
1035
1036 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1037                                        struct qlcnic_cmd_args *cmd)
1038 {
1039         struct qlcnic_vf_info *vf = trans->vf;
1040         struct qlcnic_adapter *adapter = vf->adapter;
1041         int err;
1042
1043         err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1044         if (err)
1045                 cmd->rsp.arg[0] |= (0x6 << 25);
1046         else
1047                 err = qlcnic_issue_cmd(adapter, cmd);
1048
1049         return err;
1050 }
1051
1052 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1053                                               struct qlcnic_vf_info *vf,
1054                                               struct qlcnic_cmd_args *cmd)
1055 {
1056         struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1057         u16 ctx_id, pkts, time;
1058
1059         ctx_id = cmd->req.arg[1] >> 16;
1060         pkts = cmd->req.arg[2] & 0xffff;
1061         time = cmd->req.arg[2] >> 16;
1062
1063         if (ctx_id != vf->rx_ctx_id)
1064                 return -EINVAL;
1065         if (pkts > coal->rx_packets)
1066                 return -EINVAL;
1067         if (time < coal->rx_time_us)
1068                 return -EINVAL;
1069
1070         return 0;
1071 }
1072
1073 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1074                                             struct qlcnic_cmd_args *cmd)
1075 {
1076         struct qlcnic_vf_info *vf = tran->vf;
1077         struct qlcnic_adapter *adapter = vf->adapter;
1078         int err;
1079
1080         err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1081         if (err) {
1082                 cmd->rsp.arg[0] |= (0x6 << 25);
1083                 return err;
1084         }
1085
1086         err = qlcnic_issue_cmd(adapter, cmd);
1087         return err;
1088 }
1089
1090 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1091                                              struct qlcnic_vf_info *vf,
1092                                              struct qlcnic_cmd_args *cmd)
1093 {
1094         struct qlcnic_macvlan_mbx *macvlan;
1095         struct qlcnic_vport *vp = vf->vp;
1096         u8 op, new_op;
1097
1098         if (!(cmd->req.arg[1] & BIT_8))
1099                 return -EINVAL;
1100
1101         cmd->req.arg[1] |= (vf->vp->handle << 16);
1102         cmd->req.arg[1] |= BIT_31;
1103
1104         macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1105         if (!(macvlan->mac_addr0 & BIT_0)) {
1106                 dev_err(&adapter->pdev->dev,
1107                         "MAC address change is not allowed from VF %d",
1108                         vf->pci_func);
1109                 return -EINVAL;
1110         }
1111
1112         if (vp->vlan_mode == QLC_PVID_MODE) {
1113                 op = cmd->req.arg[1] & 0x7;
1114                 cmd->req.arg[1] &= ~0x7;
1115                 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1116                          QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1117                 cmd->req.arg[3] |= vp->vlan << 16;
1118                 cmd->req.arg[1] |= new_op;
1119         }
1120
1121         return 0;
1122 }
1123
1124 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1125                                            struct qlcnic_cmd_args *cmd)
1126 {
1127         struct qlcnic_vf_info *vf = trans->vf;
1128         struct qlcnic_adapter *adapter = vf->adapter;
1129         int err;
1130
1131         err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1132         if (err) {
1133                 cmd->rsp.arg[0] |= (0x6 << 25);
1134                 return err;
1135         }
1136
1137         err = qlcnic_issue_cmd(adapter, cmd);
1138         return err;
1139 }
1140
1141 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1142                                            struct qlcnic_cmd_args *cmd)
1143 {
1144         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1145                 return -EINVAL;
1146
1147         return 0;
1148 }
1149
1150 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1151                                          struct qlcnic_cmd_args *cmd)
1152 {
1153         struct qlcnic_vf_info *vf = trans->vf;
1154         struct qlcnic_adapter *adapter = vf->adapter;
1155         int err;
1156
1157         err = qlcnic_sriov_validate_linkevent(vf, cmd);
1158         if (err) {
1159                 cmd->rsp.arg[0] |= (0x6 << 25);
1160                 return err;
1161         }
1162
1163         err = qlcnic_issue_cmd(adapter, cmd);
1164         return err;
1165 }
1166
1167 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1168                                            struct qlcnic_cmd_args *cmd)
1169 {
1170         struct qlcnic_vf_info *vf = trans->vf;
1171         struct qlcnic_adapter *adapter = vf->adapter;
1172         int err;
1173
1174         cmd->req.arg[1] |= vf->vp->handle << 16;
1175         cmd->req.arg[1] |= BIT_31;
1176         err = qlcnic_issue_cmd(adapter, cmd);
1177         return err;
1178 }
1179
1180 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1181                                        struct qlcnic_cmd_args *cmd)
1182 {
1183         struct qlcnic_vf_info *vf = trans->vf;
1184         struct qlcnic_vport *vp = vf->vp;
1185         u8 cmd_op, mode = vp->vlan_mode;
1186         struct qlcnic_adapter *adapter;
1187
1188         adapter = vf->adapter;
1189
1190         cmd_op = trans->req_hdr->cmd_op;
1191         cmd->rsp.arg[0] |= 1 << 25;
1192
1193         /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1194          * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1195          */
1196         if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1197                 return 0;
1198
1199         switch (mode) {
1200         case QLC_GUEST_VLAN_MODE:
1201                 cmd->rsp.arg[1] = mode | 1 << 8;
1202                 cmd->rsp.arg[2] = 1 << 16;
1203                 break;
1204         case QLC_PVID_MODE:
1205                 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16;
1206                 break;
1207         }
1208
1209         return 0;
1210 }
1211
1212 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1213                                           struct qlcnic_vf_info *vf)
1214
1215 {
1216         struct qlcnic_vport *vp = vf->vp;
1217
1218         if (!vp->vlan)
1219                 return -EINVAL;
1220
1221         if (!vf->rx_ctx_id) {
1222                 vp->vlan = 0;
1223                 return 0;
1224         }
1225
1226         qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1227                                     vp->vlan, QLCNIC_MAC_DEL);
1228         vp->vlan = 0;
1229         qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1230                                     0, QLCNIC_MAC_ADD);
1231         return 0;
1232 }
1233
1234 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1235                                           struct qlcnic_vf_info *vf,
1236                                           struct qlcnic_cmd_args *cmd)
1237 {
1238         struct qlcnic_vport *vp = vf->vp;
1239         int err = -EIO;
1240
1241         if (vp->vlan)
1242                 return err;
1243
1244         if (!vf->rx_ctx_id) {
1245                 vp->vlan = cmd->req.arg[1] >> 16;
1246                 return 0;
1247         }
1248
1249         err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1250                                           0, QLCNIC_MAC_DEL);
1251         if (err)
1252                 return err;
1253
1254         vp->vlan = cmd->req.arg[1] >> 16;
1255         err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1256                                           vp->vlan, QLCNIC_MAC_ADD);
1257
1258         if (err) {
1259                 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1260                                             0, QLCNIC_MAC_ADD);
1261                 vp->vlan = 0;
1262         }
1263
1264         return err;
1265 }
1266
1267 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1268                                               struct qlcnic_cmd_args *cmd)
1269 {
1270         struct qlcnic_vf_info  *vf = tran->vf;
1271         struct qlcnic_adapter *adapter =  vf->adapter;
1272         struct qlcnic_vport *vp = vf->vp;
1273         int err = -EIO;
1274         u8 op;
1275
1276         if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1277                 cmd->rsp.arg[0] |= 2 << 25;
1278                 return err;
1279         }
1280
1281         op = cmd->req.arg[1] & 0xf;
1282
1283         if (op)
1284                 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1285         else
1286                 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf);
1287
1288         cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1289         return err;
1290 }
1291
1292 static const int qlcnic_pf_passthru_supp_cmds[] = {
1293         QLCNIC_CMD_GET_STATISTICS,
1294         QLCNIC_CMD_GET_PORT_CONFIG,
1295         QLCNIC_CMD_GET_LINK_STATUS,
1296         QLCNIC_CMD_DCB_QUERY_CAP,
1297         QLCNIC_CMD_DCB_QUERY_PARAM,
1298         QLCNIC_CMD_INIT_NIC_FUNC,
1299         QLCNIC_CMD_STOP_NIC_FUNC,
1300 };
1301
1302 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1303         [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1304         [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1305         [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1306         [QLCNIC_BC_CMD_CFG_GUEST_VLAN]  = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1307 };
1308
1309 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1310         {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1311         {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1312         {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1313         {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1314         {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1315         {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1316         {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1317         {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1318         {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1319         {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1320         {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1321         {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1322         {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1323         {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1324         {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1325 };
1326
1327 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1328                                     struct qlcnic_bc_trans *trans,
1329                                     struct qlcnic_cmd_args *cmd)
1330 {
1331         u8 size, cmd_op;
1332
1333         cmd_op = trans->req_hdr->cmd_op;
1334
1335         if (trans->req_hdr->op_type == QLC_BC_CMD) {
1336                 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1337                 if (cmd_op < size) {
1338                         qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1339                         return;
1340                 }
1341         } else {
1342                 int i;
1343                 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1344                 for (i = 0; i < size; i++) {
1345                         if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1346                                 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1347                                 return;
1348                         }
1349                 }
1350
1351                 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1352                 for (i = 0; i < size; i++) {
1353                         if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1354                                 qlcnic_issue_cmd(adapter, cmd);
1355                                 return;
1356                         }
1357                 }
1358         }
1359
1360         cmd->rsp.arg[0] |= (0x9 << 25);
1361 }
1362
1363 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1364                                              u32 *int_id)
1365 {
1366         u16 vpid;
1367
1368         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1369                                                 adapter->ahw->pci_func);
1370         *int_id |= vpid;
1371 }
1372
1373 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1374                                            u32 *int_id)
1375 {
1376         u16 vpid;
1377
1378         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1379                                                 adapter->ahw->pci_func);
1380         *int_id |= vpid << 16;
1381 }
1382
1383 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1384                                               u32 *int_id)
1385 {
1386         int vpid;
1387
1388         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1389                                                 adapter->ahw->pci_func);
1390         *int_id |= vpid << 16;
1391 }
1392
1393 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1394                                            u32 *int_id)
1395 {
1396         u16 vpid;
1397
1398         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1399                                                 adapter->ahw->pci_func);
1400         *int_id |= vpid << 16;
1401 }
1402
1403 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1404                                         u32 *int_id)
1405 {
1406         u16 vpid;
1407
1408         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1409                                                 adapter->ahw->pci_func);
1410         *int_id |= (vpid << 16) | BIT_31;
1411 }
1412
1413 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1414                                        u32 *int_id)
1415 {
1416         u16 vpid;
1417
1418         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1419                                                 adapter->ahw->pci_func);
1420         *int_id |= (vpid << 16) | BIT_31;
1421 }
1422
1423 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1424                                         u32 *int_id)
1425 {
1426         u16 vpid;
1427
1428         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1429                                                 adapter->ahw->pci_func);
1430         *int_id |= (vpid << 16) | BIT_31;
1431 }
1432
1433 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1434                                     struct qlcnic_vf_info *vf)
1435 {
1436         struct qlcnic_cmd_args cmd;
1437         int vpid;
1438
1439         if (!vf->rx_ctx_id)
1440                 return;
1441
1442         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1443                 return;
1444
1445         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1446         if (vpid >= 0) {
1447                 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1448                 if (qlcnic_issue_cmd(adapter, &cmd))
1449                         dev_err(&adapter->pdev->dev,
1450                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1451                                 vf->pci_func);
1452                 else
1453                         vf->rx_ctx_id = 0;
1454         }
1455
1456         qlcnic_free_mbx_args(&cmd);
1457 }
1458
1459 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1460                                     struct qlcnic_vf_info *vf)
1461 {
1462         struct qlcnic_cmd_args cmd;
1463         int vpid;
1464
1465         if (!vf->tx_ctx_id)
1466                 return;
1467
1468         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1469                 return;
1470
1471         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1472         if (vpid >= 0) {
1473                 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1474                 if (qlcnic_issue_cmd(adapter, &cmd))
1475                         dev_err(&adapter->pdev->dev,
1476                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1477                                 vf->pci_func);
1478                 else
1479                         vf->tx_ctx_id = 0;
1480         }
1481
1482         qlcnic_free_mbx_args(&cmd);
1483 }
1484
1485 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1486                                              struct qlcnic_vf_info *vf,
1487                                              struct qlcnic_bc_trans *trans)
1488 {
1489         struct qlcnic_trans_list *t_list = &vf->rcv_act;
1490         unsigned long flag;
1491
1492         spin_lock_irqsave(&t_list->lock, flag);
1493
1494         __qlcnic_sriov_add_act_list(sriov, vf, trans);
1495
1496         spin_unlock_irqrestore(&t_list->lock, flag);
1497         return 0;
1498 }
1499
1500 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1501 {
1502         struct qlcnic_adapter *adapter = vf->adapter;
1503
1504         qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1505         cancel_work_sync(&vf->trans_work);
1506         qlcnic_sriov_cleanup_list(&vf->rcv_act);
1507
1508         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1509                 qlcnic_sriov_del_tx_ctx(adapter, vf);
1510                 qlcnic_sriov_del_rx_ctx(adapter, vf);
1511         }
1512
1513         qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1514
1515         clear_bit(QLC_BC_VF_FLR, &vf->state);
1516         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1517                 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1518                                                   vf->flr_trans);
1519                 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1520                 vf->flr_trans = NULL;
1521         }
1522 }
1523
1524 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1525 {
1526         struct qlcnic_vf_info *vf;
1527
1528         vf = container_of(work, struct qlcnic_vf_info, flr_work);
1529         __qlcnic_sriov_process_flr(vf);
1530         return;
1531 }
1532
1533 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1534                                       struct qlcnic_vf_info *vf,
1535                                       work_func_t func)
1536 {
1537         if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1538                 return;
1539
1540         INIT_WORK(&vf->flr_work, func);
1541         queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1542 }
1543
1544 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1545                                          struct qlcnic_bc_trans *trans,
1546                                          struct qlcnic_vf_info *vf)
1547 {
1548         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1549
1550         set_bit(QLC_BC_VF_FLR, &vf->state);
1551         clear_bit(QLC_BC_VF_STATE, &vf->state);
1552         set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1553         vf->flr_trans = trans;
1554         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1555         netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1556                     vf->pci_func);
1557 }
1558
1559 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1560                                  struct qlcnic_bc_trans *trans,
1561                                  struct qlcnic_vf_info *vf)
1562 {
1563         struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1564
1565         if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1566             (hdr->op_type == QLC_BC_CMD) &&
1567              test_bit(QLC_BC_VF_STATE, &vf->state)) {
1568                 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1569                 return true;
1570         }
1571
1572         return false;
1573 }
1574
1575 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1576                                 struct qlcnic_vf_info *vf)
1577 {
1578         struct net_device *dev = vf->adapter->netdev;
1579         struct qlcnic_vport *vp = vf->vp;
1580
1581         if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1582                 clear_bit(QLC_BC_VF_FLR, &vf->state);
1583                 return;
1584         }
1585
1586         if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1587                 netdev_info(dev, "FLR for PCI func %d in progress\n",
1588                             vf->pci_func);
1589                 return;
1590         }
1591
1592         if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1593                 vp->vlan = 0;
1594
1595         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1596         netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1597 }
1598
1599 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1600 {
1601         struct qlcnic_hardware_context *ahw = adapter->ahw;
1602         struct qlcnic_sriov *sriov = ahw->sriov;
1603         struct qlcnic_vf_info *vf;
1604         u16 num_vfs = sriov->num_vfs;
1605         int i;
1606
1607         for (i = 0; i < num_vfs; i++) {
1608                 vf = &sriov->vf_info[i];
1609                 vf->rx_ctx_id = 0;
1610                 vf->tx_ctx_id = 0;
1611                 cancel_work_sync(&vf->flr_work);
1612                 __qlcnic_sriov_process_flr(vf);
1613                 clear_bit(QLC_BC_VF_STATE, &vf->state);
1614         }
1615
1616         qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1617         QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1618 }
1619
1620 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1621 {
1622         struct qlcnic_hardware_context *ahw = adapter->ahw;
1623         int err;
1624
1625         if (!qlcnic_sriov_enable_check(adapter))
1626                 return 0;
1627
1628         ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1629
1630         err = qlcnic_sriov_pf_init(adapter);
1631         if (err)
1632                 return err;
1633
1634         dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1635                  __func__, ahw->op_mode);
1636         return err;
1637 }
1638
1639 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1640 {
1641         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1642         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1643         int i, num_vfs;
1644         struct qlcnic_vf_info *vf_info;
1645         u8 *curr_mac;
1646
1647         if (!qlcnic_sriov_pf_check(adapter))
1648                 return -EOPNOTSUPP;
1649
1650         num_vfs = sriov->num_vfs;
1651
1652         if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1653                 return -EINVAL;
1654
1655         if (ether_addr_equal(adapter->mac_addr, mac)) {
1656                 netdev_err(netdev, "MAC address is already in use by the PF\n");
1657                 return -EINVAL;
1658         }
1659
1660         for (i = 0; i < num_vfs; i++) {
1661                 vf_info = &sriov->vf_info[i];
1662                 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1663                         netdev_err(netdev,
1664                                    "MAC address is already in use by VF %d\n",
1665                                    i);
1666                         return -EINVAL;
1667                 }
1668         }
1669
1670         vf_info = &sriov->vf_info[vf];
1671         curr_mac = vf_info->vp->mac;
1672
1673         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1674                 netdev_err(netdev,
1675                            "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1676                            vf);
1677                 return -EOPNOTSUPP;
1678         }
1679
1680         memcpy(curr_mac, mac, netdev->addr_len);
1681         netdev_info(netdev, "MAC Address %pM  is configured for VF %d\n",
1682                     mac, vf);
1683         return 0;
1684 }
1685
1686 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1687 {
1688         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1689         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1690         struct qlcnic_vf_info *vf_info;
1691         struct qlcnic_info nic_info;
1692         struct qlcnic_vport *vp;
1693         u16 vpid;
1694
1695         if (!qlcnic_sriov_pf_check(adapter))
1696                 return -EOPNOTSUPP;
1697
1698         if (vf >= sriov->num_vfs)
1699                 return -EINVAL;
1700
1701         if (tx_rate >= 10000 || tx_rate < 100) {
1702                 netdev_err(netdev,
1703                            "Invalid Tx rate, allowed range is [%d - %d]",
1704                            QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1705                 return -EINVAL;
1706         }
1707
1708         if (tx_rate == 0)
1709                 tx_rate = 10000;
1710
1711         vf_info = &sriov->vf_info[vf];
1712         vp = vf_info->vp;
1713         vpid = vp->handle;
1714
1715         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1716                 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1717                         return -EIO;
1718
1719                 nic_info.max_tx_bw = tx_rate / 100;
1720                 nic_info.bit_offsets = BIT_0;
1721
1722                 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1723                         return -EIO;
1724         }
1725
1726         vp->max_tx_bw = tx_rate / 100;
1727         netdev_info(netdev,
1728                     "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1729                     tx_rate, vp->max_tx_bw, vf);
1730         return 0;
1731 }
1732
1733 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1734                              u16 vlan, u8 qos)
1735 {
1736         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1737         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1738         struct qlcnic_vf_info *vf_info;
1739         struct qlcnic_vport *vp;
1740
1741         if (!qlcnic_sriov_pf_check(adapter))
1742                 return -EOPNOTSUPP;
1743
1744         if (vf >= sriov->num_vfs || qos > 7)
1745                 return -EINVAL;
1746
1747         if (vlan > MAX_VLAN_ID) {
1748                 netdev_err(netdev,
1749                            "Invalid VLAN ID, allowed range is [0 - %d]\n",
1750                            MAX_VLAN_ID);
1751                 return -EINVAL;
1752         }
1753
1754         vf_info = &sriov->vf_info[vf];
1755         vp = vf_info->vp;
1756         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1757                 netdev_err(netdev,
1758                            "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1759                            vf);
1760                 return -EOPNOTSUPP;
1761         }
1762
1763         switch (vlan) {
1764         case 4095:
1765                 vp->vlan = 0;
1766                 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1767                 break;
1768         case 0:
1769                 vp->vlan_mode = QLC_NO_VLAN_MODE;
1770                 vp->vlan = 0;
1771                 vp->qos = 0;
1772                 break;
1773         default:
1774                 vp->vlan_mode = QLC_PVID_MODE;
1775                 vp->vlan = vlan;
1776                 vp->qos = qos;
1777         }
1778
1779         netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1780                     vlan, qos, vf);
1781         return 0;
1782 }
1783
1784 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1785                                       struct qlcnic_vport *vp, int vf)
1786 {
1787         __u32 vlan = 0;
1788
1789         switch (vp->vlan_mode) {
1790         case QLC_PVID_MODE:
1791                 vlan = vp->vlan;
1792                 break;
1793         case QLC_GUEST_VLAN_MODE:
1794                 vlan = MAX_VLAN_ID;
1795                 break;
1796         case QLC_NO_VLAN_MODE:
1797                 vlan = 0;
1798                 break;
1799         default:
1800                 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1801                             vp->vlan_mode, vf);
1802         }
1803
1804         return vlan;
1805 }
1806
1807 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1808                                int vf, struct ifla_vf_info *ivi)
1809 {
1810         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1811         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1812         struct qlcnic_vport *vp;
1813
1814         if (!qlcnic_sriov_pf_check(adapter))
1815                 return -EOPNOTSUPP;
1816
1817         if (vf >= sriov->num_vfs)
1818                 return -EINVAL;
1819
1820         vp = sriov->vf_info[vf].vp;
1821         memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1822         ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1823         ivi->qos = vp->qos;
1824         ivi->spoofchk = vp->spoofchk;
1825         if (vp->max_tx_bw == MAX_BW)
1826                 ivi->tx_rate = 0;
1827         else
1828                 ivi->tx_rate = vp->max_tx_bw * 100;
1829
1830         ivi->vf = vf;
1831         return 0;
1832 }
1833
1834 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1835 {
1836         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1837         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1838         struct qlcnic_vf_info *vf_info;
1839         struct qlcnic_vport *vp;
1840
1841         if (!qlcnic_sriov_pf_check(adapter))
1842                 return -EOPNOTSUPP;
1843
1844         if (vf >= sriov->num_vfs)
1845                 return -EINVAL;
1846
1847         vf_info = &sriov->vf_info[vf];
1848         vp = vf_info->vp;
1849         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1850                 netdev_err(netdev,
1851                            "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1852                            vf);
1853                 return -EOPNOTSUPP;
1854         }
1855
1856         vp->spoofchk = chk;
1857         return 0;
1858 }