projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / video / adf / adf_fops.c
1 /*
2 * Copyright (C) 2013 Google, Inc.
3 *
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 */
14
15 #include <linux/bitops.h>
16 #include <linux/circ_buf.h>
17 #include <linux/fs.h>
18 #include <linux/module.h>
19 #include <linux/poll.h>
20 #include <linux/slab.h>
21 #include <linux/uaccess.h>
22
23 #include <video/adf_client.h>
24 #include <video/adf_format.h>
25
26 #include "sw_sync.h"
27 #include "sync.h"
28
29 #include "adf.h"
30 #include "adf_fops.h"
31 #include "adf_sysfs.h"
32
33 #ifdef CONFIG_COMPAT
34 #include "adf_fops32.h"
35 #endif
36
37 static int adf_obj_set_event(struct adf_obj *obj, struct adf_file *file,
38 struct adf_set_event __user *arg)
39 {
40 struct adf_set_event data;
41 bool enabled;
42 unsigned long flags;
43 int err;
44
45 if (copy_from_user(&data, arg, sizeof(data)))
46 return -EFAULT;
47
48 err = adf_obj_check_supports_event(obj, data.type);
49 if (err < 0)
50 return err;
51
52 spin_lock_irqsave(&obj->file_lock, flags);
53 if (data.enabled)
54 enabled = test_and_set_bit(data.type,
55 file->event_subscriptions);
56 else
57 enabled = test_and_clear_bit(data.type,
58 file->event_subscriptions);
59 spin_unlock_irqrestore(&obj->file_lock, flags);
60
61 if (data.enabled == enabled)
62 return -EALREADY;
63
64 if (data.enabled)
65 adf_event_get(obj, data.type);
66 else
67 adf_event_put(obj, data.type);
68
69 return 0;
70 }
71
72 static int adf_obj_copy_custom_data_to_user(struct adf_obj *obj,
73 void __user *dst, size_t *dst_size)
74 {
75 void *custom_data;
76 size_t custom_data_size;
77 int ret;
78
79 if (!obj->ops || !obj->ops->custom_data) {
80 dev_dbg(&obj->dev, "%s: no custom_data op\n", __func__);
81 return 0;
82 }
83
84 custom_data = kzalloc(ADF_MAX_CUSTOM_DATA_SIZE, GFP_KERNEL);
85 if (!custom_data)
86 return -ENOMEM;
87
88 ret = obj->ops->custom_data(obj, custom_data, &custom_data_size);
89 if (ret < 0)
90 goto done;
91
92 if (copy_to_user(dst, custom_data, min(*dst_size, custom_data_size))) {
93 ret = -EFAULT;
94 goto done;
95 }
96 *dst_size = custom_data_size;
97
98 done:
99 kfree(custom_data);
100 return ret;
101 }
102
103 static int adf_eng_get_data(struct adf_overlay_engine *eng,
104 struct adf_overlay_engine_data __user *arg)
105 {
106 struct adf_device *dev = adf_overlay_engine_parent(eng);
107 struct adf_overlay_engine_data data;
108 size_t n_supported_formats;
109 u32 *supported_formats = NULL;
110 int ret = 0;
111
112 if (copy_from_user(&data, arg, sizeof(data)))
113 return -EFAULT;
114
115 strlcpy(data.name, eng->base.name, sizeof(data.name));
116
117 if (data.n_supported_formats > ADF_MAX_SUPPORTED_FORMATS)
118 return -EINVAL;
119
120 n_supported_formats = data.n_supported_formats;
121 data.n_supported_formats = eng->ops->n_supported_formats;
122
123 if (n_supported_formats) {
124 supported_formats = kzalloc(n_supported_formats *
125 sizeof(supported_formats[0]), GFP_KERNEL);
126 if (!supported_formats)
127 return -ENOMEM;
128 }
129
130 memcpy(supported_formats, eng->ops->supported_formats,
131 sizeof(u32) * min(n_supported_formats,
132 eng->ops->n_supported_formats));
133
134 mutex_lock(&dev->client_lock);
135 ret = adf_obj_copy_custom_data_to_user(&eng->base, arg->custom_data,
136 &data.custom_data_size);
137 mutex_unlock(&dev->client_lock);
138
139 if (ret < 0)
140 goto done;
141
142 if (copy_to_user(arg, &data, sizeof(data))) {
143 ret = -EFAULT;
144 goto done;
145 }
146
147 if (supported_formats && copy_to_user(arg->supported_formats,
148 supported_formats,
149 n_supported_formats * sizeof(supported_formats[0])))
150 ret = -EFAULT;
151
152 done:
153 kfree(supported_formats);
154 return ret;
155 }
156
157 static int adf_buffer_import(struct adf_device *dev,
158 struct adf_buffer_config __user *cfg, struct adf_buffer *buf)
159 {
160 struct adf_buffer_config user_buf;
161 size_t i;
162 int ret = 0;
163
164 if (copy_from_user(&user_buf, cfg, sizeof(user_buf)))
165 return -EFAULT;
166
167 memset(buf, 0, sizeof(*buf));
168
169 if (user_buf.n_planes > ADF_MAX_PLANES) {
170 dev_err(&dev->base.dev, "invalid plane count %u\n",
171 user_buf.n_planes);
172 return -EINVAL;
173 }
174
175 buf->overlay_engine = idr_find(&dev->overlay_engines,
176 user_buf.overlay_engine);
177 if (!buf->overlay_engine) {
178 dev_err(&dev->base.dev, "invalid overlay engine id %u\n",
179 user_buf.overlay_engine);
180 return -ENOENT;
181 }
182
183 buf->w = user_buf.w;
184 buf->h = user_buf.h;
185 buf->format = user_buf.format;
186 for (i = 0; i < user_buf.n_planes; i++) {
187 buf->dma_bufs[i] = dma_buf_get(user_buf.fd[i]);
188 if (IS_ERR(buf->dma_bufs[i])) {
189 ret = PTR_ERR(buf->dma_bufs[i]);
190 dev_err(&dev->base.dev, "importing dma_buf fd %d failed: %d\n",
191 user_buf.fd[i], ret);
192 buf->dma_bufs[i] = NULL;
193 goto done;
194 }
195 buf->offset[i] = user_buf.offset[i];
196 buf->pitch[i] = user_buf.pitch[i];
197 }
198 buf->n_planes = user_buf.n_planes;
199
200 if (user_buf.acquire_fence >= 0) {
201 buf->acquire_fence = sync_fence_fdget(user_buf.acquire_fence);
202 if (!buf->acquire_fence) {
203 dev_err(&dev->base.dev, "getting fence fd %d failed\n",
204 user_buf.acquire_fence);
205 ret = -EINVAL;
206 goto done;
207 }
208 }
209
210 done:
211 if (ret < 0)
212 adf_buffer_cleanup(buf);
213 return ret;
214 }
215
216 static int adf_device_post_config(struct adf_device *dev,
217 struct adf_post_config __user *arg)
218 {
219 struct sync_fence *complete_fence;
220 int complete_fence_fd;
221 struct adf_buffer *bufs = NULL;
222 struct adf_interface **intfs = NULL;
223 size_t n_intfs, n_bufs, i;
224 void *custom_data = NULL;
225 size_t custom_data_size;
226 int ret = 0;
227
228 complete_fence_fd = get_unused_fd();
229 if (complete_fence_fd < 0)
230 return complete_fence_fd;
231
232 if (get_user(n_intfs, &arg->n_interfaces)) {
233 ret = -EFAULT;
234 goto err_get_user;
235 }
236
237 if (n_intfs > ADF_MAX_INTERFACES) {
238 ret = -EINVAL;
239 goto err_get_user;
240 }
241
242 if (get_user(n_bufs, &arg->n_bufs)) {
243 ret = -EFAULT;
244 goto err_get_user;
245 }
246
247 if (n_bufs > ADF_MAX_BUFFERS) {
248 ret = -EINVAL;
249 goto err_get_user;
250 }
251
252 if (get_user(custom_data_size, &arg->custom_data_size)) {
253 ret = -EFAULT;
254 goto err_get_user;
255 }
256
257 if (custom_data_size > ADF_MAX_CUSTOM_DATA_SIZE) {
258 ret = -EINVAL;
259 goto err_get_user;
260 }
261
262 if (n_intfs) {
263 intfs = kmalloc(sizeof(intfs[0]) * n_intfs, GFP_KERNEL);
264 if (!intfs) {
265 ret = -ENOMEM;
266 goto err_get_user;
267 }
268 }
269
270 for (i = 0; i < n_intfs; i++) {
271 u32 intf_id;
272 if (get_user(intf_id, &arg->interfaces[i])) {
273 ret = -EFAULT;
274 goto err_get_user;
275 }
276
277 intfs[i] = idr_find(&dev->interfaces, intf_id);
278 if (!intfs[i]) {
279 ret = -EINVAL;
280 goto err_get_user;
281 }
282 }
283
284 if (n_bufs) {
285 bufs = kzalloc(sizeof(bufs[0]) * n_bufs, GFP_KERNEL);
286 if (!bufs) {
287 ret = -ENOMEM;
288 goto err_get_user;
289 }
290 }
291
292 for (i = 0; i < n_bufs; i++) {
293 ret = adf_buffer_import(dev, &arg->bufs[i], &bufs[i]);
294 if (ret < 0) {
295 memset(&bufs[i], 0, sizeof(bufs[i]));
296 goto err_import;
297 }
298 }
299
300 if (custom_data_size) {
301 custom_data = kzalloc(custom_data_size, GFP_KERNEL);
302 if (!custom_data) {
303 ret = -ENOMEM;
304 goto err_import;
305 }
306
307 if (copy_from_user(custom_data, arg->custom_data,
308 custom_data_size)) {
309 ret = -EFAULT;
310 goto err_import;
311 }
312 }
313
314 if (put_user(complete_fence_fd, &arg->complete_fence)) {
315 ret = -EFAULT;
316 goto err_import;
317 }
318
319 complete_fence = adf_device_post_nocopy(dev, intfs, n_intfs, bufs,
320 n_bufs, custom_data, custom_data_size);
321 if (IS_ERR(complete_fence)) {
322 ret = PTR_ERR(complete_fence);
323 goto err_import;
324 }
325
326 sync_fence_install(complete_fence, complete_fence_fd);
327 return 0;
328
329 err_import:
330 for (i = 0; i < n_bufs; i++)
331 adf_buffer_cleanup(&bufs[i]);
332
333 err_get_user:
334 kfree(custom_data);
335 kfree(bufs);
336 kfree(intfs);
337 put_unused_fd(complete_fence_fd);
338 return ret;
339 }
340
341 static int adf_intf_simple_post_config(struct adf_interface *intf,
342 struct adf_simple_post_config __user *arg)
343 {
344 struct adf_device *dev = intf->base.parent;
345 struct sync_fence *complete_fence;
346 int complete_fence_fd;
347 struct adf_buffer buf;
348 int ret = 0;
349
350 complete_fence_fd = get_unused_fd();
351 if (complete_fence_fd < 0)
352 return complete_fence_fd;
353
354 ret = adf_buffer_import(dev, &arg->buf, &buf);
355 if (ret < 0)
356 goto err_import;
357
358 if (put_user(complete_fence_fd, &arg->complete_fence)) {
359 ret = -EFAULT;
360 goto err_put_user;
361 }
362
363 complete_fence = adf_interface_simple_post(intf, &buf);
364 if (IS_ERR(complete_fence)) {
365 ret = PTR_ERR(complete_fence);
366 goto err_put_user;
367 }
368
369 sync_fence_install(complete_fence, complete_fence_fd);
370 return 0;
371
372 err_put_user:
373 adf_buffer_cleanup(&buf);
374 err_import:
375 put_unused_fd(complete_fence_fd);
376 return ret;
377 }
378
379 static int adf_intf_simple_buffer_alloc(struct adf_interface *intf,
380 struct adf_simple_buffer_alloc __user *arg)
381 {
382 struct adf_simple_buffer_alloc data;
383 struct dma_buf *dma_buf;
384 int ret = 0;
385
386 if (copy_from_user(&data, arg, sizeof(data)))
387 return -EFAULT;
388
389 data.fd = get_unused_fd_flags(O_CLOEXEC);
390 if (data.fd < 0)
391 return data.fd;
392
393 ret = adf_interface_simple_buffer_alloc(intf, data.w, data.h,
394 data.format, &dma_buf, &data.offset, &data.pitch);
395 if (ret < 0)
396 goto err_alloc;
397
398 if (copy_to_user(arg, &data, sizeof(*arg))) {
399 ret = -EFAULT;
400 goto err_copy;
401 }
402
403 fd_install(data.fd, dma_buf->file);
404 return 0;
405
406 err_copy:
407 dma_buf_put(dma_buf);
408
409 err_alloc:
410 put_unused_fd(data.fd);
411 return ret;
412 }
413
414 static int adf_copy_attachment_list_to_user(
415 struct adf_attachment_config __user *to, size_t n_to,
416 struct adf_attachment *from, size_t n_from)
417 {
418 struct adf_attachment_config *temp;
419 size_t n = min(n_to, n_from);
420 size_t i;
421 int ret = 0;
422
423 if (!n)
424 return 0;
425
426 temp = kzalloc(n * sizeof(temp[0]), GFP_KERNEL);
427 if (!temp)
428 return -ENOMEM;
429
430 for (i = 0; i < n; i++) {
431 temp[i].interface = from[i].interface->base.id;
432 temp[i].overlay_engine = from[i].overlay_engine->base.id;
433 }
434
435 if (copy_to_user(to, temp, n * sizeof(to[0]))) {
436 ret = -EFAULT;
437 goto done;
438 }
439
440 done:
441 kfree(temp);
442 return ret;
443 }
444
445 static int adf_device_get_data(struct adf_device *dev,
446 struct adf_device_data __user *arg)
447 {
448 struct adf_device_data data;
449 size_t n_attach;
450 struct adf_attachment *attach = NULL;
451 size_t n_allowed_attach;
452 struct adf_attachment *allowed_attach = NULL;
453 int ret = 0;
454
455 if (copy_from_user(&data, arg, sizeof(data)))
456 return -EFAULT;
457
458 if (data.n_attachments > ADF_MAX_ATTACHMENTS ||
459 data.n_allowed_attachments > ADF_MAX_ATTACHMENTS)
460 return -EINVAL;
461
462 strlcpy(data.name, dev->base.name, sizeof(data.name));
463
464 if (data.n_attachments) {
465 attach = kzalloc(data.n_attachments * sizeof(attach[0]),
466 GFP_KERNEL);
467 if (!attach)
468 return -ENOMEM;
469 }
470 n_attach = adf_device_attachments(dev, attach, data.n_attachments);
471
472 if (data.n_allowed_attachments) {
473 allowed_attach = kzalloc(data.n_allowed_attachments *
474 sizeof(allowed_attach[0]), GFP_KERNEL);
475 if (!allowed_attach) {
476 ret = -ENOMEM;
477 goto done;
478 }
479 }
480 n_allowed_attach = adf_device_attachments_allowed(dev, allowed_attach,
481 data.n_allowed_attachments);
482
483 mutex_lock(&dev->client_lock);
484 ret = adf_obj_copy_custom_data_to_user(&dev->base, arg->custom_data,
485 &data.custom_data_size);
486 mutex_unlock(&dev->client_lock);
487
488 if (ret < 0)
489 goto done;
490
491 ret = adf_copy_attachment_list_to_user(arg->attachments,
492 data.n_attachments, attach, n_attach);
493 if (ret < 0)
494 goto done;
495
496 ret = adf_copy_attachment_list_to_user(arg->allowed_attachments,
497 data.n_allowed_attachments, allowed_attach,
498 n_allowed_attach);
499 if (ret < 0)
500 goto done;
501
502 data.n_attachments = n_attach;
503 data.n_allowed_attachments = n_allowed_attach;
504
505 if (copy_to_user(arg, &data, sizeof(data)))
506 ret = -EFAULT;
507
508 done:
509 kfree(allowed_attach);
510 kfree(attach);
511 return ret;
512 }
513
514 static int adf_device_handle_attachment(struct adf_device *dev,
515 struct adf_attachment_config __user *arg, bool attach)
516 {
517 struct adf_attachment_config data;
518 struct adf_overlay_engine *eng;
519 struct adf_interface *intf;
520
521 if (copy_from_user(&data, arg, sizeof(data)))
522 return -EFAULT;
523
524 eng = idr_find(&dev->overlay_engines, data.overlay_engine);
525 if (!eng) {
526 dev_err(&dev->base.dev, "invalid overlay engine id %u\n",
527 data.overlay_engine);
528 return -EINVAL;
529 }
530
531 intf = idr_find(&dev->interfaces, data.interface);
532 if (!intf) {
533 dev_err(&dev->base.dev, "invalid interface id %u\n",
534 data.interface);
535 return -EINVAL;
536 }
537
538 if (attach)
539 return adf_device_attach(dev, eng, intf);
540 else
541 return adf_device_detach(dev, eng, intf);
542 }
543
544 static int adf_intf_set_mode(struct adf_interface *intf,
545 struct drm_mode_modeinfo __user *arg)
546 {
547 struct drm_mode_modeinfo mode;
548
549 if (copy_from_user(&mode, arg, sizeof(mode)))
550 return -EFAULT;
551
552 return adf_interface_set_mode(intf, &mode);
553 }
554
555 static int adf_intf_get_data(struct adf_interface *intf,
556 struct adf_interface_data __user *arg)
557 {
558 struct adf_device *dev = adf_interface_parent(intf);
559 struct adf_interface_data data;
560 struct drm_mode_modeinfo *modelist;
561 size_t modelist_size;
562 int err;
563 int ret = 0;
564 unsigned long flags;
565
566 if (copy_from_user(&data, arg, sizeof(data)))
567 return -EFAULT;
568
569 strlcpy(data.name, intf->base.name, sizeof(data.name));
570
571 data.type = intf->type;
572 data.id = intf->idx;
573 data.flags = intf->flags;
574
575 err = adf_interface_get_screen_size(intf, &data.width_mm,
576 &data.height_mm);
577 if (err < 0) {
578 data.width_mm = 0;
579 data.height_mm = 0;
580 }
581
582 modelist = kmalloc(sizeof(modelist[0]) * ADF_MAX_MODES, GFP_KERNEL);
583 if (!modelist)
584 return -ENOMEM;
585
586 mutex_lock(&dev->client_lock);
587 read_lock_irqsave(&intf->hotplug_modelist_lock, flags);
588 data.hotplug_detect = intf->hotplug_detect;
589 modelist_size = min(data.n_available_modes, intf->n_modes) *
590 sizeof(intf->modelist[0]);
591 memcpy(modelist, intf->modelist, modelist_size);
592 data.n_available_modes = intf->n_modes;
593 read_unlock_irqrestore(&intf->hotplug_modelist_lock, flags);
594
595 if (copy_to_user(arg->available_modes, modelist, modelist_size)) {
596 ret = -EFAULT;
597 goto done;
598 }
599
600 data.dpms_state = intf->dpms_state;
601 memcpy(&data.current_mode, &intf->current_mode,
602 sizeof(intf->current_mode));
603
604 ret = adf_obj_copy_custom_data_to_user(&intf->base, arg->custom_data,
605 &data.custom_data_size);
606 done:
607 mutex_unlock(&dev->client_lock);
608 kfree(modelist);
609
610 if (ret < 0)
611 return ret;
612
613 if (copy_to_user(arg, &data, sizeof(data)))
614 ret = -EFAULT;
615
616 return ret;
617 }
618
619 static inline long adf_obj_custom_ioctl(struct adf_obj *obj, unsigned int cmd,
620 unsigned long arg)
621 {
622 if (obj->ops && obj->ops->ioctl)
623 return obj->ops->ioctl(obj, cmd, arg);
624 return -ENOTTY;
625 }
626
627 static long adf_overlay_engine_ioctl(struct adf_overlay_engine *eng,
628 struct adf_file *file, unsigned int cmd, unsigned long arg)
629 {
630 switch (cmd) {
631 case ADF_SET_EVENT:
632 return adf_obj_set_event(&eng->base, file,
633 (struct adf_set_event __user *)arg);
634
635 case ADF_GET_OVERLAY_ENGINE_DATA:
636 return adf_eng_get_data(eng,
637 (struct adf_overlay_engine_data __user *)arg);
638
639 case ADF_BLANK:
640 case ADF_POST_CONFIG:
641 case ADF_SET_MODE:
642 case ADF_GET_DEVICE_DATA:
643 case ADF_GET_INTERFACE_DATA:
644 case ADF_SIMPLE_POST_CONFIG:
645 case ADF_SIMPLE_BUFFER_ALLOC:
646 case ADF_ATTACH:
647 case ADF_DETACH:
648 return -EINVAL;
649
650 default:
651 return adf_obj_custom_ioctl(&eng->base, cmd, arg);
652 }
653 }
654
655 static long adf_interface_ioctl(struct adf_interface *intf,
656 struct adf_file *file, unsigned int cmd, unsigned long arg)
657 {
658 switch (cmd) {
659 case ADF_SET_EVENT:
660 return adf_obj_set_event(&intf->base, file,
661 (struct adf_set_event __user *)arg);
662
663 case ADF_BLANK:
664 return adf_interface_blank(intf, arg);
665
666 case ADF_SET_MODE:
667 return adf_intf_set_mode(intf,
668 (struct drm_mode_modeinfo __user *)arg);
669
670 case ADF_GET_INTERFACE_DATA:
671 return adf_intf_get_data(intf,
672 (struct adf_interface_data __user *)arg);
673
674 case ADF_SIMPLE_POST_CONFIG:
675 return adf_intf_simple_post_config(intf,
676 (struct adf_simple_post_config __user *)arg);
677
678 case ADF_SIMPLE_BUFFER_ALLOC:
679 return adf_intf_simple_buffer_alloc(intf,
680 (struct adf_simple_buffer_alloc __user *)arg);
681
682 case ADF_POST_CONFIG:
683 case ADF_GET_DEVICE_DATA:
684 case ADF_GET_OVERLAY_ENGINE_DATA:
685 case ADF_ATTACH:
686 case ADF_DETACH:
687 return -EINVAL;
688
689 default:
690 return adf_obj_custom_ioctl(&intf->base, cmd, arg);
691 }
692 }
693
694 static long adf_device_ioctl(struct adf_device *dev, struct adf_file *file,
695 unsigned int cmd, unsigned long arg)
696 {
697 switch (cmd) {
698 case ADF_SET_EVENT:
699 return adf_obj_set_event(&dev->base, file,
700 (struct adf_set_event __user *)arg);
701
702 case ADF_POST_CONFIG:
703 return adf_device_post_config(dev,
704 (struct adf_post_config __user *)arg);
705
706 case ADF_GET_DEVICE_DATA:
707 return adf_device_get_data(dev,
708 (struct adf_device_data __user *)arg);
709
710 case ADF_ATTACH:
711 return adf_device_handle_attachment(dev,
712 (struct adf_attachment_config __user *)arg,
713 true);
714
715 case ADF_DETACH:
716 return adf_device_handle_attachment(dev,
717 (struct adf_attachment_config __user *)arg,
718 false);
719
720 case ADF_BLANK:
721 case ADF_SET_MODE:
722 case ADF_GET_INTERFACE_DATA:
723 case ADF_GET_OVERLAY_ENGINE_DATA:
724 case ADF_SIMPLE_POST_CONFIG:
725 case ADF_SIMPLE_BUFFER_ALLOC:
726 return -EINVAL;
727
728 default:
729 return adf_obj_custom_ioctl(&dev->base, cmd, arg);
730 }
731 }
732
733 static int adf_file_open(struct inode *inode, struct file *file)
734 {
735 struct adf_obj *obj;
736 struct adf_file *fpriv = NULL;
737 unsigned long flags;
738 int ret = 0;
739
740 obj = adf_obj_sysfs_find(iminor(inode));
741 if (!obj)
742 return -ENODEV;
743
744 dev_dbg(&obj->dev, "opening %s\n", dev_name(&obj->dev));
745
746 if (!try_module_get(obj->parent->ops->owner)) {
747 dev_err(&obj->dev, "getting owner module failed\n");
748 return -ENODEV;
749 }
750
751 fpriv = kzalloc(sizeof(*fpriv), GFP_KERNEL);
752 if (!fpriv) {
753 ret = -ENOMEM;
754 goto done;
755 }
756
757 INIT_LIST_HEAD(&fpriv->head);
758 fpriv->obj = obj;
759 init_waitqueue_head(&fpriv->event_wait);
760
761 file->private_data = fpriv;
762
763 if (obj->ops && obj->ops->open) {
764 ret = obj->ops->open(obj, inode, file);
765 if (ret < 0)
766 goto done;
767 }
768
769 spin_lock_irqsave(&obj->file_lock, flags);
770 list_add_tail(&fpriv->head, &obj->file_list);
771 spin_unlock_irqrestore(&obj->file_lock, flags);
772
773 done:
774 if (ret < 0) {
775 kfree(fpriv);
776 module_put(obj->parent->ops->owner);
777 }
778 return ret;
779 }
780
781 static int adf_file_release(struct inode *inode, struct file *file)
782 {
783 struct adf_file *fpriv = file->private_data;
784 struct adf_obj *obj = fpriv->obj;
785 enum adf_event_type event_type;
786 unsigned long flags;
787
788 if (obj->ops && obj->ops->release)
789 obj->ops->release(obj, inode, file);
790
791 spin_lock_irqsave(&obj->file_lock, flags);
792 list_del(&fpriv->head);
793 spin_unlock_irqrestore(&obj->file_lock, flags);
794
795 for_each_set_bit(event_type, fpriv->event_subscriptions,
796 ADF_EVENT_TYPE_MAX) {
797 adf_event_put(obj, event_type);
798 }
799
800 kfree(fpriv);
801 module_put(obj->parent->ops->owner);
802
803 dev_dbg(&obj->dev, "released %s\n", dev_name(&obj->dev));
804 return 0;
805 }
806
807 long adf_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
808 {
809 struct adf_file *fpriv = file->private_data;
810 struct adf_obj *obj = fpriv->obj;
811 long ret = -EINVAL;
812
813 dev_dbg(&obj->dev, "%s ioctl %u\n", dev_name(&obj->dev), _IOC_NR(cmd));
814
815 switch (obj->type) {
816 case ADF_OBJ_OVERLAY_ENGINE:
817 ret = adf_overlay_engine_ioctl(adf_obj_to_overlay_engine(obj),
818 fpriv, cmd, arg);
819 break;
820
821 case ADF_OBJ_INTERFACE:
822 ret = adf_interface_ioctl(adf_obj_to_interface(obj), fpriv, cmd,
823 arg);
824 break;
825
826 case ADF_OBJ_DEVICE:
827 ret = adf_device_ioctl(adf_obj_to_device(obj), fpriv, cmd, arg);
828 break;
829 }
830
831 return ret;
832 }
833
834 static inline bool adf_file_event_available(struct adf_file *fpriv)
835 {
836 int head = fpriv->event_head;
837 int tail = fpriv->event_tail;
838 return CIRC_CNT(head, tail, sizeof(fpriv->event_buf)) != 0;
839 }
840
841 void adf_file_queue_event(struct adf_file *fpriv, struct adf_event *event)
842 {
843 int head = fpriv->event_head;
844 int tail = fpriv->event_tail;
845 size_t space = CIRC_SPACE(head, tail, sizeof(fpriv->event_buf));
846 size_t space_to_end =
847 CIRC_SPACE_TO_END(head, tail, sizeof(fpriv->event_buf));
848
849 if (space < event->length) {
850 dev_dbg(&fpriv->obj->dev,
851 "insufficient buffer space for event %u\n",
852 event->type);
853 return;
854 }
855
856 if (space_to_end >= event->length) {
857 memcpy(fpriv->event_buf + head, event, event->length);
858 } else {
859 memcpy(fpriv->event_buf + head, event, space_to_end);
860 memcpy(fpriv->event_buf, (u8 *)event + space_to_end,
861 event->length - space_to_end);
862 }
863
864 smp_wmb();
865 fpriv->event_head = (fpriv->event_head + event->length) &
866 (sizeof(fpriv->event_buf) - 1);
867 wake_up_interruptible_all(&fpriv->event_wait);
868 }
869
870 static ssize_t adf_file_copy_to_user(struct adf_file *fpriv,
871 char __user *buffer, size_t buffer_size)
872 {
873 int head, tail;
874 u8 *event_buf;
875 size_t cnt, cnt_to_end, copy_size = 0;
876 ssize_t ret = 0;
877 unsigned long flags;
878
879 event_buf = kmalloc(min(buffer_size, sizeof(fpriv->event_buf)),
880 GFP_KERNEL);
881 if (!event_buf)
882 return -ENOMEM;
883
884 spin_lock_irqsave(&fpriv->obj->file_lock, flags);
885
886 if (!adf_file_event_available(fpriv))
887 goto out;
888
889 head = fpriv->event_head;
890 tail = fpriv->event_tail;
891
892 cnt = CIRC_CNT(head, tail, sizeof(fpriv->event_buf));
893 cnt_to_end = CIRC_CNT_TO_END(head, tail, sizeof(fpriv->event_buf));
894 copy_size = min(buffer_size, cnt);
895
896 if (cnt_to_end >= copy_size) {
897 memcpy(event_buf, fpriv->event_buf + tail, copy_size);
898 } else {
899 memcpy(event_buf, fpriv->event_buf + tail, cnt_to_end);
900 memcpy(event_buf + cnt_to_end, fpriv->event_buf,
901 copy_size - cnt_to_end);
902 }
903
904 fpriv->event_tail = (fpriv->event_tail + copy_size) &
905 (sizeof(fpriv->event_buf) - 1);
906
907 out:
908 spin_unlock_irqrestore(&fpriv->obj->file_lock, flags);
909 if (copy_size) {
910 if (copy_to_user(buffer, event_buf, copy_size))
911 ret = -EFAULT;
912 else
913 ret = copy_size;
914 }
915 kfree(event_buf);
916 return ret;
917 }
918
919 ssize_t adf_file_read(struct file *filp, char __user *buffer,
920 size_t count, loff_t *offset)
921 {
922 struct adf_file *fpriv = filp->private_data;
923 int err;
924
925 err = wait_event_interruptible(fpriv->event_wait,
926 adf_file_event_available(fpriv));
927 if (err < 0)
928 return err;
929
930 return adf_file_copy_to_user(fpriv, buffer, count);
931 }
932
933 unsigned int adf_file_poll(struct file *filp, struct poll_table_struct *wait)
934 {
935 struct adf_file *fpriv = filp->private_data;
936 unsigned int mask = 0;
937
938 poll_wait(filp, &fpriv->event_wait, wait);
939
940 if (adf_file_event_available(fpriv))
941 mask |= POLLIN | POLLRDNORM;
942
943 return mask;
944 }
945
946 const struct file_operations adf_fops = {
947 .owner = THIS_MODULE,
948 .unlocked_ioctl = adf_file_ioctl,
949 #ifdef CONFIG_COMPAT
950 .compat_ioctl = adf_file_compat_ioctl,
951 #endif
952 .open = adf_file_open,
953 .release = adf_file_release,
954 .llseek = default_llseek,
955 .read = adf_file_read,
956 .poll = adf_file_poll,
957 };
kernel source for telekom puls (alcatel/mediatek)