[linux-block.git] / drivers / staging / greybus / raw.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Greybus driver for the Raw protocol
 *
 * Copyright 2015 Google Inc.
 * Copyright 2015 Linaro Ltd.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sizes.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <linux/uaccess.h>
#include <linux/greybus.h>

struct gb_raw {
	struct gb_connection *connection;

	struct list_head list;
	int list_data;
	struct mutex list_lock;
	dev_t dev;
	struct cdev cdev;
	struct device *device;
};

struct raw_data {
	struct list_head entry;
	u32 len;
	u8 data[];
};

static struct class *raw_class;
static int raw_major;
static const struct file_operations raw_fops;
static DEFINE_IDA(minors);

/* Number of minor devices this driver supports */
#define NUM_MINORS	256

/* Maximum size of any one send data buffer we support */
#define MAX_PACKET_SIZE	(PAGE_SIZE * 2)

/*
 * Maximum size of the data in the receive buffer we allow before we start to
 * drop messages on the floor
 */
#define MAX_DATA_SIZE	(MAX_PACKET_SIZE * 8)

/*
 * Add the raw data message to the list of received messages.
 */
static int receive_data(struct gb_raw *raw, u32 len, u8 *data)
{
	struct raw_data *raw_data;
	struct device *dev = &raw->connection->bundle->dev;
	int retval = 0;

	if (len > MAX_PACKET_SIZE) {
		dev_err(dev, "Too big of a data packet, rejected\n");
		return -EINVAL;
	}

	mutex_lock(&raw->list_lock);
	if ((raw->list_data + len) > MAX_DATA_SIZE) {
		dev_err(dev, "Too much data in receive buffer, now dropping packets\n");
		retval = -EINVAL;
		goto exit;
	}

	raw_data = kmalloc(sizeof(*raw_data) + len, GFP_KERNEL);
	if (!raw_data) {
		retval = -ENOMEM;
		goto exit;
	}

	raw->list_data += len;
	raw_data->len = len;
	memcpy(&raw_data->data[0], data, len);

	list_add_tail(&raw_data->entry, &raw->list);
exit:
	mutex_unlock(&raw->list_lock);
	return retval;
}

static int gb_raw_request_handler(struct gb_operation *op)
{
	struct gb_connection *connection = op->connection;
	struct device *dev = &connection->bundle->dev;
	struct gb_raw *raw = greybus_get_drvdata(connection->bundle);
	struct gb_raw_send_request *receive;
	u32 len;

	if (op->type != GB_RAW_TYPE_SEND) {
		dev_err(dev, "unknown request type 0x%02x\n", op->type);
		return -EINVAL;
	}

	/* Verify size of payload */
	if (op->request->payload_size < sizeof(*receive)) {
		dev_err(dev, "raw receive request too small (%zu < %zu)\n",
			op->request->payload_size, sizeof(*receive));
		return -EINVAL;
	}
	receive = op->request->payload;
	len = le32_to_cpu(receive->len);
	if (len != (int)(op->request->payload_size - sizeof(__le32))) {
		dev_err(dev, "raw receive request wrong size %d vs %d\n", len,
			(int)(op->request->payload_size - sizeof(__le32)));
		return -EINVAL;
	}
	if (len == 0) {
		dev_err(dev, "raw receive request of 0 bytes?\n");
		return -EINVAL;
	}

	return receive_data(raw, len, receive->data);
}

static int gb_raw_send(struct gb_raw *raw, u32 len, const char __user *data)
{
	struct gb_connection *connection = raw->connection;
	struct gb_raw_send_request *request;
	int retval;

	request = kmalloc(len + sizeof(*request), GFP_KERNEL);
	if (!request)
		return -ENOMEM;

	if (copy_from_user(&request->data[0], data, len)) {
		kfree(request);
		return -EFAULT;
	}

	request->len = cpu_to_le32(len);

	retval = gb_operation_sync(connection, GB_RAW_TYPE_SEND,
				   request, len + sizeof(*request),
				   NULL, 0);

	kfree(request);
	return retval;
}

