1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Management for virtio crypto devices (refer to adf_dev_mgr.c)
3 *
4 * Copyright 2016 HUAWEI TECHNOLOGIES CO., LTD.
5 */
6
7 #include <linux/mutex.h>
8 #include <linux/list.h>
9 #include <linux/module.h>
10
11 #include <uapi/linux/virtio_crypto.h>
12 #include "virtio_crypto_common.h"
13
14 static LIST_HEAD(virtio_crypto_table);
15 static uint32_t num_devices;
16
17 /* The table_lock protects the above global list and num_devices */
18 static DEFINE_MUTEX(table_lock);
19
20 #define VIRTIO_CRYPTO_MAX_DEVICES 32
21
22
23 /*
24 * virtcrypto_devmgr_add_dev() - Add vcrypto_dev to the acceleration
25 * framework.
26 * @vcrypto_dev: Pointer to virtio crypto device.
27 *
28 * Function adds virtio crypto device to the global list.
29 * To be used by virtio crypto device specific drivers.
30 *
31 * Return: 0 on success, error code othewise.
32 */
virtcrypto_devmgr_add_dev(struct virtio_crypto * vcrypto_dev)33 int virtcrypto_devmgr_add_dev(struct virtio_crypto *vcrypto_dev)
34 {
35 struct list_head *itr;
36
37 mutex_lock(&table_lock);
38 if (num_devices == VIRTIO_CRYPTO_MAX_DEVICES) {
39 pr_info("virtio_crypto: only support up to %d devices\n",
40 VIRTIO_CRYPTO_MAX_DEVICES);
41 mutex_unlock(&table_lock);
42 return -EFAULT;
43 }
44
45 list_for_each(itr, &virtio_crypto_table) {
46 struct virtio_crypto *ptr =
47 list_entry(itr, struct virtio_crypto, list);
48
49 if (ptr == vcrypto_dev) {
50 mutex_unlock(&table_lock);
51 return -EEXIST;
52 }
53 }
54 atomic_set(&vcrypto_dev->ref_count, 0);
55 list_add_tail(&vcrypto_dev->list, &virtio_crypto_table);
56 vcrypto_dev->dev_id = num_devices++;
57 mutex_unlock(&table_lock);
58 return 0;
59 }
60
virtcrypto_devmgr_get_head(void)61 struct list_head *virtcrypto_devmgr_get_head(void)
62 {
63 return &virtio_crypto_table;
64 }
65
66 /*
67 * virtcrypto_devmgr_rm_dev() - Remove vcrypto_dev from the acceleration
68 * framework.
69 * @vcrypto_dev: Pointer to virtio crypto device.
70 *
71 * Function removes virtio crypto device from the acceleration framework.
72 * To be used by virtio crypto device specific drivers.
73 *
74 * Return: void
75 */
virtcrypto_devmgr_rm_dev(struct virtio_crypto * vcrypto_dev)76 void virtcrypto_devmgr_rm_dev(struct virtio_crypto *vcrypto_dev)
77 {
78 mutex_lock(&table_lock);
79 list_del(&vcrypto_dev->list);
80 num_devices--;
81 mutex_unlock(&table_lock);
82 }
83
84 /*
85 * virtcrypto_devmgr_get_first()
86 *
87 * Function returns the first virtio crypto device from the acceleration
88 * framework.
89 *
90 * To be used by virtio crypto device specific drivers.
91 *
92 * Return: pointer to vcrypto_dev or NULL if not found.
93 */
virtcrypto_devmgr_get_first(void)94 struct virtio_crypto *virtcrypto_devmgr_get_first(void)
95 {
96 struct virtio_crypto *dev = NULL;
97
98 mutex_lock(&table_lock);
99 if (!list_empty(&virtio_crypto_table))
100 dev = list_first_entry(&virtio_crypto_table,
101 struct virtio_crypto,
102 list);
103 mutex_unlock(&table_lock);
104 return dev;
105 }
106
107 /*
108 * virtcrypto_dev_in_use() - Check whether vcrypto_dev is currently in use
109 * @vcrypto_dev: Pointer to virtio crypto device.
110 *
111 * To be used by virtio crypto device specific drivers.
112 *
113 * Return: 1 when device is in use, 0 otherwise.
114 */
virtcrypto_dev_in_use(struct virtio_crypto * vcrypto_dev)115 int virtcrypto_dev_in_use(struct virtio_crypto *vcrypto_dev)
116 {
117 return atomic_read(&vcrypto_dev->ref_count) != 0;
118 }
119
120 /*
121 * virtcrypto_dev_get() - Increment vcrypto_dev reference count
122 * @vcrypto_dev: Pointer to virtio crypto device.
123 *
124 * Increment the vcrypto_dev refcount and if this is the first time
125 * incrementing it during this period the vcrypto_dev is in use,
126 * increment the module refcount too.
127 * To be used by virtio crypto device specific drivers.
128 *
129 * Return: 0 when successful, EFAULT when fail to bump module refcount
130 */
virtcrypto_dev_get(struct virtio_crypto * vcrypto_dev)131 int virtcrypto_dev_get(struct virtio_crypto *vcrypto_dev)
132 {
133 if (atomic_add_return(1, &vcrypto_dev->ref_count) == 1)
134 if (!try_module_get(vcrypto_dev->owner))
135 return -EFAULT;
136 return 0;
137 }
138
139 /*
140 * virtcrypto_dev_put() - Decrement vcrypto_dev reference count
141 * @vcrypto_dev: Pointer to virtio crypto device.
142 *
143 * Decrement the vcrypto_dev refcount and if this is the last time
144 * decrementing it during this period the vcrypto_dev is in use,
145 * decrement the module refcount too.
146 * To be used by virtio crypto device specific drivers.
147 *
148 * Return: void
149 */
virtcrypto_dev_put(struct virtio_crypto * vcrypto_dev)150 void virtcrypto_dev_put(struct virtio_crypto *vcrypto_dev)
151 {
152 if (atomic_sub_return(1, &vcrypto_dev->ref_count) == 0)
153 module_put(vcrypto_dev->owner);
154 }
155
156 /*
157 * virtcrypto_dev_started() - Check whether device has started
158 * @vcrypto_dev: Pointer to virtio crypto device.
159 *
160 * To be used by virtio crypto device specific drivers.
161 *
162 * Return: 1 when the device has started, 0 otherwise
163 */
virtcrypto_dev_started(struct virtio_crypto * vcrypto_dev)164 int virtcrypto_dev_started(struct virtio_crypto *vcrypto_dev)
165 {
166 return (vcrypto_dev->status & VIRTIO_CRYPTO_S_HW_READY);
167 }
168
169 /*
170 * virtcrypto_get_dev_node() - Get vcrypto_dev on the node.
171 * @node: Node id the driver works.
172 * @service: Crypto service that needs to be supported by the
173 * dev
174 * @algo: The algorithm number that needs to be supported by the
175 * dev
176 *
177 * Function returns the virtio crypto device used fewest on the node,
178 * and supports the given crypto service and algorithm.
179 *
180 * To be used by virtio crypto device specific drivers.
181 *
182 * Return: pointer to vcrypto_dev or NULL if not found.
183 */
virtcrypto_get_dev_node(int node,uint32_t service,uint32_t algo)184 struct virtio_crypto *virtcrypto_get_dev_node(int node, uint32_t service,
185 uint32_t algo)
186 {
187 struct virtio_crypto *vcrypto_dev = NULL, *tmp_dev;
188 unsigned long best = ~0;
189 unsigned long ctr;
190
191 mutex_lock(&table_lock);
192 list_for_each_entry(tmp_dev, virtcrypto_devmgr_get_head(), list) {
193
194 if ((node == dev_to_node(&tmp_dev->vdev->dev) ||
195 dev_to_node(&tmp_dev->vdev->dev) < 0) &&
196 virtcrypto_dev_started(tmp_dev) &&
197 virtcrypto_algo_is_supported(tmp_dev, service, algo)) {
198 ctr = atomic_read(&tmp_dev->ref_count);
199 if (best > ctr) {
200 vcrypto_dev = tmp_dev;
201 best = ctr;
202 }
203 }
204 }
205
206 if (!vcrypto_dev) {
207 pr_info("virtio_crypto: Could not find a device on node %d\n",
208 node);
209 /* Get any started device */
210 list_for_each_entry(tmp_dev,
211 virtcrypto_devmgr_get_head(), list) {
212 if (virtcrypto_dev_started(tmp_dev) &&
213 virtcrypto_algo_is_supported(tmp_dev,
214 service, algo)) {
215 vcrypto_dev = tmp_dev;
216 break;
217 }
218 }
219 }
220 mutex_unlock(&table_lock);
221 if (!vcrypto_dev)
222 return NULL;
223
224 virtcrypto_dev_get(vcrypto_dev);
225 return vcrypto_dev;
226 }
227
228 /*
229 * virtcrypto_dev_start() - Start virtio crypto device
230 * @vcrypto: Pointer to virtio crypto device.
231 *
232 * Function notifies all the registered services that the virtio crypto device
233 * is ready to be used.
234 * To be used by virtio crypto device specific drivers.
235 *
236 * Return: 0 on success, EFAULT when fail to register algorithms
237 */
virtcrypto_dev_start(struct virtio_crypto * vcrypto)238 int virtcrypto_dev_start(struct virtio_crypto *vcrypto)
239 {
240 if (virtio_crypto_skcipher_algs_register(vcrypto)) {
241 pr_err("virtio_crypto: Failed to register crypto skcipher algs\n");
242 return -EFAULT;
243 }
244
245 if (virtio_crypto_akcipher_algs_register(vcrypto)) {
246 pr_err("virtio_crypto: Failed to register crypto akcipher algs\n");
247 virtio_crypto_skcipher_algs_unregister(vcrypto);
248 return -EFAULT;
249 }
250
251 return 0;
252 }
253
254 /*
255 * virtcrypto_dev_stop() - Stop virtio crypto device
256 * @vcrypto: Pointer to virtio crypto device.
257 *
258 * Function notifies all the registered services that the virtio crypto device
259 * is ready to be used.
260 * To be used by virtio crypto device specific drivers.
261 *
262 * Return: void
263 */
virtcrypto_dev_stop(struct virtio_crypto * vcrypto)264 void virtcrypto_dev_stop(struct virtio_crypto *vcrypto)
265 {
266 virtio_crypto_skcipher_algs_unregister(vcrypto);
267 virtio_crypto_akcipher_algs_unregister(vcrypto);
268 }
269
270 /*
271 * vcrypto_algo_is_supported()
272 * @vcrypto: Pointer to virtio crypto device.
273 * @service: The bit number for service validate.
274 * See VIRTIO_CRYPTO_SERVICE_*
275 * @algo : The bit number for the algorithm to validate.
276 *
277 *
278 * Validate if the virtio crypto device supports a service and
279 * algo.
280 *
281 * Return true if device supports a service and algo.
282 */
283
virtcrypto_algo_is_supported(struct virtio_crypto * vcrypto,uint32_t service,uint32_t algo)284 bool virtcrypto_algo_is_supported(struct virtio_crypto *vcrypto,
285 uint32_t service,
286 uint32_t algo)
287 {
288 uint32_t service_mask = 1u << service;
289 uint32_t algo_mask = 0;
290 bool low = true;
291
292 if (algo > 31) {
293 algo -= 32;
294 low = false;
295 }
296
297 if (!(vcrypto->crypto_services & service_mask))
298 return false;
299
300 switch (service) {
301 case VIRTIO_CRYPTO_SERVICE_CIPHER:
302 if (low)
303 algo_mask = vcrypto->cipher_algo_l;
304 else
305 algo_mask = vcrypto->cipher_algo_h;
306 break;
307
308 case VIRTIO_CRYPTO_SERVICE_HASH:
309 algo_mask = vcrypto->hash_algo;
310 break;
311
312 case VIRTIO_CRYPTO_SERVICE_MAC:
313 if (low)
314 algo_mask = vcrypto->mac_algo_l;
315 else
316 algo_mask = vcrypto->mac_algo_h;
317 break;
318
319 case VIRTIO_CRYPTO_SERVICE_AEAD:
320 algo_mask = vcrypto->aead_algo;
321 break;
322
323 case VIRTIO_CRYPTO_SERVICE_AKCIPHER:
324 algo_mask = vcrypto->akcipher_algo;
325 break;
326 }
327
328 if (!(algo_mask & (1u << algo)))
329 return false;
330
331 return true;
332 }
333