drivers/staging/greybus/raw.c

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