1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Generic Counter interface 4 * Copyright (C) 2020 William Breathitt Gray 5 */ 6 #include <linux/cdev.h> 7 #include <linux/counter.h> 8 #include <linux/device.h> 9 #include <linux/device/bus.h> 10 #include <linux/export.h> 11 #include <linux/fs.h> 12 #include <linux/gfp.h> 13 #include <linux/idr.h> 14 #include <linux/init.h> 15 #include <linux/kdev_t.h> 16 #include <linux/module.h> 17 #include <linux/mutex.h> 18 #include <linux/slab.h> 19 #include <linux/types.h> 20 #include <linux/wait.h> 21 22 #include "counter-chrdev.h" 23 #include "counter-sysfs.h" 24 25 /* Provides a unique ID for each counter device */ 26 static DEFINE_IDA(counter_ida); 27 28 struct counter_device_allochelper { 29 struct counter_device counter; 30 31 /* 32 * This is cache line aligned to ensure private data behaves like if it 33 * were kmalloced separately. 34 */ 35 unsigned long privdata[] ____cacheline_aligned; 36 }; 37 38 static void counter_device_release(struct device *dev) 39 { 40 struct counter_device *const counter = 41 container_of(dev, struct counter_device, dev); 42 43 counter_chrdev_remove(counter); 44 ida_free(&counter_ida, dev->id); 45 46 kfree(container_of(counter, struct counter_device_allochelper, counter)); 47 } 48 49 static struct device_type counter_device_type = { 50 .name = "counter_device", 51 .release = counter_device_release, 52 }; 53 54 static struct bus_type counter_bus_type = { 55 .name = "counter", 56 .dev_name = "counter", 57 }; 58 59 static dev_t counter_devt; 60 61 /** 62 * counter_priv - access counter device private data 63 * @counter: counter device 64 * 65 * Get the counter device private data 66 */ 67 void *counter_priv(const struct counter_device *const counter) 68 { 69 struct counter_device_allochelper *ch = 70 container_of(counter, struct counter_device_allochelper, counter); 71 72 return &ch->privdata; 73 } 74 EXPORT_SYMBOL_GPL(counter_priv); 75 76 /** 77 * counter_alloc - allocate a counter_device 78 * @sizeof_priv: size of the driver private data 79 * 80 * This is part one of counter registration. The structure is allocated 81 * dynamically to ensure the right lifetime for the embedded struct device. 82 * 83 * If this succeeds, call counter_put() to get rid of the counter_device again. 84 */ 85 struct counter_device *counter_alloc(size_t sizeof_priv) 86 { 87 struct counter_device_allochelper *ch; 88 struct counter_device *counter; 89 struct device *dev; 90 int err; 91 92 ch = kzalloc(sizeof(*ch) + sizeof_priv, GFP_KERNEL); 93 if (!ch) { 94 err = -ENOMEM; 95 goto err_alloc_ch; 96 } 97 98 counter = &ch->counter; 99 dev = &counter->dev; 100 101 /* Acquire unique ID */ 102 err = ida_alloc(&counter_ida, GFP_KERNEL); 103 if (err < 0) 104 goto err_ida_alloc; 105 dev->id = err; 106 107 mutex_init(&counter->ops_exist_lock); 108 dev->type = &counter_device_type; 109 dev->bus = &counter_bus_type; 110 dev->devt = MKDEV(MAJOR(counter_devt), dev->id); 111 112 err = counter_chrdev_add(counter); 113 if (err < 0) 114 goto err_chrdev_add; 115 116 device_initialize(dev); 117 118 return counter; 119 120 err_chrdev_add: 121 122 ida_free(&counter_ida, dev->id); 123 err_ida_alloc: 124 125 kfree(ch); 126 err_alloc_ch: 127 128 return ERR_PTR(err); 129 } 130 EXPORT_SYMBOL_GPL(counter_alloc); 131 132 void counter_put(struct counter_device *counter) 133 { 134 put_device(&counter->dev); 135 } 136 EXPORT_SYMBOL_GPL(counter_put); 137 138 /** 139 * counter_add - complete registration of a counter 140 * @counter: the counter to add 141 * 142 * This is part two of counter registration. 143 * 144 * If this succeeds, call counter_unregister() to get rid of the counter_device again. 145 */ 146 int counter_add(struct counter_device *counter) 147 { 148 int err; 149 struct device *dev = &counter->dev; 150 151 if (counter->parent) { 152 dev->parent = counter->parent; 153 dev->of_node = counter->parent->of_node; 154 } 155 156 err = counter_sysfs_add(counter); 157 if (err < 0) 158 return err; 159 160 /* implies device_add(dev) */ 161 return cdev_device_add(&counter->chrdev, dev); 162 } 163 EXPORT_SYMBOL_GPL(counter_add); 164 165 /** 166 * counter_unregister - unregister Counter from the system 167 * @counter: pointer to Counter to unregister 168 * 169 * The Counter is unregistered from the system. 170 */ 171 void counter_unregister(struct counter_device *const counter) 172 { 173 if (!counter) 174 return; 175 176 cdev_device_del(&counter->chrdev, &counter->dev); 177 178 mutex_lock(&counter->ops_exist_lock); 179 180 counter->ops = NULL; 181 wake_up(&counter->events_wait); 182 183 mutex_unlock(&counter->ops_exist_lock); 184 } 185 EXPORT_SYMBOL_GPL(counter_unregister); 186 187 static void devm_counter_release(void *counter) 188 { 189 counter_unregister(counter); 190 } 191 192 static void devm_counter_put(void *counter) 193 { 194 counter_put(counter); 195 } 196 197 /** 198 * devm_counter_alloc - allocate a counter_device 199 * @dev: the device to register the release callback for 200 * @sizeof_priv: size of the driver private data 201 * 202 * This is the device managed version of counter_add(). It registers a cleanup 203 * callback to care for calling counter_put(). 204 */ 205 struct counter_device *devm_counter_alloc(struct device *dev, size_t sizeof_priv) 206 { 207 struct counter_device *counter; 208 int err; 209 210 counter = counter_alloc(sizeof_priv); 211 if (IS_ERR(counter)) 212 return counter; 213 214 err = devm_add_action_or_reset(dev, devm_counter_put, counter); 215 if (err < 0) 216 return ERR_PTR(err); 217 218 return counter; 219 } 220 EXPORT_SYMBOL_GPL(devm_counter_alloc); 221 222 /** 223 * devm_counter_add - complete registration of a counter 224 * @dev: the device to register the release callback for 225 * @counter: the counter to add 226 * 227 * This is the device managed version of counter_add(). It registers a cleanup 228 * callback to care for calling counter_unregister(). 229 */ 230 int devm_counter_add(struct device *dev, 231 struct counter_device *const counter) 232 { 233 int err; 234 235 err = counter_add(counter); 236 if (err < 0) 237 return err; 238 239 return devm_add_action_or_reset(dev, devm_counter_release, counter); 240 } 241 EXPORT_SYMBOL_GPL(devm_counter_add); 242 243 #define COUNTER_DEV_MAX 256 244 245 static int __init counter_init(void) 246 { 247 int err; 248 249 err = bus_register(&counter_bus_type); 250 if (err < 0) 251 return err; 252 253 err = alloc_chrdev_region(&counter_devt, 0, COUNTER_DEV_MAX, "counter"); 254 if (err < 0) 255 goto err_unregister_bus; 256 257 return 0; 258 259 err_unregister_bus: 260 bus_unregister(&counter_bus_type); 261 return err; 262 } 263 264 static void __exit counter_exit(void) 265 { 266 unregister_chrdev_region(counter_devt, COUNTER_DEV_MAX); 267 bus_unregister(&counter_bus_type); 268 } 269 270 subsys_initcall(counter_init); 271 module_exit(counter_exit); 272 273 MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>"); 274 MODULE_DESCRIPTION("Generic Counter interface"); 275 MODULE_LICENSE("GPL v2"); 276