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         rtnl_lock();
 401         if (netif_running(netdev))
 402                 __qlcnic_down(adapter, netdev);
 403
 404         qlcnic_sriov_pf_disable(adapter);
 405
 406         qlcnic_sriov_pf_cleanup(adapter);
 407
 408         /* After disabling SRIOV re-init the driver in default mode
 409            configure opmode based on op_mode of function
 410          */
 411         if (qlcnic_83xx_configure_opmode(adapter)) {
 412                 rtnl_unlock();
 413                 return -EIO;
 414         }
 415
 416         if (netif_running(netdev))
 417                 __qlcnic_up(adapter, netdev);
 418
 419         rtnl_unlock();
 420         return 0;
 421 }
 422
 423 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
 424 {
 425         struct qlcnic_hardware_context *ahw = adapter->ahw;
 426         struct qlcnic_info nic_info, pf_info, vp_info;
 427         int err;
 428         u8 func = ahw->pci_func;
 429
 430         if (!qlcnic_sriov_enable_check(adapter))
 431                 return 0;
 432
 433         err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
 434         if (err)
 435                 return err;
 436
 437         err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
 438         if (err)
 439                 goto disable_vlan_filtering;
 440
 441         err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 442         if (err)
 443                 goto disable_eswitch;
 444
 445         err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
 446         if (err)
 447                 goto delete_vport;
 448
 449         err = qlcnic_get_nic_info(adapter, &nic_info, func);
 450         if (err)
 451                 goto delete_vport;
 452
 453         err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
 454         if (err)
 455                 goto delete_vport;
 456
 457         err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
 458         if (err)
 459                 goto delete_vport;
 460
 461         ahw->physical_port = (u8) nic_info.phys_port;
 462         ahw->switch_mode = nic_info.switch_mode;
 463         ahw->max_mtu = nic_info.max_mtu;
 464         ahw->capabilities = nic_info.capabilities;
 465         ahw->nic_mode = QLC_83XX_SRIOV_MODE;
 466         return err;
 467
 468 delete_vport:
 469         qlcnic_sriov_pf_config_vport(adapter, 0, func);
 470
 471 disable_eswitch:
 472         qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
 473
 474 disable_vlan_filtering:
 475         qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
 476
 477         return err;
 478 }
 479
 480 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
 481 {
 482         int err;
 483
 484         if (!qlcnic_sriov_enable_check(adapter))
 485                 return 0;
 486
 487         err = pci_enable_sriov(adapter->pdev, num_vfs);
 488         if (err)
 489                 qlcnic_sriov_pf_cleanup(adapter);
 490
 491         return err;
 492 }
 493
 494 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
 495                                      int num_vfs)
 496 {
 497         int err = 0;
 498
 499         set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 500         adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
 501
 502         err = qlcnic_sriov_init(adapter, num_vfs);
 503         if (err)
 504                 goto clear_op_mode;
 505
 506         err = qlcnic_sriov_pf_create_flr_queue(adapter);
 507         if (err)
 508                 goto sriov_cleanup;
 509
 510         err = qlcnic_sriov_pf_init(adapter);
 511         if (err)
 512                 goto del_flr_queue;
 513
 514         err = qlcnic_sriov_pf_enable(adapter, num_vfs);
 515         return err;
 516
 517 del_flr_queue:
 518         qlcnic_sriov_pf_del_flr_queue(adapter);
 519
 520 sriov_cleanup:
 521         __qlcnic_sriov_cleanup(adapter);
 522
 523 clear_op_mode:
 524         clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 525         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
 526         return err;
 527 }
 528
 529 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
 530 {
 531         struct net_device *netdev = adapter->netdev;
 532         int err;
 533
 534         if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
 535                 netdev_err(netdev,
 536                            "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
 537                 return -EIO;
 538         }
 539
 540         rtnl_lock();
 541         if (netif_running(netdev))
 542                 __qlcnic_down(adapter, netdev);
 543
 544         err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
 545         if (err) {
 546                 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
 547                             adapter->portnum);
 548
 549                 err = -EIO;
 550                 if (qlcnic_83xx_configure_opmode(adapter))
 551                         goto error;
 552         } else {
 553                 netdev_info(netdev,
 554                             "SR-IOV is enabled successfully on port %d\n",
 555                             adapter->portnum);
 556                 /* Return number of vfs enabled */
 557                 err = num_vfs;
 558         }
 559         if (netif_running(netdev))
 560                 __qlcnic_up(adapter, netdev);
 561
 562 error:
 563         rtnl_unlock();
 564         return err;
 565 }
 566
 567 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
 568 {
 569         struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
 570         int err;
 571
 572         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 573                 return -EBUSY;
 574
 575         if (num_vfs == 0)
 576                 err = qlcnic_pci_sriov_disable(adapter);
 577         else
 578                 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
 579
 580         clear_bit(__QLCNIC_RESETTING, &adapter->state);
 581         return err;
 582 }
 583
 584 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
 585 {
 586         struct qlcnic_cmd_args cmd;
 587         struct qlcnic_vport *vp;
 588         int err, id;
 589         u8 *mac;
 590
 591         id = qlcnic_sriov_func_to_index(adapter, func);
 592         if (id < 0)
 593                 return id;
 594
 595         vp = adapter->ahw->sriov->vf_info[id].vp;
 596         err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
 597         if (err)
 598                 return err;
 599
 600         cmd.req.arg[1] = 0x3 | func << 16;
 601         if (vp->spoofchk == true) {
 602                 mac = vp->mac;
 603                 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
 604                 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
 605                                  mac[2] << 24;
 606                 cmd.req.arg[5] = mac[1] | mac[0] << 8;
 607         }
 608
 609         if (vp->vlan_mode == QLC_PVID_MODE) {
 610                 cmd.req.arg[2] |= BIT_6;
 611                 cmd.req.arg[3] |= vp->vlan << 8;
 612         }
 613
 614         err = qlcnic_issue_cmd(adapter, &cmd);
 615         if (err)
 616                 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
 617                         err);
 618
 619         qlcnic_free_mbx_args(&cmd);
 620         return err;
 621 }
 622
 623 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
 624                                           u16 func)
 625 {
 626         struct qlcnic_info defvp_info;
 627         int err;
 628
 629         err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
 630         if (err)
 631                 return -EIO;
 632
 633         err = qlcnic_sriov_set_vf_acl(adapter, func);
 634         if (err)
 635                 return err;
 636
 637         return 0;
 638 }
 639
 640 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
 641                                            struct qlcnic_cmd_args *cmd)
 642 {
 643         struct qlcnic_vf_info *vf = trans->vf;
 644         struct qlcnic_vport *vp = vf->vp;
 645         struct qlcnic_adapter *adapter;
 646         u16 func = vf->pci_func;
 647         int err;
 648
 649         adapter = vf->adapter;
 650
 651         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
 652                 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 653                 if (!err) {
 654                         err = qlcnic_sriov_set_vf_vport_info(adapter, func);
 655                         if (err)
 656                                 qlcnic_sriov_pf_config_vport(adapter, 0, func);
 657                 }
 658         } else {
 659                 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
 660                         vp->vlan = 0;
 661                 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
 662         }
 663
 664         if (err)
 665                 goto err_out;
 666
 667         cmd->rsp.arg[0] |= (1 << 25);
 668
 669         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
 670                 set_bit(QLC_BC_VF_STATE, &vf->state);
 671         else
 672                 clear_bit(QLC_BC_VF_STATE, &vf->state);
 673
 674         return err;
 675
 676 err_out:
 677         cmd->rsp.arg[0] |= (2 << 25);
 678         return err;
 679 }
 680
 681 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
 682                                        struct qlcnic_vport *vp,
 683                                        u16 func, u16 vlan, u8 op)
 684 {
 685         struct qlcnic_cmd_args cmd;
 686         struct qlcnic_macvlan_mbx mv;
 687         u8 *addr;
 688         int err;
 689         u32 *buf;
 690         int vpid;
 691
 692         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
 693                 return -ENOMEM;
 694
 695         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
 696         if (vpid < 0) {
 697                 err = -EINVAL;
 698                 goto out;
 699         }
 700
 701         if (vlan)
 702                 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
 703                       QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
 704
 705         cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
 706         cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
 707
 708         addr = vp->mac;
 709         mv.vlan = vlan;
 710         mv.mac_addr0 = addr[0];
 711         mv.mac_addr1 = addr[1];
 712         mv.mac_addr2 = addr[2];
 713         mv.mac_addr3 = addr[3];
 714         mv.mac_addr4 = addr[4];
 715         mv.mac_addr5 = addr[5];
 716         buf = &cmd.req.arg[2];
 717         memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
 718
 719         err = qlcnic_issue_cmd(adapter, &cmd);
 720
 721         if (err)
 722                 dev_err(&adapter->pdev->dev,
 723                         "MAC-VLAN %s to CAM failed, err=%d.\n",
 724                         ((op == 1) ? "add " : "delete "), err);
 725
 726 out:
 727         qlcnic_free_mbx_args(&cmd);
 728         return err;
 729 }
 730
 731 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
 732 {
 733         if ((cmd->req.arg[0] >> 29) != 0x3)
 734                 return -EINVAL;
 735
 736         return 0;
 737 }
 738
 739 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
 740                                              struct qlcnic_cmd_args *cmd)
 741 {
 742         struct qlcnic_vf_info *vf = tran->vf;
 743         struct qlcnic_adapter *adapter = vf->adapter;
 744         struct qlcnic_rcv_mbx_out *mbx_out;
 745         int err;
 746         u16 vlan;
 747
 748         err = qlcnic_sriov_validate_create_rx_ctx(cmd);
 749         if (err) {
 750                 cmd->rsp.arg[0] |= (0x6 << 25);
 751                 return err;
 752         }
 753
 754         cmd->req.arg[6] = vf->vp->handle;
 755         err = qlcnic_issue_cmd(adapter, cmd);
 756
 757         vlan = vf->vp->vlan;
 758         if (!err) {
 759                 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
 760                 vf->rx_ctx_id = mbx_out->ctx_id;
 761                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
 762                                             vlan, QLCNIC_MAC_ADD);
 763         } else {
 764                 vf->rx_ctx_id = 0;
 765         }
 766
 767         return err;
 768 }
 769
 770 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
 771                                            struct qlcnic_cmd_args *cmd)
 772 {
 773         struct qlcnic_vf_info *vf = trans->vf;
 774         u8 type, *mac;
 775
 776         type = cmd->req.arg[1];
 777         switch (type) {
 778         case QLCNIC_SET_STATION_MAC:
 779         case QLCNIC_SET_FAC_DEF_MAC:
 780                 cmd->rsp.arg[0] = (2 << 25);
 781                 break;
 782         case QLCNIC_GET_CURRENT_MAC:
 783                 cmd->rsp.arg[0] = (1 << 25);
 784                 mac = vf->vp->mac;
 785                 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
 786                 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
 787                                   ((mac[3]) << 16 & 0xff0000) |
 788                                   ((mac[2]) << 24 & 0xff000000);
 789         }
 790
 791         return 0;
 792 }
 793
 794 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
 795 {
 796         if ((cmd->req.arg[0] >> 29) != 0x3)
 797                 return -EINVAL;
 798
 799         return 0;
 800 }
 801
 802 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 803                                              struct qlcnic_cmd_args *cmd)
 804 {
 805         struct qlcnic_vf_info *vf = trans->vf;
 806         struct qlcnic_adapter *adapter = vf->adapter;
 807         struct qlcnic_tx_mbx_out *mbx_out;
 808         int err;
 809
 810         err = qlcnic_sriov_validate_create_tx_ctx(cmd);
 811         if (err) {
 812                 cmd->rsp.arg[0] |= (0x6 << 25);
 813                 return err;
 814         }
 815
 816         cmd->req.arg[5] |= vf->vp->handle << 16;
 817         err = qlcnic_issue_cmd(adapter, cmd);
 818         if (!err) {
 819                 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
 820                 vf->tx_ctx_id = mbx_out->ctx_id;
 821         } else {
 822                 vf->tx_ctx_id = 0;
 823         }
 824
 825         return err;
 826 }
 827
 828 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
 829                                             struct qlcnic_cmd_args *cmd)
 830 {
 831         if ((cmd->req.arg[0] >> 29) != 0x3)
 832                 return -EINVAL;
 833
 834         if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
 835                 return -EINVAL;
 836
 837         return 0;
 838 }
 839
 840 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
 841                                           struct qlcnic_cmd_args *cmd)
 842 {
 843         struct qlcnic_vf_info *vf = trans->vf;
 844         struct qlcnic_adapter *adapter = vf->adapter;
 845         int err;
 846         u16 vlan;
 847
 848         err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
 849         if (err) {
 850                 cmd->rsp.arg[0] |= (0x6 << 25);
 851                 return err;
 852         }
 853
 854         vlan = vf->vp->vlan;
 855         qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
 856                                     vlan, QLCNIC_MAC_DEL);
 857         cmd->req.arg[1] |= vf->vp->handle << 16;
 858         err = qlcnic_issue_cmd(adapter, cmd);
 859
 860         if (!err)
 861                 vf->rx_ctx_id = 0;
 862
 863         return err;
 864 }
 865
 866 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
 867                                             struct qlcnic_cmd_args *cmd)
 868 {
 869         if ((cmd->req.arg[0] >> 29) != 0x3)
 870                 return -EINVAL;
 871
 872         if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
 873                 return -EINVAL;
 874
 875         return 0;
 876 }
 877
 878 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 879                                           struct qlcnic_cmd_args *cmd)
 880 {
 881         struct qlcnic_vf_info *vf = trans->vf;
 882         struct qlcnic_adapter *adapter = vf->adapter;
 883         int err;
 884
 885         err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
 886         if (err) {
 887                 cmd->rsp.arg[0] |= (0x6 << 25);
 888                 return err;
 889         }
 890
 891         cmd->req.arg[1] |= vf->vp->handle << 16;
 892         err = qlcnic_issue_cmd(adapter, cmd);
 893
 894         if (!err)
 895                 vf->tx_ctx_id = 0;
 896
 897         return err;
 898 }
 899
 900 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
 901                                          struct qlcnic_cmd_args *cmd)
 902 {
 903         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
 904                 return -EINVAL;
 905
 906         return 0;
 907 }
 908
 909 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
 910                                        struct qlcnic_cmd_args *cmd)
 911 {
 912         struct qlcnic_vf_info *vf = trans->vf;
 913         struct qlcnic_adapter *adapter = vf->adapter;
 914         int err;
 915
 916         err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
 917         if (err) {
 918                 cmd->rsp.arg[0] |= (0x6 << 25);
 919                 return err;
 920         }
 921
 922         err = qlcnic_issue_cmd(adapter, cmd);
 923         return err;
 924 }
 925
 926 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
 927                                       struct qlcnic_cmd_args *cmd)
 928 {
 929         struct qlcnic_vf_info *vf = trans->vf;
 930         struct qlcnic_adapter *adapter = vf->adapter;
 931         int err = -EIO;
 932         u8 op;
 933
 934         op =  cmd->req.arg[1] & 0xff;
 935
 936         cmd->req.arg[1] |= vf->vp->handle << 16;
 937         cmd->req.arg[1] |= BIT_31;
 938
 939         err = qlcnic_issue_cmd(adapter, cmd);
 940         return err;
 941 }
 942
 943 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
 944                                             struct qlcnic_cmd_args *cmd)
 945 {
 946         if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
 947                 return -EINVAL;
 948
 949         if (!(cmd->req.arg[1] & BIT_16))
 950                 return -EINVAL;
 951
 952         if ((cmd->req.arg[1] & 0xff) != 0x1)
 953                 return -EINVAL;
 954
 955         return 0;
 956 }
 957
 958 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
 959                                           struct qlcnic_cmd_args *cmd)
 960 {
 961         struct qlcnic_vf_info *vf = trans->vf;
 962         struct qlcnic_adapter *adapter = vf->adapter;
 963         int err;
 964
 965         err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
 966         if (err)
 967                 cmd->rsp.arg[0] |= (0x6 << 25);
 968         else
 969                 err = qlcnic_issue_cmd(adapter, cmd);
 970
 971         return err;
 972 }
 973
 974 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
 975                                      struct qlcnic_vf_info *vf,
 976                                      struct qlcnic_cmd_args *cmd)
 977 {
 978         if (cmd->req.arg[1] != vf->rx_ctx_id)
 979                 return -EINVAL;
 980
 981         if (cmd->req.arg[2] > adapter->ahw->max_mtu)
 982                 return -EINVAL;
 983
 984         return 0;
 985 }
 986
 987 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
 988                                        struct qlcnic_cmd_args *cmd)
 989 {
 990         struct qlcnic_vf_info *vf = trans->vf;
 991         struct qlcnic_adapter *adapter = vf->adapter;
 992         int err;
 993
 994         err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
 995         if (err)
 996                 cmd->rsp.arg[0] |= (0x6 << 25);
 997         else
 998                 err = qlcnic_issue_cmd(adapter, cmd);
 999
1000         return err;
1001 }
1002
1003 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1004                                               struct qlcnic_cmd_args *cmd)
1005 {
1006         if (cmd->req.arg[1] & BIT_31) {
1007                 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1008                         return -EINVAL;
1009         } else {
1010                 cmd->req.arg[1] |= vf->vp->handle << 16;
1011         }
1012
1013         return 0;
1014 }
1015
1016 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1017                                             struct qlcnic_cmd_args *cmd)
1018 {
1019         struct qlcnic_vf_info *vf = trans->vf;
1020         struct qlcnic_adapter *adapter = vf->adapter;
1021         int err;
1022
1023         err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1024         if (err) {
1025                 cmd->rsp.arg[0] |= (0x6 << 25);
1026                 return err;
1027         }
1028
1029         err = qlcnic_issue_cmd(adapter, cmd);
1030         return err;
1031 }
1032
1033 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1034                                          struct qlcnic_cmd_args *cmd)
1035 {
1036         if (cmd->req.arg[1] != vf->rx_ctx_id)
1037                 return -EINVAL;
1038
1039         return 0;
1040 }
1041
1042 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1043                                        struct qlcnic_cmd_args *cmd)
1044 {
1045         struct qlcnic_vf_info *vf = trans->vf;
1046         struct qlcnic_adapter *adapter = vf->adapter;
1047         int err;
1048
1049         err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1050         if (err)
1051                 cmd->rsp.arg[0] |= (0x6 << 25);
1052         else
1053                 err = qlcnic_issue_cmd(adapter, cmd);
1054
1055         return err;
1056 }
1057
1058 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1059                                               struct qlcnic_vf_info *vf,
1060                                               struct qlcnic_cmd_args *cmd)
1061 {
1062         struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1063         u16 ctx_id, pkts, time;
1064
1065         ctx_id = cmd->req.arg[1] >> 16;
1066         pkts = cmd->req.arg[2] & 0xffff;
1067         time = cmd->req.arg[2] >> 16;
1068
1069         if (ctx_id != vf->rx_ctx_id)
1070                 return -EINVAL;
1071         if (pkts > coal->rx_packets)
1072                 return -EINVAL;
1073         if (time < coal->rx_time_us)
1074                 return -EINVAL;
1075
1076         return 0;
1077 }
1078
1079 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1080                                             struct qlcnic_cmd_args *cmd)
1081 {
1082         struct qlcnic_vf_info *vf = tran->vf;
1083         struct qlcnic_adapter *adapter = vf->adapter;
1084         int err;
1085
1086         err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1087         if (err) {
1088                 cmd->rsp.arg[0] |= (0x6 << 25);
1089                 return err;
1090         }
1091
1092         err = qlcnic_issue_cmd(adapter, cmd);
1093         return err;
1094 }
1095
1096 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1097                                              struct qlcnic_vf_info *vf,
1098                                              struct qlcnic_cmd_args *cmd)
1099 {
1100         struct qlcnic_macvlan_mbx *macvlan;
1101         struct qlcnic_vport *vp = vf->vp;
1102         u8 op, new_op;
1103
1104         if (!(cmd->req.arg[1] & BIT_8))
1105                 return -EINVAL;
1106
1107         cmd->req.arg[1] |= (vf->vp->handle << 16);
1108         cmd->req.arg[1] |= BIT_31;
1109
1110         macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1111         if (!(macvlan->mac_addr0 & BIT_0)) {
1112                 dev_err(&adapter->pdev->dev,
1113                         "MAC address change is not allowed from VF %d",
1114                         vf->pci_func);
1115                 return -EINVAL;
1116         }
1117
1118         if (vp->vlan_mode == QLC_PVID_MODE) {
1119                 op = cmd->req.arg[1] & 0x7;
1120                 cmd->req.arg[1] &= ~0x7;
1121                 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1122                          QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1123                 cmd->req.arg[3] |= vp->vlan << 16;
1124                 cmd->req.arg[1] |= new_op;
1125         }
1126
1127         return 0;
1128 }
1129
1130 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1131                                            struct qlcnic_cmd_args *cmd)
1132 {
1133         struct qlcnic_vf_info *vf = trans->vf;
1134         struct qlcnic_adapter *adapter = vf->adapter;
1135         int err;
1136
1137         err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1138         if (err) {
1139                 cmd->rsp.arg[0] |= (0x6 << 25);
1140                 return err;
1141         }
1142
1143         err = qlcnic_issue_cmd(adapter, cmd);
1144         return err;
1145 }
1146
1147 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1148                                            struct qlcnic_cmd_args *cmd)
1149 {
1150         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1151                 return -EINVAL;
1152
1153         return 0;
1154 }
1155
1156 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1157                                          struct qlcnic_cmd_args *cmd)
1158 {
1159         struct qlcnic_vf_info *vf = trans->vf;
1160         struct qlcnic_adapter *adapter = vf->adapter;
1161         int err;
1162
1163         err = qlcnic_sriov_validate_linkevent(vf, cmd);
1164         if (err) {
1165                 cmd->rsp.arg[0] |= (0x6 << 25);
1166                 return err;
1167         }
1168
1169         err = qlcnic_issue_cmd(adapter, cmd);
1170         return err;
1171 }
1172
1173 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1174                                            struct qlcnic_cmd_args *cmd)
1175 {
1176         struct qlcnic_vf_info *vf = trans->vf;
1177         struct qlcnic_adapter *adapter = vf->adapter;
1178         int err;
1179
1180         cmd->req.arg[1] |= vf->vp->handle << 16;
1181         cmd->req.arg[1] |= BIT_31;
1182         err = qlcnic_issue_cmd(adapter, cmd);
1183         return err;
1184 }
1185
1186 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1187                                        struct qlcnic_cmd_args *cmd)
1188 {
1189         struct qlcnic_vf_info *vf = trans->vf;
1190         struct qlcnic_vport *vp = vf->vp;
1191         u8 cmd_op, mode = vp->vlan_mode;
1192         struct qlcnic_adapter *adapter;
1193
1194         adapter = vf->adapter;
1195
1196         cmd_op = trans->req_hdr->cmd_op;
1197         cmd->rsp.arg[0] |= 1 << 25;
1198
1199         /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1200          * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1201          */
1202         if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1203                 return 0;
1204
1205         switch (mode) {
1206         case QLC_GUEST_VLAN_MODE:
1207                 cmd->rsp.arg[1] = mode | 1 << 8;
1208                 cmd->rsp.arg[2] = 1 << 16;
1209                 break;
1210         case QLC_PVID_MODE:
1211                 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16;
1212                 break;
1213         }
1214
1215         return 0;
1216 }
1217
1218 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1219                                           struct qlcnic_vf_info *vf)
1220
1221 {
1222         struct qlcnic_vport *vp = vf->vp;
1223
1224         if (!vp->vlan)
1225                 return -EINVAL;
1226
1227         if (!vf->rx_ctx_id) {
1228                 vp->vlan = 0;
1229                 return 0;
1230         }
1231
1232         qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1233                                     vp->vlan, QLCNIC_MAC_DEL);
1234         vp->vlan = 0;
1235         qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1236                                     0, QLCNIC_MAC_ADD);
1237         return 0;
1238 }
1239
1240 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1241                                           struct qlcnic_vf_info *vf,
1242                                           struct qlcnic_cmd_args *cmd)
1243 {
1244         struct qlcnic_vport *vp = vf->vp;
1245         int err = -EIO;
1246
1247         if (vp->vlan)
1248                 return err;
1249
1250         if (!vf->rx_ctx_id) {
1251                 vp->vlan = cmd->req.arg[1] >> 16;
1252                 return 0;
1253         }
1254
1255         err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1256                                           0, QLCNIC_MAC_DEL);
1257         if (err)
1258                 return err;
1259
1260         vp->vlan = cmd->req.arg[1] >> 16;
1261         err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1262                                           vp->vlan, QLCNIC_MAC_ADD);
1263
1264         if (err) {
1265                 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1266                                             0, QLCNIC_MAC_ADD);
1267                 vp->vlan = 0;
1268         }
1269
1270         return err;
1271 }
1272
1273 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1274                                               struct qlcnic_cmd_args *cmd)
1275 {
1276         struct qlcnic_vf_info  *vf = tran->vf;
1277         struct qlcnic_adapter *adapter =  vf->adapter;
1278         struct qlcnic_vport *vp = vf->vp;
1279         int err = -EIO;
1280         u8 op;
1281
1282         if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1283                 cmd->rsp.arg[0] |= 2 << 25;
1284                 return err;
1285         }
1286
1287         op = cmd->req.arg[1] & 0xf;
1288
1289         if (op)
1290                 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1291         else
1292                 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf);
1293
1294         cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1295         return err;
1296 }
1297
1298 static const int qlcnic_pf_passthru_supp_cmds[] = {
1299         QLCNIC_CMD_GET_STATISTICS,
1300         QLCNIC_CMD_GET_PORT_CONFIG,
1301         QLCNIC_CMD_GET_LINK_STATUS,
1302         QLCNIC_CMD_DCB_QUERY_CAP,
1303         QLCNIC_CMD_DCB_QUERY_PARAM,
1304         QLCNIC_CMD_INIT_NIC_FUNC,
1305         QLCNIC_CMD_STOP_NIC_FUNC,
1306 };
1307
1308 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1309         [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1310         [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1311         [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1312         [QLCNIC_BC_CMD_CFG_GUEST_VLAN]  = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1313 };
1314
1315 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1316         {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1317         {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1318         {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1319         {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1320         {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1321         {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1322         {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1323         {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1324         {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1325         {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1326         {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1327         {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1328         {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1329         {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1330         {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1331 };
1332
1333 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1334                                     struct qlcnic_bc_trans *trans,
1335                                     struct qlcnic_cmd_args *cmd)
1336 {
1337         u8 size, cmd_op;
1338
1339         cmd_op = trans->req_hdr->cmd_op;
1340
1341         if (trans->req_hdr->op_type == QLC_BC_CMD) {
1342                 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1343                 if (cmd_op < size) {
1344                         qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1345                         return;
1346                 }
1347         } else {
1348                 int i;
1349                 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1350                 for (i = 0; i < size; i++) {
1351                         if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1352                                 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1353                                 return;
1354                         }
1355                 }
1356
1357                 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1358                 for (i = 0; i < size; i++) {
1359                         if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1360                                 qlcnic_issue_cmd(adapter, cmd);
1361                                 return;
1362                         }
1363                 }
1364         }
1365
1366         cmd->rsp.arg[0] |= (0x9 << 25);
1367 }
1368
1369 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1370                                              u32 *int_id)
1371 {
1372         u16 vpid;
1373
1374         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1375                                                 adapter->ahw->pci_func);
1376         *int_id |= vpid;
1377 }
1378
1379 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1380                                            u32 *int_id)
1381 {
1382         u16 vpid;
1383
1384         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1385                                                 adapter->ahw->pci_func);
1386         *int_id |= vpid << 16;
1387 }
1388
1389 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1390                                               u32 *int_id)
1391 {
1392         int vpid;
1393
1394         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1395                                                 adapter->ahw->pci_func);
1396         *int_id |= vpid << 16;
1397 }
1398
1399 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1400                                            u32 *int_id)
1401 {
1402         u16 vpid;
1403
1404         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1405                                                 adapter->ahw->pci_func);
1406         *int_id |= vpid << 16;
1407 }
1408
1409 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1410                                         u32 *int_id)
1411 {
1412         u16 vpid;
1413
1414         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1415                                                 adapter->ahw->pci_func);
1416         *int_id |= (vpid << 16) | BIT_31;
1417 }
1418
1419 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1420                                        u32 *int_id)
1421 {
1422         u16 vpid;
1423
1424         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1425                                                 adapter->ahw->pci_func);
1426         *int_id |= (vpid << 16) | BIT_31;
1427 }
1428
1429 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1430                                         u32 *int_id)
1431 {
1432         u16 vpid;
1433
1434         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1435                                                 adapter->ahw->pci_func);
1436         *int_id |= (vpid << 16) | BIT_31;
1437 }
1438
1439 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1440                                     struct qlcnic_vf_info *vf)
1441 {
1442         struct qlcnic_cmd_args cmd;
1443         int vpid;
1444
1445         if (!vf->rx_ctx_id)
1446                 return;
1447
1448         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1449                 return;
1450
1451         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1452         if (vpid >= 0) {
1453                 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1454                 if (qlcnic_issue_cmd(adapter, &cmd))
1455                         dev_err(&adapter->pdev->dev,
1456                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1457                                 vf->pci_func);
1458                 else
1459                         vf->rx_ctx_id = 0;
1460         }
1461
1462         qlcnic_free_mbx_args(&cmd);
1463 }
1464
1465 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1466                                     struct qlcnic_vf_info *vf)
1467 {
1468         struct qlcnic_cmd_args cmd;
1469         int vpid;
1470
1471         if (!vf->tx_ctx_id)
1472                 return;
1473
1474         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1475                 return;
1476
1477         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1478         if (vpid >= 0) {
1479                 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1480                 if (qlcnic_issue_cmd(adapter, &cmd))
1481                         dev_err(&adapter->pdev->dev,
1482                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1483                                 vf->pci_func);
1484                 else
1485                         vf->tx_ctx_id = 0;
1486         }
1487
1488         qlcnic_free_mbx_args(&cmd);
1489 }
1490
1491 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1492                                              struct qlcnic_vf_info *vf,
1493                                              struct qlcnic_bc_trans *trans)
1494 {
1495         struct qlcnic_trans_list *t_list = &vf->rcv_act;
1496         unsigned long flag;
1497
1498         spin_lock_irqsave(&t_list->lock, flag);
1499
1500         __qlcnic_sriov_add_act_list(sriov, vf, trans);
1501
1502         spin_unlock_irqrestore(&t_list->lock, flag);
1503         return 0;
1504 }
1505
1506 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1507 {
1508         struct qlcnic_adapter *adapter = vf->adapter;
1509
1510         qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1511         cancel_work_sync(&vf->trans_work);
1512         qlcnic_sriov_cleanup_list(&vf->rcv_act);
1513
1514         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1515                 qlcnic_sriov_del_tx_ctx(adapter, vf);
1516                 qlcnic_sriov_del_rx_ctx(adapter, vf);
1517         }
1518
1519         qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1520
1521         clear_bit(QLC_BC_VF_FLR, &vf->state);
1522         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1523                 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1524                                                   vf->flr_trans);
1525                 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1526                 vf->flr_trans = NULL;
1527         }
1528 }
1529
1530 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1531 {
1532         struct qlcnic_vf_info *vf;
1533
1534         vf = container_of(work, struct qlcnic_vf_info, flr_work);
1535         __qlcnic_sriov_process_flr(vf);
1536         return;
1537 }
1538
1539 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1540                                       struct qlcnic_vf_info *vf,
1541                                       work_func_t func)
1542 {
1543         if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1544                 return;
1545
1546         INIT_WORK(&vf->flr_work, func);
1547         queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1548 }
1549
1550 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1551                                          struct qlcnic_bc_trans *trans,
1552                                          struct qlcnic_vf_info *vf)
1553 {
1554         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1555
1556         set_bit(QLC_BC_VF_FLR, &vf->state);
1557         clear_bit(QLC_BC_VF_STATE, &vf->state);
1558         set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1559         vf->flr_trans = trans;
1560         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1561         netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1562                     vf->pci_func);
1563 }
1564
1565 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1566                                  struct qlcnic_bc_trans *trans,
1567                                  struct qlcnic_vf_info *vf)
1568 {
1569         struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1570
1571         if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1572             (hdr->op_type == QLC_BC_CMD) &&
1573              test_bit(QLC_BC_VF_STATE, &vf->state)) {
1574                 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1575                 return true;
1576         }
1577
1578         return false;
1579 }
1580
1581 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1582                                 struct qlcnic_vf_info *vf)
1583 {
1584         struct net_device *dev = vf->adapter->netdev;
1585         struct qlcnic_vport *vp = vf->vp;
1586
1587         if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1588                 clear_bit(QLC_BC_VF_FLR, &vf->state);
1589                 return;
1590         }
1591
1592         if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1593                 netdev_info(dev, "FLR for PCI func %d in progress\n",
1594                             vf->pci_func);
1595                 return;
1596         }
1597
1598         if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1599                 vp->vlan = 0;
1600
1601         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1602         netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1603 }
1604
1605 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1606 {
1607         struct qlcnic_hardware_context *ahw = adapter->ahw;
1608         struct qlcnic_sriov *sriov = ahw->sriov;
1609         struct qlcnic_vf_info *vf;
1610         u16 num_vfs = sriov->num_vfs;
1611         int i;
1612
1613         for (i = 0; i < num_vfs; i++) {
1614                 vf = &sriov->vf_info[i];
1615                 vf->rx_ctx_id = 0;
1616                 vf->tx_ctx_id = 0;
1617                 cancel_work_sync(&vf->flr_work);
1618                 __qlcnic_sriov_process_flr(vf);
1619                 clear_bit(QLC_BC_VF_STATE, &vf->state);
1620         }
1621
1622         qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1623         QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1624 }
1625
1626 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1627 {
1628         struct qlcnic_hardware_context *ahw = adapter->ahw;
1629         int err;
1630
1631         if (!qlcnic_sriov_enable_check(adapter))
1632                 return 0;
1633
1634         ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1635
1636         err = qlcnic_sriov_pf_init(adapter);
1637         if (err)
1638                 return err;
1639
1640         dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1641                  __func__, ahw->op_mode);
1642         return err;
1643 }
1644
1645 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1646 {
1647         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1648         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1649         int i, num_vfs;
1650         struct qlcnic_vf_info *vf_info;
1651         u8 *curr_mac;
1652
1653         if (!qlcnic_sriov_pf_check(adapter))
1654                 return -EOPNOTSUPP;
1655
1656         num_vfs = sriov->num_vfs;
1657
1658         if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1659                 return -EINVAL;
1660
1661         if (ether_addr_equal(adapter->mac_addr, mac)) {
1662                 netdev_err(netdev, "MAC address is already in use by the PF\n");
1663                 return -EINVAL;
1664         }
1665
1666         for (i = 0; i < num_vfs; i++) {
1667                 vf_info = &sriov->vf_info[i];
1668                 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1669                         netdev_err(netdev,
1670                                    "MAC address is already in use by VF %d\n",
1671                                    i);
1672                         return -EINVAL;
1673                 }
1674         }
1675
1676         vf_info = &sriov->vf_info[vf];
1677         curr_mac = vf_info->vp->mac;
1678
1679         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1680                 netdev_err(netdev,
1681                            "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1682                            vf);
1683                 return -EOPNOTSUPP;
1684         }
1685
1686         memcpy(curr_mac, mac, netdev->addr_len);
1687         netdev_info(netdev, "MAC Address %pM  is configured for VF %d\n",
1688                     mac, vf);
1689         return 0;
1690 }
1691
1692 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1693 {
1694         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1695         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1696         struct qlcnic_vf_info *vf_info;
1697         struct qlcnic_info nic_info;
1698         struct qlcnic_vport *vp;
1699         u16 vpid;
1700
1701         if (!qlcnic_sriov_pf_check(adapter))
1702                 return -EOPNOTSUPP;
1703
1704         if (vf >= sriov->num_vfs)
1705                 return -EINVAL;
1706
1707         if (tx_rate >= 10000 || tx_rate < 100) {
1708                 netdev_err(netdev,
1709                            "Invalid Tx rate, allowed range is [%d - %d]",
1710                            QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1711                 return -EINVAL;
1712         }
1713
1714         if (tx_rate == 0)
1715                 tx_rate = 10000;
1716
1717         vf_info = &sriov->vf_info[vf];
1718         vp = vf_info->vp;
1719         vpid = vp->handle;
1720
1721         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1722                 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1723                         return -EIO;
1724
1725                 nic_info.max_tx_bw = tx_rate / 100;
1726                 nic_info.bit_offsets = BIT_0;
1727
1728                 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1729                         return -EIO;
1730         }
1731
1732         vp->max_tx_bw = tx_rate / 100;
1733         netdev_info(netdev,
1734                     "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1735                     tx_rate, vp->max_tx_bw, vf);
1736         return 0;
1737 }
1738
1739 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1740                              u16 vlan, u8 qos)
1741 {
1742         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1743         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1744         struct qlcnic_vf_info *vf_info;
1745         struct qlcnic_vport *vp;
1746
1747         if (!qlcnic_sriov_pf_check(adapter))
1748                 return -EOPNOTSUPP;
1749
1750         if (vf >= sriov->num_vfs || qos > 7)
1751                 return -EINVAL;
1752
1753         if (vlan > MAX_VLAN_ID) {
1754                 netdev_err(netdev,
1755                            "Invalid VLAN ID, allowed range is [0 - %d]\n",
1756                            MAX_VLAN_ID);
1757                 return -EINVAL;
1758         }
1759
1760         vf_info = &sriov->vf_info[vf];
1761         vp = vf_info->vp;
1762         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1763                 netdev_err(netdev,
1764                            "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1765                            vf);
1766                 return -EOPNOTSUPP;
1767         }
1768
1769         switch (vlan) {
1770         case 4095:
1771                 vp->vlan = 0;
1772                 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1773                 break;
1774         case 0:
1775                 vp->vlan_mode = QLC_NO_VLAN_MODE;
1776                 vp->vlan = 0;
1777                 vp->qos = 0;
1778                 break;
1779         default:
1780                 vp->vlan_mode = QLC_PVID_MODE;
1781                 vp->vlan = vlan;
1782                 vp->qos = qos;
1783         }
1784
1785         netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1786                     vlan, qos, vf);
1787         return 0;
1788 }
1789
1790 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1791                                       struct qlcnic_vport *vp, int vf)
1792 {
1793         __u32 vlan = 0;
1794
1795         switch (vp->vlan_mode) {
1796         case QLC_PVID_MODE:
1797                 vlan = vp->vlan;
1798                 break;
1799         case QLC_GUEST_VLAN_MODE:
1800                 vlan = MAX_VLAN_ID;
1801                 break;
1802         case QLC_NO_VLAN_MODE:
1803                 vlan = 0;
1804                 break;
1805         default:
1806                 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1807                             vp->vlan_mode, vf);
1808         }
1809
1810         return vlan;
1811 }
1812
1813 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1814                                int vf, struct ifla_vf_info *ivi)
1815 {
1816         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1817         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1818         struct qlcnic_vport *vp;
1819
1820         if (!qlcnic_sriov_pf_check(adapter))
1821                 return -EOPNOTSUPP;
1822
1823         if (vf >= sriov->num_vfs)
1824                 return -EINVAL;
1825
1826         vp = sriov->vf_info[vf].vp;
1827         memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1828         ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1829         ivi->qos = vp->qos;
1830         ivi->spoofchk = vp->spoofchk;
1831         if (vp->max_tx_bw == MAX_BW)
1832                 ivi->tx_rate = 0;
1833         else
1834                 ivi->tx_rate = vp->max_tx_bw * 100;
1835
1836         ivi->vf = vf;
1837         return 0;
1838 }
1839
1840 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1841 {
1842         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1843         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1844         struct qlcnic_vf_info *vf_info;
1845         struct qlcnic_vport *vp;
1846
1847         if (!qlcnic_sriov_pf_check(adapter))
1848                 return -EOPNOTSUPP;
1849
1850         if (vf >= sriov->num_vfs)
1851                 return -EINVAL;
1852
1853         vf_info = &sriov->vf_info[vf];
1854         vp = vf_info->vp;
1855         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1856                 netdev_err(netdev,
1857                            "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1858                            vf);
1859                 return -EOPNOTSUPP;
1860         }
1861
1862         vp->spoofchk = chk;
1863         return 0;
1864 }