]> Git Repo - linux.git/blob - drivers/misc/rpmb-core.c
crypto: akcipher - Drop sign/verify operations
[linux.git] / drivers / misc / rpmb-core.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright(c) 2015 - 2019 Intel Corporation. All rights reserved.
4  * Copyright(c) 2021 - 2024 Linaro Ltd.
5  */
6 #include <linux/device.h>
7 #include <linux/init.h>
8 #include <linux/kernel.h>
9 #include <linux/list.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/rpmb.h>
13 #include <linux/slab.h>
14
15 static DEFINE_IDA(rpmb_ida);
16 static DEFINE_MUTEX(rpmb_mutex);
17
18 /**
19  * rpmb_dev_get() - increase rpmb device ref counter
20  * @rdev: rpmb device
21  */
22 struct rpmb_dev *rpmb_dev_get(struct rpmb_dev *rdev)
23 {
24         if (rdev)
25                 get_device(&rdev->dev);
26         return rdev;
27 }
28 EXPORT_SYMBOL_GPL(rpmb_dev_get);
29
30 /**
31  * rpmb_dev_put() - decrease rpmb device ref counter
32  * @rdev: rpmb device
33  */
34 void rpmb_dev_put(struct rpmb_dev *rdev)
35 {
36         if (rdev)
37                 put_device(&rdev->dev);
38 }
39 EXPORT_SYMBOL_GPL(rpmb_dev_put);
40
41 /**
42  * rpmb_route_frames() - route rpmb frames to rpmb device
43  * @rdev:       rpmb device
44  * @req:        rpmb request frames
45  * @req_len:    length of rpmb request frames in bytes
46  * @rsp:        rpmb response frames
47  * @rsp_len:    length of rpmb response frames in bytes
48  *
49  * Returns: < 0 on failure
50  */
51 int rpmb_route_frames(struct rpmb_dev *rdev, u8 *req,
52                       unsigned int req_len, u8 *rsp, unsigned int rsp_len)
53 {
54         if (!req || !req_len || !rsp || !rsp_len)
55                 return -EINVAL;
56
57         return rdev->descr.route_frames(rdev->dev.parent, req, req_len,
58                                         rsp, rsp_len);
59 }
60 EXPORT_SYMBOL_GPL(rpmb_route_frames);
61
62 static void rpmb_dev_release(struct device *dev)
63 {
64         struct rpmb_dev *rdev = to_rpmb_dev(dev);
65
66         mutex_lock(&rpmb_mutex);
67         ida_simple_remove(&rpmb_ida, rdev->id);
68         mutex_unlock(&rpmb_mutex);
69         kfree(rdev->descr.dev_id);
70         kfree(rdev);
71 }
72
73 static struct class rpmb_class = {
74         .name = "rpmb",
75         .dev_release = rpmb_dev_release,
76 };
77
78 /**
79  * rpmb_dev_find_device() - return first matching rpmb device
80  * @start: rpmb device to begin with
81  * @data: data for the match function
82  * @match: the matching function
83  *
84  * Iterate over registered RPMB devices, and call @match() for each passing
85  * it the RPMB device and @data.
86  *
87  * The return value of @match() is checked for each call. If it returns
88  * anything other 0, break and return the found RPMB device.
89  *
90  * It's the callers responsibility to call rpmb_dev_put() on the returned
91  * device, when it's done with it.
92  *
93  * Returns: a matching rpmb device or NULL on failure
94  */
95 struct rpmb_dev *rpmb_dev_find_device(const void *data,
96                                       const struct rpmb_dev *start,
97                                       int (*match)(struct device *dev,
98                                                    const void *data))
99 {
100         struct device *dev;
101         const struct device *start_dev = NULL;
102
103         if (start)
104                 start_dev = &start->dev;
105         dev = class_find_device(&rpmb_class, start_dev, data, match);
106
107         return dev ? to_rpmb_dev(dev) : NULL;
108 }
109 EXPORT_SYMBOL_GPL(rpmb_dev_find_device);
110
111 int rpmb_interface_register(struct class_interface *intf)
112 {
113         intf->class = &rpmb_class;
114
115         return class_interface_register(intf);
116 }
117 EXPORT_SYMBOL_GPL(rpmb_interface_register);
118
119 void rpmb_interface_unregister(struct class_interface *intf)
120 {
121         class_interface_unregister(intf);
122 }
123 EXPORT_SYMBOL_GPL(rpmb_interface_unregister);
124
125 /**
126  * rpmb_dev_unregister() - unregister RPMB partition from the RPMB subsystem
127  * @rdev: the rpmb device to unregister
128  *
129  * This function should be called from the release function of the
130  * underlying device used when the RPMB device was registered.
131  *
132  * Returns: < 0 on failure
133  */
134 int rpmb_dev_unregister(struct rpmb_dev *rdev)
135 {
136         if (!rdev)
137                 return -EINVAL;
138
139         device_del(&rdev->dev);
140
141         rpmb_dev_put(rdev);
142
143         return 0;
144 }
145 EXPORT_SYMBOL_GPL(rpmb_dev_unregister);
146
147 /**
148  * rpmb_dev_register - register RPMB partition with the RPMB subsystem
149  * @dev: storage device of the rpmb device
150  * @descr: RPMB device description
151  *
152  * While registering the RPMB partition extract needed device information
153  * while needed resources are available.
154  *
155  * Returns: a pointer to a 'struct rpmb_dev' or an ERR_PTR on failure
156  */
157 struct rpmb_dev *rpmb_dev_register(struct device *dev,
158                                    struct rpmb_descr *descr)
159 {
160         struct rpmb_dev *rdev;
161         int ret;
162
163         if (!dev || !descr || !descr->route_frames || !descr->dev_id ||
164             !descr->dev_id_len)
165                 return ERR_PTR(-EINVAL);
166
167         rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
168         if (!rdev)
169                 return ERR_PTR(-ENOMEM);
170         rdev->descr = *descr;
171         rdev->descr.dev_id = kmemdup(descr->dev_id, descr->dev_id_len,
172                                      GFP_KERNEL);
173         if (!rdev->descr.dev_id) {
174                 ret = -ENOMEM;
175                 goto err_free_rdev;
176         }
177
178         mutex_lock(&rpmb_mutex);
179         ret = ida_simple_get(&rpmb_ida, 0, 0, GFP_KERNEL);
180         mutex_unlock(&rpmb_mutex);
181         if (ret < 0)
182                 goto err_free_dev_id;
183         rdev->id = ret;
184
185         dev_set_name(&rdev->dev, "rpmb%d", rdev->id);
186         rdev->dev.class = &rpmb_class;
187         rdev->dev.parent = dev;
188
189         ret = device_register(&rdev->dev);
190         if (ret) {
191                 put_device(&rdev->dev);
192                 return ERR_PTR(ret);
193         }
194
195         dev_dbg(&rdev->dev, "registered device\n");
196
197         return rdev;
198
199 err_free_dev_id:
200         kfree(rdev->descr.dev_id);
201 err_free_rdev:
202         kfree(rdev);
203         return ERR_PTR(ret);
204 }
205 EXPORT_SYMBOL_GPL(rpmb_dev_register);
206
207 static int __init rpmb_init(void)
208 {
209         int ret;
210
211         ret = class_register(&rpmb_class);
212         if (ret) {
213                 pr_err("couldn't create class\n");
214                 return ret;
215         }
216         ida_init(&rpmb_ida);
217         return 0;
218 }
219
220 static void __exit rpmb_exit(void)
221 {
222         ida_destroy(&rpmb_ida);
223         class_unregister(&rpmb_class);
224 }
225
226 subsys_initcall(rpmb_init);
227 module_exit(rpmb_exit);
228
229 MODULE_AUTHOR("Jens Wiklander <[email protected]>");
230 MODULE_DESCRIPTION("RPMB class");
231 MODULE_LICENSE("GPL");
This page took 0.044327 seconds and 4 git commands to generate.