mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
578 lines
15 KiB
578 lines
15 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* Copyright(c) 2013 - 2018 Intel Corporation. */ |
|
|
|
#include <linux/list.h> |
|
#include <linux/errno.h> |
|
|
|
#include "iavf.h" |
|
#include "iavf_prototype.h" |
|
#include "iavf_client.h" |
|
|
|
static |
|
const char iavf_client_interface_version_str[] = IAVF_CLIENT_VERSION_STR; |
|
static struct iavf_client *vf_registered_client; |
|
static LIST_HEAD(iavf_devices); |
|
static DEFINE_MUTEX(iavf_device_mutex); |
|
|
|
static u32 iavf_client_virtchnl_send(struct iavf_info *ldev, |
|
struct iavf_client *client, |
|
u8 *msg, u16 len); |
|
|
|
static int iavf_client_setup_qvlist(struct iavf_info *ldev, |
|
struct iavf_client *client, |
|
struct iavf_qvlist_info *qvlist_info); |
|
|
|
static struct iavf_ops iavf_lan_ops = { |
|
.virtchnl_send = iavf_client_virtchnl_send, |
|
.setup_qvlist = iavf_client_setup_qvlist, |
|
}; |
|
|
|
/** |
|
* iavf_client_get_params - retrieve relevant client parameters |
|
* @vsi: VSI with parameters |
|
* @params: client param struct |
|
**/ |
|
static |
|
void iavf_client_get_params(struct iavf_vsi *vsi, struct iavf_params *params) |
|
{ |
|
int i; |
|
|
|
memset(params, 0, sizeof(struct iavf_params)); |
|
params->mtu = vsi->netdev->mtu; |
|
params->link_up = vsi->back->link_up; |
|
|
|
for (i = 0; i < IAVF_MAX_USER_PRIORITY; i++) { |
|
params->qos.prio_qos[i].tc = 0; |
|
params->qos.prio_qos[i].qs_handle = vsi->qs_handle; |
|
} |
|
} |
|
|
|
/** |
|
* iavf_notify_client_message - call the client message receive callback |
|
* @vsi: the VSI associated with this client |
|
* @msg: message buffer |
|
* @len: length of message |
|
* |
|
* If there is a client to this VSI, call the client |
|
**/ |
|
void iavf_notify_client_message(struct iavf_vsi *vsi, u8 *msg, u16 len) |
|
{ |
|
struct iavf_client_instance *cinst; |
|
|
|
if (!vsi) |
|
return; |
|
|
|
cinst = vsi->back->cinst; |
|
if (!cinst || !cinst->client || !cinst->client->ops || |
|
!cinst->client->ops->virtchnl_receive) { |
|
dev_dbg(&vsi->back->pdev->dev, |
|
"Cannot locate client instance virtchnl_receive function\n"); |
|
return; |
|
} |
|
cinst->client->ops->virtchnl_receive(&cinst->lan_info, cinst->client, |
|
msg, len); |
|
} |
|
|
|
/** |
|
* iavf_notify_client_l2_params - call the client notify callback |
|
* @vsi: the VSI with l2 param changes |
|
* |
|
* If there is a client to this VSI, call the client |
|
**/ |
|
void iavf_notify_client_l2_params(struct iavf_vsi *vsi) |
|
{ |
|
struct iavf_client_instance *cinst; |
|
struct iavf_params params; |
|
|
|
if (!vsi) |
|
return; |
|
|
|
cinst = vsi->back->cinst; |
|
|
|
if (!cinst || !cinst->client || !cinst->client->ops || |
|
!cinst->client->ops->l2_param_change) { |
|
dev_dbg(&vsi->back->pdev->dev, |
|
"Cannot locate client instance l2_param_change function\n"); |
|
return; |
|
} |
|
iavf_client_get_params(vsi, ¶ms); |
|
cinst->lan_info.params = params; |
|
cinst->client->ops->l2_param_change(&cinst->lan_info, cinst->client, |
|
¶ms); |
|
} |
|
|
|
/** |
|
* iavf_notify_client_open - call the client open callback |
|
* @vsi: the VSI with netdev opened |
|
* |
|
* If there is a client to this netdev, call the client with open |
|
**/ |
|
void iavf_notify_client_open(struct iavf_vsi *vsi) |
|
{ |
|
struct iavf_adapter *adapter = vsi->back; |
|
struct iavf_client_instance *cinst = adapter->cinst; |
|
int ret; |
|
|
|
if (!cinst || !cinst->client || !cinst->client->ops || |
|
!cinst->client->ops->open) { |
|
dev_dbg(&vsi->back->pdev->dev, |
|
"Cannot locate client instance open function\n"); |
|
return; |
|
} |
|
if (!(test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state))) { |
|
ret = cinst->client->ops->open(&cinst->lan_info, cinst->client); |
|
if (!ret) |
|
set_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state); |
|
} |
|
} |
|
|
|
/** |
|
* iavf_client_release_qvlist - send a message to the PF to release iwarp qv map |
|
* @ldev: pointer to L2 context. |
|
* |
|
* Return 0 on success or < 0 on error |
|
**/ |
|
static int iavf_client_release_qvlist(struct iavf_info *ldev) |
|
{ |
|
struct iavf_adapter *adapter = ldev->vf; |
|
enum iavf_status err; |
|
|
|
if (adapter->aq_required) |
|
return -EAGAIN; |
|
|
|
err = iavf_aq_send_msg_to_pf(&adapter->hw, |
|
VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP, |
|
IAVF_SUCCESS, NULL, 0, NULL); |
|
|
|
if (err) |
|
dev_err(&adapter->pdev->dev, |
|
"Unable to send iWarp vector release message to PF, error %d, aq status %d\n", |
|
err, adapter->hw.aq.asq_last_status); |
|
|
|
return err; |
|
} |
|
|
|
/** |
|
* iavf_notify_client_close - call the client close callback |
|
* @vsi: the VSI with netdev closed |
|
* @reset: true when close called due to reset pending |
|
* |
|
* If there is a client to this netdev, call the client with close |
|
**/ |
|
void iavf_notify_client_close(struct iavf_vsi *vsi, bool reset) |
|
{ |
|
struct iavf_adapter *adapter = vsi->back; |
|
struct iavf_client_instance *cinst = adapter->cinst; |
|
|
|
if (!cinst || !cinst->client || !cinst->client->ops || |
|
!cinst->client->ops->close) { |
|
dev_dbg(&vsi->back->pdev->dev, |
|
"Cannot locate client instance close function\n"); |
|
return; |
|
} |
|
cinst->client->ops->close(&cinst->lan_info, cinst->client, reset); |
|
iavf_client_release_qvlist(&cinst->lan_info); |
|
clear_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state); |
|
} |
|
|
|
/** |
|
* iavf_client_add_instance - add a client instance to the instance list |
|
* @adapter: pointer to the board struct |
|
* |
|
* Returns cinst ptr on success, NULL on failure |
|
**/ |
|
static struct iavf_client_instance * |
|
iavf_client_add_instance(struct iavf_adapter *adapter) |
|
{ |
|
struct iavf_client_instance *cinst = NULL; |
|
struct iavf_vsi *vsi = &adapter->vsi; |
|
struct netdev_hw_addr *mac = NULL; |
|
struct iavf_params params; |
|
|
|
if (!vf_registered_client) |
|
goto out; |
|
|
|
if (adapter->cinst) { |
|
cinst = adapter->cinst; |
|
goto out; |
|
} |
|
|
|
cinst = kzalloc(sizeof(*cinst), GFP_KERNEL); |
|
if (!cinst) |
|
goto out; |
|
|
|
cinst->lan_info.vf = (void *)adapter; |
|
cinst->lan_info.netdev = vsi->netdev; |
|
cinst->lan_info.pcidev = adapter->pdev; |
|
cinst->lan_info.fid = 0; |
|
cinst->lan_info.ftype = IAVF_CLIENT_FTYPE_VF; |
|
cinst->lan_info.hw_addr = adapter->hw.hw_addr; |
|
cinst->lan_info.ops = &iavf_lan_ops; |
|
cinst->lan_info.version.major = IAVF_CLIENT_VERSION_MAJOR; |
|
cinst->lan_info.version.minor = IAVF_CLIENT_VERSION_MINOR; |
|
cinst->lan_info.version.build = IAVF_CLIENT_VERSION_BUILD; |
|
iavf_client_get_params(vsi, ¶ms); |
|
cinst->lan_info.params = params; |
|
set_bit(__IAVF_CLIENT_INSTANCE_NONE, &cinst->state); |
|
|
|
cinst->lan_info.msix_count = adapter->num_iwarp_msix; |
|
cinst->lan_info.msix_entries = |
|
&adapter->msix_entries[adapter->iwarp_base_vector]; |
|
|
|
mac = list_first_entry(&cinst->lan_info.netdev->dev_addrs.list, |
|
struct netdev_hw_addr, list); |
|
if (mac) |
|
ether_addr_copy(cinst->lan_info.lanmac, mac->addr); |
|
else |
|
dev_err(&adapter->pdev->dev, "MAC address list is empty!\n"); |
|
|
|
cinst->client = vf_registered_client; |
|
adapter->cinst = cinst; |
|
out: |
|
return cinst; |
|
} |
|
|
|
/** |
|
* iavf_client_del_instance - removes a client instance from the list |
|
* @adapter: pointer to the board struct |
|
* |
|
**/ |
|
static |
|
void iavf_client_del_instance(struct iavf_adapter *adapter) |
|
{ |
|
kfree(adapter->cinst); |
|
adapter->cinst = NULL; |
|
} |
|
|
|
/** |
|
* iavf_client_subtask - client maintenance work |
|
* @adapter: board private structure |
|
**/ |
|
void iavf_client_subtask(struct iavf_adapter *adapter) |
|
{ |
|
struct iavf_client *client = vf_registered_client; |
|
struct iavf_client_instance *cinst; |
|
int ret = 0; |
|
|
|
if (adapter->state < __IAVF_DOWN) |
|
return; |
|
|
|
/* first check client is registered */ |
|
if (!client) |
|
return; |
|
|
|
/* Add the client instance to the instance list */ |
|
cinst = iavf_client_add_instance(adapter); |
|
if (!cinst) |
|
return; |
|
|
|
dev_info(&adapter->pdev->dev, "Added instance of Client %s\n", |
|
client->name); |
|
|
|
if (!test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state)) { |
|
/* Send an Open request to the client */ |
|
|
|
if (client->ops && client->ops->open) |
|
ret = client->ops->open(&cinst->lan_info, client); |
|
if (!ret) |
|
set_bit(__IAVF_CLIENT_INSTANCE_OPENED, |
|
&cinst->state); |
|
else |
|
/* remove client instance */ |
|
iavf_client_del_instance(adapter); |
|
} |
|
} |
|
|
|
/** |
|
* iavf_lan_add_device - add a lan device struct to the list of lan devices |
|
* @adapter: pointer to the board struct |
|
* |
|
* Returns 0 on success or none 0 on error |
|
**/ |
|
int iavf_lan_add_device(struct iavf_adapter *adapter) |
|
{ |
|
struct iavf_device *ldev; |
|
int ret = 0; |
|
|
|
mutex_lock(&iavf_device_mutex); |
|
list_for_each_entry(ldev, &iavf_devices, list) { |
|
if (ldev->vf == adapter) { |
|
ret = -EEXIST; |
|
goto out; |
|
} |
|
} |
|
ldev = kzalloc(sizeof(*ldev), GFP_KERNEL); |
|
if (!ldev) { |
|
ret = -ENOMEM; |
|
goto out; |
|
} |
|
ldev->vf = adapter; |
|
INIT_LIST_HEAD(&ldev->list); |
|
list_add(&ldev->list, &iavf_devices); |
|
dev_info(&adapter->pdev->dev, "Added LAN device bus=0x%02x dev=0x%02x func=0x%02x\n", |
|
adapter->hw.bus.bus_id, adapter->hw.bus.device, |
|
adapter->hw.bus.func); |
|
|
|
/* Since in some cases register may have happened before a device gets |
|
* added, we can schedule a subtask to go initiate the clients. |
|
*/ |
|
adapter->flags |= IAVF_FLAG_SERVICE_CLIENT_REQUESTED; |
|
|
|
out: |
|
mutex_unlock(&iavf_device_mutex); |
|
return ret; |
|
} |
|
|
|
/** |
|
* iavf_lan_del_device - removes a lan device from the device list |
|
* @adapter: pointer to the board struct |
|
* |
|
* Returns 0 on success or non-0 on error |
|
**/ |
|
int iavf_lan_del_device(struct iavf_adapter *adapter) |
|
{ |
|
struct iavf_device *ldev, *tmp; |
|
int ret = -ENODEV; |
|
|
|
mutex_lock(&iavf_device_mutex); |
|
list_for_each_entry_safe(ldev, tmp, &iavf_devices, list) { |
|
if (ldev->vf == adapter) { |
|
dev_info(&adapter->pdev->dev, |
|
"Deleted LAN device bus=0x%02x dev=0x%02x func=0x%02x\n", |
|
adapter->hw.bus.bus_id, adapter->hw.bus.device, |
|
adapter->hw.bus.func); |
|
list_del(&ldev->list); |
|
kfree(ldev); |
|
ret = 0; |
|
break; |
|
} |
|
} |
|
|
|
mutex_unlock(&iavf_device_mutex); |
|
return ret; |
|
} |
|
|
|
/** |
|
* iavf_client_release - release client specific resources |
|
* @client: pointer to the registered client |
|
* |
|
**/ |
|
static void iavf_client_release(struct iavf_client *client) |
|
{ |
|
struct iavf_client_instance *cinst; |
|
struct iavf_device *ldev; |
|
struct iavf_adapter *adapter; |
|
|
|
mutex_lock(&iavf_device_mutex); |
|
list_for_each_entry(ldev, &iavf_devices, list) { |
|
adapter = ldev->vf; |
|
cinst = adapter->cinst; |
|
if (!cinst) |
|
continue; |
|
if (test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state)) { |
|
if (client->ops && client->ops->close) |
|
client->ops->close(&cinst->lan_info, client, |
|
false); |
|
iavf_client_release_qvlist(&cinst->lan_info); |
|
clear_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state); |
|
|
|
dev_warn(&adapter->pdev->dev, |
|
"Client %s instance closed\n", client->name); |
|
} |
|
/* delete the client instance */ |
|
iavf_client_del_instance(adapter); |
|
dev_info(&adapter->pdev->dev, "Deleted client instance of Client %s\n", |
|
client->name); |
|
} |
|
mutex_unlock(&iavf_device_mutex); |
|
} |
|
|
|
/** |
|
* iavf_client_prepare - prepare client specific resources |
|
* @client: pointer to the registered client |
|
* |
|
**/ |
|
static void iavf_client_prepare(struct iavf_client *client) |
|
{ |
|
struct iavf_device *ldev; |
|
struct iavf_adapter *adapter; |
|
|
|
mutex_lock(&iavf_device_mutex); |
|
list_for_each_entry(ldev, &iavf_devices, list) { |
|
adapter = ldev->vf; |
|
/* Signal the watchdog to service the client */ |
|
adapter->flags |= IAVF_FLAG_SERVICE_CLIENT_REQUESTED; |
|
} |
|
mutex_unlock(&iavf_device_mutex); |
|
} |
|
|
|
/** |
|
* iavf_client_virtchnl_send - send a message to the PF instance |
|
* @ldev: pointer to L2 context. |
|
* @client: Client pointer. |
|
* @msg: pointer to message buffer |
|
* @len: message length |
|
* |
|
* Return 0 on success or < 0 on error |
|
**/ |
|
static u32 iavf_client_virtchnl_send(struct iavf_info *ldev, |
|
struct iavf_client *client, |
|
u8 *msg, u16 len) |
|
{ |
|
struct iavf_adapter *adapter = ldev->vf; |
|
enum iavf_status err; |
|
|
|
if (adapter->aq_required) |
|
return -EAGAIN; |
|
|
|
err = iavf_aq_send_msg_to_pf(&adapter->hw, VIRTCHNL_OP_IWARP, |
|
IAVF_SUCCESS, msg, len, NULL); |
|
if (err) |
|
dev_err(&adapter->pdev->dev, "Unable to send iWarp message to PF, error %d, aq status %d\n", |
|
err, adapter->hw.aq.asq_last_status); |
|
|
|
return err; |
|
} |
|
|
|
/** |
|
* iavf_client_setup_qvlist - send a message to the PF to setup iwarp qv map |
|
* @ldev: pointer to L2 context. |
|
* @client: Client pointer. |
|
* @qvlist_info: queue and vector list |
|
* |
|
* Return 0 on success or < 0 on error |
|
**/ |
|
static int iavf_client_setup_qvlist(struct iavf_info *ldev, |
|
struct iavf_client *client, |
|
struct iavf_qvlist_info *qvlist_info) |
|
{ |
|
struct virtchnl_iwarp_qvlist_info *v_qvlist_info; |
|
struct iavf_adapter *adapter = ldev->vf; |
|
struct iavf_qv_info *qv_info; |
|
enum iavf_status err; |
|
u32 v_idx, i; |
|
size_t msg_size; |
|
|
|
if (adapter->aq_required) |
|
return -EAGAIN; |
|
|
|
/* A quick check on whether the vectors belong to the client */ |
|
for (i = 0; i < qvlist_info->num_vectors; i++) { |
|
qv_info = &qvlist_info->qv_info[i]; |
|
if (!qv_info) |
|
continue; |
|
v_idx = qv_info->v_idx; |
|
if ((v_idx >= |
|
(adapter->iwarp_base_vector + adapter->num_iwarp_msix)) || |
|
(v_idx < adapter->iwarp_base_vector)) |
|
return -EINVAL; |
|
} |
|
|
|
v_qvlist_info = (struct virtchnl_iwarp_qvlist_info *)qvlist_info; |
|
msg_size = struct_size(v_qvlist_info, qv_info, |
|
v_qvlist_info->num_vectors - 1); |
|
|
|
adapter->client_pending |= BIT(VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP); |
|
err = iavf_aq_send_msg_to_pf(&adapter->hw, |
|
VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP, IAVF_SUCCESS, |
|
(u8 *)v_qvlist_info, msg_size, NULL); |
|
|
|
if (err) { |
|
dev_err(&adapter->pdev->dev, |
|
"Unable to send iWarp vector config message to PF, error %d, aq status %d\n", |
|
err, adapter->hw.aq.asq_last_status); |
|
goto out; |
|
} |
|
|
|
err = -EBUSY; |
|
for (i = 0; i < 5; i++) { |
|
msleep(100); |
|
if (!(adapter->client_pending & |
|
BIT(VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP))) { |
|
err = 0; |
|
break; |
|
} |
|
} |
|
out: |
|
return err; |
|
} |
|
|
|
/** |
|
* iavf_register_client - Register a iavf client driver with the L2 driver |
|
* @client: pointer to the iavf_client struct |
|
* |
|
* Returns 0 on success or non-0 on error |
|
**/ |
|
int iavf_register_client(struct iavf_client *client) |
|
{ |
|
int ret = 0; |
|
|
|
if (!client) { |
|
ret = -EIO; |
|
goto out; |
|
} |
|
|
|
if (strlen(client->name) == 0) { |
|
pr_info("iavf: Failed to register client with no name\n"); |
|
ret = -EIO; |
|
goto out; |
|
} |
|
|
|
if (vf_registered_client) { |
|
pr_info("iavf: Client %s has already been registered!\n", |
|
client->name); |
|
ret = -EEXIST; |
|
goto out; |
|
} |
|
|
|
if ((client->version.major != IAVF_CLIENT_VERSION_MAJOR) || |
|
(client->version.minor != IAVF_CLIENT_VERSION_MINOR)) { |
|
pr_info("iavf: Failed to register client %s due to mismatched client interface version\n", |
|
client->name); |
|
pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n", |
|
client->version.major, client->version.minor, |
|
client->version.build, |
|
iavf_client_interface_version_str); |
|
ret = -EIO; |
|
goto out; |
|
} |
|
|
|
vf_registered_client = client; |
|
|
|
iavf_client_prepare(client); |
|
|
|
pr_info("iavf: Registered client %s with return code %d\n", |
|
client->name, ret); |
|
out: |
|
return ret; |
|
} |
|
EXPORT_SYMBOL(iavf_register_client); |
|
|
|
/** |
|
* iavf_unregister_client - Unregister a iavf client driver with the L2 driver |
|
* @client: pointer to the iavf_client struct |
|
* |
|
* Returns 0 on success or non-0 on error |
|
**/ |
|
int iavf_unregister_client(struct iavf_client *client) |
|
{ |
|
int ret = 0; |
|
|
|
/* When a unregister request comes through we would have to send |
|
* a close for each of the client instances that were opened. |
|
* client_release function is called to handle this. |
|
*/ |
|
iavf_client_release(client); |
|
|
|
if (vf_registered_client != client) { |
|
pr_info("iavf: Client %s has not been registered\n", |
|
client->name); |
|
ret = -ENODEV; |
|
goto out; |
|
} |
|
vf_registered_client = NULL; |
|
pr_info("iavf: Unregistered client %s\n", client->name); |
|
out: |
|
return ret; |
|
} |
|
EXPORT_SYMBOL(iavf_unregister_client);
|
|
|