Pileus Git - ~andy/linux/blob - drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_pf.c

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