static int gb_raw_probe(struct gb_bundle *bundle,
			const struct greybus_bundle_id *id)
{
	struct greybus_descriptor_cport *cport_desc;
	struct gb_connection *connection;
	struct gb_raw *raw;
	int retval;
	int minor;

	if (bundle->num_cports != 1)
		return -ENODEV;

	cport_desc = &bundle->cport_desc[0];
	if (cport_desc->protocol_id != GREYBUS_PROTOCOL_RAW)
		return -ENODEV;

	raw = kzalloc(sizeof(*raw), GFP_KERNEL);
	if (!raw)
		return -ENOMEM;

	connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
					  gb_raw_request_handler);
	if (IS_ERR(connection)) {
		retval = PTR_ERR(connection);
		goto error_free;
	}

	INIT_LIST_HEAD(&raw->list);
	mutex_init(&raw->list_lock);

	raw->connection = connection;
	greybus_set_drvdata(bundle, raw);

	minor = ida_simple_get(&minors, 0, 0, GFP_KERNEL);
	if (minor < 0) {
		retval = minor;
		goto error_connection_destroy;
	}

	raw->dev = MKDEV(raw_major, minor);
	cdev_init(&raw->cdev, &raw_fops);

	retval = gb_connection_enable(connection);
	if (retval)
		goto error_remove_ida;

	retval = cdev_add(&raw->cdev, raw->dev, 1);
	if (retval)
		goto error_connection_disable;

	raw->device = device_create(raw_class, &connection->bundle->dev,
				    raw->dev, raw, "gb!raw%d", minor);
	if (IS_ERR(raw->device)) {
		retval = PTR_ERR(raw->device);
		goto error_del_cdev;
	}

	return 0;

error_del_cdev:
	cdev_del(&raw->cdev);

error_connection_disable:
	gb_connection_disable(connection);

error_remove_ida:
	ida_simple_remove(&minors, minor);

error_connection_destroy:
	gb_connection_destroy(connection);

error_free:
	kfree(raw);
	return retval;
}

static void gb_raw_disconnect(struct gb_bundle *bundle)
{
	struct gb_raw *raw = greybus_get_drvdata(bundle);
	struct gb_connection *connection = raw->connection;
	struct raw_data *raw_data;
	struct raw_data *temp;

	// FIXME - handle removing a connection when the char device node is open.
	device_destroy(raw_class, raw->dev);
	cdev_del(&raw->cdev);
	gb_connection_disable(connection);
	ida_simple_remove(&minors, MINOR(raw->dev));
	gb_connection_destroy(connection);

	mutex_lock(&raw->list_lock);
	list_for_each_entry_safe(raw_data, temp, &raw->list, entry) {
		list_del(&raw_data->entry);
		kfree(raw_data);
	}
	mutex_unlock(&raw->list_lock);

	kfree(raw);
}

/*
 * Character device node interfaces.
 *
 * Note, we are using read/write to only allow a single read/write per message.
 * This means for read(), you have to provide a big enough buffer for the full
 * message to be copied into.  If the buffer isn't big enough, the read() will
 * fail with -ENOSPC.
 */

static int raw_open(struct inode *inode, struct file *file)
{
	struct cdev *cdev = inode->i_cdev;
	struct gb_raw *raw = container_of(cdev, struct gb_raw, cdev);

	file->private_data = raw;
	return 0;
}

static ssize_t raw_write(struct file *file, const char __user *buf,
			 size_t count, loff_t *ppos)
{
	struct gb_raw *raw = file->private_data;
	int retval;

	if (!count)
		return 0;

	if (count > MAX_PACKET_SIZE)
		return -E2BIG;

	retval = gb_raw_send(raw, count, buf);
	if (retval)
		return retval;

	return count;
}

static ssize_t raw_read(struct file *file, char __user *buf, size_t count,
			loff_t *ppos)
{
	struct gb_raw *raw = file->private_data;
	int retval = 0;
	struct raw_data *raw_data;

	mutex_lock(&raw->list_lock);
	if (list_empty(&raw->list))
		goto exit;

	raw_data = list_first_entry(&raw->list, struct raw_data, entry);
	if (raw_data->len > count) {
		retval = -ENOSPC;
		goto exit;
	}

	if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) {
		retval = -EFAULT;
		goto exit;
	}

	list_del(&raw_data->entry);
	raw->list_data -= raw_data->len;
	retval = raw_data->len;
	kfree(raw_data);

