drivers/staging/greybus/raw.c

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