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