exit:
	mutex_unlock(&raw->list_lock);
	return retval;
}

static const struct file_operations raw_fops = {
	.owner		= THIS_MODULE,
	.write		= raw_write,
	.read		= raw_read,
	.open		= raw_open,
	.llseek		= noop_llseek,
};

static const struct greybus_bundle_id gb_raw_id_table[] = {
	{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_RAW) },
	{ }
};
MODULE_DEVICE_TABLE(greybus, gb_raw_id_table);

static struct greybus_driver gb_raw_driver = {
	.name		= "raw",
	.probe		= gb_raw_probe,
	.disconnect	= gb_raw_disconnect,
	.id_table	= gb_raw_id_table,
};

static int raw_init(void)
{
	dev_t dev;
	int retval;

	raw_class = class_create(THIS_MODULE, "gb_raw");
	if (IS_ERR(raw_class)) {
		retval = PTR_ERR(raw_class);
		goto error_class;
	}

	retval = alloc_chrdev_region(&dev, 0, NUM_MINORS, "gb_raw");
	if (retval < 0)
		goto error_chrdev;

	raw_major = MAJOR(dev);

	retval = greybus_register(&gb_raw_driver);
	if (retval)
		goto error_gb;

	return 0;

error_gb:
	unregister_chrdev_region(dev, NUM_MINORS);
error_chrdev:
	class_destroy(raw_class);
error_class:
	return retval;
}
module_init(raw_init);

static void __exit raw_exit(void)
{
	greybus_deregister(&gb_raw_driver);
	unregister_chrdev_region(MKDEV(raw_major, 0), NUM_MINORS);
	class_destroy(raw_class);
	ida_destroy(&minors);
}
module_exit(raw_exit);

MODULE_LICENSE("GPL v2");
Commit	Line	Data
eb50fd3a	1	// SPDX-License-Identifier: GPL-2.0
e806c7fb GKH	2	/*
	3	* Greybus driver for the Raw protocol
	4	*
	5	* Copyright 2015 Google Inc.
	6	* Copyright 2015 Linaro Ltd.
e806c7fb GKH	7	*/
	8	#include <linux/kernel.h>
	9	#include <linux/module.h>
	10	#include <linux/slab.h>
	11	#include <linux/sizes.h>
	12	#include <linux/cdev.h>
	13	#include <linux/fs.h>
	14	#include <linux/idr.h>
4f8ab110	15	#include <linux/uaccess.h>
ec0ad868	16	#include <linux/greybus.h>
e806c7fb GKH	17
	18	struct gb_raw {
	19	struct gb_connection *connection;
e806c7fb GKH	20
	21	struct list_head list;
	22	int list_data;
	23	struct mutex list_lock;
	24	dev_t dev;
	25	struct cdev cdev;
	26	struct device *device;
	27	};
	28
