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