xillybus_class.c

  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
 19MODULE_DESCRIPTION("Driver for Xillybus class");
 20MODULE_AUTHOR("Eli Billauer, Xillybus Ltd.");
 21MODULE_ALIAS("xillybus_class");
 22MODULE_LICENSE("GPL v2");
 23
 24static DEFINE_MUTEX(unit_mutex);
 25static LIST_HEAD(unit_list);
 26static const struct class xillybus_class = {
 27	.name = "xillybus",
 28};
 29
 30#define UNITNAMELEN 16
 31
 32struct 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
 43int 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
155unroll_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
162unregister_chrdev:
163	unregister_chrdev_region(MKDEV(unit->major, unit->lowest_minor),
164				 unit->num_nodes);
165
166fail_obtain:
167	mutex_unlock(&unit_mutex);
168
169	kfree(unit);
170
171	return rc;
172}
173EXPORT_SYMBOL(xillybus_init_chrdev);
174
175void 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}
213EXPORT_SYMBOL(xillybus_cleanup_chrdev);
214
215int 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}
243EXPORT_SYMBOL(xillybus_find_inode);
244
245static int __init xillybus_class_init(void)
246{
247	return class_register(&xillybus_class);
248}
249
250static void __exit xillybus_class_exit(void)
251{
252	class_unregister(&xillybus_class);
253}
254
255module_init(xillybus_class_init);
256module_exit(xillybus_class_exit);