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