Quelle  hnae3.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2016-2017 Hisilicon Limited.

#include <linux/list.h>
#include <linux/spinlock.h>

#include "hnae3.h"

static LIST_HEAD(hnae3_ae_algo_list);
static LIST_HEAD(hnae3_client_list);
static LIST_HEAD(hnae3_ae_dev_list);

void hnae3_unregister_ae_algo_prepare(struct hnae3_ae_algo *ae_algo)
{
 const struct pci_device_id *pci_id;
 struct hnae3_ae_dev *ae_dev;

 if (!ae_algo)
  return;

 list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
  if (!hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))
   continue;

  pci_id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
  if (!pci_id)
   continue;
  if (IS_ENABLED(CONFIG_PCI_IOV)) {
   device_lock(&ae_dev->pdev->dev);
   pci_disable_sriov(ae_dev->pdev);
   device_unlock(&ae_dev->pdev->dev);
  }
 }
}
EXPORT_SYMBOL(hnae3_unregister_ae_algo_prepare);

/* we are keeping things simple and using single lock for all the
 * list. This is a non-critical code so other updations, if happen
 * in parallel, can wait.
 */
static DEFINE_MUTEX(hnae3_common_lock);

/* ensure the drivers being unloaded one by one */
static DEFINE_MUTEX(hnae3_unload_lock);

void hnae3_acquire_unload_lock(void)
{
 mutex_lock(&hnae3_unload_lock);
}
EXPORT_SYMBOL(hnae3_acquire_unload_lock);

void hnae3_release_unload_lock(void)
{
 mutex_unlock(&hnae3_unload_lock);
}
EXPORT_SYMBOL(hnae3_release_unload_lock);

static bool hnae3_client_match(enum hnae3_client_type client_type)
{
 if (client_type == HNAE3_CLIENT_KNIC ||
     client_type == HNAE3_CLIENT_ROCE)
  return true;

 return false;
}

void hnae3_set_client_init_flag(struct hnae3_client *client,
    struct hnae3_ae_dev *ae_dev,
    unsigned int inited)
{
 if (!client || !ae_dev)
  return;

 switch (client->type) {
 case HNAE3_CLIENT_KNIC:
  hnae3_set_bit(ae_dev->flag, HNAE3_KNIC_CLIENT_INITED_B, inited);
  break;
 case HNAE3_CLIENT_ROCE:
  hnae3_set_bit(ae_dev->flag, HNAE3_ROCE_CLIENT_INITED_B, inited);
  break;
 default:
  break;
 }
}
EXPORT_SYMBOL(hnae3_set_client_init_flag);

static int hnae3_get_client_init_flag(struct hnae3_client *client,
          struct hnae3_ae_dev *ae_dev)
{
 int inited = 0;

 switch (client->type) {
 case HNAE3_CLIENT_KNIC:
  inited = hnae3_get_bit(ae_dev->flag,
           HNAE3_KNIC_CLIENT_INITED_B);
  break;
 case HNAE3_CLIENT_ROCE:
  inited = hnae3_get_bit(ae_dev->flag,
           HNAE3_ROCE_CLIENT_INITED_B);
  break;
 default:
  break;
 }

 return inited;
}

static int hnae3_init_client_instance(struct hnae3_client *client,
          struct hnae3_ae_dev *ae_dev)
{
 int ret;

 /* check if this client matches the type of ae_dev */
 if (!(hnae3_client_match(client->type) &&
       hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))) {
  return 0;
 }

 ret = ae_dev->ops->init_client_instance(client, ae_dev);
 if (ret)
  dev_err(&ae_dev->pdev->dev,
   "fail to instantiate client, ret = %d\n", ret);

 return ret;
}

static void hnae3_uninit_client_instance(struct hnae3_client *client,
      struct hnae3_ae_dev *ae_dev)
{
 /* check if this client matches the type of ae_dev */
 if (!(hnae3_client_match(client->type) &&
       hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B)))
  return;

 if (hnae3_get_client_init_flag(client, ae_dev)) {
  ae_dev->ops->uninit_client_instance(client, ae_dev);

  hnae3_set_client_init_flag(client, ae_dev, 0);
 }
}

