drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_pf.c

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