Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Greg Kroah-Hartman | 1372 | 83.05% | 6 | 42.86% |
Viresh Kumar | 270 | 16.34% | 6 | 42.86% |
Johan Hovold | 10 | 0.61% | 2 | 14.29% |
Total | 1652 | 14 |
// 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[0]; }; 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");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1