int hnae3_register_client(struct hnae3_client *client)
{
 struct hnae3_client *client_tmp;
 struct hnae3_ae_dev *ae_dev;

 if (!client)
  return -ENODEV;

 mutex_lock(&hnae3_common_lock);
 /* one system should only have one client for every type */
 list_for_each_entry(client_tmp, &hnae3_client_list, node) {
  if (client_tmp->type == client->type)
   goto exit;
 }

 list_add_tail(&client->node, &hnae3_client_list);

 /* initialize the client on every matched port */
 list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
  /* if the client could not be initialized on current port, for
 * any error reasons, move on to next available port
 */
  int ret = hnae3_init_client_instance(client, ae_dev);
  if (ret)
   dev_err(&ae_dev->pdev->dev,
    "match and instantiation failed for port, ret = %d\n",
    ret);
 }

exit:
 mutex_unlock(&hnae3_common_lock);

 return 0;
}
EXPORT_SYMBOL(hnae3_register_client);

void hnae3_unregister_client(struct hnae3_client *client)
{
 struct hnae3_client *client_tmp;
 struct hnae3_ae_dev *ae_dev;
 bool existed = false;

 if (!client)
  return;

 mutex_lock(&hnae3_common_lock);
 /* one system should only have one client for every type */
 list_for_each_entry(client_tmp, &hnae3_client_list, node) {
  if (client_tmp->type == client->type) {
   existed = true;
   break;
  }
 }

 if (!existed) {
  mutex_unlock(&hnae3_common_lock);
  pr_err("client %s does not exist!\n", client->name);
  return;
 }

 /* un-initialize the client on every matched port */
 list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
  hnae3_uninit_client_instance(client, ae_dev);
 }

 list_del(&client->node);
 mutex_unlock(&hnae3_common_lock);
}
EXPORT_SYMBOL(hnae3_unregister_client);

/* hnae3_register_ae_algo - register a AE algorithm to hnae3 framework
 * @ae_algo: AE algorithm
 * NOTE: the duplicated name will not be checked
 */
void hnae3_register_ae_algo(struct hnae3_ae_algo *ae_algo)
{
 const struct pci_device_id *id;
 struct hnae3_ae_dev *ae_dev;
 struct hnae3_client *client;
 int ret;

 if (!ae_algo)
  return;

 mutex_lock(&hnae3_common_lock);

 list_add_tail(&ae_algo->node, &hnae3_ae_algo_list);

 /* Check if this algo/ops matches the list of ae_devs */
 list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
  id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
  if (!id)
   continue;

  if (!ae_algo->ops) {
   dev_err(&ae_dev->pdev->dev, "ae_algo ops are null\n");
   continue;
  }
  ae_dev->ops = ae_algo->ops;

  ret = ae_algo->ops->init_ae_dev(ae_dev);
  if (ret) {
   dev_err(&ae_dev->pdev->dev,
    "init ae_dev error, ret = %d\n", ret);
   continue;
  }

  /* ae_dev init should set flag */
  hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 1);

  /* check the client list for the match with this ae_dev type and
 * initialize the figure out client instance
 */
  list_for_each_entry(client, &hnae3_client_list, node) {
   ret = hnae3_init_client_instance(client, ae_dev);
   if (ret)
    dev_err(&ae_dev->pdev->dev,
     "match and instantiation failed, ret = %d\n",
     ret);
  }
 }

 mutex_unlock(&hnae3_common_lock);
}
EXPORT_SYMBOL(hnae3_register_ae_algo);

/* hnae3_unregister_ae_algo - unregisters a AE algorithm
 * @ae_algo: the AE algorithm to unregister
 */