e806c7fb GKH	29	struct raw_data {
	30	struct list_head entry;
	31	u32 len;
8acd7c56	32	u8 data[];
e806c7fb GKH	33	};
	34
	35	static struct class *raw_class;
	36	static int raw_major;
	37	static const struct file_operations raw_fops;
	38	static DEFINE_IDA(minors);
	39
	40	/* Number of minor devices this driver supports */
	41	#define NUM_MINORS 256
	42
	43	/* Maximum size of any one send data buffer we support */
	44	#define MAX_PACKET_SIZE (PAGE_SIZE * 2)
	45
	46	/*
	47	* Maximum size of the data in the receive buffer we allow before we start to
	48	* drop messages on the floor
	49	*/
	50	#define MAX_DATA_SIZE (MAX_PACKET_SIZE * 8)
	51
	52	/*
	53	* Add the raw data message to the list of received messages.
	54	*/
	55	static int receive_data(struct gb_raw raw, u32 len, u8 data)
	56	{
	57	struct raw_data *raw_data;
2554eda5	58	struct device *dev = &raw->connection->bundle->dev;
e806c7fb GKH	59	int retval = 0;
	60
	61	if (len > MAX_PACKET_SIZE) {
2554eda5	62	dev_err(dev, "Too big of a data packet, rejected\n");
e806c7fb GKH	63	return -EINVAL;
	64	}
	65
	66	mutex_lock(&raw->list_lock);
	67	if ((raw->list_data + len) > MAX_DATA_SIZE) {
2554eda5	68	dev_err(dev, "Too much data in receive buffer, now dropping packets\n");
e806c7fb GKH	69	retval = -EINVAL;
	70	goto exit;
	71	}
	72
	73	raw_data = kmalloc(sizeof(*raw_data) + len, GFP_KERNEL);
	74	if (!raw_data) {
	75	retval = -ENOMEM;
	76	goto exit;
	77	}
	78
	79	raw->list_data += len;
	80	raw_data->len = len;
	81	memcpy(&raw_data->data[0], data, len);
	82
	83	list_add_tail(&raw_data->entry, &raw->list);
	84	exit:
	85	mutex_unlock(&raw->list_lock);
	86	return retval;
	87	}
	88
512cc327	89	static int gb_raw_request_handler(struct gb_operation *op)
e806c7fb GKH	90	{
e806c7fb GKH	91	struct gb_connection *connection = op->connection;
2554eda5	92	struct device *dev = &connection->bundle->dev;
512cc327	93	struct gb_raw *raw = greybus_get_drvdata(connection->bundle);
e806c7fb GKH	94	struct gb_raw_send_request *receive;
	95	u32 len;
	96
512cc327	97	if (op->type != GB_RAW_TYPE_SEND) {
c7733b61	98	dev_err(dev, "unknown request type 0x%02x\n", op->type);
e806c7fb GKH	99	return -EINVAL;
	100	}
	101
	102	/* Verify size of payload */
	103	if (op->request->payload_size < sizeof(*receive)) {
2554eda5	104	dev_err(dev, "raw receive request too small (%zu < %zu)\n",
7fea641c	105	op->request->payload_size, sizeof(*receive));
e806c7fb GKH	106	return -EINVAL;
	107	}
	108	receive = op->request->payload;
	109	len = le32_to_cpu(receive->len);
	110	if (len != (int)(op->request->payload_size - sizeof(__le32))) {
2554eda5	111	dev_err(dev, "raw receive request wrong size %d vs %d\n", len,
e806c7fb GKH	112	(int)(op->request->payload_size - sizeof(__le32)));
	113	return -EINVAL;
	114	}
	115	if (len == 0) {
2554eda5	116	dev_err(dev, "raw receive request of 0 bytes?\n");
e806c7fb GKH	117	return -EINVAL;
	118	}
	119
	120	return receive_data(raw, len, receive->data);
	121	}
	122
	123	static int gb_raw_send(struct gb_raw raw, u32 len, const char __user data)
	124	{
	125	struct gb_connection *connection = raw->connection;
	126	struct gb_raw_send_request *request;
	127	int retval;
	128
	129	request = kmalloc(len + sizeof(*request), GFP_KERNEL);
	130	if (!request)
	131	return -ENOMEM;
	132
	133	if (copy_from_user(&request->data[0], data, len)) {
	134	kfree(request);
	135	return -EFAULT;
	136	}
	137
	138	request->len = cpu_to_le32(len);
	139
	140	retval = gb_operation_sync(connection, GB_RAW_TYPE_SEND,
	141	request, len + sizeof(*request),
	142	NULL, 0);
	143
	144	kfree(request);
	145	return retval;
	146	}
	147
