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