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 <jens.wiklander@linaro.org>");
 230 MODULE_DESCRIPTION("RPMB class");
 231 MODULE_LICENSE("GPL");