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