void hnae3_unregister_ae_algo(struct hnae3_ae_algo *ae_algo)
{
 const struct pci_device_id *id;
 struct hnae3_ae_dev *ae_dev;
 struct hnae3_client *client;

 if (!ae_algo)
  return;

 mutex_lock(&hnae3_common_lock);
 /* Check if there are matched ae_dev */
 list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
  if (!hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))
   continue;

  id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
  if (!id)
   continue;

  /* check the client list for the match with this ae_dev type and
 * un-initialize the figure out client instance
 */
  list_for_each_entry(client, &hnae3_client_list, node)
   hnae3_uninit_client_instance(client, ae_dev);

  ae_algo->ops->uninit_ae_dev(ae_dev);
  hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 0);
  ae_dev->ops = NULL;
 }

 list_del(&ae_algo->node);
 mutex_unlock(&hnae3_common_lock);
}
EXPORT_SYMBOL(hnae3_unregister_ae_algo);

/* hnae3_register_ae_dev - registers a AE device to hnae3 framework
 * @ae_dev: the AE device
 * NOTE: the duplicated name will not be checked
 */
int hnae3_register_ae_dev(struct hnae3_ae_dev *ae_dev)
{
 const struct pci_device_id *id;
 struct hnae3_ae_algo *ae_algo;
 struct hnae3_client *client;
 int ret;

 if (!ae_dev)
  return -ENODEV;

 mutex_lock(&hnae3_common_lock);

 list_add_tail(&ae_dev->node, &hnae3_ae_dev_list);

 /* Check if there are matched ae_algo */
 list_for_each_entry(ae_algo, &hnae3_ae_algo_list, node) {
  id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
  if (!id)
   continue;

  if (!ae_algo->ops) {
   dev_err(&ae_dev->pdev->dev, "ae_algo ops are null\n");
   ret = -EOPNOTSUPP;
   goto out_err;
  }
  ae_dev->ops = ae_algo->ops;

  ret = ae_dev->ops->init_ae_dev(ae_dev);
  if (ret) {
   dev_err(&ae_dev->pdev->dev,
    "init ae_dev error, ret = %d\n", ret);
   goto out_err;
  }

  /* ae_dev init should set flag */
  hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 1);
  break;
 }

 /* check the client list for the match with this ae_dev type and
 * initialize the figure out client instance
 */
 list_for_each_entry(client, &hnae3_client_list, node) {
  ret = hnae3_init_client_instance(client, ae_dev);
  if (ret)
   dev_err(&ae_dev->pdev->dev,
    "match and instantiation failed, ret = %d\n",
    ret);
 }

 mutex_unlock(&hnae3_common_lock);

 return 0;

out_err:
 list_del(&ae_dev->node);
 mutex_unlock(&hnae3_common_lock);

 return ret;
}
EXPORT_SYMBOL(hnae3_register_ae_dev);

/* hnae3_unregister_ae_dev - unregisters a AE device
 * @ae_dev: the AE device to unregister
 */
void hnae3_unregister_ae_dev(struct hnae3_ae_dev *ae_dev)
{
 const struct pci_device_id *id;
 struct hnae3_ae_algo *ae_algo;
 struct hnae3_client *client;

 if (!ae_dev)
  return;

 mutex_lock(&hnae3_common_lock);
 /* Check if there are matched ae_algo */
 list_for_each_entry(ae_algo, &hnae3_ae_algo_list, node) {
  if (!hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))
   continue;

  id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
  if (!id)
   continue;

  list_for_each_entry(client, &hnae3_client_list, node)
   hnae3_uninit_client_instance(client, ae_dev);

  ae_algo->ops->uninit_ae_dev(ae_dev);
  hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 0);
  ae_dev->ops = NULL;
 }

 list_del(&ae_dev->node);
 mutex_unlock(&hnae3_common_lock);
}
EXPORT_SYMBOL(hnae3_unregister_ae_dev);

MODULE_AUTHOR("Huawei Tech. Co., Ltd.");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("HNAE3(Hisilicon Network Acceleration Engine) Framework");
MODULE_VERSION(HNAE3_MOD_VERSION);