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