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