drivers/net/ethernet/hisilicon/hns3/hnae3.c

   1 /*
   2  * Copyright (c) 2016-2017 Hisilicon Limited.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  */
   9
  10 #include <linux/list.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13
  14 #include "hnae3.h"
  15
  16 static LIST_HEAD(hnae3_ae_algo_list);
  17 static LIST_HEAD(hnae3_client_list);
  18 static LIST_HEAD(hnae3_ae_dev_list);
  19
  20 /* we are keeping things simple and using single lock for all the
  21  * list. This is a non-critical code so other updations, if happen
  22  * in parallel, can wait.
  23  */
  24 static DEFINE_MUTEX(hnae3_common_lock);
  25
  26 static bool hnae3_client_match(enum hnae3_client_type client_type,
  27                                enum hnae3_dev_type dev_type)
  28 {
  29         if ((dev_type == HNAE3_DEV_KNIC) && (client_type == HNAE3_CLIENT_KNIC ||
  30                                              client_type == HNAE3_CLIENT_ROCE))
  31                 return true;
  32
  33         if (dev_type == HNAE3_DEV_UNIC && client_type == HNAE3_CLIENT_UNIC)
  34                 return true;
  35
  36         return false;
  37 }
  38
  39 static int hnae3_match_n_instantiate(struct hnae3_client *client,
  40                                      struct hnae3_ae_dev *ae_dev,
  41                                      bool is_reg, bool *matched)
  42 {
  43         int ret;
  44
  45         *matched = false;
  46
  47         /* check if this client matches the type of ae_dev */
  48         if (!(hnae3_client_match(client->type, ae_dev->dev_type) &&
  49               hnae_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))) {
  50                 return 0;
  51         }
  52         /* there is a match of client and dev */
  53         *matched = true;
  54
  55         /* now, (un-)instantiate client by calling lower layer */
  56         if (is_reg) {
  57                 ret = ae_dev->ops->init_client_instance(client, ae_dev);
  58                 if (ret)
  59                         dev_err(&ae_dev->pdev->dev,
  60                                 "fail to instantiate client\n");
  61                 return ret;
  62         }
  63
  64         ae_dev->ops->uninit_client_instance(client, ae_dev);
  65         return 0;
  66 }
  67
  68 int hnae3_register_client(struct hnae3_client *client)
  69 {
  70         struct hnae3_client *client_tmp;
  71         struct hnae3_ae_dev *ae_dev;
  72         bool matched;
  73         int ret = 0;
  74
  75         mutex_lock(&hnae3_common_lock);
  76         /* one system should only have one client for every type */
  77         list_for_each_entry(client_tmp, &hnae3_client_list, node) {
  78                 if (client_tmp->type == client->type)
  79                         goto exit;
  80         }
  81
  82         list_add_tail(&client->node, &hnae3_client_list);
  83
  84         /* initialize the client on every matched port */
  85         list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
  86                 /* if the client could not be initialized on current port, for
  87                  * any error reasons, move on to next available port
  88                  */
  89                 ret = hnae3_match_n_instantiate(client, ae_dev, true, &matched);
  90                 if (ret)
  91                         dev_err(&ae_dev->pdev->dev,
  92                                 "match and instantiation failed for port\n");
  93         }
  94
  95 exit:
  96         mutex_unlock(&hnae3_common_lock);
  97
  98         return ret;
  99 }
 100 EXPORT_SYMBOL(hnae3_register_client);
 101
 102 void hnae3_unregister_client(struct hnae3_client *client)
 103 {
 104         struct hnae3_ae_dev *ae_dev;
 105         bool matched;
 106
 107         mutex_lock(&hnae3_common_lock);
 108         /* un-initialize the client on every matched port */
 109         list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
 110                 hnae3_match_n_instantiate(client, ae_dev, false, &matched);
 111         }
 112
 113         list_del(&client->node);
 114         mutex_unlock(&hnae3_common_lock);
 115 }
 116 EXPORT_SYMBOL(hnae3_unregister_client);
 117
 118 /* hnae3_register_ae_algo - register a AE algorithm to hnae3 framework
 119  * @ae_algo: AE algorithm
 120  * NOTE: the duplicated name will not be checked
 121  */
 122 int hnae3_register_ae_algo(struct hnae3_ae_algo *ae_algo)
 123 {
 124         const struct pci_device_id *id;
 125         struct hnae3_ae_dev *ae_dev;
 126         struct hnae3_client *client;
 127         bool matched;
 128         int ret = 0;
 129
 130         mutex_lock(&hnae3_common_lock);
 131
 132         list_add_tail(&ae_algo->node, &hnae3_ae_algo_list);
 133
 134         /* Check if this algo/ops matches the list of ae_devs */
 135         list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
 136                 id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
 137                 if (!id)
 138                         continue;
 139
 140                 /* ae_dev init should set flag */
 141                 ae_dev->ops = ae_algo->ops;
 142                 ret = ae_algo->ops->init_ae_dev(ae_dev);
 143                 if (ret) {
 144                         dev_err(&ae_dev->pdev->dev, "init ae_dev error.\n");
 145                         continue;
 146                 }
 147
 148                 hnae_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 1);
 149
 150                 /* check the client list for the match with this ae_dev type and
 151                  * initialize the figure out client instance
 152                  */
 153                 list_for_each_entry(client, &hnae3_client_list, node) {
 154                         ret = hnae3_match_n_instantiate(client, ae_dev, true,
 155                                                         &matched);
 156                         if (ret)
 157                                 dev_err(&ae_dev->pdev->dev,
 158                                         "match and instantiation failed\n");
 159                         if (matched)
 160                                 break;
 161                 }
 162         }
 163
 164         mutex_unlock(&hnae3_common_lock);
 165
 166         return ret;
 167 }
 168 EXPORT_SYMBOL(hnae3_register_ae_algo);
 169
 170 /* hnae3_unregister_ae_algo - unregisters a AE algorithm
 171  * @ae_algo: the AE algorithm to unregister
 172  */
 173 void hnae3_unregister_ae_algo(struct hnae3_ae_algo *ae_algo)
 174 {
 175         const struct pci_device_id *id;
 176         struct hnae3_ae_dev *ae_dev;
 177         struct hnae3_client *client;
 178         bool matched;
 179
 180         mutex_lock(&hnae3_common_lock);
 181         /* Check if there are matched ae_dev */
 182         list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
 183                 id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
 184                 if (!id)
 185                         continue;
 186
 187                 /* check the client list for the match with this ae_dev type and
 188                  * un-initialize the figure out client instance
 189                  */
 190                 list_for_each_entry(client, &hnae3_client_list, node) {
 191                         hnae3_match_n_instantiate(client, ae_dev, false,
 192                                                   &matched);
 193                         if (matched)
 194                                 break;
 195                 }
 196
 197                 ae_algo->ops->uninit_ae_dev(ae_dev);
 198                 hnae_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 0);
 199         }
 200
 201         list_del(&ae_algo->node);
 202         mutex_unlock(&hnae3_common_lock);
 203 }
 204 EXPORT_SYMBOL(hnae3_unregister_ae_algo);
 205
 206 /* hnae3_register_ae_dev - registers a AE device to hnae3 framework
 207  * @ae_dev: the AE device
 208  * NOTE: the duplicated name will not be checked
 209  */
 210 int hnae3_register_ae_dev(struct hnae3_ae_dev *ae_dev)
 211 {
 212         const struct pci_device_id *id;
 213         struct hnae3_ae_algo *ae_algo;
 214         struct hnae3_client *client;
 215         bool matched;
 216         int ret = 0;
 217
 218         mutex_lock(&hnae3_common_lock);
 219         list_add_tail(&ae_dev->node, &hnae3_ae_dev_list);
 220
 221         /* Check if there are matched ae_algo */
 222         list_for_each_entry(ae_algo, &hnae3_ae_algo_list, node) {
 223                 id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
 224                 if (!id)
 225                         continue;
 226
 227                 ae_dev->ops = ae_algo->ops;
 228
 229                 if (!ae_dev->ops) {
 230                         dev_err(&ae_dev->pdev->dev, "ae_dev ops are null\n");
 231                         goto out_err;
 232                 }
 233
 234                 /* ae_dev init should set flag */
 235                 ret = ae_dev->ops->init_ae_dev(ae_dev);
 236                 if (ret) {
 237                         dev_err(&ae_dev->pdev->dev, "init ae_dev error\n");
 238                         goto out_err;
 239                 }
 240
 241                 hnae_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 1);
 242                 break;
 243         }
 244
 245         /* check the client list for the match with this ae_dev type and
 246          * initialize the figure out client instance
 247          */
 248         list_for_each_entry(client, &hnae3_client_list, node) {
 249                 ret = hnae3_match_n_instantiate(client, ae_dev, true,
 250                                                 &matched);
 251                 if (ret)
 252                         dev_err(&ae_dev->pdev->dev,
 253                                 "match and instantiation failed\n");
 254                 if (matched)
 255                         break;
 256         }
 257
 258 out_err:
 259         mutex_unlock(&hnae3_common_lock);
 260
 261         return ret;
 262 }
 263 EXPORT_SYMBOL(hnae3_register_ae_dev);
 264
 265 /* hnae3_unregister_ae_dev - unregisters a AE device
 266  * @ae_dev: the AE device to unregister
 267  */
 268 void hnae3_unregister_ae_dev(struct hnae3_ae_dev *ae_dev)
 269 {
 270         const struct pci_device_id *id;
 271         struct hnae3_ae_algo *ae_algo;
 272         struct hnae3_client *client;
 273         bool matched;
 274
 275         mutex_lock(&hnae3_common_lock);
 276         /* Check if there are matched ae_algo */
 277         list_for_each_entry(ae_algo, &hnae3_ae_algo_list, node) {
 278                 id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
 279                 if (!id)
 280                         continue;
 281
 282                 list_for_each_entry(client, &hnae3_client_list, node) {
 283                         hnae3_match_n_instantiate(client, ae_dev, false,
 284                                                   &matched);
 285                         if (matched)
 286                                 break;
 287                 }
 288
 289                 ae_algo->ops->uninit_ae_dev(ae_dev);
 290                 hnae_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 0);
 291         }
 292
 293         list_del(&ae_dev->node);
 294         mutex_unlock(&hnae3_common_lock);
 295 }
 296 EXPORT_SYMBOL(hnae3_unregister_ae_dev);
 297
 298 MODULE_AUTHOR("Huawei Tech. Co., Ltd.");
 299 MODULE_LICENSE("GPL");
 300 MODULE_DESCRIPTION("HNAE3(Hisilicon Network Acceleration Engine) Framework");