1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright 2021 Xillybus Ltd, http://xillybus.com
4 *
5 * Driver for the Xillybus class
6 */
7
8 #include <linux/types.h>
9 #include <linux/module.h>
10 #include <linux/device.h>
11 #include <linux/fs.h>
12 #include <linux/cdev.h>
13 #include <linux/slab.h>
14 #include <linux/list.h>
15 #include <linux/mutex.h>
16
17 #include "xillybus_class.h"
18
19 MODULE_DESCRIPTION("Driver for Xillybus class");
20 MODULE_AUTHOR("Eli Billauer, Xillybus Ltd.");
21 MODULE_ALIAS("xillybus_class");
22 MODULE_LICENSE("GPL v2");
23
24 static DEFINE_MUTEX(unit_mutex);
25 static LIST_HEAD(unit_list);
26 static const struct class xillybus_class = {
27 .name = "xillybus",
28 };
29
30 #define UNITNAMELEN 16
31
32 struct xilly_unit {
33 struct list_head list_entry;
34 void *private_data;
35
36 struct cdev *cdev;
37 char name[UNITNAMELEN];
38 int major;
39 int lowest_minor;
40 int num_nodes;
41 };
42
xillybus_init_chrdev(struct device * dev,const struct file_operations * fops,struct module * owner,void * private_data,unsigned char * idt,unsigned int len,int num_nodes,const char * prefix,bool enumerate)43 int xillybus_init_chrdev(struct device *dev,
44 const struct file_operations *fops,
45 struct module *owner,
46 void *private_data,
47 unsigned char *idt, unsigned int len,
48 int num_nodes,
49 const char *prefix, bool enumerate)
50 {
51 int rc;
52 dev_t mdev;
53 int i;
54 char devname[48];
55
56 struct device *device;
57 size_t namelen;
58 struct xilly_unit *unit, *u;
59
60 unit = kzalloc(sizeof(*unit), GFP_KERNEL);
61
62 if (!unit)
63 return -ENOMEM;
64
65 mutex_lock(&unit_mutex);
66
67 if (!enumerate)
68 snprintf(unit->name, UNITNAMELEN, "%s", prefix);
69
70 for (i = 0; enumerate; i++) {
71 snprintf(unit->name, UNITNAMELEN, "%s_%02d",
72 prefix, i);
73
74 enumerate = false;
75 list_for_each_entry(u, &unit_list, list_entry)
76 if (!strcmp(unit->name, u->name)) {
77 enumerate = true;
78 break;
79 }
80 }
81
82 rc = alloc_chrdev_region(&mdev, 0, num_nodes, unit->name);
83
84 if (rc) {
85 dev_warn(dev, "Failed to obtain major/minors");
86 goto fail_obtain;
87 }
88
89 unit->major = MAJOR(mdev);
90 unit->lowest_minor = MINOR(mdev);
91 unit->num_nodes = num_nodes;
92 unit->private_data = private_data;
93
94 unit->cdev = cdev_alloc();
95 if (!unit->cdev) {
96 rc = -ENOMEM;
97 goto unregister_chrdev;
98 }
99 unit->cdev->ops = fops;
100 unit->cdev->owner = owner;
101
102 rc = cdev_add(unit->cdev, MKDEV(unit->major, unit->lowest_minor),
103 unit->num_nodes);
104 if (rc) {
105 dev_err(dev, "Failed to add cdev.\n");
106 /* kobject_put() is normally done by cdev_del() */
107 kobject_put(&unit->cdev->kobj);
108 goto unregister_chrdev;
109 }
110
111 for (i = 0; i < num_nodes; i++) {
112 namelen = strnlen(idt, len);
113
114 if (namelen == len) {
115 dev_err(dev, "IDT's list of names is too short. This is exceptionally weird, because its CRC is OK\n");
116 rc = -ENODEV;
117 goto unroll_device_create;
118 }
119
120 snprintf(devname, sizeof(devname), "%s_%s",
121 unit->name, idt);
122
123 len -= namelen + 1;
124 idt += namelen + 1;
125
126 device = device_create(&xillybus_class,
127 NULL,
128 MKDEV(unit->major,
129 i + unit->lowest_minor),
130 NULL,
131 "%s", devname);
132
133 if (IS_ERR(device)) {
134 dev_err(dev, "Failed to create %s device. Aborting.\n",
135 devname);
136 rc = -ENODEV;
137 goto unroll_device_create;
138 }
139 }
140
141 if (len) {
142 dev_err(dev, "IDT's list of names is too long. This is exceptionally weird, because its CRC is OK\n");
143 rc = -ENODEV;
144 goto unroll_device_create;
145 }
146
147 list_add_tail(&unit->list_entry, &unit_list);
148
149 dev_info(dev, "Created %d device files.\n", num_nodes);
150
151 mutex_unlock(&unit_mutex);
152
153 return 0;
154
155 unroll_device_create:
156 for (i--; i >= 0; i--)
157 device_destroy(&xillybus_class, MKDEV(unit->major,
158 i + unit->lowest_minor));
159
160 cdev_del(unit->cdev);
161
162 unregister_chrdev:
163 unregister_chrdev_region(MKDEV(unit->major, unit->lowest_minor),
164 unit->num_nodes);
165
166 fail_obtain:
167 mutex_unlock(&unit_mutex);
168
169 kfree(unit);
170
171 return rc;
172 }
173 EXPORT_SYMBOL(xillybus_init_chrdev);
174
xillybus_cleanup_chrdev(void * private_data,struct device * dev)175 void xillybus_cleanup_chrdev(void *private_data,
176 struct device *dev)
177 {
178 int minor;
179 struct xilly_unit *unit = NULL, *iter;
180
181 mutex_lock(&unit_mutex);
182
183 list_for_each_entry(iter, &unit_list, list_entry)
184 if (iter->private_data == private_data) {
185 unit = iter;
186 break;
187 }
188
189 if (!unit) {
190 dev_err(dev, "Weird bug: Failed to find unit\n");
191 mutex_unlock(&unit_mutex);
192 return;
193 }
194
195 for (minor = unit->lowest_minor;
196 minor < (unit->lowest_minor + unit->num_nodes);
197 minor++)
198 device_destroy(&xillybus_class, MKDEV(unit->major, minor));
199
200 cdev_del(unit->cdev);
201
202 unregister_chrdev_region(MKDEV(unit->major, unit->lowest_minor),
203 unit->num_nodes);
204
205 dev_info(dev, "Removed %d device files.\n",
206 unit->num_nodes);
207
208 list_del(&unit->list_entry);
209 kfree(unit);
210
211 mutex_unlock(&unit_mutex);
212 }
213 EXPORT_SYMBOL(xillybus_cleanup_chrdev);
214
xillybus_find_inode(struct inode * inode,void ** private_data,int * index)215 int xillybus_find_inode(struct inode *inode,
216 void **private_data, int *index)
217 {
218 int minor = iminor(inode);
219 int major = imajor(inode);
220 struct xilly_unit *unit = NULL, *iter;
221
222 mutex_lock(&unit_mutex);
223
224 list_for_each_entry(iter, &unit_list, list_entry)
225 if (iter->major == major &&
226 minor >= iter->lowest_minor &&
227 minor < (iter->lowest_minor + iter->num_nodes)) {
228 unit = iter;
229 break;
230 }
231
232 if (!unit) {
233 mutex_unlock(&unit_mutex);
234 return -ENODEV;
235 }
236
237 *private_data = unit->private_data;
238 *index = minor - unit->lowest_minor;
239
240 mutex_unlock(&unit_mutex);
241 return 0;
242 }
243 EXPORT_SYMBOL(xillybus_find_inode);
244
xillybus_class_init(void)245 static int __init xillybus_class_init(void)
246 {
247 return class_register(&xillybus_class);
248 }
249
xillybus_class_exit(void)250 static void __exit xillybus_class_exit(void)
251 {
252 class_unregister(&xillybus_class);
253 }
254
255 module_init(xillybus_class_init);
256 module_exit(xillybus_class_exit);
257