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