forked from Minki/linux
f80bc8fe6d
o 82xx adapter requires VLAN id in little endian format. Instead of passing vlan id parameter as __le16, pass the parameter as u16 and use cpu_to_le16 at appropriate places. Signed-off-by: Rajesh Borundia <rajesh.borundia@qlogic.com> Signed-off-by: David S. Miller <davem@davemloft.net>
1176 lines
29 KiB
C
1176 lines
29 KiB
C
/*
|
|
* QLogic qlcnic NIC Driver
|
|
* Copyright (c) 2009-2013 QLogic Corporation
|
|
*
|
|
* See LICENSE.qlcnic for copyright and licensing details.
|
|
*/
|
|
|
|
#include "qlcnic_sriov.h"
|
|
#include "qlcnic.h"
|
|
#include <linux/types.h>
|
|
|
|
#define QLCNIC_SRIOV_VF_MAX_MAC 1
|
|
|
|
static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
|
|
|
|
struct qlcnic_sriov_cmd_handler {
|
|
int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
|
|
};
|
|
|
|
struct qlcnic_sriov_fw_cmd_handler {
|
|
u32 cmd;
|
|
int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
|
|
};
|
|
|
|
static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_info *npar_info,
|
|
u16 vport_id)
|
|
{
|
|
struct qlcnic_cmd_args cmd;
|
|
int err;
|
|
|
|
if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
|
|
return -ENOMEM;
|
|
|
|
cmd.req.arg[1] = (vport_id << 16) | 0x1;
|
|
cmd.req.arg[2] = npar_info->bit_offsets;
|
|
cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
|
|
cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
|
|
cmd.req.arg[4] = npar_info->max_tx_mac_filters;
|
|
cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
|
|
cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
|
|
(npar_info->max_rx_ip_addr << 16);
|
|
cmd.req.arg[6] = npar_info->max_rx_lro_flow |
|
|
(npar_info->max_rx_status_rings << 16);
|
|
cmd.req.arg[7] = npar_info->max_rx_buf_rings |
|
|
(npar_info->max_rx_ques << 16);
|
|
cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
|
|
cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
|
|
cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
|
|
|
|
err = qlcnic_issue_cmd(adapter, &cmd);
|
|
if (err)
|
|
dev_err(&adapter->pdev->dev,
|
|
"Failed to set vport info, err=%d\n", err);
|
|
|
|
qlcnic_free_mbx_args(&cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_info *info, u16 func)
|
|
{
|
|
struct qlcnic_sriov *sriov = adapter->ahw->sriov;
|
|
struct qlcnic_resources *res = &sriov->ff_max;
|
|
int ret = -EIO, vpid;
|
|
u32 temp, num_vf_macs, num_vfs, max;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
|
|
if (vpid < 0)
|
|
return -EINVAL;
|
|
|
|
num_vfs = sriov->num_vfs;
|
|
max = num_vfs + 1;
|
|
info->bit_offsets = 0xffff;
|
|
info->min_tx_bw = 0;
|
|
info->max_tx_bw = MAX_BW;
|
|
info->max_tx_ques = res->num_tx_queues / max;
|
|
info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
|
|
num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC;
|
|
|
|
if (adapter->ahw->pci_func == func) {
|
|
temp = res->num_rx_mcast_mac_filters - (num_vfs * num_vf_macs);
|
|
info->max_rx_ucast_mac_filters = temp;
|
|
temp = res->num_tx_mac_filters - (num_vfs * num_vf_macs);
|
|
info->max_tx_mac_filters = temp;
|
|
} else {
|
|
info->max_rx_ucast_mac_filters = num_vf_macs;
|
|
info->max_tx_mac_filters = num_vf_macs;
|
|
}
|
|
|
|
info->max_rx_ip_addr = res->num_destip / max;
|
|
info->max_rx_status_rings = res->num_rx_status_rings / max;
|
|
info->max_rx_buf_rings = res->num_rx_buf_rings / max;
|
|
info->max_rx_ques = res->num_rx_queues / max;
|
|
info->max_rx_lro_flow = res->num_lro_flows_supported / max;
|
|
info->max_tx_vlan_keys = res->num_txvlan_keys;
|
|
info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
|
|
info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
|
|
|
|
ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_info *info)
|
|
{
|
|
struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
|
|
|
|
ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
|
|
ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
|
|
ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
|
|
ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
|
|
ff_max->num_rx_queues = info->max_rx_ques;
|
|
ff_max->num_tx_queues = info->max_tx_ques;
|
|
ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
|
|
ff_max->num_destip = info->max_rx_ip_addr;
|
|
ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
|
|
ff_max->num_rx_status_rings = info->max_rx_status_rings;
|
|
ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
|
|
ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
|
|
}
|
|
|
|
static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_info *npar_info)
|
|
{
|
|
int err;
|
|
struct qlcnic_cmd_args cmd;
|
|
|
|
if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
|
|
return -ENOMEM;
|
|
|
|
cmd.req.arg[1] = 0x2;
|
|
err = qlcnic_issue_cmd(adapter, &cmd);
|
|
if (err) {
|
|
dev_err(&adapter->pdev->dev,
|
|
"Failed to get PF info, err=%d\n", err);
|
|
goto out;
|
|
}
|
|
|
|
npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
|
|
npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
|
|
npar_info->max_vports = MSW(cmd.rsp.arg[2]);
|
|
npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
|
|
npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
|
|
npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
|
|
npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
|
|
npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
|
|
npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
|
|
npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
|
|
npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
|
|
npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
|
|
npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
|
|
npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
|
|
npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
|
|
|
|
qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
|
|
dev_info(&adapter->pdev->dev,
|
|
"\n\ttotal_pf: %d,\n"
|
|
"\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
|
|
"\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
|
|
"\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
|
|
"\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
|
|
"\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
|
|
"\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
|
|
npar_info->total_pf, npar_info->total_rss_engines,
|
|
npar_info->max_vports, npar_info->max_tx_ques,
|
|
npar_info->max_tx_mac_filters,
|
|
npar_info->max_rx_mcast_mac_filters,
|
|
npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
|
|
npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
|
|
npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
|
|
npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
|
|
npar_info->max_remote_ipv6_addrs);
|
|
|
|
out:
|
|
qlcnic_free_mbx_args(&cmd);
|
|
return err;
|
|
}
|
|
|
|
static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
|
|
u8 func)
|
|
{
|
|
struct qlcnic_sriov *sriov = adapter->ahw->sriov;
|
|
struct qlcnic_vport *vp;
|
|
int index;
|
|
|
|
if (adapter->ahw->pci_func == func) {
|
|
sriov->vp_handle = 0;
|
|
} else {
|
|
index = qlcnic_sriov_func_to_index(adapter, func);
|
|
if (index < 0)
|
|
return;
|
|
vp = sriov->vf_info[index].vp;
|
|
vp->handle = 0;
|
|
}
|
|
}
|
|
|
|
static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
|
|
u16 vport_handle, u8 func)
|
|
{
|
|
struct qlcnic_sriov *sriov = adapter->ahw->sriov;
|
|
struct qlcnic_vport *vp;
|
|
int index;
|
|
|
|
if (adapter->ahw->pci_func == func) {
|
|
sriov->vp_handle = vport_handle;
|
|
} else {
|
|
index = qlcnic_sriov_func_to_index(adapter, func);
|
|
if (index < 0)
|
|
return;
|
|
vp = sriov->vf_info[index].vp;
|
|
vp->handle = vport_handle;
|
|
}
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
|
|
u8 func)
|
|
{
|
|
struct qlcnic_sriov *sriov = adapter->ahw->sriov;
|
|
struct qlcnic_vf_info *vf_info;
|
|
int index;
|
|
|
|
if (adapter->ahw->pci_func == func) {
|
|
return sriov->vp_handle;
|
|
} else {
|
|
index = qlcnic_sriov_func_to_index(adapter, func);
|
|
if (index >= 0) {
|
|
vf_info = &sriov->vf_info[index];
|
|
return vf_info->vp->handle;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
|
|
u8 flag, u16 func)
|
|
{
|
|
struct qlcnic_cmd_args cmd;
|
|
int ret;
|
|
int vpid;
|
|
|
|
if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
|
|
return -ENOMEM;
|
|
|
|
if (flag) {
|
|
cmd.req.arg[3] = func << 8;
|
|
} else {
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
|
|
if (vpid < 0) {
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
|
|
}
|
|
|
|
ret = qlcnic_issue_cmd(adapter, &cmd);
|
|
if (ret) {
|
|
dev_err(&adapter->pdev->dev,
|
|
"Failed %s vport, err %d for func 0x%x\n",
|
|
(flag ? "enable" : "disable"), ret, func);
|
|
goto out;
|
|
}
|
|
|
|
if (flag) {
|
|
vpid = cmd.rsp.arg[2] & 0xffff;
|
|
qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
|
|
} else {
|
|
qlcnic_sriov_pf_reset_vport_handle(adapter, func);
|
|
}
|
|
|
|
out:
|
|
qlcnic_free_mbx_args(&cmd);
|
|
return ret;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
|
|
u8 func, u8 enable)
|
|
{
|
|
struct qlcnic_cmd_args cmd;
|
|
int err = -EIO;
|
|
|
|
if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
|
|
return -ENOMEM;
|
|
|
|
cmd.req.arg[0] |= (3 << 29);
|
|
cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
|
|
if (enable)
|
|
cmd.req.arg[1] |= BIT_0;
|
|
|
|
err = qlcnic_issue_cmd(adapter, &cmd);
|
|
|
|
if (err != QLCNIC_RCODE_SUCCESS) {
|
|
dev_err(&adapter->pdev->dev,
|
|
"Failed to enable sriov eswitch%d\n", err);
|
|
err = -EIO;
|
|
}
|
|
|
|
qlcnic_free_mbx_args(&cmd);
|
|
return err;
|
|
}
|
|
|
|
void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
|
|
{
|
|
u8 func = adapter->ahw->pci_func;
|
|
|
|
if (!qlcnic_sriov_enable_check(adapter))
|
|
return;
|
|
|
|
qlcnic_sriov_cfg_bc_intr(adapter, 0);
|
|
qlcnic_sriov_pf_config_vport(adapter, 0, func);
|
|
qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
|
|
__qlcnic_sriov_cleanup(adapter);
|
|
adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
|
|
clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
|
|
}
|
|
|
|
void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
|
|
{
|
|
if (!qlcnic_sriov_pf_check(adapter))
|
|
return;
|
|
|
|
if (!qlcnic_sriov_enable_check(adapter))
|
|
return;
|
|
|
|
pci_disable_sriov(adapter->pdev);
|
|
netdev_info(adapter->netdev,
|
|
"SR-IOV is disabled successfully on port %d\n",
|
|
adapter->portnum);
|
|
}
|
|
|
|
static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
|
|
{
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
if (netif_running(netdev))
|
|
__qlcnic_down(adapter, netdev);
|
|
|
|
qlcnic_sriov_pf_disable(adapter);
|
|
|
|
qlcnic_sriov_pf_cleanup(adapter);
|
|
|
|
/* After disabling SRIOV re-init the driver in default mode
|
|
configure opmode based on op_mode of function
|
|
*/
|
|
if (qlcnic_83xx_configure_opmode(adapter))
|
|
return -EIO;
|
|
|
|
if (netif_running(netdev))
|
|
__qlcnic_up(adapter, netdev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
|
|
{
|
|
struct qlcnic_hardware_context *ahw = adapter->ahw;
|
|
struct qlcnic_info nic_info, pf_info, vp_info;
|
|
int err;
|
|
u8 func = ahw->pci_func;
|
|
|
|
if (!qlcnic_sriov_enable_check(adapter))
|
|
return 0;
|
|
|
|
err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
|
|
if (err)
|
|
goto clear_sriov_enable;
|
|
|
|
err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
|
|
if (err)
|
|
goto disable_eswitch;
|
|
|
|
err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
|
|
if (err)
|
|
goto delete_vport;
|
|
|
|
err = qlcnic_get_nic_info(adapter, &nic_info, func);
|
|
if (err)
|
|
goto delete_vport;
|
|
|
|
err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
|
|
if (err)
|
|
goto delete_vport;
|
|
|
|
err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
|
|
if (err)
|
|
goto delete_vport;
|
|
|
|
ahw->physical_port = (u8) nic_info.phys_port;
|
|
ahw->switch_mode = nic_info.switch_mode;
|
|
ahw->max_mtu = nic_info.max_mtu;
|
|
ahw->capabilities = nic_info.capabilities;
|
|
ahw->nic_mode = QLC_83XX_SRIOV_MODE;
|
|
return err;
|
|
|
|
delete_vport:
|
|
qlcnic_sriov_pf_config_vport(adapter, 0, func);
|
|
|
|
disable_eswitch:
|
|
qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
|
|
|
|
clear_sriov_enable:
|
|
__qlcnic_sriov_cleanup(adapter);
|
|
adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
|
|
clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
|
|
{
|
|
int err;
|
|
|
|
if (!qlcnic_sriov_enable_check(adapter))
|
|
return 0;
|
|
|
|
err = pci_enable_sriov(adapter->pdev, num_vfs);
|
|
if (err)
|
|
qlcnic_sriov_pf_cleanup(adapter);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
|
|
int num_vfs)
|
|
{
|
|
int err = 0;
|
|
|
|
set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
|
|
adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
|
|
|
|
if (qlcnic_sriov_init(adapter, num_vfs)) {
|
|
clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
|
|
adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
|
|
return -EIO;
|
|
}
|
|
|
|
if (qlcnic_sriov_pf_init(adapter))
|
|
return -EIO;
|
|
|
|
err = qlcnic_sriov_pf_enable(adapter, num_vfs);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
|
|
{
|
|
struct net_device *netdev = adapter->netdev;
|
|
int err;
|
|
|
|
if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
|
|
netdev_err(netdev,
|
|
"SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
|
|
return -EIO;
|
|
}
|
|
|
|
if (netif_running(netdev))
|
|
__qlcnic_down(adapter, netdev);
|
|
|
|
err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
|
|
if (err) {
|
|
netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
|
|
adapter->portnum);
|
|
|
|
if (qlcnic_83xx_configure_opmode(adapter))
|
|
goto error;
|
|
} else {
|
|
netdev_info(adapter->netdev,
|
|
"SR-IOV is enabled successfully on port %d\n",
|
|
adapter->portnum);
|
|
}
|
|
if (netif_running(netdev))
|
|
__qlcnic_up(adapter, netdev);
|
|
|
|
error:
|
|
return err;
|
|
}
|
|
|
|
int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
|
|
{
|
|
struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
|
|
int err;
|
|
|
|
if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
|
|
return -EBUSY;
|
|
|
|
if (num_vfs == 0)
|
|
err = qlcnic_pci_sriov_disable(adapter);
|
|
else
|
|
err = qlcnic_pci_sriov_enable(adapter, num_vfs);
|
|
|
|
clear_bit(__QLCNIC_RESETTING, &adapter->state);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
|
|
u16 func)
|
|
{
|
|
struct qlcnic_info defvp_info;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
|
|
if (err)
|
|
return -EIO;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
u16 func = vf->pci_func;
|
|
|
|
cmd->rsp.arg[0] = trans->req_hdr->cmd_op;
|
|
cmd->rsp.arg[0] |= (1 << 16);
|
|
|
|
if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
|
|
err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
|
|
if (!err) {
|
|
err = qlcnic_sriov_set_vf_vport_info(adapter, func);
|
|
if (err)
|
|
qlcnic_sriov_pf_config_vport(adapter, 0, func);
|
|
}
|
|
} else {
|
|
err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
|
|
}
|
|
|
|
if (err)
|
|
goto err_out;
|
|
|
|
cmd->rsp.arg[0] |= (1 << 25);
|
|
|
|
if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
|
|
set_bit(QLC_BC_VF_STATE, &vf->state);
|
|
else
|
|
clear_bit(QLC_BC_VF_STATE, &vf->state);
|
|
|
|
return err;
|
|
|
|
err_out:
|
|
cmd->rsp.arg[0] |= (2 << 25);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_vport *vp,
|
|
u16 func, u16 vlan, u8 op)
|
|
{
|
|
struct qlcnic_cmd_args cmd;
|
|
struct qlcnic_macvlan_mbx mv;
|
|
u8 *addr;
|
|
int err;
|
|
u32 *buf;
|
|
int vpid;
|
|
|
|
if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
|
|
return -ENOMEM;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
|
|
if (vpid < 0) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (vlan)
|
|
op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
|
|
QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
|
|
|
|
cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
|
|
cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
|
|
|
|
addr = vp->mac;
|
|
mv.vlan = vlan;
|
|
mv.mac_addr0 = addr[0];
|
|
mv.mac_addr1 = addr[1];
|
|
mv.mac_addr2 = addr[2];
|
|
mv.mac_addr3 = addr[3];
|
|
mv.mac_addr4 = addr[4];
|
|
mv.mac_addr5 = addr[5];
|
|
buf = &cmd.req.arg[2];
|
|
memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
|
|
|
|
err = qlcnic_issue_cmd(adapter, &cmd);
|
|
|
|
if (err)
|
|
dev_err(&adapter->pdev->dev,
|
|
"MAC-VLAN %s to CAM failed, err=%d.\n",
|
|
((op == 1) ? "add " : "delete "), err);
|
|
|
|
out:
|
|
qlcnic_free_mbx_args(&cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if ((cmd->req.arg[0] >> 29) != 0x3)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = tran->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
struct qlcnic_rcv_mbx_out *mbx_out;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_create_rx_ctx(cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
cmd->req.arg[6] = vf->vp->handle;
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
|
|
if (!err) {
|
|
mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
|
|
vf->rx_ctx_id = mbx_out->ctx_id;
|
|
qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
|
|
0, QLCNIC_MAC_ADD);
|
|
} else {
|
|
vf->rx_ctx_id = 0;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
u8 type, *mac;
|
|
|
|
type = cmd->req.arg[1];
|
|
switch (type) {
|
|
case QLCNIC_SET_STATION_MAC:
|
|
case QLCNIC_SET_FAC_DEF_MAC:
|
|
cmd->rsp.arg[0] = (2 << 25);
|
|
break;
|
|
case QLCNIC_GET_CURRENT_MAC:
|
|
cmd->rsp.arg[0] = (1 << 25);
|
|
mac = vf->vp->mac;
|
|
cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
|
|
cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
|
|
((mac[3]) << 16 & 0xff0000) |
|
|
((mac[2]) << 24 & 0xff000000);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if ((cmd->req.arg[0] >> 29) != 0x3)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
struct qlcnic_tx_mbx_out *mbx_out;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_create_tx_ctx(cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
cmd->req.arg[5] |= vf->vp->handle << 16;
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
if (!err) {
|
|
mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
|
|
vf->tx_ctx_id = mbx_out->ctx_id;
|
|
} else {
|
|
vf->tx_ctx_id = 0;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if ((cmd->req.arg[0] >> 29) != 0x3)
|
|
return -EINVAL;
|
|
|
|
if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
|
|
0, QLCNIC_MAC_DEL);
|
|
cmd->req.arg[1] |= vf->vp->handle << 16;
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
|
|
if (!err)
|
|
vf->rx_ctx_id = 0;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if ((cmd->req.arg[0] >> 29) != 0x3)
|
|
return -EINVAL;
|
|
|
|
if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
cmd->req.arg[1] |= vf->vp->handle << 16;
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
|
|
if (!err)
|
|
vf->tx_ctx_id = 0;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err = -EIO;
|
|
u8 op;
|
|
|
|
op = cmd->req.arg[1] & 0xff;
|
|
|
|
cmd->req.arg[1] |= vf->vp->handle << 16;
|
|
cmd->req.arg[1] |= BIT_31;
|
|
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
|
|
return -EINVAL;
|
|
|
|
if (!(cmd->req.arg[1] & BIT_16))
|
|
return -EINVAL;
|
|
|
|
if ((cmd->req.arg[1] & 0xff) != 0x1)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
|
|
if (err)
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
else
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if (cmd->req.arg[1] != vf->rx_ctx_id)
|
|
return -EINVAL;
|
|
|
|
if (cmd->req.arg[2] > adapter->ahw->max_mtu)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
|
|
if (err)
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
else
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if (cmd->req.arg[1] & BIT_31) {
|
|
if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
|
|
return -EINVAL;
|
|
} else {
|
|
cmd->req.arg[1] |= vf->vp->handle << 16;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if (cmd->req.arg[1] != vf->rx_ctx_id)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
|
|
if (err)
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
else
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
|
|
u16 ctx_id, pkts, time;
|
|
|
|
ctx_id = cmd->req.arg[1] >> 16;
|
|
pkts = cmd->req.arg[2] & 0xffff;
|
|
time = cmd->req.arg[2] >> 16;
|
|
|
|
if (ctx_id != vf->rx_ctx_id)
|
|
return -EINVAL;
|
|
if (pkts > coal->rx_packets)
|
|
return -EINVAL;
|
|
if (time < coal->rx_time_us)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = tran->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_macvlan_mbx *macvlan;
|
|
|
|
if (!(cmd->req.arg[1] & BIT_8))
|
|
return -EINVAL;
|
|
|
|
cmd->req.arg[1] |= (vf->vp->handle << 16);
|
|
cmd->req.arg[1] |= BIT_31;
|
|
|
|
macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
|
|
if (!(macvlan->mac_addr0 & BIT_0)) {
|
|
dev_err(&adapter->pdev->dev,
|
|
"MAC address change is not allowed from VF %d",
|
|
vf->pci_func);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
|
|
return -EINVAL;
|
|
|
|
if (!(cmd->req.arg[1] & BIT_8))
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
err = qlcnic_sriov_validate_linkevent(vf, cmd);
|
|
if (err) {
|
|
cmd->rsp.arg[0] |= (0x6 << 25);
|
|
return err;
|
|
}
|
|
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
struct qlcnic_vf_info *vf = trans->vf;
|
|
struct qlcnic_adapter *adapter = vf->adapter;
|
|
int err;
|
|
|
|
cmd->req.arg[1] |= vf->vp->handle << 16;
|
|
cmd->req.arg[1] |= BIT_31;
|
|
err = qlcnic_issue_cmd(adapter, cmd);
|
|
return err;
|
|
}
|
|
|
|
static const int qlcnic_pf_passthru_supp_cmds[] = {
|
|
QLCNIC_CMD_GET_STATISTICS,
|
|
QLCNIC_CMD_GET_PORT_CONFIG,
|
|
QLCNIC_CMD_GET_LINK_STATUS,
|
|
};
|
|
|
|
static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
|
|
[QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
|
|
[QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
|
|
};
|
|
|
|
static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
|
|
{QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
|
|
{QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
|
|
{QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
|
|
{QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
|
|
{QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
|
|
{QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
|
|
{QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
|
|
{QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
|
|
{QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
|
|
{QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
|
|
{QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
|
|
{QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
|
|
{QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
|
|
{QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
|
|
{QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
|
|
};
|
|
|
|
void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
|
|
struct qlcnic_bc_trans *trans,
|
|
struct qlcnic_cmd_args *cmd)
|
|
{
|
|
u8 size, cmd_op;
|
|
|
|
cmd_op = trans->req_hdr->cmd_op;
|
|
|
|
if (trans->req_hdr->op_type == QLC_BC_CMD) {
|
|
size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
|
|
if (cmd_op < size) {
|
|
qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
|
|
return;
|
|
}
|
|
} else {
|
|
int i;
|
|
size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
|
|
for (i = 0; i < size; i++) {
|
|
if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
|
|
qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
|
|
return;
|
|
}
|
|
}
|
|
|
|
size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
|
|
for (i = 0; i < size; i++) {
|
|
if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
|
|
qlcnic_issue_cmd(adapter, cmd);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
cmd->rsp.arg[0] |= (0x9 << 25);
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
u16 vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= vpid;
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
u16 vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= vpid << 16;
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
int vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= vpid << 16;
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
u16 vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= vpid << 16;
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
u16 vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= (vpid << 16) | BIT_31;
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
u16 vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= (vpid << 16) | BIT_31;
|
|
}
|
|
|
|
void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
|
|
u32 *int_id)
|
|
{
|
|
u16 vpid;
|
|
|
|
vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
|
|
adapter->ahw->pci_func);
|
|
*int_id |= (vpid << 16) | BIT_31;
|
|
}
|