512cc327 VK	148	static int gb_raw_probe(struct gb_bundle *bundle,
512cc327 VK	149	const struct greybus_bundle_id *id)
e806c7fb	150	{
512cc327 VK	151	struct greybus_descriptor_cport *cport_desc;
512cc327 VK	152	struct gb_connection *connection;
e806c7fb GKH	153	struct gb_raw *raw;
	154	int retval;
	155	int minor;
	156
512cc327 VK	157	if (bundle->num_cports != 1)
	158	return -ENODEV;
	159
	160	cport_desc = &bundle->cport_desc[0];
	161	if (cport_desc->protocol_id != GREYBUS_PROTOCOL_RAW)
	162	return -ENODEV;
	163
e806c7fb GKH	164	raw = kzalloc(sizeof(*raw), GFP_KERNEL);
	165	if (!raw)
	166	return -ENOMEM;
	167
512cc327 VK	168	connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
	169	gb_raw_request_handler);
	170	if (IS_ERR(connection)) {
	171	retval = PTR_ERR(connection);
	172	goto error_free;
	173	}
e806c7fb	174
e806c7fb GKH	175	INIT_LIST_HEAD(&raw->list);
	176	mutex_init(&raw->list_lock);
	177
512cc327 VK	178	raw->connection = connection;
	179	greybus_set_drvdata(bundle, raw);
	180
e806c7fb GKH	181	minor = ida_simple_get(&minors, 0, 0, GFP_KERNEL);
	182	if (minor < 0) {
	183	retval = minor;
512cc327	184	goto error_connection_destroy;
e806c7fb GKH	185	}
	186
	187	raw->dev = MKDEV(raw_major, minor);
	188	cdev_init(&raw->cdev, &raw_fops);
512cc327 VK	189
512cc327 VK	190	retval = gb_connection_enable(connection);
e806c7fb	191	if (retval)
c463593c	192	goto error_remove_ida;
e806c7fb	193
512cc327 VK	194	retval = cdev_add(&raw->cdev, raw->dev, 1);
	195	if (retval)
	196	goto error_connection_disable;
	197
29a167ec GKH	198	raw->device = device_create(raw_class, &connection->bundle->dev,
29a167ec GKH	199	raw->dev, raw, "gb!raw%d", minor);
e806c7fb GKH	200	if (IS_ERR(raw->device)) {
e806c7fb GKH	201	retval = PTR_ERR(raw->device);
c463593c	202	goto error_del_cdev;
e806c7fb GKH	203	}
	204
	205	return 0;
	206
c463593c	207	error_del_cdev:
e806c7fb GKH	208	cdev_del(&raw->cdev);
e806c7fb GKH	209
512cc327 VK	210	error_connection_disable:
	211	gb_connection_disable(connection);
	212
c463593c	213	error_remove_ida:
e806c7fb GKH	214	ida_simple_remove(&minors, minor);
e806c7fb GKH	215
512cc327 VK	216	error_connection_destroy:
	217	gb_connection_destroy(connection);
	218
e806c7fb GKH	219	error_free:
	220	kfree(raw);
	221	return retval;
	222	}
	223
512cc327	224	static void gb_raw_disconnect(struct gb_bundle *bundle)
e806c7fb	225	{
512cc327 VK	226	struct gb_raw *raw = greybus_get_drvdata(bundle);
512cc327 VK	227	struct gb_connection *connection = raw->connection;
e806c7fb GKH	228	struct raw_data *raw_data;
	229	struct raw_data *temp;
	230
	231	// FIXME - handle removing a connection when the char device node is open.
397d3415	232	device_destroy(raw_class, raw->dev);
e806c7fb	233	cdev_del(&raw->cdev);
512cc327	234	gb_connection_disable(connection);
e806c7fb	235	ida_simple_remove(&minors, MINOR(raw->dev));
512cc327 VK	236	gb_connection_destroy(connection);
512cc327 VK	237
e806c7fb GKH	238	mutex_lock(&raw->list_lock);
	239	list_for_each_entry_safe(raw_data, temp, &raw->list, entry) {
	240	list_del(&raw_data->entry);
	241	kfree(raw_data);
	242	}
	243	mutex_unlock(&raw->list_lock);
	244
	245	kfree(raw);
	246	}
	247
