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 #include <linux/greybus.h>
  17
  18 struct gb_raw {
  19         struct gb_connection *connection;
  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
  29 struct raw_data {
  30         struct list_head entry;
  31         u32 len;
  32         u8 data[];
  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;
  58         struct device *dev = &raw->connection->bundle->dev;
  59         int retval = 0;
  60
  61         if (len > MAX_PACKET_SIZE) {
  62                 dev_err(dev, "Too big of a data packet, rejected\n");
  63                 return -EINVAL;
  64         }
  65
  66         mutex_lock(&raw->list_lock);
  67         if ((raw->list_data + len) > MAX_DATA_SIZE) {
  68                 dev_err(dev, "Too much data in receive buffer, now dropping packets\n");
  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
  89 static int gb_raw_request_handler(struct gb_operation *op)
  90 {
  91         struct gb_connection *connection = op->connection;
  92         struct device *dev = &connection->bundle->dev;
  93         struct gb_raw *raw = greybus_get_drvdata(connection->bundle);
  94         struct gb_raw_send_request *receive;
  95         u32 len;
  96
  97         if (op->type != GB_RAW_TYPE_SEND) {
  98                 dev_err(dev, "unknown request type 0x%02x\n", op->type);
  99                 return -EINVAL;
 100         }
 101
 102         /* Verify size of payload */
 103         if (op->request->payload_size < sizeof(*receive)) {
 104                 dev_err(dev, "raw receive request too small (%zu < %zu)\n",
 105                         op->request->payload_size, sizeof(*receive));
 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))) {
 111                 dev_err(dev, "raw receive request wrong size %d vs %d\n", len,
 112                         (int)(op->request->payload_size - sizeof(__le32)));
 113                 return -EINVAL;
 114         }
 115         if (len == 0) {
 116                 dev_err(dev, "raw receive request of 0 bytes?\n");
 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
 148 static int gb_raw_probe(struct gb_bundle *bundle,
 149                         const struct greybus_bundle_id *id)
 150 {
 151         struct greybus_descriptor_cport *cport_desc;
 152         struct gb_connection *connection;
 153         struct gb_raw *raw;
 154         int retval;
 155         int minor;
 156
 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
 164         raw = kzalloc(sizeof(*raw), GFP_KERNEL);
 165         if (!raw)
 166                 return -ENOMEM;
 167
 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         }
 174
 175         INIT_LIST_HEAD(&raw->list);
 176         mutex_init(&raw->list_lock);
 177
 178         raw->connection = connection;
 179         greybus_set_drvdata(bundle, raw);
 180
 181         minor = ida_simple_get(&minors, 0, 0, GFP_KERNEL);
 182         if (minor < 0) {
 183                 retval = minor;
 184                 goto error_connection_destroy;
 185         }
 186
 187         raw->dev = MKDEV(raw_major, minor);
 188         cdev_init(&raw->cdev, &raw_fops);
 189
 190         retval = gb_connection_enable(connection);
 191         if (retval)
 192                 goto error_remove_ida;
 193
 194         retval = cdev_add(&raw->cdev, raw->dev, 1);
 195         if (retval)
 196                 goto error_connection_disable;
 197
 198         raw->device = device_create(raw_class, &connection->bundle->dev,
 199                                     raw->dev, raw, "gb!raw%d", minor);
 200         if (IS_ERR(raw->device)) {
 201                 retval = PTR_ERR(raw->device);
 202                 goto error_del_cdev;
 203         }
 204
 205         return 0;
 206
 207 error_del_cdev:
 208         cdev_del(&raw->cdev);
 209
 210 error_connection_disable:
 211         gb_connection_disable(connection);
 212
 213 error_remove_ida:
 214         ida_simple_remove(&minors, minor);
 215
 216 error_connection_destroy:
 217         gb_connection_destroy(connection);
 218
 219 error_free:
 220         kfree(raw);
 221         return retval;
 222 }
 223
 224 static void gb_raw_disconnect(struct gb_bundle *bundle)
 225 {
 226         struct gb_raw *raw = greybus_get_drvdata(bundle);
 227         struct gb_connection *connection = raw->connection;
 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.
 232         device_destroy(raw_class, raw->dev);
 233         cdev_del(&raw->cdev);
 234         gb_connection_disable(connection);
 235         ida_simple_remove(&minors, MINOR(raw->dev));
 236         gb_connection_destroy(connection);
 237
 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
 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
 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
 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
 353         raw_major = MAJOR(dev);
 354
 355         retval = greybus_register(&gb_raw_driver);
 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 }
 368 module_init(raw_init);
 369
 370 static void __exit raw_exit(void)
 371 {
 372         greybus_deregister(&gb_raw_driver);
 373         unregister_chrdev_region(MKDEV(raw_major, 0), NUM_MINORS);
 374         class_destroy(raw_class);
 375         ida_destroy(&minors);
 376 }
 377 module_exit(raw_exit);
 378
 379 MODULE_LICENSE("GPL v2");