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