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("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"); 380