e806c7fb GKH	248	/*
	249	* Character device node interfaces.
	250	*
	251	* Note, we are using read/write to only allow a single read/write per message.
	252	* This means for read(), you have to provide a big enough buffer for the full
	253	* message to be copied into. If the buffer isn't big enough, the read() will
	254	* fail with -ENOSPC.
	255	*/
	256
	257	static int raw_open(struct inode inode, struct file file)
	258	{
	259	struct cdev *cdev = inode->i_cdev;
	260	struct gb_raw *raw = container_of(cdev, struct gb_raw, cdev);
	261
	262	file->private_data = raw;
	263	return 0;
	264	}
	265
	266	static ssize_t raw_write(struct file file, const char __user buf,
	267	size_t count, loff_t *ppos)
	268	{
	269	struct gb_raw *raw = file->private_data;
	270	int retval;
	271
	272	if (!count)
	273	return 0;
	274
	275	if (count > MAX_PACKET_SIZE)
	276	return -E2BIG;
	277
	278	retval = gb_raw_send(raw, count, buf);
	279	if (retval)
	280	return retval;
	281
	282	return count;
	283	}
	284
	285	static ssize_t raw_read(struct file file, char __user buf, size_t count,
	286	loff_t *ppos)
	287	{
	288	struct gb_raw *raw = file->private_data;
	289	int retval = 0;
	290	struct raw_data *raw_data;
	291
	292	mutex_lock(&raw->list_lock);
	293	if (list_empty(&raw->list))
	294	goto exit;
	295
	296	raw_data = list_first_entry(&raw->list, struct raw_data, entry);
	297	if (raw_data->len > count) {
	298	retval = -ENOSPC;
	299	goto exit;
	300	}
	301
	302	if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) {
	303	retval = -EFAULT;
	304	goto exit;
	305	}
	306
	307	list_del(&raw_data->entry);
	308	raw->list_data -= raw_data->len;
	309	retval = raw_data->len;
	310	kfree(raw_data);
	311
312	exit:
313	mutex_unlock(&raw->list_lock);
314	return retval;
315	}
316
317	static const struct file_operations raw_fops = {
318	.owner = THIS_MODULE,
319	.write = raw_write,
320	.read = raw_read,
321	.open = raw_open,
322	.llseek = noop_llseek,
323	};
324
512cc327 VK	325	static const struct greybus_bundle_id gb_raw_id_table[] = {
	326	{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_RAW) },
	327	{ }
	328	};
	329	MODULE_DEVICE_TABLE(greybus, gb_raw_id_table);
	330
	331	static struct greybus_driver gb_raw_driver = {
	332	.name = "raw",
	333	.probe = gb_raw_probe,
	334	.disconnect = gb_raw_disconnect,
	335	.id_table = gb_raw_id_table,
	336	};
	337
e806c7fb GKH	338	static int raw_init(void)
	339	{
	340	dev_t dev;
	341	int retval;
	342
	343	raw_class = class_create(THIS_MODULE, "gb_raw");
	344	if (IS_ERR(raw_class)) {
	345	retval = PTR_ERR(raw_class);
	346	goto error_class;
	347	}
	348
	349	retval = alloc_chrdev_region(&dev, 0, NUM_MINORS, "gb_raw");
	350	if (retval < 0)
	351	goto error_chrdev;
	352
e806c7fb GKH	353	raw_major = MAJOR(dev);
e806c7fb GKH	354
512cc327	355	retval = greybus_register(&gb_raw_driver);
e806c7fb GKH	356	if (retval)
	357	goto error_gb;
	358
	359	return 0;
	360
	361	error_gb:
	362	unregister_chrdev_region(dev, NUM_MINORS);
	363	error_chrdev:
	364	class_destroy(raw_class);
	365	error_class:
	366	return retval;
	367	}
8ba2522f	368	module_init(raw_init);
e806c7fb GKH	369
	370	static void __exit raw_exit(void)
	371	{
512cc327	372	greybus_deregister(&gb_raw_driver);
e806c7fb GKH	373	unregister_chrdev_region(MKDEV(raw_major, 0), NUM_MINORS);
e806c7fb GKH	374	class_destroy(raw_class);
5c1ac694	375	ida_destroy(&minors);
e806c7fb	376	}
e806c7fb GKH	377	module_exit(raw_exit);
	378
	379	MODULE_LICENSE("GPL v2");