1  // SPDX-License-Identifier: GPL-2.0+
2  // Copyright (c) 2016-2017 Hisilicon Limited.
3  
4  #include <linux/list.h>
5  #include <linux/spinlock.h>
6  
7  #include "hnae3.h"
8  
9  static LIST_HEAD(hnae3_ae_algo_list);
10  static LIST_HEAD(hnae3_client_list);
11  static LIST_HEAD(hnae3_ae_dev_list);
12  
hnae3_unregister_ae_algo_prepare(struct hnae3_ae_algo * ae_algo)13  void hnae3_unregister_ae_algo_prepare(struct hnae3_ae_algo *ae_algo)
14  {
15  	const struct pci_device_id *pci_id;
16  	struct hnae3_ae_dev *ae_dev;
17  
18  	if (!ae_algo)
19  		return;
20  
21  	list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
22  		if (!hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))
23  			continue;
24  
25  		pci_id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
26  		if (!pci_id)
27  			continue;
28  		if (IS_ENABLED(CONFIG_PCI_IOV)) {
29  			device_lock(&ae_dev->pdev->dev);
30  			pci_disable_sriov(ae_dev->pdev);
31  			device_unlock(&ae_dev->pdev->dev);
32  		}
33  	}
34  }
35  EXPORT_SYMBOL(hnae3_unregister_ae_algo_prepare);
36  
37  /* we are keeping things simple and using single lock for all the
38   * list. This is a non-critical code so other updations, if happen
39   * in parallel, can wait.
40   */
41  static DEFINE_MUTEX(hnae3_common_lock);
42  
hnae3_client_match(enum hnae3_client_type client_type)43  static bool hnae3_client_match(enum hnae3_client_type client_type)
44  {
45  	if (client_type == HNAE3_CLIENT_KNIC ||
46  	    client_type == HNAE3_CLIENT_ROCE)
47  		return true;
48  
49  	return false;
50  }
51  
hnae3_set_client_init_flag(struct hnae3_client * client,struct hnae3_ae_dev * ae_dev,unsigned int inited)52  void hnae3_set_client_init_flag(struct hnae3_client *client,
53  				struct hnae3_ae_dev *ae_dev,
54  				unsigned int inited)
55  {
56  	if (!client || !ae_dev)
57  		return;
58  
59  	switch (client->type) {
60  	case HNAE3_CLIENT_KNIC:
61  		hnae3_set_bit(ae_dev->flag, HNAE3_KNIC_CLIENT_INITED_B, inited);
62  		break;
63  	case HNAE3_CLIENT_ROCE:
64  		hnae3_set_bit(ae_dev->flag, HNAE3_ROCE_CLIENT_INITED_B, inited);
65  		break;
66  	default:
67  		break;
68  	}
69  }
70  EXPORT_SYMBOL(hnae3_set_client_init_flag);
71  
hnae3_get_client_init_flag(struct hnae3_client * client,struct hnae3_ae_dev * ae_dev)72  static int hnae3_get_client_init_flag(struct hnae3_client *client,
73  				      struct hnae3_ae_dev *ae_dev)
74  {
75  	int inited = 0;
76  
77  	switch (client->type) {
78  	case HNAE3_CLIENT_KNIC:
79  		inited = hnae3_get_bit(ae_dev->flag,
80  				       HNAE3_KNIC_CLIENT_INITED_B);
81  		break;
82  	case HNAE3_CLIENT_ROCE:
83  		inited = hnae3_get_bit(ae_dev->flag,
84  				       HNAE3_ROCE_CLIENT_INITED_B);
85  		break;
86  	default:
87  		break;
88  	}
89  
90  	return inited;
91  }
92  
hnae3_init_client_instance(struct hnae3_client * client,struct hnae3_ae_dev * ae_dev)93  static int hnae3_init_client_instance(struct hnae3_client *client,
94  				      struct hnae3_ae_dev *ae_dev)
95  {
96  	int ret;
97  
98  	/* check if this client matches the type of ae_dev */
99  	if (!(hnae3_client_match(client->type) &&
100  	      hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))) {
101  		return 0;
102  	}
103  
104  	ret = ae_dev->ops->init_client_instance(client, ae_dev);
105  	if (ret)
106  		dev_err(&ae_dev->pdev->dev,
107  			"fail to instantiate client, ret = %d\n", ret);
108  
109  	return ret;
110  }
111  
hnae3_uninit_client_instance(struct hnae3_client * client,struct hnae3_ae_dev * ae_dev)112  static void hnae3_uninit_client_instance(struct hnae3_client *client,
113  					 struct hnae3_ae_dev *ae_dev)
114  {
115  	/* check if this client matches the type of ae_dev */
116  	if (!(hnae3_client_match(client->type) &&
117  	      hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B)))
118  		return;
119  
120  	if (hnae3_get_client_init_flag(client, ae_dev)) {
121  		ae_dev->ops->uninit_client_instance(client, ae_dev);
122  
123  		hnae3_set_client_init_flag(client, ae_dev, 0);
124  	}
125  }
126  
hnae3_register_client(struct hnae3_client * client)127  int hnae3_register_client(struct hnae3_client *client)
128  {
129  	struct hnae3_client *client_tmp;
130  	struct hnae3_ae_dev *ae_dev;
131  
132  	if (!client)
133  		return -ENODEV;
134  
135  	mutex_lock(&hnae3_common_lock);
136  	/* one system should only have one client for every type */
137  	list_for_each_entry(client_tmp, &hnae3_client_list, node) {
138  		if (client_tmp->type == client->type)
139  			goto exit;
140  	}
141  
142  	list_add_tail(&client->node, &hnae3_client_list);
143  
144  	/* initialize the client on every matched port */
145  	list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
146  		/* if the client could not be initialized on current port, for
147  		 * any error reasons, move on to next available port
148  		 */
149  		int ret = hnae3_init_client_instance(client, ae_dev);
150  		if (ret)
151  			dev_err(&ae_dev->pdev->dev,
152  				"match and instantiation failed for port, ret = %d\n",
153  				ret);
154  	}
155  
156  exit:
157  	mutex_unlock(&hnae3_common_lock);
158  
159  	return 0;
160  }
161  EXPORT_SYMBOL(hnae3_register_client);
162  
hnae3_unregister_client(struct hnae3_client * client)163  void hnae3_unregister_client(struct hnae3_client *client)
164  {
165  	struct hnae3_client *client_tmp;
166  	struct hnae3_ae_dev *ae_dev;
167  	bool existed = false;
168  
169  	if (!client)
170  		return;
171  
172  	mutex_lock(&hnae3_common_lock);
173  	/* one system should only have one client for every type */
174  	list_for_each_entry(client_tmp, &hnae3_client_list, node) {
175  		if (client_tmp->type == client->type) {
176  			existed = true;
177  			break;
178  		}
179  	}
180  
181  	if (!existed) {
182  		mutex_unlock(&hnae3_common_lock);
183  		pr_err("client %s does not exist!\n", client->name);
184  		return;
185  	}
186  
187  	/* un-initialize the client on every matched port */
188  	list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
189  		hnae3_uninit_client_instance(client, ae_dev);
190  	}
191  
192  	list_del(&client->node);
193  	mutex_unlock(&hnae3_common_lock);
194  }
195  EXPORT_SYMBOL(hnae3_unregister_client);
196  
197  /* hnae3_register_ae_algo - register a AE algorithm to hnae3 framework
198   * @ae_algo: AE algorithm
199   * NOTE: the duplicated name will not be checked
200   */
hnae3_register_ae_algo(struct hnae3_ae_algo * ae_algo)201  void hnae3_register_ae_algo(struct hnae3_ae_algo *ae_algo)
202  {
203  	const struct pci_device_id *id;
204  	struct hnae3_ae_dev *ae_dev;
205  	struct hnae3_client *client;
206  	int ret;
207  
208  	if (!ae_algo)
209  		return;
210  
211  	mutex_lock(&hnae3_common_lock);
212  
213  	list_add_tail(&ae_algo->node, &hnae3_ae_algo_list);
214  
215  	/* Check if this algo/ops matches the list of ae_devs */
216  	list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
217  		id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
218  		if (!id)
219  			continue;
220  
221  		if (!ae_algo->ops) {
222  			dev_err(&ae_dev->pdev->dev, "ae_algo ops are null\n");
223  			continue;
224  		}
225  		ae_dev->ops = ae_algo->ops;
226  
227  		ret = ae_algo->ops->init_ae_dev(ae_dev);
228  		if (ret) {
229  			dev_err(&ae_dev->pdev->dev,
230  				"init ae_dev error, ret = %d\n", ret);
231  			continue;
232  		}
233  
234  		/* ae_dev init should set flag */
235  		hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 1);
236  
237  		/* check the client list for the match with this ae_dev type and
238  		 * initialize the figure out client instance
239  		 */
240  		list_for_each_entry(client, &hnae3_client_list, node) {
241  			ret = hnae3_init_client_instance(client, ae_dev);
242  			if (ret)
243  				dev_err(&ae_dev->pdev->dev,
244  					"match and instantiation failed, ret = %d\n",
245  					ret);
246  		}
247  	}
248  
249  	mutex_unlock(&hnae3_common_lock);
250  }
251  EXPORT_SYMBOL(hnae3_register_ae_algo);
252  
253  /* hnae3_unregister_ae_algo - unregisters a AE algorithm
254   * @ae_algo: the AE algorithm to unregister
255   */
hnae3_unregister_ae_algo(struct hnae3_ae_algo * ae_algo)256  void hnae3_unregister_ae_algo(struct hnae3_ae_algo *ae_algo)
257  {
258  	const struct pci_device_id *id;
259  	struct hnae3_ae_dev *ae_dev;
260  	struct hnae3_client *client;
261  
262  	if (!ae_algo)
263  		return;
264  
265  	mutex_lock(&hnae3_common_lock);
266  	/* Check if there are matched ae_dev */
267  	list_for_each_entry(ae_dev, &hnae3_ae_dev_list, node) {
268  		if (!hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))
269  			continue;
270  
271  		id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
272  		if (!id)
273  			continue;
274  
275  		/* check the client list for the match with this ae_dev type and
276  		 * un-initialize the figure out client instance
277  		 */
278  		list_for_each_entry(client, &hnae3_client_list, node)
279  			hnae3_uninit_client_instance(client, ae_dev);
280  
281  		ae_algo->ops->uninit_ae_dev(ae_dev);
282  		hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 0);
283  		ae_dev->ops = NULL;
284  	}
285  
286  	list_del(&ae_algo->node);
287  	mutex_unlock(&hnae3_common_lock);
288  }
289  EXPORT_SYMBOL(hnae3_unregister_ae_algo);
290  
291  /* hnae3_register_ae_dev - registers a AE device to hnae3 framework
292   * @ae_dev: the AE device
293   * NOTE: the duplicated name will not be checked
294   */
hnae3_register_ae_dev(struct hnae3_ae_dev * ae_dev)295  int hnae3_register_ae_dev(struct hnae3_ae_dev *ae_dev)
296  {
297  	const struct pci_device_id *id;
298  	struct hnae3_ae_algo *ae_algo;
299  	struct hnae3_client *client;
300  	int ret;
301  
302  	if (!ae_dev)
303  		return -ENODEV;
304  
305  	mutex_lock(&hnae3_common_lock);
306  
307  	list_add_tail(&ae_dev->node, &hnae3_ae_dev_list);
308  
309  	/* Check if there are matched ae_algo */
310  	list_for_each_entry(ae_algo, &hnae3_ae_algo_list, node) {
311  		id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
312  		if (!id)
313  			continue;
314  
315  		if (!ae_algo->ops) {
316  			dev_err(&ae_dev->pdev->dev, "ae_algo ops are null\n");
317  			ret = -EOPNOTSUPP;
318  			goto out_err;
319  		}
320  		ae_dev->ops = ae_algo->ops;
321  
322  		ret = ae_dev->ops->init_ae_dev(ae_dev);
323  		if (ret) {
324  			dev_err(&ae_dev->pdev->dev,
325  				"init ae_dev error, ret = %d\n", ret);
326  			goto out_err;
327  		}
328  
329  		/* ae_dev init should set flag */
330  		hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 1);
331  		break;
332  	}
333  
334  	/* check the client list for the match with this ae_dev type and
335  	 * initialize the figure out client instance
336  	 */
337  	list_for_each_entry(client, &hnae3_client_list, node) {
338  		ret = hnae3_init_client_instance(client, ae_dev);
339  		if (ret)
340  			dev_err(&ae_dev->pdev->dev,
341  				"match and instantiation failed, ret = %d\n",
342  				ret);
343  	}
344  
345  	mutex_unlock(&hnae3_common_lock);
346  
347  	return 0;
348  
349  out_err:
350  	list_del(&ae_dev->node);
351  	mutex_unlock(&hnae3_common_lock);
352  
353  	return ret;
354  }
355  EXPORT_SYMBOL(hnae3_register_ae_dev);
356  
357  /* hnae3_unregister_ae_dev - unregisters a AE device
358   * @ae_dev: the AE device to unregister
359   */
hnae3_unregister_ae_dev(struct hnae3_ae_dev * ae_dev)360  void hnae3_unregister_ae_dev(struct hnae3_ae_dev *ae_dev)
361  {
362  	const struct pci_device_id *id;
363  	struct hnae3_ae_algo *ae_algo;
364  	struct hnae3_client *client;
365  
366  	if (!ae_dev)
367  		return;
368  
369  	mutex_lock(&hnae3_common_lock);
370  	/* Check if there are matched ae_algo */
371  	list_for_each_entry(ae_algo, &hnae3_ae_algo_list, node) {
372  		if (!hnae3_get_bit(ae_dev->flag, HNAE3_DEV_INITED_B))
373  			continue;
374  
375  		id = pci_match_id(ae_algo->pdev_id_table, ae_dev->pdev);
376  		if (!id)
377  			continue;
378  
379  		list_for_each_entry(client, &hnae3_client_list, node)
380  			hnae3_uninit_client_instance(client, ae_dev);
381  
382  		ae_algo->ops->uninit_ae_dev(ae_dev);
383  		hnae3_set_bit(ae_dev->flag, HNAE3_DEV_INITED_B, 0);
384  		ae_dev->ops = NULL;
385  	}
386  
387  	list_del(&ae_dev->node);
388  	mutex_unlock(&hnae3_common_lock);
389  }
390  EXPORT_SYMBOL(hnae3_unregister_ae_dev);
391  
392  MODULE_AUTHOR("Huawei Tech. Co., Ltd.");
393  MODULE_LICENSE("GPL");
394  MODULE_DESCRIPTION("HNAE3(Hisilicon Network Acceleration Engine) Framework");
395  MODULE_VERSION(HNAE3_MOD_VERSION);
396