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         rtnl_lock();
 465         if (netif_running(netdev))
 466                 __qlcnic_down(adapter, netdev);
 467
 468         qlcnic_sriov_pf_disable(adapter);
 469
 470         qlcnic_sriov_free_vlans(adapter);
 471
 472         qlcnic_sriov_pf_cleanup(adapter);
 473
 474         /* After disabling SRIOV re-init the driver in default mode
 475            configure opmode based on op_mode of function
 476          */
 477         if (qlcnic_83xx_configure_opmode(adapter)) {
 478                 rtnl_unlock();
 479                 return -EIO;
 480         }
 481
 482         if (netif_running(netdev))
 483                 __qlcnic_up(adapter, netdev);
 484
 485         rtnl_unlock();
 486         return 0;
 487 }
 488
 489 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
 490 {
 491         struct qlcnic_hardware_context *ahw = adapter->ahw;
 492         struct qlcnic_info nic_info, pf_info, vp_info;
 493         int err;
 494         u8 func = ahw->pci_func;
 495
 496         if (!qlcnic_sriov_enable_check(adapter))
 497                 return 0;
 498
 499         err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
 500         if (err)
 501                 return err;
 502
 503         if (qlcnic_84xx_check(adapter)) {
 504                 err = qlcnic_sriov_pf_cfg_flood(adapter);
 505                 if (err)
 506                         goto disable_vlan_filtering;
 507         }
 508
 509         err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
 510         if (err)
 511                 goto disable_vlan_filtering;
 512
 513         err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 514         if (err)
 515                 goto disable_eswitch;
 516
 517         err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
 518         if (err)
 519                 goto delete_vport;
 520
 521         err = qlcnic_get_nic_info(adapter, &nic_info, func);
 522         if (err)
 523                 goto delete_vport;
 524
 525         err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
 526         if (err)
 527                 goto delete_vport;
 528
 529         err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
 530         if (err)
 531                 goto delete_vport;
 532
 533         ahw->physical_port = (u8) nic_info.phys_port;
 534         ahw->switch_mode = nic_info.switch_mode;
 535         ahw->max_mtu = nic_info.max_mtu;
 536         ahw->capabilities = nic_info.capabilities;
 537         ahw->nic_mode = QLC_83XX_SRIOV_MODE;
 538         return err;
 539
 540 delete_vport:
 541         qlcnic_sriov_pf_config_vport(adapter, 0, func);
 542
 543 disable_eswitch:
 544         qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
 545
 546 disable_vlan_filtering:
 547         qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
 548
 549         return err;
 550 }
 551
 552 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
 553 {
 554         int err;
 555
 556         if (!qlcnic_sriov_enable_check(adapter))
 557                 return 0;
 558
 559         err = pci_enable_sriov(adapter->pdev, num_vfs);
 560         if (err)
 561                 qlcnic_sriov_pf_cleanup(adapter);
 562
 563         return err;
 564 }
 565
 566 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
 567                                      int num_vfs)
 568 {
 569         int err = 0;
 570
 571         set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 572         adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
 573
 574         err = qlcnic_sriov_init(adapter, num_vfs);
 575         if (err)
 576                 goto clear_op_mode;
 577
 578         err = qlcnic_sriov_pf_create_flr_queue(adapter);
 579         if (err)
 580                 goto sriov_cleanup;
 581
 582         err = qlcnic_sriov_pf_init(adapter);
 583         if (err)
 584                 goto del_flr_queue;
 585
 586         qlcnic_sriov_alloc_vlans(adapter);
 587
 588         err = qlcnic_sriov_pf_enable(adapter, num_vfs);
 589         return err;
 590
 591 del_flr_queue:
 592         qlcnic_sriov_pf_del_flr_queue(adapter);
 593
 594 sriov_cleanup:
 595         __qlcnic_sriov_cleanup(adapter);
 596
 597 clear_op_mode:
 598         clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
 599         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
 600         return err;
 601 }
 602
 603 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
 604 {
 605         struct net_device *netdev = adapter->netdev;
 606         int err;
 607
 608         if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
 609                 netdev_err(netdev,
 610                            "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
 611                 return -EIO;
 612         }
 613
 614         rtnl_lock();
 615         if (netif_running(netdev))
 616                 __qlcnic_down(adapter, netdev);
 617
 618         err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
 619         if (err) {
 620                 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
 621                             adapter->portnum);
 622
 623                 err = -EIO;
 624                 if (qlcnic_83xx_configure_opmode(adapter))
 625                         goto error;
 626         } else {
 627                 netdev_info(netdev,
 628                             "SR-IOV is enabled successfully on port %d\n",
 629                             adapter->portnum);
 630                 /* Return number of vfs enabled */
 631                 err = num_vfs;
 632         }
 633         if (netif_running(netdev))
 634                 __qlcnic_up(adapter, netdev);
 635
 636 error:
 637         rtnl_unlock();
 638         return err;
 639 }
 640
 641 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
 642 {
 643         struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
 644         int err;
 645
 646         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 647                 return -EBUSY;
 648
 649         if (num_vfs == 0)
 650                 err = qlcnic_pci_sriov_disable(adapter);
 651         else
 652                 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
 653
 654         clear_bit(__QLCNIC_RESETTING, &adapter->state);
 655         return err;
 656 }
 657
 658 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
 659 {
 660         struct qlcnic_cmd_args cmd;
 661         struct qlcnic_vport *vp;
 662         int err, id;
 663         u8 *mac;
 664
 665         id = qlcnic_sriov_func_to_index(adapter, func);
 666         if (id < 0)
 667                 return id;
 668
 669         vp = adapter->ahw->sriov->vf_info[id].vp;
 670         err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
 671         if (err)
 672                 return err;
 673
 674         cmd.req.arg[1] = 0x3 | func << 16;
 675         if (vp->spoofchk == true) {
 676                 mac = vp->mac;
 677                 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
 678                 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
 679                                  mac[2] << 24;
 680                 cmd.req.arg[5] = mac[1] | mac[0] << 8;
 681         }
 682
 683         if (vp->vlan_mode == QLC_PVID_MODE) {
 684                 cmd.req.arg[2] |= BIT_6;
 685                 cmd.req.arg[3] |= vp->pvid << 8;
 686         }
 687
 688         err = qlcnic_issue_cmd(adapter, &cmd);
 689         if (err)
 690                 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
 691                         err);
 692
 693         qlcnic_free_mbx_args(&cmd);
 694         return err;
 695 }
 696
 697 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
 698                                           u16 func)
 699 {
 700         struct qlcnic_info defvp_info;
 701         int err;
 702
 703         err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
 704         if (err)
 705                 return -EIO;
 706
 707         err = qlcnic_sriov_set_vf_acl(adapter, func);
 708         if (err)
 709                 return err;
 710
 711         return 0;
 712 }
 713
 714 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
 715                                            struct qlcnic_cmd_args *cmd)
 716 {
 717         struct qlcnic_vf_info *vf = trans->vf;
 718         struct qlcnic_vport *vp = vf->vp;
 719         struct qlcnic_adapter *adapter;
 720         struct qlcnic_sriov *sriov;
 721         u16 func = vf->pci_func;
 722         size_t size;
 723         int err;
 724
 725         adapter = vf->adapter;
 726         sriov = adapter->ahw->sriov;
 727
 728         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
 729                 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
 730                 if (!err) {
 731                         err = qlcnic_sriov_set_vf_vport_info(adapter, func);
 732                         if (err)
 733                                 qlcnic_sriov_pf_config_vport(adapter, 0, func);
 734                 }
 735         } else {
 736                 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) {
 737                         size = sizeof(*vf->sriov_vlans);
 738                         size = size * sriov->num_allowed_vlans;
 739                         memset(vf->sriov_vlans, 0, size);
 740                 }
 741
 742                 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
 743         }
 744
 745         if (err)
 746                 goto err_out;
 747
 748         cmd->rsp.arg[0] |= (1 << 25);
 749
 750         if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
 751                 set_bit(QLC_BC_VF_STATE, &vf->state);
 752         else
 753                 clear_bit(QLC_BC_VF_STATE, &vf->state);
 754
 755         return err;
 756
 757 err_out:
 758         cmd->rsp.arg[0] |= (2 << 25);
 759         return err;
 760 }
 761
 762 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
 763                                        struct qlcnic_vf_info *vf,
 764                                        u16 vlan, u8 op)
 765 {
 766         struct qlcnic_cmd_args cmd;
 767         struct qlcnic_macvlan_mbx mv;
 768         struct qlcnic_vport *vp;
 769         u8 *addr;
 770         int err;
 771         u32 *buf;
 772         int vpid;
 773
 774         vp = vf->vp;
 775
 776         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
 777                 return -ENOMEM;
 778
 779         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
 780         if (vpid < 0) {
 781                 err = -EINVAL;
 782                 goto out;
 783         }
 784
 785         if (vlan)
 786                 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
 787                       QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
 788
 789         cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
 790         cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
 791
 792         addr = vp->mac;
 793         mv.vlan = vlan;
 794         mv.mac_addr0 = addr[0];
 795         mv.mac_addr1 = addr[1];
 796         mv.mac_addr2 = addr[2];
 797         mv.mac_addr3 = addr[3];
 798         mv.mac_addr4 = addr[4];
 799         mv.mac_addr5 = addr[5];
 800         buf = &cmd.req.arg[2];
 801         memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
 802
 803         err = qlcnic_issue_cmd(adapter, &cmd);
 804
 805         if (err)
 806                 dev_err(&adapter->pdev->dev,
 807                         "MAC-VLAN %s to CAM failed, err=%d.\n",
 808                         ((op == 1) ? "add " : "delete "), err);
 809
 810 out:
 811         qlcnic_free_mbx_args(&cmd);
 812         return err;
 813 }
 814
 815 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
 816 {
 817         if ((cmd->req.arg[0] >> 29) != 0x3)
 818                 return -EINVAL;
 819
 820         return 0;
 821 }
 822
 823 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter,
 824                                              struct qlcnic_vf_info *vf,
 825                                              int opcode)
 826 {
 827         struct qlcnic_sriov *sriov;
 828         u16 vlan;
 829         int i;
 830
 831         sriov = adapter->ahw->sriov;
 832
 833         mutex_lock(&vf->vlan_list_lock);
 834         if (vf->num_vlan) {
 835                 for (i = 0; i < sriov->num_allowed_vlans; i++) {
 836                         vlan = vf->sriov_vlans[i];
 837                         if (vlan)
 838                                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan,
 839                                                             opcode);
 840                 }
 841         }
 842         mutex_unlock(&vf->vlan_list_lock);
 843
 844         if (vf->vp->vlan_mode != QLC_PVID_MODE) {
 845                 if (qlcnic_83xx_pf_check(adapter) &&
 846                     qlcnic_sriov_check_any_vlan(vf))
 847                         return;
 848                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode);
 849         }
 850 }
 851
 852 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
 853                                              struct qlcnic_cmd_args *cmd)
 854 {
 855         struct qlcnic_vf_info *vf = tran->vf;
 856         struct qlcnic_adapter *adapter = vf->adapter;
 857         struct qlcnic_rcv_mbx_out *mbx_out;
 858         int err;
 859
 860         err = qlcnic_sriov_validate_create_rx_ctx(cmd);
 861         if (err) {
 862                 cmd->rsp.arg[0] |= (0x6 << 25);
 863                 return err;
 864         }
 865
 866         cmd->req.arg[6] = vf->vp->handle;
 867         err = qlcnic_issue_cmd(adapter, cmd);
 868
 869         if (!err) {
 870                 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
 871                 vf->rx_ctx_id = mbx_out->ctx_id;
 872                 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD);
 873         } else {
 874                 vf->rx_ctx_id = 0;
 875         }
 876
 877         return err;
 878 }
 879
 880 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
 881                                            struct qlcnic_cmd_args *cmd)
 882 {
 883         struct qlcnic_vf_info *vf = trans->vf;
 884         u8 type, *mac;
 885
 886         type = cmd->req.arg[1];
 887         switch (type) {
 888         case QLCNIC_SET_STATION_MAC:
 889         case QLCNIC_SET_FAC_DEF_MAC:
 890                 cmd->rsp.arg[0] = (2 << 25);
 891                 break;
 892         case QLCNIC_GET_CURRENT_MAC:
 893                 cmd->rsp.arg[0] = (1 << 25);
 894                 mac = vf->vp->mac;
 895                 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
 896                 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
 897                                   ((mac[3]) << 16 & 0xff0000) |
 898                                   ((mac[2]) << 24 & 0xff000000);
 899         }
 900
 901         return 0;
 902 }
 903
 904 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
 905 {
 906         if ((cmd->req.arg[0] >> 29) != 0x3)
 907                 return -EINVAL;
 908
 909         return 0;
 910 }
 911
 912 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 913                                              struct qlcnic_cmd_args *cmd)
 914 {
 915         struct qlcnic_vf_info *vf = trans->vf;
 916         struct qlcnic_adapter *adapter = vf->adapter;
 917         struct qlcnic_tx_mbx_out *mbx_out;
 918         int err;
 919
 920         err = qlcnic_sriov_validate_create_tx_ctx(cmd);
 921         if (err) {
 922                 cmd->rsp.arg[0] |= (0x6 << 25);
 923                 return err;
 924         }
 925
 926         cmd->req.arg[5] |= vf->vp->handle << 16;
 927         err = qlcnic_issue_cmd(adapter, cmd);
 928         if (!err) {
 929                 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
 930                 vf->tx_ctx_id = mbx_out->ctx_id;
 931         } else {
 932                 vf->tx_ctx_id = 0;
 933         }
 934
 935         return err;
 936 }
 937
 938 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
 939                                             struct qlcnic_cmd_args *cmd)
 940 {
 941         if ((cmd->req.arg[0] >> 29) != 0x3)
 942                 return -EINVAL;
 943
 944         if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
 945                 return -EINVAL;
 946
 947         return 0;
 948 }
 949
 950 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
 951                                           struct qlcnic_cmd_args *cmd)
 952 {
 953         struct qlcnic_vf_info *vf = trans->vf;
 954         struct qlcnic_adapter *adapter = vf->adapter;
 955         int err;
 956
 957         err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
 958         if (err) {
 959                 cmd->rsp.arg[0] |= (0x6 << 25);
 960                 return err;
 961         }
 962
 963         qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL);
 964         cmd->req.arg[1] |= vf->vp->handle << 16;
 965         err = qlcnic_issue_cmd(adapter, cmd);
 966
 967         if (!err)
 968                 vf->rx_ctx_id = 0;
 969
 970         return err;
 971 }
 972
 973 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
 974                                             struct qlcnic_cmd_args *cmd)
 975 {
 976         if ((cmd->req.arg[0] >> 29) != 0x3)
 977                 return -EINVAL;
 978
 979         if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
 980                 return -EINVAL;
 981
 982         return 0;
 983 }
 984
 985 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
 986                                           struct qlcnic_cmd_args *cmd)
 987 {
 988         struct qlcnic_vf_info *vf = trans->vf;
 989         struct qlcnic_adapter *adapter = vf->adapter;
 990         int err;
 991
 992         err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
 993         if (err) {
 994                 cmd->rsp.arg[0] |= (0x6 << 25);
 995                 return err;
 996         }
 997
 998         cmd->req.arg[1] |= vf->vp->handle << 16;
 999         err = qlcnic_issue_cmd(adapter, cmd);
1000
1001         if (!err)
1002                 vf->tx_ctx_id = 0;
1003
1004         return err;
1005 }
1006
1007 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
1008                                          struct qlcnic_cmd_args *cmd)
1009 {
1010         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1011                 return -EINVAL;
1012
1013         return 0;
1014 }
1015
1016 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
1017                                        struct qlcnic_cmd_args *cmd)
1018 {
1019         struct qlcnic_vf_info *vf = trans->vf;
1020         struct qlcnic_adapter *adapter = vf->adapter;
1021         int err;
1022
1023         err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
1024         if (err) {
1025                 cmd->rsp.arg[0] |= (0x6 << 25);
1026                 return err;
1027         }
1028
1029         err = qlcnic_issue_cmd(adapter, cmd);
1030         return err;
1031 }
1032
1033 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
1034                                       struct qlcnic_cmd_args *cmd)
1035 {
1036         struct qlcnic_vf_info *vf = trans->vf;
1037         struct qlcnic_adapter *adapter = vf->adapter;
1038         int err = -EIO;
1039         u8 op;
1040
1041         op =  cmd->req.arg[1] & 0xff;
1042
1043         cmd->req.arg[1] |= vf->vp->handle << 16;
1044         cmd->req.arg[1] |= BIT_31;
1045
1046         err = qlcnic_issue_cmd(adapter, cmd);
1047         return err;
1048 }
1049
1050 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
1051                                             struct qlcnic_cmd_args *cmd)
1052 {
1053         if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
1054                 return -EINVAL;
1055
1056         if (!(cmd->req.arg[1] & BIT_16))
1057                 return -EINVAL;
1058
1059         if ((cmd->req.arg[1] & 0xff) != 0x1)
1060                 return -EINVAL;
1061
1062         return 0;
1063 }
1064
1065 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
1066                                           struct qlcnic_cmd_args *cmd)
1067 {
1068         struct qlcnic_vf_info *vf = trans->vf;
1069         struct qlcnic_adapter *adapter = vf->adapter;
1070         int err;
1071
1072         err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
1073         if (err)
1074                 cmd->rsp.arg[0] |= (0x6 << 25);
1075         else
1076                 err = qlcnic_issue_cmd(adapter, cmd);
1077
1078         return err;
1079 }
1080
1081 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
1082                                      struct qlcnic_vf_info *vf,
1083                                      struct qlcnic_cmd_args *cmd)
1084 {
1085         if (cmd->req.arg[1] != vf->rx_ctx_id)
1086                 return -EINVAL;
1087
1088         if (cmd->req.arg[2] > adapter->ahw->max_mtu)
1089                 return -EINVAL;
1090
1091         return 0;
1092 }
1093
1094 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
1095                                        struct qlcnic_cmd_args *cmd)
1096 {
1097         struct qlcnic_vf_info *vf = trans->vf;
1098         struct qlcnic_adapter *adapter = vf->adapter;
1099         int err;
1100
1101         err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
1102         if (err)
1103                 cmd->rsp.arg[0] |= (0x6 << 25);
1104         else
1105                 err = qlcnic_issue_cmd(adapter, cmd);
1106
1107         return err;
1108 }
1109
1110 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1111                                               struct qlcnic_cmd_args *cmd)
1112 {
1113         if (cmd->req.arg[1] & BIT_31) {
1114                 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1115                         return -EINVAL;
1116         } else {
1117                 cmd->req.arg[1] |= vf->vp->handle << 16;
1118         }
1119
1120         return 0;
1121 }
1122
1123 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1124                                             struct qlcnic_cmd_args *cmd)
1125 {
1126         struct qlcnic_vf_info *vf = trans->vf;
1127         struct qlcnic_adapter *adapter = vf->adapter;
1128         int err;
1129
1130         err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1131         if (err) {
1132                 cmd->rsp.arg[0] |= (0x6 << 25);
1133                 return err;
1134         }
1135
1136         err = qlcnic_issue_cmd(adapter, cmd);
1137         return err;
1138 }
1139
1140 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1141                                          struct qlcnic_cmd_args *cmd)
1142 {
1143         if (cmd->req.arg[1] != vf->rx_ctx_id)
1144                 return -EINVAL;
1145
1146         return 0;
1147 }
1148
1149 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1150                                        struct qlcnic_cmd_args *cmd)
1151 {
1152         struct qlcnic_vf_info *vf = trans->vf;
1153         struct qlcnic_adapter *adapter = vf->adapter;
1154         int err;
1155
1156         err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1157         if (err)
1158                 cmd->rsp.arg[0] |= (0x6 << 25);
1159         else
1160                 err = qlcnic_issue_cmd(adapter, cmd);
1161
1162         return err;
1163 }
1164
1165 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1166                                               struct qlcnic_vf_info *vf,
1167                                               struct qlcnic_cmd_args *cmd)
1168 {
1169         struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1170         u16 ctx_id, pkts, time;
1171
1172         ctx_id = cmd->req.arg[1] >> 16;
1173         pkts = cmd->req.arg[2] & 0xffff;
1174         time = cmd->req.arg[2] >> 16;
1175
1176         if (ctx_id != vf->rx_ctx_id)
1177                 return -EINVAL;
1178         if (pkts > coal->rx_packets)
1179                 return -EINVAL;
1180         if (time < coal->rx_time_us)
1181                 return -EINVAL;
1182
1183         return 0;
1184 }
1185
1186 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1187                                             struct qlcnic_cmd_args *cmd)
1188 {
1189         struct qlcnic_vf_info *vf = tran->vf;
1190         struct qlcnic_adapter *adapter = vf->adapter;
1191         int err;
1192
1193         err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1194         if (err) {
1195                 cmd->rsp.arg[0] |= (0x6 << 25);
1196                 return err;
1197         }
1198
1199         err = qlcnic_issue_cmd(adapter, cmd);
1200         return err;
1201 }
1202
1203 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1204                                              struct qlcnic_vf_info *vf,
1205                                              struct qlcnic_cmd_args *cmd)
1206 {
1207         struct qlcnic_macvlan_mbx *macvlan;
1208         struct qlcnic_vport *vp = vf->vp;
1209         u8 op, new_op;
1210
1211         if (!(cmd->req.arg[1] & BIT_8))
1212                 return -EINVAL;
1213
1214         cmd->req.arg[1] |= (vf->vp->handle << 16);
1215         cmd->req.arg[1] |= BIT_31;
1216
1217         macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1218         if (!(macvlan->mac_addr0 & BIT_0)) {
1219                 dev_err(&adapter->pdev->dev,
1220                         "MAC address change is not allowed from VF %d",
1221                         vf->pci_func);
1222                 return -EINVAL;
1223         }
1224
1225         if (vp->vlan_mode == QLC_PVID_MODE) {
1226                 op = cmd->req.arg[1] & 0x7;
1227                 cmd->req.arg[1] &= ~0x7;
1228                 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1229                          QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1230                 cmd->req.arg[3] |= vp->pvid << 16;
1231                 cmd->req.arg[1] |= new_op;
1232         }
1233
1234         return 0;
1235 }
1236
1237 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1238                                            struct qlcnic_cmd_args *cmd)
1239 {
1240         struct qlcnic_vf_info *vf = trans->vf;
1241         struct qlcnic_adapter *adapter = vf->adapter;
1242         int err;
1243
1244         err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1245         if (err) {
1246                 cmd->rsp.arg[0] |= (0x6 << 25);
1247                 return err;
1248         }
1249
1250         err = qlcnic_issue_cmd(adapter, cmd);
1251         return err;
1252 }
1253
1254 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1255                                            struct qlcnic_cmd_args *cmd)
1256 {
1257         if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1258                 return -EINVAL;
1259
1260         return 0;
1261 }
1262
1263 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1264                                          struct qlcnic_cmd_args *cmd)
1265 {
1266         struct qlcnic_vf_info *vf = trans->vf;
1267         struct qlcnic_adapter *adapter = vf->adapter;
1268         int err;
1269
1270         err = qlcnic_sriov_validate_linkevent(vf, cmd);
1271         if (err) {
1272                 cmd->rsp.arg[0] |= (0x6 << 25);
1273                 return err;
1274         }
1275
1276         err = qlcnic_issue_cmd(adapter, cmd);
1277         return err;
1278 }
1279
1280 static int qlcnic_sriov_pf_cfg_promisc_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         cmd->req.arg[1] |= vf->vp->handle << 16;
1288         cmd->req.arg[1] |= BIT_31;
1289         err = qlcnic_issue_cmd(adapter, cmd);
1290         return err;
1291 }
1292
1293 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1294                                        struct qlcnic_cmd_args *cmd)
1295 {
1296         struct qlcnic_vf_info *vf = trans->vf;
1297         struct qlcnic_vport *vp = vf->vp;
1298         u8 cmd_op, mode = vp->vlan_mode;
1299         struct qlcnic_adapter *adapter;
1300         struct qlcnic_sriov *sriov;
1301
1302         adapter = vf->adapter;
1303         sriov = adapter->ahw->sriov;
1304
1305         cmd_op = trans->req_hdr->cmd_op;
1306         cmd->rsp.arg[0] |= 1 << 25;
1307
1308         /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1309          * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1310          */
1311         if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1312                 return 0;
1313
1314         switch (mode) {
1315         case QLC_GUEST_VLAN_MODE:
1316                 cmd->rsp.arg[1] = mode | 1 << 8;
1317                 cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16;
1318                 break;
1319         case QLC_PVID_MODE:
1320                 cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16;
1321                 break;
1322         }
1323
1324         return 0;
1325 }
1326
1327 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1328                                           struct qlcnic_vf_info *vf,
1329                                           struct qlcnic_cmd_args *cmd)
1330 {
1331         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1332         u16 vlan;
1333
1334         if (!qlcnic_sriov_check_any_vlan(vf))
1335                 return -EINVAL;
1336
1337         vlan = cmd->req.arg[1] >> 16;
1338         if (!vf->rx_ctx_id) {
1339                 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1340                 return 0;
1341         }
1342
1343         qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL);
1344         qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1345
1346         if (qlcnic_83xx_pf_check(adapter))
1347                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf,
1348                                             0, QLCNIC_MAC_ADD);
1349         return 0;
1350 }
1351
1352 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1353                                           struct qlcnic_vf_info *vf,
1354                                           struct qlcnic_cmd_args *cmd)
1355 {
1356         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1357         int err = -EIO;
1358         u16 vlan;
1359
1360         if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf))
1361                 return err;
1362
1363         vlan = cmd->req.arg[1] >> 16;
1364
1365         if (!vf->rx_ctx_id) {
1366                 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1367                 return 0;
1368         }
1369
1370         if (qlcnic_83xx_pf_check(adapter)) {
1371                 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1372                                                   QLCNIC_MAC_DEL);
1373                 if (err)
1374                         return err;
1375         }
1376
1377         err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD);
1378
1379         if (err) {
1380                 if (qlcnic_83xx_pf_check(adapter))
1381                         qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1382                                                     QLCNIC_MAC_ADD);
1383                 return err;
1384         }
1385
1386         qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1387         return err;
1388 }
1389
1390 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1391                                               struct qlcnic_cmd_args *cmd)
1392 {
1393         struct qlcnic_vf_info  *vf = tran->vf;
1394         struct qlcnic_adapter *adapter =  vf->adapter;
1395         struct qlcnic_vport *vp = vf->vp;
1396         int err = -EIO;
1397         u8 op;
1398
1399         if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1400                 cmd->rsp.arg[0] |= 2 << 25;
1401                 return err;
1402         }
1403
1404         op = cmd->req.arg[1] & 0xf;
1405
1406         if (op)
1407                 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1408         else
1409                 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd);
1410
1411         cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1412         return err;
1413 }
1414
1415 static const int qlcnic_pf_passthru_supp_cmds[] = {
1416         QLCNIC_CMD_GET_STATISTICS,
1417         QLCNIC_CMD_GET_PORT_CONFIG,
1418         QLCNIC_CMD_GET_LINK_STATUS,
1419         QLCNIC_CMD_INIT_NIC_FUNC,
1420         QLCNIC_CMD_STOP_NIC_FUNC,
1421 };
1422
1423 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1424         [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1425         [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1426         [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1427         [QLCNIC_BC_CMD_CFG_GUEST_VLAN]  = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1428 };
1429
1430 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1431         {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1432         {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1433         {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1434         {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1435         {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1436         {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1437         {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1438         {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1439         {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1440         {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1441         {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1442         {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1443         {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1444         {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1445         {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1446 };
1447
1448 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1449                                     struct qlcnic_bc_trans *trans,
1450                                     struct qlcnic_cmd_args *cmd)
1451 {
1452         u8 size, cmd_op;
1453
1454         cmd_op = trans->req_hdr->cmd_op;
1455
1456         if (trans->req_hdr->op_type == QLC_BC_CMD) {
1457                 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1458                 if (cmd_op < size) {
1459                         qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1460                         return;
1461                 }
1462         } else {
1463                 int i;
1464                 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1465                 for (i = 0; i < size; i++) {
1466                         if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1467                                 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1468                                 return;
1469                         }
1470                 }
1471
1472                 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1473                 for (i = 0; i < size; i++) {
1474                         if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1475                                 qlcnic_issue_cmd(adapter, cmd);
1476                                 return;
1477                         }
1478                 }
1479         }
1480
1481         cmd->rsp.arg[0] |= (0x9 << 25);
1482 }
1483
1484 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1485                                              u32 *int_id)
1486 {
1487         u16 vpid;
1488
1489         vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1490                                                 adapter->ahw->pci_func);
1491         *int_id |= vpid;
1492 }
1493
1494 void qlcnic_pf_set_interface_id_del_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 << 16;
1502 }
1503
1504 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1505                                               u32 *int_id)
1506 {
1507         int 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_del_tx_ctx(struct qlcnic_adapter *adapter,
1515                                            u32 *int_id)
1516 {
1517         u16 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_promisc(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) | BIT_31;
1532 }
1533
1534 void qlcnic_pf_set_interface_id_ipaddr(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_macaddr(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 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1555                                     struct qlcnic_vf_info *vf)
1556 {
1557         struct qlcnic_cmd_args cmd;
1558         int vpid;
1559
1560         if (!vf->rx_ctx_id)
1561                 return;
1562
1563         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1564                 return;
1565
1566         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1567         if (vpid >= 0) {
1568                 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1569                 if (qlcnic_issue_cmd(adapter, &cmd))
1570                         dev_err(&adapter->pdev->dev,
1571                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1572                                 vf->pci_func);
1573                 else
1574                         vf->rx_ctx_id = 0;
1575         }
1576
1577         qlcnic_free_mbx_args(&cmd);
1578 }
1579
1580 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1581                                     struct qlcnic_vf_info *vf)
1582 {
1583         struct qlcnic_cmd_args cmd;
1584         int vpid;
1585
1586         if (!vf->tx_ctx_id)
1587                 return;
1588
1589         if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1590                 return;
1591
1592         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1593         if (vpid >= 0) {
1594                 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1595                 if (qlcnic_issue_cmd(adapter, &cmd))
1596                         dev_err(&adapter->pdev->dev,
1597                                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1598                                 vf->pci_func);
1599                 else
1600                         vf->tx_ctx_id = 0;
1601         }
1602
1603         qlcnic_free_mbx_args(&cmd);
1604 }
1605
1606 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1607                                              struct qlcnic_vf_info *vf,
1608                                              struct qlcnic_bc_trans *trans)
1609 {
1610         struct qlcnic_trans_list *t_list = &vf->rcv_act;
1611         unsigned long flag;
1612
1613         spin_lock_irqsave(&t_list->lock, flag);
1614
1615         __qlcnic_sriov_add_act_list(sriov, vf, trans);
1616
1617         spin_unlock_irqrestore(&t_list->lock, flag);
1618         return 0;
1619 }
1620
1621 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1622 {
1623         struct qlcnic_adapter *adapter = vf->adapter;
1624
1625         qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1626         cancel_work_sync(&vf->trans_work);
1627         qlcnic_sriov_cleanup_list(&vf->rcv_act);
1628
1629         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1630                 qlcnic_sriov_del_tx_ctx(adapter, vf);
1631                 qlcnic_sriov_del_rx_ctx(adapter, vf);
1632         }
1633
1634         qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1635
1636         clear_bit(QLC_BC_VF_FLR, &vf->state);
1637         if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1638                 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1639                                                   vf->flr_trans);
1640                 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1641                 vf->flr_trans = NULL;
1642         }
1643 }
1644
1645 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1646 {
1647         struct qlcnic_vf_info *vf;
1648
1649         vf = container_of(work, struct qlcnic_vf_info, flr_work);
1650         __qlcnic_sriov_process_flr(vf);
1651         return;
1652 }
1653
1654 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1655                                       struct qlcnic_vf_info *vf,
1656                                       work_func_t func)
1657 {
1658         if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1659                 return;
1660
1661         INIT_WORK(&vf->flr_work, func);
1662         queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1663 }
1664
1665 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1666                                          struct qlcnic_bc_trans *trans,
1667                                          struct qlcnic_vf_info *vf)
1668 {
1669         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1670
1671         set_bit(QLC_BC_VF_FLR, &vf->state);
1672         clear_bit(QLC_BC_VF_STATE, &vf->state);
1673         set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1674         vf->flr_trans = trans;
1675         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1676         netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1677                     vf->pci_func);
1678 }
1679
1680 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1681                                  struct qlcnic_bc_trans *trans,
1682                                  struct qlcnic_vf_info *vf)
1683 {
1684         struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1685
1686         if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1687             (hdr->op_type == QLC_BC_CMD) &&
1688              test_bit(QLC_BC_VF_STATE, &vf->state)) {
1689                 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1690                 return true;
1691         }
1692
1693         return false;
1694 }
1695
1696 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1697                                 struct qlcnic_vf_info *vf)
1698 {
1699         struct net_device *dev = vf->adapter->netdev;
1700         struct qlcnic_vport *vp = vf->vp;
1701
1702         if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1703                 clear_bit(QLC_BC_VF_FLR, &vf->state);
1704                 return;
1705         }
1706
1707         if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1708                 netdev_info(dev, "FLR for PCI func %d in progress\n",
1709                             vf->pci_func);
1710                 return;
1711         }
1712
1713         if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1714                 memset(vf->sriov_vlans, 0,
1715                        sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans);
1716
1717         qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1718         netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1719 }
1720
1721 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1722 {
1723         struct qlcnic_hardware_context *ahw = adapter->ahw;
1724         struct qlcnic_sriov *sriov = ahw->sriov;
1725         struct qlcnic_vf_info *vf;
1726         u16 num_vfs = sriov->num_vfs;
1727         int i;
1728
1729         for (i = 0; i < num_vfs; i++) {
1730                 vf = &sriov->vf_info[i];
1731                 vf->rx_ctx_id = 0;
1732                 vf->tx_ctx_id = 0;
1733                 cancel_work_sync(&vf->flr_work);
1734                 __qlcnic_sriov_process_flr(vf);
1735                 clear_bit(QLC_BC_VF_STATE, &vf->state);
1736         }
1737
1738         qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1739         QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1740 }
1741
1742 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1743 {
1744         struct qlcnic_hardware_context *ahw = adapter->ahw;
1745         int err;
1746
1747         if (!qlcnic_sriov_enable_check(adapter))
1748                 return 0;
1749
1750         ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1751
1752         err = qlcnic_sriov_pf_init(adapter);
1753         if (err)
1754                 return err;
1755
1756         dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1757                  __func__, ahw->op_mode);
1758         return err;
1759 }
1760
1761 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1762 {
1763         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1764         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1765         int i, num_vfs;
1766         struct qlcnic_vf_info *vf_info;
1767         u8 *curr_mac;
1768
1769         if (!qlcnic_sriov_pf_check(adapter))
1770                 return -EOPNOTSUPP;
1771
1772         num_vfs = sriov->num_vfs;
1773
1774         if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1775                 return -EINVAL;
1776
1777         if (ether_addr_equal(adapter->mac_addr, mac)) {
1778                 netdev_err(netdev, "MAC address is already in use by the PF\n");
1779                 return -EINVAL;
1780         }
1781
1782         for (i = 0; i < num_vfs; i++) {
1783                 vf_info = &sriov->vf_info[i];
1784                 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1785                         netdev_err(netdev,
1786                                    "MAC address is already in use by VF %d\n",
1787                                    i);
1788                         return -EINVAL;
1789                 }
1790         }
1791
1792         vf_info = &sriov->vf_info[vf];
1793         curr_mac = vf_info->vp->mac;
1794
1795         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1796                 netdev_err(netdev,
1797                            "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1798                            vf);
1799                 return -EOPNOTSUPP;
1800         }
1801
1802         memcpy(curr_mac, mac, netdev->addr_len);
1803         netdev_info(netdev, "MAC Address %pM  is configured for VF %d\n",
1804                     mac, vf);
1805         return 0;
1806 }
1807
1808 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1809 {
1810         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1811         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1812         struct qlcnic_vf_info *vf_info;
1813         struct qlcnic_info nic_info;
1814         struct qlcnic_vport *vp;
1815         u16 vpid;
1816
1817         if (!qlcnic_sriov_pf_check(adapter))
1818                 return -EOPNOTSUPP;
1819
1820         if (vf >= sriov->num_vfs)
1821                 return -EINVAL;
1822
1823         if (tx_rate >= 10000 || tx_rate < 100) {
1824                 netdev_err(netdev,
1825                            "Invalid Tx rate, allowed range is [%d - %d]",
1826                            QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1827                 return -EINVAL;
1828         }
1829
1830         if (tx_rate == 0)
1831                 tx_rate = 10000;
1832
1833         vf_info = &sriov->vf_info[vf];
1834         vp = vf_info->vp;
1835         vpid = vp->handle;
1836
1837         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1838                 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1839                         return -EIO;
1840
1841                 nic_info.max_tx_bw = tx_rate / 100;
1842                 nic_info.bit_offsets = BIT_0;
1843
1844                 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1845                         return -EIO;
1846         }
1847
1848         vp->max_tx_bw = tx_rate / 100;
1849         netdev_info(netdev,
1850                     "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1851                     tx_rate, vp->max_tx_bw, vf);
1852         return 0;
1853 }
1854
1855 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1856                              u16 vlan, u8 qos)
1857 {
1858         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1859         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1860         struct qlcnic_vf_info *vf_info;
1861         struct qlcnic_vport *vp;
1862
1863         if (!qlcnic_sriov_pf_check(adapter))
1864                 return -EOPNOTSUPP;
1865
1866         if (vf >= sriov->num_vfs || qos > 7)
1867                 return -EINVAL;
1868
1869         if (vlan > MAX_VLAN_ID) {
1870                 netdev_err(netdev,
1871                            "Invalid VLAN ID, allowed range is [0 - %d]\n",
1872                            MAX_VLAN_ID);
1873                 return -EINVAL;
1874         }
1875
1876         vf_info = &sriov->vf_info[vf];
1877         vp = vf_info->vp;
1878         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1879                 netdev_err(netdev,
1880                            "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1881                            vf);
1882                 return -EOPNOTSUPP;
1883         }
1884
1885         memset(vf_info->sriov_vlans, 0,
1886                sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans);
1887
1888         switch (vlan) {
1889         case 4095:
1890                 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1891                 break;
1892         case 0:
1893                 vp->vlan_mode = QLC_NO_VLAN_MODE;
1894                 vp->qos = 0;
1895                 break;
1896         default:
1897                 vp->vlan_mode = QLC_PVID_MODE;
1898                 qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan);
1899                 vp->qos = qos;
1900                 vp->pvid = vlan;
1901         }
1902
1903         netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1904                     vlan, qos, vf);
1905         return 0;
1906 }
1907
1908 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1909                                       struct qlcnic_vport *vp, int vf)
1910 {
1911         __u32 vlan = 0;
1912
1913         switch (vp->vlan_mode) {
1914         case QLC_PVID_MODE:
1915                 vlan = vp->pvid;
1916                 break;
1917         case QLC_GUEST_VLAN_MODE:
1918                 vlan = MAX_VLAN_ID;
1919                 break;
1920         case QLC_NO_VLAN_MODE:
1921                 vlan = 0;
1922                 break;
1923         default:
1924                 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1925                             vp->vlan_mode, vf);
1926         }
1927
1928         return vlan;
1929 }
1930
1931 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1932                                int vf, struct ifla_vf_info *ivi)
1933 {
1934         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1935         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1936         struct qlcnic_vport *vp;
1937
1938         if (!qlcnic_sriov_pf_check(adapter))
1939                 return -EOPNOTSUPP;
1940
1941         if (vf >= sriov->num_vfs)
1942                 return -EINVAL;
1943
1944         vp = sriov->vf_info[vf].vp;
1945         memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1946         ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1947         ivi->qos = vp->qos;
1948         ivi->spoofchk = vp->spoofchk;
1949         if (vp->max_tx_bw == MAX_BW)
1950                 ivi->tx_rate = 0;
1951         else
1952                 ivi->tx_rate = vp->max_tx_bw * 100;
1953
1954         ivi->vf = vf;
1955         return 0;
1956 }
1957
1958 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1959 {
1960         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1961         struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1962         struct qlcnic_vf_info *vf_info;
1963         struct qlcnic_vport *vp;
1964
1965         if (!qlcnic_sriov_pf_check(adapter))
1966                 return -EOPNOTSUPP;
1967
1968         if (vf >= sriov->num_vfs)
1969                 return -EINVAL;
1970
1971         vf_info = &sriov->vf_info[vf];
1972         vp = vf_info->vp;
1973         if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1974                 netdev_err(netdev,
1975                            "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1976                            vf);
1977                 return -EOPNOTSUPP;
1978         }
1979
1980         vp->spoofchk = chk;
1981         return 0;
1982 }