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

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