Loading...
1/*
2 * Copyright (C) 2012 Samsung Electronics Co.Ltd
3 * Authors:
4 * Eunchul Kim <chulspro.kim@samsung.com>
5 * Jinyoung Jeon <jy0.jeon@samsung.com>
6 * Sangmin Lee <lsmin.lee@samsung.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14#include <linux/kernel.h>
15#include <linux/platform_device.h>
16#include <linux/types.h>
17#include <linux/clk.h>
18#include <linux/pm_runtime.h>
19
20#include <drm/drmP.h>
21#include <drm/exynos_drm.h>
22#include "exynos_drm_drv.h"
23#include "exynos_drm_gem.h"
24#include "exynos_drm_ipp.h"
25#include "exynos_drm_iommu.h"
26
27/*
28 * IPP stands for Image Post Processing and
29 * supports image scaler/rotator and input/output DMA operations.
30 * using FIMC, GSC, Rotator, so on.
31 * IPP is integration device driver of same attribute h/w
32 */
33
34/*
35 * TODO
36 * 1. expand command control id.
37 * 2. integrate property and config.
38 * 3. removed send_event id check routine.
39 * 4. compare send_event id if needed.
40 * 5. free subdrv_remove notifier callback list if needed.
41 * 6. need to check subdrv_open about multi-open.
42 * 7. need to power_on implement power and sysmmu ctrl.
43 */
44
45#define get_ipp_context(dev) platform_get_drvdata(to_platform_device(dev))
46#define ipp_is_m2m_cmd(c) (c == IPP_CMD_M2M)
47
48/*
49 * A structure of event.
50 *
51 * @base: base of event.
52 * @event: ipp event.
53 */
54struct drm_exynos_ipp_send_event {
55 struct drm_pending_event base;
56 struct drm_exynos_ipp_event event;
57};
58
59/*
60 * A structure of memory node.
61 *
62 * @list: list head to memory queue information.
63 * @ops_id: id of operations.
64 * @prop_id: id of property.
65 * @buf_id: id of buffer.
66 * @buf_info: gem objects and dma address, size.
67 * @filp: a pointer to drm_file.
68 */
69struct drm_exynos_ipp_mem_node {
70 struct list_head list;
71 enum drm_exynos_ops_id ops_id;
72 u32 prop_id;
73 u32 buf_id;
74 struct drm_exynos_ipp_buf_info buf_info;
75};
76
77/*
78 * A structure of ipp context.
79 *
80 * @subdrv: prepare initialization using subdrv.
81 * @ipp_lock: lock for synchronization of access to ipp_idr.
82 * @prop_lock: lock for synchronization of access to prop_idr.
83 * @ipp_idr: ipp driver idr.
84 * @prop_idr: property idr.
85 * @event_workq: event work queue.
86 * @cmd_workq: command work queue.
87 */
88struct ipp_context {
89 struct exynos_drm_subdrv subdrv;
90 struct mutex ipp_lock;
91 struct mutex prop_lock;
92 struct idr ipp_idr;
93 struct idr prop_idr;
94 struct workqueue_struct *event_workq;
95 struct workqueue_struct *cmd_workq;
96};
97
98static LIST_HEAD(exynos_drm_ippdrv_list);
99static DEFINE_MUTEX(exynos_drm_ippdrv_lock);
100static BLOCKING_NOTIFIER_HEAD(exynos_drm_ippnb_list);
101
102int exynos_drm_ippdrv_register(struct exynos_drm_ippdrv *ippdrv)
103{
104 mutex_lock(&exynos_drm_ippdrv_lock);
105 list_add_tail(&ippdrv->drv_list, &exynos_drm_ippdrv_list);
106 mutex_unlock(&exynos_drm_ippdrv_lock);
107
108 return 0;
109}
110
111int exynos_drm_ippdrv_unregister(struct exynos_drm_ippdrv *ippdrv)
112{
113 mutex_lock(&exynos_drm_ippdrv_lock);
114 list_del(&ippdrv->drv_list);
115 mutex_unlock(&exynos_drm_ippdrv_lock);
116
117 return 0;
118}
119
120static int ipp_create_id(struct idr *id_idr, struct mutex *lock, void *obj)
121{
122 int ret;
123
124 mutex_lock(lock);
125 ret = idr_alloc(id_idr, obj, 1, 0, GFP_KERNEL);
126 mutex_unlock(lock);
127
128 return ret;
129}
130
131static void ipp_remove_id(struct idr *id_idr, struct mutex *lock, u32 id)
132{
133 mutex_lock(lock);
134 idr_remove(id_idr, id);
135 mutex_unlock(lock);
136}
137
138static void *ipp_find_obj(struct idr *id_idr, struct mutex *lock, u32 id)
139{
140 void *obj;
141
142 mutex_lock(lock);
143 obj = idr_find(id_idr, id);
144 mutex_unlock(lock);
145
146 return obj;
147}
148
149static int ipp_check_driver(struct exynos_drm_ippdrv *ippdrv,
150 struct drm_exynos_ipp_property *property)
151{
152 if (ippdrv->dedicated || (!ipp_is_m2m_cmd(property->cmd) &&
153 !pm_runtime_suspended(ippdrv->dev)))
154 return -EBUSY;
155
156 if (ippdrv->check_property &&
157 ippdrv->check_property(ippdrv->dev, property))
158 return -EINVAL;
159
160 return 0;
161}
162
163static struct exynos_drm_ippdrv *ipp_find_driver(struct ipp_context *ctx,
164 struct drm_exynos_ipp_property *property)
165{
166 struct exynos_drm_ippdrv *ippdrv;
167 u32 ipp_id = property->ipp_id;
168 int ret;
169
170 if (ipp_id) {
171 ippdrv = ipp_find_obj(&ctx->ipp_idr, &ctx->ipp_lock, ipp_id);
172 if (!ippdrv) {
173 DRM_DEBUG("ipp%d driver not found\n", ipp_id);
174 return ERR_PTR(-ENODEV);
175 }
176
177 ret = ipp_check_driver(ippdrv, property);
178 if (ret < 0) {
179 DRM_DEBUG("ipp%d driver check error %d\n", ipp_id, ret);
180 return ERR_PTR(ret);
181 }
182
183 return ippdrv;
184 } else {
185 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
186 ret = ipp_check_driver(ippdrv, property);
187 if (ret == 0)
188 return ippdrv;
189 }
190
191 DRM_DEBUG("cannot find driver suitable for given property.\n");
192 }
193
194 return ERR_PTR(-ENODEV);
195}
196
197static struct exynos_drm_ippdrv *ipp_find_drv_by_handle(u32 prop_id)
198{
199 struct exynos_drm_ippdrv *ippdrv;
200 struct drm_exynos_ipp_cmd_node *c_node;
201 int count = 0;
202
203 DRM_DEBUG_KMS("prop_id[%d]\n", prop_id);
204
205 /*
206 * This case is search ipp driver by prop_id handle.
207 * sometimes, ipp subsystem find driver by prop_id.
208 * e.g PAUSE state, queue buf, command control.
209 */
210 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
211 DRM_DEBUG_KMS("count[%d]ippdrv[%p]\n", count++, ippdrv);
212
213 mutex_lock(&ippdrv->cmd_lock);
214 list_for_each_entry(c_node, &ippdrv->cmd_list, list) {
215 if (c_node->property.prop_id == prop_id) {
216 mutex_unlock(&ippdrv->cmd_lock);
217 return ippdrv;
218 }
219 }
220 mutex_unlock(&ippdrv->cmd_lock);
221 }
222
223 return ERR_PTR(-ENODEV);
224}
225
226int exynos_drm_ipp_get_property(struct drm_device *drm_dev, void *data,
227 struct drm_file *file)
228{
229 struct drm_exynos_file_private *file_priv = file->driver_priv;
230 struct device *dev = file_priv->ipp_dev;
231 struct ipp_context *ctx = get_ipp_context(dev);
232 struct drm_exynos_ipp_prop_list *prop_list = data;
233 struct exynos_drm_ippdrv *ippdrv;
234 int count = 0;
235
236 if (!ctx) {
237 DRM_ERROR("invalid context.\n");
238 return -EINVAL;
239 }
240
241 if (!prop_list) {
242 DRM_ERROR("invalid property parameter.\n");
243 return -EINVAL;
244 }
245
246 DRM_DEBUG_KMS("ipp_id[%d]\n", prop_list->ipp_id);
247
248 if (!prop_list->ipp_id) {
249 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list)
250 count++;
251
252 /*
253 * Supports ippdrv list count for user application.
254 * First step user application getting ippdrv count.
255 * and second step getting ippdrv capability using ipp_id.
256 */
257 prop_list->count = count;
258 } else {
259 /*
260 * Getting ippdrv capability by ipp_id.
261 * some device not supported wb, output interface.
262 * so, user application detect correct ipp driver
263 * using this ioctl.
264 */
265 ippdrv = ipp_find_obj(&ctx->ipp_idr, &ctx->ipp_lock,
266 prop_list->ipp_id);
267 if (!ippdrv) {
268 DRM_ERROR("not found ipp%d driver.\n",
269 prop_list->ipp_id);
270 return -ENODEV;
271 }
272
273 *prop_list = ippdrv->prop_list;
274 }
275
276 return 0;
277}
278
279static void ipp_print_property(struct drm_exynos_ipp_property *property,
280 int idx)
281{
282 struct drm_exynos_ipp_config *config = &property->config[idx];
283 struct drm_exynos_pos *pos = &config->pos;
284 struct drm_exynos_sz *sz = &config->sz;
285
286 DRM_DEBUG_KMS("prop_id[%d]ops[%s]fmt[0x%x]\n",
287 property->prop_id, idx ? "dst" : "src", config->fmt);
288
289 DRM_DEBUG_KMS("pos[%d %d %d %d]sz[%d %d]f[%d]r[%d]\n",
290 pos->x, pos->y, pos->w, pos->h,
291 sz->hsize, sz->vsize, config->flip, config->degree);
292}
293
294static struct drm_exynos_ipp_cmd_work *ipp_create_cmd_work(void)
295{
296 struct drm_exynos_ipp_cmd_work *cmd_work;
297
298 cmd_work = kzalloc(sizeof(*cmd_work), GFP_KERNEL);
299 if (!cmd_work)
300 return ERR_PTR(-ENOMEM);
301
302 INIT_WORK((struct work_struct *)cmd_work, ipp_sched_cmd);
303
304 return cmd_work;
305}
306
307static struct drm_exynos_ipp_event_work *ipp_create_event_work(void)
308{
309 struct drm_exynos_ipp_event_work *event_work;
310
311 event_work = kzalloc(sizeof(*event_work), GFP_KERNEL);
312 if (!event_work)
313 return ERR_PTR(-ENOMEM);
314
315 INIT_WORK(&event_work->work, ipp_sched_event);
316
317 return event_work;
318}
319
320int exynos_drm_ipp_set_property(struct drm_device *drm_dev, void *data,
321 struct drm_file *file)
322{
323 struct drm_exynos_file_private *file_priv = file->driver_priv;
324 struct device *dev = file_priv->ipp_dev;
325 struct ipp_context *ctx = get_ipp_context(dev);
326 struct drm_exynos_ipp_property *property = data;
327 struct exynos_drm_ippdrv *ippdrv;
328 struct drm_exynos_ipp_cmd_node *c_node;
329 u32 prop_id;
330 int ret, i;
331
332 if (!ctx) {
333 DRM_ERROR("invalid context.\n");
334 return -EINVAL;
335 }
336
337 if (!property) {
338 DRM_ERROR("invalid property parameter.\n");
339 return -EINVAL;
340 }
341
342 prop_id = property->prop_id;
343
344 /*
345 * This is log print for user application property.
346 * user application set various property.
347 */
348 for_each_ipp_ops(i)
349 ipp_print_property(property, i);
350
351 /*
352 * In case prop_id is not zero try to set existing property.
353 */
354 if (prop_id) {
355 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock, prop_id);
356
357 if (!c_node || c_node->filp != file) {
358 DRM_DEBUG_KMS("prop_id[%d] not found\n", prop_id);
359 return -EINVAL;
360 }
361
362 if (c_node->state != IPP_STATE_STOP) {
363 DRM_DEBUG_KMS("prop_id[%d] not stopped\n", prop_id);
364 return -EINVAL;
365 }
366
367 c_node->property = *property;
368
369 return 0;
370 }
371
372 /* find ipp driver using ipp id */
373 ippdrv = ipp_find_driver(ctx, property);
374 if (IS_ERR(ippdrv)) {
375 DRM_ERROR("failed to get ipp driver.\n");
376 return -EINVAL;
377 }
378
379 /* allocate command node */
380 c_node = kzalloc(sizeof(*c_node), GFP_KERNEL);
381 if (!c_node)
382 return -ENOMEM;
383
384 ret = ipp_create_id(&ctx->prop_idr, &ctx->prop_lock, c_node);
385 if (ret < 0) {
386 DRM_ERROR("failed to create id.\n");
387 goto err_clear;
388 }
389 property->prop_id = ret;
390
391 DRM_DEBUG_KMS("created prop_id[%d]cmd[%d]ippdrv[%p]\n",
392 property->prop_id, property->cmd, ippdrv);
393
394 /* stored property information and ippdrv in private data */
395 c_node->property = *property;
396 c_node->state = IPP_STATE_IDLE;
397 c_node->filp = file;
398
399 c_node->start_work = ipp_create_cmd_work();
400 if (IS_ERR(c_node->start_work)) {
401 DRM_ERROR("failed to create start work.\n");
402 ret = PTR_ERR(c_node->start_work);
403 goto err_remove_id;
404 }
405
406 c_node->stop_work = ipp_create_cmd_work();
407 if (IS_ERR(c_node->stop_work)) {
408 DRM_ERROR("failed to create stop work.\n");
409 ret = PTR_ERR(c_node->stop_work);
410 goto err_free_start;
411 }
412
413 c_node->event_work = ipp_create_event_work();
414 if (IS_ERR(c_node->event_work)) {
415 DRM_ERROR("failed to create event work.\n");
416 ret = PTR_ERR(c_node->event_work);
417 goto err_free_stop;
418 }
419
420 mutex_init(&c_node->lock);
421 mutex_init(&c_node->mem_lock);
422 mutex_init(&c_node->event_lock);
423
424 init_completion(&c_node->start_complete);
425 init_completion(&c_node->stop_complete);
426
427 for_each_ipp_ops(i)
428 INIT_LIST_HEAD(&c_node->mem_list[i]);
429
430 INIT_LIST_HEAD(&c_node->event_list);
431 mutex_lock(&ippdrv->cmd_lock);
432 list_add_tail(&c_node->list, &ippdrv->cmd_list);
433 mutex_unlock(&ippdrv->cmd_lock);
434
435 /* make dedicated state without m2m */
436 if (!ipp_is_m2m_cmd(property->cmd))
437 ippdrv->dedicated = true;
438
439 return 0;
440
441err_free_stop:
442 kfree(c_node->stop_work);
443err_free_start:
444 kfree(c_node->start_work);
445err_remove_id:
446 ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock, property->prop_id);
447err_clear:
448 kfree(c_node);
449 return ret;
450}
451
452static int ipp_validate_mem_node(struct drm_device *drm_dev,
453 struct drm_exynos_ipp_mem_node *m_node,
454 struct drm_exynos_ipp_cmd_node *c_node)
455{
456 struct drm_exynos_ipp_config *ipp_cfg;
457 unsigned int num_plane;
458 unsigned long size, buf_size = 0, plane_size, img_size = 0;
459 unsigned int bpp, width, height;
460 int i;
461
462 ipp_cfg = &c_node->property.config[m_node->ops_id];
463 num_plane = drm_format_num_planes(ipp_cfg->fmt);
464
465 /**
466 * This is a rather simplified validation of a memory node.
467 * It basically verifies provided gem object handles
468 * and the buffer sizes with respect to current configuration.
469 * This is not the best that can be done
470 * but it seems more than enough
471 */
472 for (i = 0; i < num_plane; ++i) {
473 width = ipp_cfg->sz.hsize;
474 height = ipp_cfg->sz.vsize;
475 bpp = drm_format_plane_cpp(ipp_cfg->fmt, i);
476
477 /*
478 * The result of drm_format_plane_cpp() for chroma planes must
479 * be used with drm_format_xxxx_chroma_subsampling() for
480 * correct result.
481 */
482 if (i > 0) {
483 width /= drm_format_horz_chroma_subsampling(
484 ipp_cfg->fmt);
485 height /= drm_format_vert_chroma_subsampling(
486 ipp_cfg->fmt);
487 }
488 plane_size = width * height * bpp;
489 img_size += plane_size;
490
491 if (m_node->buf_info.handles[i]) {
492 size = exynos_drm_gem_get_size(drm_dev,
493 m_node->buf_info.handles[i],
494 c_node->filp);
495 if (plane_size > size) {
496 DRM_ERROR(
497 "buffer %d is smaller than required\n",
498 i);
499 return -EINVAL;
500 }
501
502 buf_size += size;
503 }
504 }
505
506 if (buf_size < img_size) {
507 DRM_ERROR("size of buffers(%lu) is smaller than image(%lu)\n",
508 buf_size, img_size);
509 return -EINVAL;
510 }
511
512 return 0;
513}
514
515static int ipp_put_mem_node(struct drm_device *drm_dev,
516 struct drm_exynos_ipp_cmd_node *c_node,
517 struct drm_exynos_ipp_mem_node *m_node)
518{
519 int i;
520
521 DRM_DEBUG_KMS("node[%p]\n", m_node);
522
523 if (!m_node) {
524 DRM_ERROR("invalid dequeue node.\n");
525 return -EFAULT;
526 }
527
528 DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id);
529
530 /* put gem buffer */
531 for_each_ipp_planar(i) {
532 unsigned long handle = m_node->buf_info.handles[i];
533 if (handle)
534 exynos_drm_gem_put_dma_addr(drm_dev, handle,
535 c_node->filp);
536 }
537
538 list_del(&m_node->list);
539 kfree(m_node);
540
541 return 0;
542}
543
544static struct drm_exynos_ipp_mem_node
545 *ipp_get_mem_node(struct drm_device *drm_dev,
546 struct drm_exynos_ipp_cmd_node *c_node,
547 struct drm_exynos_ipp_queue_buf *qbuf)
548{
549 struct drm_exynos_ipp_mem_node *m_node;
550 struct drm_exynos_ipp_buf_info *buf_info;
551 int i;
552
553 m_node = kzalloc(sizeof(*m_node), GFP_KERNEL);
554 if (!m_node)
555 return ERR_PTR(-ENOMEM);
556
557 buf_info = &m_node->buf_info;
558
559 /* operations, buffer id */
560 m_node->ops_id = qbuf->ops_id;
561 m_node->prop_id = qbuf->prop_id;
562 m_node->buf_id = qbuf->buf_id;
563 INIT_LIST_HEAD(&m_node->list);
564
565 DRM_DEBUG_KMS("m_node[%p]ops_id[%d]\n", m_node, qbuf->ops_id);
566 DRM_DEBUG_KMS("prop_id[%d]buf_id[%d]\n", qbuf->prop_id, m_node->buf_id);
567
568 for_each_ipp_planar(i) {
569 DRM_DEBUG_KMS("i[%d]handle[0x%x]\n", i, qbuf->handle[i]);
570
571 /* get dma address by handle */
572 if (qbuf->handle[i]) {
573 dma_addr_t *addr;
574
575 addr = exynos_drm_gem_get_dma_addr(drm_dev,
576 qbuf->handle[i], c_node->filp);
577 if (IS_ERR(addr)) {
578 DRM_ERROR("failed to get addr.\n");
579 ipp_put_mem_node(drm_dev, c_node, m_node);
580 return ERR_PTR(-EFAULT);
581 }
582
583 buf_info->handles[i] = qbuf->handle[i];
584 buf_info->base[i] = *addr;
585 DRM_DEBUG_KMS("i[%d]base[%pad]hd[0x%lx]\n", i,
586 &buf_info->base[i], buf_info->handles[i]);
587 }
588 }
589
590 mutex_lock(&c_node->mem_lock);
591 if (ipp_validate_mem_node(drm_dev, m_node, c_node)) {
592 ipp_put_mem_node(drm_dev, c_node, m_node);
593 mutex_unlock(&c_node->mem_lock);
594 return ERR_PTR(-EFAULT);
595 }
596 list_add_tail(&m_node->list, &c_node->mem_list[qbuf->ops_id]);
597 mutex_unlock(&c_node->mem_lock);
598
599 return m_node;
600}
601
602static void ipp_clean_mem_nodes(struct drm_device *drm_dev,
603 struct drm_exynos_ipp_cmd_node *c_node, int ops)
604{
605 struct drm_exynos_ipp_mem_node *m_node, *tm_node;
606 struct list_head *head = &c_node->mem_list[ops];
607
608 mutex_lock(&c_node->mem_lock);
609
610 list_for_each_entry_safe(m_node, tm_node, head, list) {
611 int ret;
612
613 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
614 if (ret)
615 DRM_ERROR("failed to put m_node.\n");
616 }
617
618 mutex_unlock(&c_node->mem_lock);
619}
620
621static int ipp_get_event(struct drm_device *drm_dev,
622 struct drm_exynos_ipp_cmd_node *c_node,
623 struct drm_exynos_ipp_queue_buf *qbuf)
624{
625 struct drm_exynos_ipp_send_event *e;
626 int ret;
627
628 DRM_DEBUG_KMS("ops_id[%d]buf_id[%d]\n", qbuf->ops_id, qbuf->buf_id);
629
630 e = kzalloc(sizeof(*e), GFP_KERNEL);
631 if (!e)
632 return -ENOMEM;
633
634 /* make event */
635 e->event.base.type = DRM_EXYNOS_IPP_EVENT;
636 e->event.base.length = sizeof(e->event);
637 e->event.user_data = qbuf->user_data;
638 e->event.prop_id = qbuf->prop_id;
639 e->event.buf_id[EXYNOS_DRM_OPS_DST] = qbuf->buf_id;
640
641 ret = drm_event_reserve_init(drm_dev, c_node->filp, &e->base, &e->event.base);
642 if (ret) {
643 kfree(e);
644 return ret;
645 }
646
647 mutex_lock(&c_node->event_lock);
648 list_add_tail(&e->base.link, &c_node->event_list);
649 mutex_unlock(&c_node->event_lock);
650
651 return 0;
652}
653
654static void ipp_put_event(struct drm_exynos_ipp_cmd_node *c_node,
655 struct drm_exynos_ipp_queue_buf *qbuf)
656{
657 struct drm_exynos_ipp_send_event *e, *te;
658 int count = 0;
659
660 mutex_lock(&c_node->event_lock);
661 list_for_each_entry_safe(e, te, &c_node->event_list, base.link) {
662 DRM_DEBUG_KMS("count[%d]e[%p]\n", count++, e);
663
664 /*
665 * qbuf == NULL condition means all event deletion.
666 * stop operations want to delete all event list.
667 * another case delete only same buf id.
668 */
669 if (!qbuf) {
670 /* delete list */
671 list_del(&e->base.link);
672 kfree(e);
673 }
674
675 /* compare buffer id */
676 if (qbuf && (qbuf->buf_id ==
677 e->event.buf_id[EXYNOS_DRM_OPS_DST])) {
678 /* delete list */
679 list_del(&e->base.link);
680 kfree(e);
681 goto out_unlock;
682 }
683 }
684
685out_unlock:
686 mutex_unlock(&c_node->event_lock);
687 return;
688}
689
690static void ipp_clean_cmd_node(struct ipp_context *ctx,
691 struct drm_exynos_ipp_cmd_node *c_node)
692{
693 int i;
694
695 /* cancel works */
696 cancel_work_sync(&c_node->start_work->work);
697 cancel_work_sync(&c_node->stop_work->work);
698 cancel_work_sync(&c_node->event_work->work);
699
700 /* put event */
701 ipp_put_event(c_node, NULL);
702
703 for_each_ipp_ops(i)
704 ipp_clean_mem_nodes(ctx->subdrv.drm_dev, c_node, i);
705
706 /* delete list */
707 list_del(&c_node->list);
708
709 ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock,
710 c_node->property.prop_id);
711
712 /* destroy mutex */
713 mutex_destroy(&c_node->lock);
714 mutex_destroy(&c_node->mem_lock);
715 mutex_destroy(&c_node->event_lock);
716
717 /* free command node */
718 kfree(c_node->start_work);
719 kfree(c_node->stop_work);
720 kfree(c_node->event_work);
721 kfree(c_node);
722}
723
724static bool ipp_check_mem_list(struct drm_exynos_ipp_cmd_node *c_node)
725{
726 switch (c_node->property.cmd) {
727 case IPP_CMD_WB:
728 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]);
729 case IPP_CMD_OUTPUT:
730 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]);
731 case IPP_CMD_M2M:
732 default:
733 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]) &&
734 !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]);
735 }
736}
737
738static struct drm_exynos_ipp_mem_node
739 *ipp_find_mem_node(struct drm_exynos_ipp_cmd_node *c_node,
740 struct drm_exynos_ipp_queue_buf *qbuf)
741{
742 struct drm_exynos_ipp_mem_node *m_node;
743 struct list_head *head;
744 int count = 0;
745
746 DRM_DEBUG_KMS("buf_id[%d]\n", qbuf->buf_id);
747
748 /* source/destination memory list */
749 head = &c_node->mem_list[qbuf->ops_id];
750
751 /* find memory node from memory list */
752 list_for_each_entry(m_node, head, list) {
753 DRM_DEBUG_KMS("count[%d]m_node[%p]\n", count++, m_node);
754
755 /* compare buffer id */
756 if (m_node->buf_id == qbuf->buf_id)
757 return m_node;
758 }
759
760 return NULL;
761}
762
763static int ipp_set_mem_node(struct exynos_drm_ippdrv *ippdrv,
764 struct drm_exynos_ipp_cmd_node *c_node,
765 struct drm_exynos_ipp_mem_node *m_node)
766{
767 struct exynos_drm_ipp_ops *ops = NULL;
768 int ret = 0;
769
770 DRM_DEBUG_KMS("node[%p]\n", m_node);
771
772 if (!m_node) {
773 DRM_ERROR("invalid queue node.\n");
774 return -EFAULT;
775 }
776
777 DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id);
778
779 /* get operations callback */
780 ops = ippdrv->ops[m_node->ops_id];
781 if (!ops) {
782 DRM_ERROR("not support ops.\n");
783 return -EFAULT;
784 }
785
786 /* set address and enable irq */
787 if (ops->set_addr) {
788 ret = ops->set_addr(ippdrv->dev, &m_node->buf_info,
789 m_node->buf_id, IPP_BUF_ENQUEUE);
790 if (ret) {
791 DRM_ERROR("failed to set addr.\n");
792 return ret;
793 }
794 }
795
796 return ret;
797}
798
799static void ipp_handle_cmd_work(struct device *dev,
800 struct exynos_drm_ippdrv *ippdrv,
801 struct drm_exynos_ipp_cmd_work *cmd_work,
802 struct drm_exynos_ipp_cmd_node *c_node)
803{
804 struct ipp_context *ctx = get_ipp_context(dev);
805
806 cmd_work->ippdrv = ippdrv;
807 cmd_work->c_node = c_node;
808 queue_work(ctx->cmd_workq, &cmd_work->work);
809}
810
811static int ipp_queue_buf_with_run(struct device *dev,
812 struct drm_exynos_ipp_cmd_node *c_node,
813 struct drm_exynos_ipp_mem_node *m_node,
814 struct drm_exynos_ipp_queue_buf *qbuf)
815{
816 struct exynos_drm_ippdrv *ippdrv;
817 struct drm_exynos_ipp_property *property;
818 struct exynos_drm_ipp_ops *ops;
819 int ret;
820
821 ippdrv = ipp_find_drv_by_handle(qbuf->prop_id);
822 if (IS_ERR(ippdrv)) {
823 DRM_ERROR("failed to get ipp driver.\n");
824 return -EFAULT;
825 }
826
827 ops = ippdrv->ops[qbuf->ops_id];
828 if (!ops) {
829 DRM_ERROR("failed to get ops.\n");
830 return -EFAULT;
831 }
832
833 property = &c_node->property;
834
835 if (c_node->state != IPP_STATE_START) {
836 DRM_DEBUG_KMS("bypass for invalid state.\n");
837 return 0;
838 }
839
840 mutex_lock(&c_node->mem_lock);
841 if (!ipp_check_mem_list(c_node)) {
842 mutex_unlock(&c_node->mem_lock);
843 DRM_DEBUG_KMS("empty memory.\n");
844 return 0;
845 }
846
847 /*
848 * If set destination buffer and enabled clock,
849 * then m2m operations need start operations at queue_buf
850 */
851 if (ipp_is_m2m_cmd(property->cmd)) {
852 struct drm_exynos_ipp_cmd_work *cmd_work = c_node->start_work;
853
854 cmd_work->ctrl = IPP_CTRL_PLAY;
855 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
856 } else {
857 ret = ipp_set_mem_node(ippdrv, c_node, m_node);
858 if (ret) {
859 mutex_unlock(&c_node->mem_lock);
860 DRM_ERROR("failed to set m node.\n");
861 return ret;
862 }
863 }
864 mutex_unlock(&c_node->mem_lock);
865
866 return 0;
867}
868
869static void ipp_clean_queue_buf(struct drm_device *drm_dev,
870 struct drm_exynos_ipp_cmd_node *c_node,
871 struct drm_exynos_ipp_queue_buf *qbuf)
872{
873 struct drm_exynos_ipp_mem_node *m_node, *tm_node;
874
875 /* delete list */
876 mutex_lock(&c_node->mem_lock);
877 list_for_each_entry_safe(m_node, tm_node,
878 &c_node->mem_list[qbuf->ops_id], list) {
879 if (m_node->buf_id == qbuf->buf_id &&
880 m_node->ops_id == qbuf->ops_id)
881 ipp_put_mem_node(drm_dev, c_node, m_node);
882 }
883 mutex_unlock(&c_node->mem_lock);
884}
885
886int exynos_drm_ipp_queue_buf(struct drm_device *drm_dev, void *data,
887 struct drm_file *file)
888{
889 struct drm_exynos_file_private *file_priv = file->driver_priv;
890 struct device *dev = file_priv->ipp_dev;
891 struct ipp_context *ctx = get_ipp_context(dev);
892 struct drm_exynos_ipp_queue_buf *qbuf = data;
893 struct drm_exynos_ipp_cmd_node *c_node;
894 struct drm_exynos_ipp_mem_node *m_node;
895 int ret;
896
897 if (!qbuf) {
898 DRM_ERROR("invalid buf parameter.\n");
899 return -EINVAL;
900 }
901
902 if (qbuf->ops_id >= EXYNOS_DRM_OPS_MAX) {
903 DRM_ERROR("invalid ops parameter.\n");
904 return -EINVAL;
905 }
906
907 DRM_DEBUG_KMS("prop_id[%d]ops_id[%s]buf_id[%d]buf_type[%d]\n",
908 qbuf->prop_id, qbuf->ops_id ? "dst" : "src",
909 qbuf->buf_id, qbuf->buf_type);
910
911 /* find command node */
912 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock,
913 qbuf->prop_id);
914 if (!c_node || c_node->filp != file) {
915 DRM_ERROR("failed to get command node.\n");
916 return -ENODEV;
917 }
918
919 /* buffer control */
920 switch (qbuf->buf_type) {
921 case IPP_BUF_ENQUEUE:
922 /* get memory node */
923 m_node = ipp_get_mem_node(drm_dev, c_node, qbuf);
924 if (IS_ERR(m_node)) {
925 DRM_ERROR("failed to get m_node.\n");
926 return PTR_ERR(m_node);
927 }
928
929 /*
930 * first step get event for destination buffer.
931 * and second step when M2M case run with destination buffer
932 * if needed.
933 */
934 if (qbuf->ops_id == EXYNOS_DRM_OPS_DST) {
935 /* get event for destination buffer */
936 ret = ipp_get_event(drm_dev, c_node, qbuf);
937 if (ret) {
938 DRM_ERROR("failed to get event.\n");
939 goto err_clean_node;
940 }
941
942 /*
943 * M2M case run play control for streaming feature.
944 * other case set address and waiting.
945 */
946 ret = ipp_queue_buf_with_run(dev, c_node, m_node, qbuf);
947 if (ret) {
948 DRM_ERROR("failed to run command.\n");
949 goto err_clean_node;
950 }
951 }
952 break;
953 case IPP_BUF_DEQUEUE:
954 mutex_lock(&c_node->lock);
955
956 /* put event for destination buffer */
957 if (qbuf->ops_id == EXYNOS_DRM_OPS_DST)
958 ipp_put_event(c_node, qbuf);
959
960 ipp_clean_queue_buf(drm_dev, c_node, qbuf);
961
962 mutex_unlock(&c_node->lock);
963 break;
964 default:
965 DRM_ERROR("invalid buffer control.\n");
966 return -EINVAL;
967 }
968
969 return 0;
970
971err_clean_node:
972 DRM_ERROR("clean memory nodes.\n");
973
974 ipp_clean_queue_buf(drm_dev, c_node, qbuf);
975 return ret;
976}
977
978static bool exynos_drm_ipp_check_valid(struct device *dev,
979 enum drm_exynos_ipp_ctrl ctrl, enum drm_exynos_ipp_state state)
980{
981 if (ctrl != IPP_CTRL_PLAY) {
982 if (pm_runtime_suspended(dev)) {
983 DRM_ERROR("pm:runtime_suspended.\n");
984 goto err_status;
985 }
986 }
987
988 switch (ctrl) {
989 case IPP_CTRL_PLAY:
990 if (state != IPP_STATE_IDLE)
991 goto err_status;
992 break;
993 case IPP_CTRL_STOP:
994 if (state == IPP_STATE_STOP)
995 goto err_status;
996 break;
997 case IPP_CTRL_PAUSE:
998 if (state != IPP_STATE_START)
999 goto err_status;
1000 break;
1001 case IPP_CTRL_RESUME:
1002 if (state != IPP_STATE_STOP)
1003 goto err_status;
1004 break;
1005 default:
1006 DRM_ERROR("invalid state.\n");
1007 goto err_status;
1008 }
1009
1010 return true;
1011
1012err_status:
1013 DRM_ERROR("invalid status:ctrl[%d]state[%d]\n", ctrl, state);
1014 return false;
1015}
1016
1017int exynos_drm_ipp_cmd_ctrl(struct drm_device *drm_dev, void *data,
1018 struct drm_file *file)
1019{
1020 struct drm_exynos_file_private *file_priv = file->driver_priv;
1021 struct exynos_drm_ippdrv *ippdrv = NULL;
1022 struct device *dev = file_priv->ipp_dev;
1023 struct ipp_context *ctx = get_ipp_context(dev);
1024 struct drm_exynos_ipp_cmd_ctrl *cmd_ctrl = data;
1025 struct drm_exynos_ipp_cmd_work *cmd_work;
1026 struct drm_exynos_ipp_cmd_node *c_node;
1027
1028 if (!ctx) {
1029 DRM_ERROR("invalid context.\n");
1030 return -EINVAL;
1031 }
1032
1033 if (!cmd_ctrl) {
1034 DRM_ERROR("invalid control parameter.\n");
1035 return -EINVAL;
1036 }
1037
1038 DRM_DEBUG_KMS("ctrl[%d]prop_id[%d]\n",
1039 cmd_ctrl->ctrl, cmd_ctrl->prop_id);
1040
1041 ippdrv = ipp_find_drv_by_handle(cmd_ctrl->prop_id);
1042 if (IS_ERR(ippdrv)) {
1043 DRM_ERROR("failed to get ipp driver.\n");
1044 return PTR_ERR(ippdrv);
1045 }
1046
1047 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock,
1048 cmd_ctrl->prop_id);
1049 if (!c_node || c_node->filp != file) {
1050 DRM_ERROR("invalid command node list.\n");
1051 return -ENODEV;
1052 }
1053
1054 if (!exynos_drm_ipp_check_valid(ippdrv->dev, cmd_ctrl->ctrl,
1055 c_node->state)) {
1056 DRM_ERROR("invalid state.\n");
1057 return -EINVAL;
1058 }
1059
1060 switch (cmd_ctrl->ctrl) {
1061 case IPP_CTRL_PLAY:
1062 if (pm_runtime_suspended(ippdrv->dev))
1063 pm_runtime_get_sync(ippdrv->dev);
1064
1065 c_node->state = IPP_STATE_START;
1066
1067 cmd_work = c_node->start_work;
1068 cmd_work->ctrl = cmd_ctrl->ctrl;
1069 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1070 break;
1071 case IPP_CTRL_STOP:
1072 cmd_work = c_node->stop_work;
1073 cmd_work->ctrl = cmd_ctrl->ctrl;
1074 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1075
1076 if (!wait_for_completion_timeout(&c_node->stop_complete,
1077 msecs_to_jiffies(300))) {
1078 DRM_ERROR("timeout stop:prop_id[%d]\n",
1079 c_node->property.prop_id);
1080 }
1081
1082 c_node->state = IPP_STATE_STOP;
1083 ippdrv->dedicated = false;
1084 mutex_lock(&ippdrv->cmd_lock);
1085 ipp_clean_cmd_node(ctx, c_node);
1086
1087 if (list_empty(&ippdrv->cmd_list))
1088 pm_runtime_put_sync(ippdrv->dev);
1089 mutex_unlock(&ippdrv->cmd_lock);
1090 break;
1091 case IPP_CTRL_PAUSE:
1092 cmd_work = c_node->stop_work;
1093 cmd_work->ctrl = cmd_ctrl->ctrl;
1094 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1095
1096 if (!wait_for_completion_timeout(&c_node->stop_complete,
1097 msecs_to_jiffies(200))) {
1098 DRM_ERROR("timeout stop:prop_id[%d]\n",
1099 c_node->property.prop_id);
1100 }
1101
1102 c_node->state = IPP_STATE_STOP;
1103 break;
1104 case IPP_CTRL_RESUME:
1105 c_node->state = IPP_STATE_START;
1106 cmd_work = c_node->start_work;
1107 cmd_work->ctrl = cmd_ctrl->ctrl;
1108 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1109 break;
1110 default:
1111 DRM_ERROR("could not support this state currently.\n");
1112 return -EINVAL;
1113 }
1114
1115 DRM_DEBUG_KMS("done ctrl[%d]prop_id[%d]\n",
1116 cmd_ctrl->ctrl, cmd_ctrl->prop_id);
1117
1118 return 0;
1119}
1120
1121int exynos_drm_ippnb_register(struct notifier_block *nb)
1122{
1123 return blocking_notifier_chain_register(
1124 &exynos_drm_ippnb_list, nb);
1125}
1126
1127int exynos_drm_ippnb_unregister(struct notifier_block *nb)
1128{
1129 return blocking_notifier_chain_unregister(
1130 &exynos_drm_ippnb_list, nb);
1131}
1132
1133int exynos_drm_ippnb_send_event(unsigned long val, void *v)
1134{
1135 return blocking_notifier_call_chain(
1136 &exynos_drm_ippnb_list, val, v);
1137}
1138
1139static int ipp_set_property(struct exynos_drm_ippdrv *ippdrv,
1140 struct drm_exynos_ipp_property *property)
1141{
1142 struct exynos_drm_ipp_ops *ops = NULL;
1143 bool swap = false;
1144 int ret, i;
1145
1146 if (!property) {
1147 DRM_ERROR("invalid property parameter.\n");
1148 return -EINVAL;
1149 }
1150
1151 DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1152
1153 /* reset h/w block */
1154 if (ippdrv->reset &&
1155 ippdrv->reset(ippdrv->dev)) {
1156 return -EINVAL;
1157 }
1158
1159 /* set source,destination operations */
1160 for_each_ipp_ops(i) {
1161 struct drm_exynos_ipp_config *config =
1162 &property->config[i];
1163
1164 ops = ippdrv->ops[i];
1165 if (!ops || !config) {
1166 DRM_ERROR("not support ops and config.\n");
1167 return -EINVAL;
1168 }
1169
1170 /* set format */
1171 if (ops->set_fmt) {
1172 ret = ops->set_fmt(ippdrv->dev, config->fmt);
1173 if (ret)
1174 return ret;
1175 }
1176
1177 /* set transform for rotation, flip */
1178 if (ops->set_transf) {
1179 ret = ops->set_transf(ippdrv->dev, config->degree,
1180 config->flip, &swap);
1181 if (ret)
1182 return ret;
1183 }
1184
1185 /* set size */
1186 if (ops->set_size) {
1187 ret = ops->set_size(ippdrv->dev, swap, &config->pos,
1188 &config->sz);
1189 if (ret)
1190 return ret;
1191 }
1192 }
1193
1194 return 0;
1195}
1196
1197static int ipp_start_property(struct exynos_drm_ippdrv *ippdrv,
1198 struct drm_exynos_ipp_cmd_node *c_node)
1199{
1200 struct drm_exynos_ipp_mem_node *m_node;
1201 struct drm_exynos_ipp_property *property = &c_node->property;
1202 struct list_head *head;
1203 int ret, i;
1204
1205 DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1206
1207 /* store command info in ippdrv */
1208 ippdrv->c_node = c_node;
1209
1210 mutex_lock(&c_node->mem_lock);
1211 if (!ipp_check_mem_list(c_node)) {
1212 DRM_DEBUG_KMS("empty memory.\n");
1213 ret = -ENOMEM;
1214 goto err_unlock;
1215 }
1216
1217 /* set current property in ippdrv */
1218 ret = ipp_set_property(ippdrv, property);
1219 if (ret) {
1220 DRM_ERROR("failed to set property.\n");
1221 ippdrv->c_node = NULL;
1222 goto err_unlock;
1223 }
1224
1225 /* check command */
1226 switch (property->cmd) {
1227 case IPP_CMD_M2M:
1228 for_each_ipp_ops(i) {
1229 /* source/destination memory list */
1230 head = &c_node->mem_list[i];
1231
1232 m_node = list_first_entry(head,
1233 struct drm_exynos_ipp_mem_node, list);
1234
1235 DRM_DEBUG_KMS("m_node[%p]\n", m_node);
1236
1237 ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1238 if (ret) {
1239 DRM_ERROR("failed to set m node.\n");
1240 goto err_unlock;
1241 }
1242 }
1243 break;
1244 case IPP_CMD_WB:
1245 /* destination memory list */
1246 head = &c_node->mem_list[EXYNOS_DRM_OPS_DST];
1247
1248 list_for_each_entry(m_node, head, list) {
1249 ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1250 if (ret) {
1251 DRM_ERROR("failed to set m node.\n");
1252 goto err_unlock;
1253 }
1254 }
1255 break;
1256 case IPP_CMD_OUTPUT:
1257 /* source memory list */
1258 head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC];
1259
1260 list_for_each_entry(m_node, head, list) {
1261 ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1262 if (ret) {
1263 DRM_ERROR("failed to set m node.\n");
1264 goto err_unlock;
1265 }
1266 }
1267 break;
1268 default:
1269 DRM_ERROR("invalid operations.\n");
1270 ret = -EINVAL;
1271 goto err_unlock;
1272 }
1273 mutex_unlock(&c_node->mem_lock);
1274
1275 DRM_DEBUG_KMS("cmd[%d]\n", property->cmd);
1276
1277 /* start operations */
1278 if (ippdrv->start) {
1279 ret = ippdrv->start(ippdrv->dev, property->cmd);
1280 if (ret) {
1281 DRM_ERROR("failed to start ops.\n");
1282 ippdrv->c_node = NULL;
1283 return ret;
1284 }
1285 }
1286
1287 return 0;
1288
1289err_unlock:
1290 mutex_unlock(&c_node->mem_lock);
1291 ippdrv->c_node = NULL;
1292 return ret;
1293}
1294
1295static int ipp_stop_property(struct drm_device *drm_dev,
1296 struct exynos_drm_ippdrv *ippdrv,
1297 struct drm_exynos_ipp_cmd_node *c_node)
1298{
1299 struct drm_exynos_ipp_property *property = &c_node->property;
1300 int i;
1301
1302 DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1303
1304 /* stop operations */
1305 if (ippdrv->stop)
1306 ippdrv->stop(ippdrv->dev, property->cmd);
1307
1308 /* check command */
1309 switch (property->cmd) {
1310 case IPP_CMD_M2M:
1311 for_each_ipp_ops(i)
1312 ipp_clean_mem_nodes(drm_dev, c_node, i);
1313 break;
1314 case IPP_CMD_WB:
1315 ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_DST);
1316 break;
1317 case IPP_CMD_OUTPUT:
1318 ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_SRC);
1319 break;
1320 default:
1321 DRM_ERROR("invalid operations.\n");
1322 return -EINVAL;
1323 }
1324
1325 return 0;
1326}
1327
1328void ipp_sched_cmd(struct work_struct *work)
1329{
1330 struct drm_exynos_ipp_cmd_work *cmd_work =
1331 container_of(work, struct drm_exynos_ipp_cmd_work, work);
1332 struct exynos_drm_ippdrv *ippdrv;
1333 struct drm_exynos_ipp_cmd_node *c_node;
1334 struct drm_exynos_ipp_property *property;
1335 int ret;
1336
1337 ippdrv = cmd_work->ippdrv;
1338 if (!ippdrv) {
1339 DRM_ERROR("invalid ippdrv list.\n");
1340 return;
1341 }
1342
1343 c_node = cmd_work->c_node;
1344 if (!c_node) {
1345 DRM_ERROR("invalid command node list.\n");
1346 return;
1347 }
1348
1349 mutex_lock(&c_node->lock);
1350
1351 property = &c_node->property;
1352
1353 switch (cmd_work->ctrl) {
1354 case IPP_CTRL_PLAY:
1355 case IPP_CTRL_RESUME:
1356 ret = ipp_start_property(ippdrv, c_node);
1357 if (ret) {
1358 DRM_ERROR("failed to start property:prop_id[%d]\n",
1359 c_node->property.prop_id);
1360 goto err_unlock;
1361 }
1362
1363 /*
1364 * M2M case supports wait_completion of transfer.
1365 * because M2M case supports single unit operation
1366 * with multiple queue.
1367 * M2M need to wait completion of data transfer.
1368 */
1369 if (ipp_is_m2m_cmd(property->cmd)) {
1370 if (!wait_for_completion_timeout
1371 (&c_node->start_complete, msecs_to_jiffies(200))) {
1372 DRM_ERROR("timeout event:prop_id[%d]\n",
1373 c_node->property.prop_id);
1374 goto err_unlock;
1375 }
1376 }
1377 break;
1378 case IPP_CTRL_STOP:
1379 case IPP_CTRL_PAUSE:
1380 ret = ipp_stop_property(ippdrv->drm_dev, ippdrv,
1381 c_node);
1382 if (ret) {
1383 DRM_ERROR("failed to stop property.\n");
1384 goto err_unlock;
1385 }
1386
1387 complete(&c_node->stop_complete);
1388 break;
1389 default:
1390 DRM_ERROR("unknown control type\n");
1391 break;
1392 }
1393
1394 DRM_DEBUG_KMS("ctrl[%d] done.\n", cmd_work->ctrl);
1395
1396err_unlock:
1397 mutex_unlock(&c_node->lock);
1398}
1399
1400static int ipp_send_event(struct exynos_drm_ippdrv *ippdrv,
1401 struct drm_exynos_ipp_cmd_node *c_node, int *buf_id)
1402{
1403 struct drm_device *drm_dev = ippdrv->drm_dev;
1404 struct drm_exynos_ipp_property *property = &c_node->property;
1405 struct drm_exynos_ipp_mem_node *m_node;
1406 struct drm_exynos_ipp_queue_buf qbuf;
1407 struct drm_exynos_ipp_send_event *e;
1408 struct list_head *head;
1409 struct timeval now;
1410 u32 tbuf_id[EXYNOS_DRM_OPS_MAX] = {0, };
1411 int ret, i;
1412
1413 for_each_ipp_ops(i)
1414 DRM_DEBUG_KMS("%s buf_id[%d]\n", i ? "dst" : "src", buf_id[i]);
1415
1416 if (!drm_dev) {
1417 DRM_ERROR("failed to get drm_dev.\n");
1418 return -EINVAL;
1419 }
1420
1421 if (!property) {
1422 DRM_ERROR("failed to get property.\n");
1423 return -EINVAL;
1424 }
1425
1426 mutex_lock(&c_node->event_lock);
1427 if (list_empty(&c_node->event_list)) {
1428 DRM_DEBUG_KMS("event list is empty.\n");
1429 ret = 0;
1430 goto err_event_unlock;
1431 }
1432
1433 mutex_lock(&c_node->mem_lock);
1434 if (!ipp_check_mem_list(c_node)) {
1435 DRM_DEBUG_KMS("empty memory.\n");
1436 ret = 0;
1437 goto err_mem_unlock;
1438 }
1439
1440 /* check command */
1441 switch (property->cmd) {
1442 case IPP_CMD_M2M:
1443 for_each_ipp_ops(i) {
1444 /* source/destination memory list */
1445 head = &c_node->mem_list[i];
1446
1447 m_node = list_first_entry(head,
1448 struct drm_exynos_ipp_mem_node, list);
1449
1450 tbuf_id[i] = m_node->buf_id;
1451 DRM_DEBUG_KMS("%s buf_id[%d]\n",
1452 i ? "dst" : "src", tbuf_id[i]);
1453
1454 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1455 if (ret)
1456 DRM_ERROR("failed to put m_node.\n");
1457 }
1458 break;
1459 case IPP_CMD_WB:
1460 /* clear buf for finding */
1461 memset(&qbuf, 0x0, sizeof(qbuf));
1462 qbuf.ops_id = EXYNOS_DRM_OPS_DST;
1463 qbuf.buf_id = buf_id[EXYNOS_DRM_OPS_DST];
1464
1465 /* get memory node entry */
1466 m_node = ipp_find_mem_node(c_node, &qbuf);
1467 if (!m_node) {
1468 DRM_ERROR("empty memory node.\n");
1469 ret = -ENOMEM;
1470 goto err_mem_unlock;
1471 }
1472
1473 tbuf_id[EXYNOS_DRM_OPS_DST] = m_node->buf_id;
1474
1475 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1476 if (ret)
1477 DRM_ERROR("failed to put m_node.\n");
1478 break;
1479 case IPP_CMD_OUTPUT:
1480 /* source memory list */
1481 head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC];
1482
1483 m_node = list_first_entry(head,
1484 struct drm_exynos_ipp_mem_node, list);
1485
1486 tbuf_id[EXYNOS_DRM_OPS_SRC] = m_node->buf_id;
1487
1488 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1489 if (ret)
1490 DRM_ERROR("failed to put m_node.\n");
1491 break;
1492 default:
1493 DRM_ERROR("invalid operations.\n");
1494 ret = -EINVAL;
1495 goto err_mem_unlock;
1496 }
1497 mutex_unlock(&c_node->mem_lock);
1498
1499 if (tbuf_id[EXYNOS_DRM_OPS_DST] != buf_id[EXYNOS_DRM_OPS_DST])
1500 DRM_ERROR("failed to match buf_id[%d %d]prop_id[%d]\n",
1501 tbuf_id[1], buf_id[1], property->prop_id);
1502
1503 /*
1504 * command node have event list of destination buffer
1505 * If destination buffer enqueue to mem list,
1506 * then we make event and link to event list tail.
1507 * so, we get first event for first enqueued buffer.
1508 */
1509 e = list_first_entry(&c_node->event_list,
1510 struct drm_exynos_ipp_send_event, base.link);
1511
1512 do_gettimeofday(&now);
1513 DRM_DEBUG_KMS("tv_sec[%ld]tv_usec[%ld]\n", now.tv_sec, now.tv_usec);
1514 e->event.tv_sec = now.tv_sec;
1515 e->event.tv_usec = now.tv_usec;
1516 e->event.prop_id = property->prop_id;
1517
1518 /* set buffer id about source destination */
1519 for_each_ipp_ops(i)
1520 e->event.buf_id[i] = tbuf_id[i];
1521
1522 drm_send_event(drm_dev, &e->base);
1523 mutex_unlock(&c_node->event_lock);
1524
1525 DRM_DEBUG_KMS("done cmd[%d]prop_id[%d]buf_id[%d]\n",
1526 property->cmd, property->prop_id, tbuf_id[EXYNOS_DRM_OPS_DST]);
1527
1528 return 0;
1529
1530err_mem_unlock:
1531 mutex_unlock(&c_node->mem_lock);
1532err_event_unlock:
1533 mutex_unlock(&c_node->event_lock);
1534 return ret;
1535}
1536
1537void ipp_sched_event(struct work_struct *work)
1538{
1539 struct drm_exynos_ipp_event_work *event_work =
1540 container_of(work, struct drm_exynos_ipp_event_work, work);
1541 struct exynos_drm_ippdrv *ippdrv;
1542 struct drm_exynos_ipp_cmd_node *c_node;
1543 int ret;
1544
1545 if (!event_work) {
1546 DRM_ERROR("failed to get event_work.\n");
1547 return;
1548 }
1549
1550 DRM_DEBUG_KMS("buf_id[%d]\n", event_work->buf_id[EXYNOS_DRM_OPS_DST]);
1551
1552 ippdrv = event_work->ippdrv;
1553 if (!ippdrv) {
1554 DRM_ERROR("failed to get ipp driver.\n");
1555 return;
1556 }
1557
1558 c_node = ippdrv->c_node;
1559 if (!c_node) {
1560 DRM_ERROR("failed to get command node.\n");
1561 return;
1562 }
1563
1564 /*
1565 * IPP supports command thread, event thread synchronization.
1566 * If IPP close immediately from user land, then IPP make
1567 * synchronization with command thread, so make complete event.
1568 * or going out operations.
1569 */
1570 if (c_node->state != IPP_STATE_START) {
1571 DRM_DEBUG_KMS("bypass state[%d]prop_id[%d]\n",
1572 c_node->state, c_node->property.prop_id);
1573 goto err_completion;
1574 }
1575
1576 ret = ipp_send_event(ippdrv, c_node, event_work->buf_id);
1577 if (ret) {
1578 DRM_ERROR("failed to send event.\n");
1579 goto err_completion;
1580 }
1581
1582err_completion:
1583 if (ipp_is_m2m_cmd(c_node->property.cmd))
1584 complete(&c_node->start_complete);
1585}
1586
1587static int ipp_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
1588{
1589 struct ipp_context *ctx = get_ipp_context(dev);
1590 struct exynos_drm_ippdrv *ippdrv;
1591 int ret, count = 0;
1592
1593 /* get ipp driver entry */
1594 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
1595 ippdrv->drm_dev = drm_dev;
1596
1597 ret = ipp_create_id(&ctx->ipp_idr, &ctx->ipp_lock, ippdrv);
1598 if (ret < 0) {
1599 DRM_ERROR("failed to create id.\n");
1600 goto err;
1601 }
1602 ippdrv->prop_list.ipp_id = ret;
1603
1604 DRM_DEBUG_KMS("count[%d]ippdrv[%p]ipp_id[%d]\n",
1605 count++, ippdrv, ret);
1606
1607 /* store parent device for node */
1608 ippdrv->parent_dev = dev;
1609
1610 /* store event work queue and handler */
1611 ippdrv->event_workq = ctx->event_workq;
1612 ippdrv->sched_event = ipp_sched_event;
1613 INIT_LIST_HEAD(&ippdrv->cmd_list);
1614 mutex_init(&ippdrv->cmd_lock);
1615
1616 ret = drm_iommu_attach_device(drm_dev, ippdrv->dev);
1617 if (ret) {
1618 DRM_ERROR("failed to activate iommu\n");
1619 goto err;
1620 }
1621 }
1622
1623 return 0;
1624
1625err:
1626 /* get ipp driver entry */
1627 list_for_each_entry_continue_reverse(ippdrv, &exynos_drm_ippdrv_list,
1628 drv_list) {
1629 drm_iommu_detach_device(drm_dev, ippdrv->dev);
1630
1631 ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock,
1632 ippdrv->prop_list.ipp_id);
1633 }
1634
1635 return ret;
1636}
1637
1638static void ipp_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
1639{
1640 struct exynos_drm_ippdrv *ippdrv, *t;
1641 struct ipp_context *ctx = get_ipp_context(dev);
1642
1643 /* get ipp driver entry */
1644 list_for_each_entry_safe(ippdrv, t, &exynos_drm_ippdrv_list, drv_list) {
1645 drm_iommu_detach_device(drm_dev, ippdrv->dev);
1646
1647 ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock,
1648 ippdrv->prop_list.ipp_id);
1649
1650 ippdrv->drm_dev = NULL;
1651 exynos_drm_ippdrv_unregister(ippdrv);
1652 }
1653}
1654
1655static int ipp_subdrv_open(struct drm_device *drm_dev, struct device *dev,
1656 struct drm_file *file)
1657{
1658 struct drm_exynos_file_private *file_priv = file->driver_priv;
1659
1660 file_priv->ipp_dev = dev;
1661
1662 DRM_DEBUG_KMS("done priv[%p]\n", dev);
1663
1664 return 0;
1665}
1666
1667static void ipp_subdrv_close(struct drm_device *drm_dev, struct device *dev,
1668 struct drm_file *file)
1669{
1670 struct exynos_drm_ippdrv *ippdrv = NULL;
1671 struct ipp_context *ctx = get_ipp_context(dev);
1672 struct drm_exynos_ipp_cmd_node *c_node, *tc_node;
1673 int count = 0;
1674
1675 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
1676 mutex_lock(&ippdrv->cmd_lock);
1677 list_for_each_entry_safe(c_node, tc_node,
1678 &ippdrv->cmd_list, list) {
1679 DRM_DEBUG_KMS("count[%d]ippdrv[%p]\n",
1680 count++, ippdrv);
1681
1682 if (c_node->filp == file) {
1683 /*
1684 * userland goto unnormal state. process killed.
1685 * and close the file.
1686 * so, IPP didn't called stop cmd ctrl.
1687 * so, we are make stop operation in this state.
1688 */
1689 if (c_node->state == IPP_STATE_START) {
1690 ipp_stop_property(drm_dev, ippdrv,
1691 c_node);
1692 c_node->state = IPP_STATE_STOP;
1693 }
1694
1695 ippdrv->dedicated = false;
1696 ipp_clean_cmd_node(ctx, c_node);
1697 if (list_empty(&ippdrv->cmd_list))
1698 pm_runtime_put_sync(ippdrv->dev);
1699 }
1700 }
1701 mutex_unlock(&ippdrv->cmd_lock);
1702 }
1703
1704 return;
1705}
1706
1707static int ipp_probe(struct platform_device *pdev)
1708{
1709 struct device *dev = &pdev->dev;
1710 struct ipp_context *ctx;
1711 struct exynos_drm_subdrv *subdrv;
1712 int ret;
1713
1714 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
1715 if (!ctx)
1716 return -ENOMEM;
1717
1718 mutex_init(&ctx->ipp_lock);
1719 mutex_init(&ctx->prop_lock);
1720
1721 idr_init(&ctx->ipp_idr);
1722 idr_init(&ctx->prop_idr);
1723
1724 /*
1725 * create single thread for ipp event
1726 * IPP supports event thread for IPP drivers.
1727 * IPP driver send event_work to this thread.
1728 * and IPP event thread send event to user process.
1729 */
1730 ctx->event_workq = create_singlethread_workqueue("ipp_event");
1731 if (!ctx->event_workq) {
1732 dev_err(dev, "failed to create event workqueue\n");
1733 return -EINVAL;
1734 }
1735
1736 /*
1737 * create single thread for ipp command
1738 * IPP supports command thread for user process.
1739 * user process make command node using set property ioctl.
1740 * and make start_work and send this work to command thread.
1741 * and then this command thread start property.
1742 */
1743 ctx->cmd_workq = create_singlethread_workqueue("ipp_cmd");
1744 if (!ctx->cmd_workq) {
1745 dev_err(dev, "failed to create cmd workqueue\n");
1746 ret = -EINVAL;
1747 goto err_event_workq;
1748 }
1749
1750 /* set sub driver informations */
1751 subdrv = &ctx->subdrv;
1752 subdrv->dev = dev;
1753 subdrv->probe = ipp_subdrv_probe;
1754 subdrv->remove = ipp_subdrv_remove;
1755 subdrv->open = ipp_subdrv_open;
1756 subdrv->close = ipp_subdrv_close;
1757
1758 platform_set_drvdata(pdev, ctx);
1759
1760 ret = exynos_drm_subdrv_register(subdrv);
1761 if (ret < 0) {
1762 DRM_ERROR("failed to register drm ipp device.\n");
1763 goto err_cmd_workq;
1764 }
1765
1766 dev_info(dev, "drm ipp registered successfully.\n");
1767
1768 return 0;
1769
1770err_cmd_workq:
1771 destroy_workqueue(ctx->cmd_workq);
1772err_event_workq:
1773 destroy_workqueue(ctx->event_workq);
1774 return ret;
1775}
1776
1777static int ipp_remove(struct platform_device *pdev)
1778{
1779 struct ipp_context *ctx = platform_get_drvdata(pdev);
1780
1781 /* unregister sub driver */
1782 exynos_drm_subdrv_unregister(&ctx->subdrv);
1783
1784 /* remove,destroy ipp idr */
1785 idr_destroy(&ctx->ipp_idr);
1786 idr_destroy(&ctx->prop_idr);
1787
1788 mutex_destroy(&ctx->ipp_lock);
1789 mutex_destroy(&ctx->prop_lock);
1790
1791 /* destroy command, event work queue */
1792 destroy_workqueue(ctx->cmd_workq);
1793 destroy_workqueue(ctx->event_workq);
1794
1795 return 0;
1796}
1797
1798struct platform_driver ipp_driver = {
1799 .probe = ipp_probe,
1800 .remove = ipp_remove,
1801 .driver = {
1802 .name = "exynos-drm-ipp",
1803 .owner = THIS_MODULE,
1804 },
1805};
1806
1/*
2 * Copyright (C) 2017 Samsung Electronics Co.Ltd
3 * Authors:
4 * Marek Szyprowski <m.szyprowski@samsung.com>
5 *
6 * Exynos DRM Image Post Processing (IPP) related functions
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 */
18
19#include <linux/uaccess.h>
20
21#include <drm/drm_blend.h>
22#include <drm/drm_file.h>
23#include <drm/drm_fourcc.h>
24#include <drm/drm_mode.h>
25#include <drm/exynos_drm.h>
26
27#include "exynos_drm_drv.h"
28#include "exynos_drm_gem.h"
29#include "exynos_drm_ipp.h"
30
31static int num_ipp;
32static LIST_HEAD(ipp_list);
33
34/**
35 * exynos_drm_ipp_register - Register a new picture processor hardware module
36 * @dev: DRM device
37 * @ipp: ipp module to init
38 * @funcs: callbacks for the new ipp object
39 * @caps: bitmask of ipp capabilities (%DRM_EXYNOS_IPP_CAP_*)
40 * @formats: array of supported formats
41 * @num_formats: size of the supported formats array
42 * @name: name (for debugging purposes)
43 *
44 * Initializes a ipp module.
45 *
46 * Returns:
47 * Zero on success, error code on failure.
48 */
49int exynos_drm_ipp_register(struct device *dev, struct exynos_drm_ipp *ipp,
50 const struct exynos_drm_ipp_funcs *funcs, unsigned int caps,
51 const struct exynos_drm_ipp_formats *formats,
52 unsigned int num_formats, const char *name)
53{
54 WARN_ON(!ipp);
55 WARN_ON(!funcs);
56 WARN_ON(!formats);
57 WARN_ON(!num_formats);
58
59 spin_lock_init(&ipp->lock);
60 INIT_LIST_HEAD(&ipp->todo_list);
61 init_waitqueue_head(&ipp->done_wq);
62 ipp->dev = dev;
63 ipp->funcs = funcs;
64 ipp->capabilities = caps;
65 ipp->name = name;
66 ipp->formats = formats;
67 ipp->num_formats = num_formats;
68
69 /* ipp_list modification is serialized by component framework */
70 list_add_tail(&ipp->head, &ipp_list);
71 ipp->id = num_ipp++;
72
73 DRM_DEV_DEBUG_DRIVER(dev, "Registered ipp %d\n", ipp->id);
74
75 return 0;
76}
77
78/**
79 * exynos_drm_ipp_unregister - Unregister the picture processor module
80 * @dev: DRM device
81 * @ipp: ipp module
82 */
83void exynos_drm_ipp_unregister(struct device *dev,
84 struct exynos_drm_ipp *ipp)
85{
86 WARN_ON(ipp->task);
87 WARN_ON(!list_empty(&ipp->todo_list));
88 list_del(&ipp->head);
89}
90
91/**
92 * exynos_drm_ipp_get_res_ioctl - enumerate all ipp modules
93 * @dev: DRM device
94 * @data: ioctl data
95 * @file_priv: DRM file info
96 *
97 * Construct a list of ipp ids.
98 *
99 * Called by the user via ioctl.
100 *
101 * Returns:
102 * Zero on success, negative errno on failure.
103 */
104int exynos_drm_ipp_get_res_ioctl(struct drm_device *dev, void *data,
105 struct drm_file *file_priv)
106{
107 struct drm_exynos_ioctl_ipp_get_res *resp = data;
108 struct exynos_drm_ipp *ipp;
109 uint32_t __user *ipp_ptr = (uint32_t __user *)
110 (unsigned long)resp->ipp_id_ptr;
111 unsigned int count = num_ipp, copied = 0;
112
113 /*
114 * This ioctl is called twice, once to determine how much space is
115 * needed, and the 2nd time to fill it.
116 */
117 if (count && resp->count_ipps >= count) {
118 list_for_each_entry(ipp, &ipp_list, head) {
119 if (put_user(ipp->id, ipp_ptr + copied))
120 return -EFAULT;
121 copied++;
122 }
123 }
124 resp->count_ipps = count;
125
126 return 0;
127}
128
129static inline struct exynos_drm_ipp *__ipp_get(uint32_t id)
130{
131 struct exynos_drm_ipp *ipp;
132
133 list_for_each_entry(ipp, &ipp_list, head)
134 if (ipp->id == id)
135 return ipp;
136 return NULL;
137}
138
139/**
140 * exynos_drm_ipp_get_caps_ioctl - get ipp module capabilities and formats
141 * @dev: DRM device
142 * @data: ioctl data
143 * @file_priv: DRM file info
144 *
145 * Construct a structure describing ipp module capabilities.
146 *
147 * Called by the user via ioctl.
148 *
149 * Returns:
150 * Zero on success, negative errno on failure.
151 */
152int exynos_drm_ipp_get_caps_ioctl(struct drm_device *dev, void *data,
153 struct drm_file *file_priv)
154{
155 struct drm_exynos_ioctl_ipp_get_caps *resp = data;
156 void __user *ptr = (void __user *)(unsigned long)resp->formats_ptr;
157 struct exynos_drm_ipp *ipp;
158 int i;
159
160 ipp = __ipp_get(resp->ipp_id);
161 if (!ipp)
162 return -ENOENT;
163
164 resp->ipp_id = ipp->id;
165 resp->capabilities = ipp->capabilities;
166
167 /*
168 * This ioctl is called twice, once to determine how much space is
169 * needed, and the 2nd time to fill it.
170 */
171 if (resp->formats_count >= ipp->num_formats) {
172 for (i = 0; i < ipp->num_formats; i++) {
173 struct drm_exynos_ipp_format tmp = {
174 .fourcc = ipp->formats[i].fourcc,
175 .type = ipp->formats[i].type,
176 .modifier = ipp->formats[i].modifier,
177 };
178
179 if (copy_to_user(ptr, &tmp, sizeof(tmp)))
180 return -EFAULT;
181 ptr += sizeof(tmp);
182 }
183 }
184 resp->formats_count = ipp->num_formats;
185
186 return 0;
187}
188
189static inline const struct exynos_drm_ipp_formats *__ipp_format_get(
190 struct exynos_drm_ipp *ipp, uint32_t fourcc,
191 uint64_t mod, unsigned int type)
192{
193 int i;
194
195 for (i = 0; i < ipp->num_formats; i++) {
196 if ((ipp->formats[i].type & type) &&
197 ipp->formats[i].fourcc == fourcc &&
198 ipp->formats[i].modifier == mod)
199 return &ipp->formats[i];
200 }
201 return NULL;
202}
203
204/**
205 * exynos_drm_ipp_get_limits_ioctl - get ipp module limits
206 * @dev: DRM device
207 * @data: ioctl data
208 * @file_priv: DRM file info
209 *
210 * Construct a structure describing ipp module limitations for provided
211 * picture format.
212 *
213 * Called by the user via ioctl.
214 *
215 * Returns:
216 * Zero on success, negative errno on failure.
217 */
218int exynos_drm_ipp_get_limits_ioctl(struct drm_device *dev, void *data,
219 struct drm_file *file_priv)
220{
221 struct drm_exynos_ioctl_ipp_get_limits *resp = data;
222 void __user *ptr = (void __user *)(unsigned long)resp->limits_ptr;
223 const struct exynos_drm_ipp_formats *format;
224 struct exynos_drm_ipp *ipp;
225
226 if (resp->type != DRM_EXYNOS_IPP_FORMAT_SOURCE &&
227 resp->type != DRM_EXYNOS_IPP_FORMAT_DESTINATION)
228 return -EINVAL;
229
230 ipp = __ipp_get(resp->ipp_id);
231 if (!ipp)
232 return -ENOENT;
233
234 format = __ipp_format_get(ipp, resp->fourcc, resp->modifier,
235 resp->type);
236 if (!format)
237 return -EINVAL;
238
239 /*
240 * This ioctl is called twice, once to determine how much space is
241 * needed, and the 2nd time to fill it.
242 */
243 if (format->num_limits && resp->limits_count >= format->num_limits)
244 if (copy_to_user((void __user *)ptr, format->limits,
245 sizeof(*format->limits) * format->num_limits))
246 return -EFAULT;
247 resp->limits_count = format->num_limits;
248
249 return 0;
250}
251
252struct drm_pending_exynos_ipp_event {
253 struct drm_pending_event base;
254 struct drm_exynos_ipp_event event;
255};
256
257static inline struct exynos_drm_ipp_task *
258 exynos_drm_ipp_task_alloc(struct exynos_drm_ipp *ipp)
259{
260 struct exynos_drm_ipp_task *task;
261
262 task = kzalloc(sizeof(*task), GFP_KERNEL);
263 if (!task)
264 return NULL;
265
266 task->dev = ipp->dev;
267 task->ipp = ipp;
268
269 /* some defaults */
270 task->src.rect.w = task->dst.rect.w = UINT_MAX;
271 task->src.rect.h = task->dst.rect.h = UINT_MAX;
272 task->transform.rotation = DRM_MODE_ROTATE_0;
273
274 DRM_DEV_DEBUG_DRIVER(task->dev, "Allocated task %pK\n", task);
275
276 return task;
277}
278
279static const struct exynos_drm_param_map {
280 unsigned int id;
281 unsigned int size;
282 unsigned int offset;
283} exynos_drm_ipp_params_maps[] = {
284 {
285 DRM_EXYNOS_IPP_TASK_BUFFER | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE,
286 sizeof(struct drm_exynos_ipp_task_buffer),
287 offsetof(struct exynos_drm_ipp_task, src.buf),
288 }, {
289 DRM_EXYNOS_IPP_TASK_BUFFER |
290 DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION,
291 sizeof(struct drm_exynos_ipp_task_buffer),
292 offsetof(struct exynos_drm_ipp_task, dst.buf),
293 }, {
294 DRM_EXYNOS_IPP_TASK_RECTANGLE | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE,
295 sizeof(struct drm_exynos_ipp_task_rect),
296 offsetof(struct exynos_drm_ipp_task, src.rect),
297 }, {
298 DRM_EXYNOS_IPP_TASK_RECTANGLE |
299 DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION,
300 sizeof(struct drm_exynos_ipp_task_rect),
301 offsetof(struct exynos_drm_ipp_task, dst.rect),
302 }, {
303 DRM_EXYNOS_IPP_TASK_TRANSFORM,
304 sizeof(struct drm_exynos_ipp_task_transform),
305 offsetof(struct exynos_drm_ipp_task, transform),
306 }, {
307 DRM_EXYNOS_IPP_TASK_ALPHA,
308 sizeof(struct drm_exynos_ipp_task_alpha),
309 offsetof(struct exynos_drm_ipp_task, alpha),
310 },
311};
312
313static int exynos_drm_ipp_task_set(struct exynos_drm_ipp_task *task,
314 struct drm_exynos_ioctl_ipp_commit *arg)
315{
316 const struct exynos_drm_param_map *map = exynos_drm_ipp_params_maps;
317 void __user *params = (void __user *)(unsigned long)arg->params_ptr;
318 unsigned int size = arg->params_size;
319 uint32_t id;
320 int i;
321
322 while (size) {
323 if (get_user(id, (uint32_t __user *)params))
324 return -EFAULT;
325
326 for (i = 0; i < ARRAY_SIZE(exynos_drm_ipp_params_maps); i++)
327 if (map[i].id == id)
328 break;
329 if (i == ARRAY_SIZE(exynos_drm_ipp_params_maps) ||
330 map[i].size > size)
331 return -EINVAL;
332
333 if (copy_from_user((void *)task + map[i].offset, params,
334 map[i].size))
335 return -EFAULT;
336
337 params += map[i].size;
338 size -= map[i].size;
339 }
340
341 DRM_DEV_DEBUG_DRIVER(task->dev,
342 "Got task %pK configuration from userspace\n",
343 task);
344 return 0;
345}
346
347static int exynos_drm_ipp_task_setup_buffer(struct exynos_drm_ipp_buffer *buf,
348 struct drm_file *filp)
349{
350 int ret = 0;
351 int i;
352
353 /* get GEM buffers and check their size */
354 for (i = 0; i < buf->format->num_planes; i++) {
355 unsigned int height = (i == 0) ? buf->buf.height :
356 DIV_ROUND_UP(buf->buf.height, buf->format->vsub);
357 unsigned long size = height * buf->buf.pitch[i];
358 struct exynos_drm_gem *gem = exynos_drm_gem_get(filp,
359 buf->buf.gem_id[i]);
360 if (!gem) {
361 ret = -ENOENT;
362 goto gem_free;
363 }
364 buf->exynos_gem[i] = gem;
365
366 if (size + buf->buf.offset[i] > buf->exynos_gem[i]->size) {
367 i++;
368 ret = -EINVAL;
369 goto gem_free;
370 }
371 buf->dma_addr[i] = buf->exynos_gem[i]->dma_addr +
372 buf->buf.offset[i];
373 }
374
375 return 0;
376gem_free:
377 while (i--) {
378 exynos_drm_gem_put(buf->exynos_gem[i]);
379 buf->exynos_gem[i] = NULL;
380 }
381 return ret;
382}
383
384static void exynos_drm_ipp_task_release_buf(struct exynos_drm_ipp_buffer *buf)
385{
386 int i;
387
388 if (!buf->exynos_gem[0])
389 return;
390 for (i = 0; i < buf->format->num_planes; i++)
391 exynos_drm_gem_put(buf->exynos_gem[i]);
392}
393
394static void exynos_drm_ipp_task_free(struct exynos_drm_ipp *ipp,
395 struct exynos_drm_ipp_task *task)
396{
397 DRM_DEV_DEBUG_DRIVER(task->dev, "Freeing task %pK\n", task);
398
399 exynos_drm_ipp_task_release_buf(&task->src);
400 exynos_drm_ipp_task_release_buf(&task->dst);
401 if (task->event)
402 drm_event_cancel_free(ipp->drm_dev, &task->event->base);
403 kfree(task);
404}
405
406struct drm_ipp_limit {
407 struct drm_exynos_ipp_limit_val h;
408 struct drm_exynos_ipp_limit_val v;
409};
410
411enum drm_ipp_size_id {
412 IPP_LIMIT_BUFFER, IPP_LIMIT_AREA, IPP_LIMIT_ROTATED, IPP_LIMIT_MAX
413};
414
415static const enum drm_exynos_ipp_limit_type limit_id_fallback[IPP_LIMIT_MAX][4] = {
416 [IPP_LIMIT_BUFFER] = { DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER },
417 [IPP_LIMIT_AREA] = { DRM_EXYNOS_IPP_LIMIT_SIZE_AREA,
418 DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER },
419 [IPP_LIMIT_ROTATED] = { DRM_EXYNOS_IPP_LIMIT_SIZE_ROTATED,
420 DRM_EXYNOS_IPP_LIMIT_SIZE_AREA,
421 DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER },
422};
423
424static inline void __limit_set_val(unsigned int *ptr, unsigned int val)
425{
426 if (!*ptr)
427 *ptr = val;
428}
429
430static void __get_size_limit(const struct drm_exynos_ipp_limit *limits,
431 unsigned int num_limits, enum drm_ipp_size_id id,
432 struct drm_ipp_limit *res)
433{
434 const struct drm_exynos_ipp_limit *l = limits;
435 int i = 0;
436
437 memset(res, 0, sizeof(*res));
438 for (i = 0; limit_id_fallback[id][i]; i++)
439 for (l = limits; l - limits < num_limits; l++) {
440 if (((l->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) !=
441 DRM_EXYNOS_IPP_LIMIT_TYPE_SIZE) ||
442 ((l->type & DRM_EXYNOS_IPP_LIMIT_SIZE_MASK) !=
443 limit_id_fallback[id][i]))
444 continue;
445 __limit_set_val(&res->h.min, l->h.min);
446 __limit_set_val(&res->h.max, l->h.max);
447 __limit_set_val(&res->h.align, l->h.align);
448 __limit_set_val(&res->v.min, l->v.min);
449 __limit_set_val(&res->v.max, l->v.max);
450 __limit_set_val(&res->v.align, l->v.align);
451 }
452}
453
454static inline bool __align_check(unsigned int val, unsigned int align)
455{
456 if (align && (val & (align - 1))) {
457 DRM_DEBUG_DRIVER("Value %d exceeds HW limits (align %d)\n",
458 val, align);
459 return false;
460 }
461 return true;
462}
463
464static inline bool __size_limit_check(unsigned int val,
465 struct drm_exynos_ipp_limit_val *l)
466{
467 if ((l->min && val < l->min) || (l->max && val > l->max)) {
468 DRM_DEBUG_DRIVER("Value %d exceeds HW limits (min %d, max %d)\n",
469 val, l->min, l->max);
470 return false;
471 }
472 return __align_check(val, l->align);
473}
474
475static int exynos_drm_ipp_check_size_limits(struct exynos_drm_ipp_buffer *buf,
476 const struct drm_exynos_ipp_limit *limits, unsigned int num_limits,
477 bool rotate, bool swap)
478{
479 enum drm_ipp_size_id id = rotate ? IPP_LIMIT_ROTATED : IPP_LIMIT_AREA;
480 struct drm_ipp_limit l;
481 struct drm_exynos_ipp_limit_val *lh = &l.h, *lv = &l.v;
482 int real_width = buf->buf.pitch[0] / buf->format->cpp[0];
483
484 if (!limits)
485 return 0;
486
487 __get_size_limit(limits, num_limits, IPP_LIMIT_BUFFER, &l);
488 if (!__size_limit_check(real_width, &l.h) ||
489 !__size_limit_check(buf->buf.height, &l.v))
490 return -EINVAL;
491
492 if (swap) {
493 lv = &l.h;
494 lh = &l.v;
495 }
496 __get_size_limit(limits, num_limits, id, &l);
497 if (!__size_limit_check(buf->rect.w, lh) ||
498 !__align_check(buf->rect.x, lh->align) ||
499 !__size_limit_check(buf->rect.h, lv) ||
500 !__align_check(buf->rect.y, lv->align))
501 return -EINVAL;
502
503 return 0;
504}
505
506static inline bool __scale_limit_check(unsigned int src, unsigned int dst,
507 unsigned int min, unsigned int max)
508{
509 if ((max && (dst << 16) > src * max) ||
510 (min && (dst << 16) < src * min)) {
511 DRM_DEBUG_DRIVER("Scale from %d to %d exceeds HW limits (ratio min %d.%05d, max %d.%05d)\n",
512 src, dst,
513 min >> 16, 100000 * (min & 0xffff) / (1 << 16),
514 max >> 16, 100000 * (max & 0xffff) / (1 << 16));
515 return false;
516 }
517 return true;
518}
519
520static int exynos_drm_ipp_check_scale_limits(
521 struct drm_exynos_ipp_task_rect *src,
522 struct drm_exynos_ipp_task_rect *dst,
523 const struct drm_exynos_ipp_limit *limits,
524 unsigned int num_limits, bool swap)
525{
526 const struct drm_exynos_ipp_limit_val *lh, *lv;
527 int dw, dh;
528
529 for (; num_limits; limits++, num_limits--)
530 if ((limits->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) ==
531 DRM_EXYNOS_IPP_LIMIT_TYPE_SCALE)
532 break;
533 if (!num_limits)
534 return 0;
535
536 lh = (!swap) ? &limits->h : &limits->v;
537 lv = (!swap) ? &limits->v : &limits->h;
538 dw = (!swap) ? dst->w : dst->h;
539 dh = (!swap) ? dst->h : dst->w;
540
541 if (!__scale_limit_check(src->w, dw, lh->min, lh->max) ||
542 !__scale_limit_check(src->h, dh, lv->min, lv->max))
543 return -EINVAL;
544
545 return 0;
546}
547
548static int exynos_drm_ipp_check_format(struct exynos_drm_ipp_task *task,
549 struct exynos_drm_ipp_buffer *buf,
550 struct exynos_drm_ipp_buffer *src,
551 struct exynos_drm_ipp_buffer *dst,
552 bool rotate, bool swap)
553{
554 const struct exynos_drm_ipp_formats *fmt;
555 int ret, i;
556
557 fmt = __ipp_format_get(task->ipp, buf->buf.fourcc, buf->buf.modifier,
558 buf == src ? DRM_EXYNOS_IPP_FORMAT_SOURCE :
559 DRM_EXYNOS_IPP_FORMAT_DESTINATION);
560 if (!fmt) {
561 DRM_DEV_DEBUG_DRIVER(task->dev,
562 "Task %pK: %s format not supported\n",
563 task, buf == src ? "src" : "dst");
564 return -EINVAL;
565 }
566
567 /* basic checks */
568 if (buf->buf.width == 0 || buf->buf.height == 0)
569 return -EINVAL;
570
571 buf->format = drm_format_info(buf->buf.fourcc);
572 for (i = 0; i < buf->format->num_planes; i++) {
573 unsigned int width = (i == 0) ? buf->buf.width :
574 DIV_ROUND_UP(buf->buf.width, buf->format->hsub);
575
576 if (buf->buf.pitch[i] == 0)
577 buf->buf.pitch[i] = width * buf->format->cpp[i];
578 if (buf->buf.pitch[i] < width * buf->format->cpp[i])
579 return -EINVAL;
580 if (!buf->buf.gem_id[i])
581 return -ENOENT;
582 }
583
584 /* pitch for additional planes must match */
585 if (buf->format->num_planes > 2 &&
586 buf->buf.pitch[1] != buf->buf.pitch[2])
587 return -EINVAL;
588
589 /* check driver limits */
590 ret = exynos_drm_ipp_check_size_limits(buf, fmt->limits,
591 fmt->num_limits,
592 rotate,
593 buf == dst ? swap : false);
594 if (ret)
595 return ret;
596 ret = exynos_drm_ipp_check_scale_limits(&src->rect, &dst->rect,
597 fmt->limits,
598 fmt->num_limits, swap);
599 return ret;
600}
601
602static int exynos_drm_ipp_task_check(struct exynos_drm_ipp_task *task)
603{
604 struct exynos_drm_ipp *ipp = task->ipp;
605 struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst;
606 unsigned int rotation = task->transform.rotation;
607 int ret = 0;
608 bool swap = drm_rotation_90_or_270(rotation);
609 bool rotate = (rotation != DRM_MODE_ROTATE_0);
610 bool scale = false;
611
612 DRM_DEV_DEBUG_DRIVER(task->dev, "Checking task %pK\n", task);
613
614 if (src->rect.w == UINT_MAX)
615 src->rect.w = src->buf.width;
616 if (src->rect.h == UINT_MAX)
617 src->rect.h = src->buf.height;
618 if (dst->rect.w == UINT_MAX)
619 dst->rect.w = dst->buf.width;
620 if (dst->rect.h == UINT_MAX)
621 dst->rect.h = dst->buf.height;
622
623 if (src->rect.x + src->rect.w > (src->buf.width) ||
624 src->rect.y + src->rect.h > (src->buf.height) ||
625 dst->rect.x + dst->rect.w > (dst->buf.width) ||
626 dst->rect.y + dst->rect.h > (dst->buf.height)) {
627 DRM_DEV_DEBUG_DRIVER(task->dev,
628 "Task %pK: defined area is outside provided buffers\n",
629 task);
630 return -EINVAL;
631 }
632
633 if ((!swap && (src->rect.w != dst->rect.w ||
634 src->rect.h != dst->rect.h)) ||
635 (swap && (src->rect.w != dst->rect.h ||
636 src->rect.h != dst->rect.w)))
637 scale = true;
638
639 if ((!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CROP) &&
640 (src->rect.x || src->rect.y || dst->rect.x || dst->rect.y)) ||
641 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_ROTATE) && rotate) ||
642 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_SCALE) && scale) ||
643 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CONVERT) &&
644 src->buf.fourcc != dst->buf.fourcc)) {
645 DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: hw capabilities exceeded\n",
646 task);
647 return -EINVAL;
648 }
649
650 ret = exynos_drm_ipp_check_format(task, src, src, dst, rotate, swap);
651 if (ret)
652 return ret;
653
654 ret = exynos_drm_ipp_check_format(task, dst, src, dst, false, swap);
655 if (ret)
656 return ret;
657
658 DRM_DEV_DEBUG_DRIVER(ipp->dev, "Task %pK: all checks done.\n",
659 task);
660
661 return ret;
662}
663
664static int exynos_drm_ipp_task_setup_buffers(struct exynos_drm_ipp_task *task,
665 struct drm_file *filp)
666{
667 struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst;
668 int ret = 0;
669
670 DRM_DEV_DEBUG_DRIVER(task->dev, "Setting buffer for task %pK\n",
671 task);
672
673 ret = exynos_drm_ipp_task_setup_buffer(src, filp);
674 if (ret) {
675 DRM_DEV_DEBUG_DRIVER(task->dev,
676 "Task %pK: src buffer setup failed\n",
677 task);
678 return ret;
679 }
680 ret = exynos_drm_ipp_task_setup_buffer(dst, filp);
681 if (ret) {
682 DRM_DEV_DEBUG_DRIVER(task->dev,
683 "Task %pK: dst buffer setup failed\n",
684 task);
685 return ret;
686 }
687
688 DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: buffers prepared.\n",
689 task);
690
691 return ret;
692}
693
694
695static int exynos_drm_ipp_event_create(struct exynos_drm_ipp_task *task,
696 struct drm_file *file_priv, uint64_t user_data)
697{
698 struct drm_pending_exynos_ipp_event *e = NULL;
699 int ret;
700
701 e = kzalloc(sizeof(*e), GFP_KERNEL);
702 if (!e)
703 return -ENOMEM;
704
705 e->event.base.type = DRM_EXYNOS_IPP_EVENT;
706 e->event.base.length = sizeof(e->event);
707 e->event.user_data = user_data;
708
709 ret = drm_event_reserve_init(task->ipp->drm_dev, file_priv, &e->base,
710 &e->event.base);
711 if (ret)
712 goto free;
713
714 task->event = e;
715 return 0;
716free:
717 kfree(e);
718 return ret;
719}
720
721static void exynos_drm_ipp_event_send(struct exynos_drm_ipp_task *task)
722{
723 struct timespec64 now;
724
725 ktime_get_ts64(&now);
726 task->event->event.tv_sec = now.tv_sec;
727 task->event->event.tv_usec = now.tv_nsec / NSEC_PER_USEC;
728 task->event->event.sequence = atomic_inc_return(&task->ipp->sequence);
729
730 drm_send_event(task->ipp->drm_dev, &task->event->base);
731}
732
733static int exynos_drm_ipp_task_cleanup(struct exynos_drm_ipp_task *task)
734{
735 int ret = task->ret;
736
737 if (ret == 0 && task->event) {
738 exynos_drm_ipp_event_send(task);
739 /* ensure event won't be canceled on task free */
740 task->event = NULL;
741 }
742
743 exynos_drm_ipp_task_free(task->ipp, task);
744 return ret;
745}
746
747static void exynos_drm_ipp_cleanup_work(struct work_struct *work)
748{
749 struct exynos_drm_ipp_task *task = container_of(work,
750 struct exynos_drm_ipp_task, cleanup_work);
751
752 exynos_drm_ipp_task_cleanup(task);
753}
754
755static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp);
756
757/**
758 * exynos_drm_ipp_task_done - finish given task and set return code
759 * @task: ipp task to finish
760 * @ret: error code or 0 if operation has been performed successfully
761 */
762void exynos_drm_ipp_task_done(struct exynos_drm_ipp_task *task, int ret)
763{
764 struct exynos_drm_ipp *ipp = task->ipp;
765 unsigned long flags;
766
767 DRM_DEV_DEBUG_DRIVER(task->dev, "ipp: %d, task %pK done: %d\n",
768 ipp->id, task, ret);
769
770 spin_lock_irqsave(&ipp->lock, flags);
771 if (ipp->task == task)
772 ipp->task = NULL;
773 task->flags |= DRM_EXYNOS_IPP_TASK_DONE;
774 task->ret = ret;
775 spin_unlock_irqrestore(&ipp->lock, flags);
776
777 exynos_drm_ipp_next_task(ipp);
778 wake_up(&ipp->done_wq);
779
780 if (task->flags & DRM_EXYNOS_IPP_TASK_ASYNC) {
781 INIT_WORK(&task->cleanup_work, exynos_drm_ipp_cleanup_work);
782 schedule_work(&task->cleanup_work);
783 }
784}
785
786static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp)
787{
788 struct exynos_drm_ipp_task *task;
789 unsigned long flags;
790 int ret;
791
792 DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, try to run new task\n",
793 ipp->id);
794
795 spin_lock_irqsave(&ipp->lock, flags);
796
797 if (ipp->task || list_empty(&ipp->todo_list)) {
798 spin_unlock_irqrestore(&ipp->lock, flags);
799 return;
800 }
801
802 task = list_first_entry(&ipp->todo_list, struct exynos_drm_ipp_task,
803 head);
804 list_del_init(&task->head);
805 ipp->task = task;
806
807 spin_unlock_irqrestore(&ipp->lock, flags);
808
809 DRM_DEV_DEBUG_DRIVER(ipp->dev,
810 "ipp: %d, selected task %pK to run\n", ipp->id,
811 task);
812
813 ret = ipp->funcs->commit(ipp, task);
814 if (ret)
815 exynos_drm_ipp_task_done(task, ret);
816}
817
818static void exynos_drm_ipp_schedule_task(struct exynos_drm_ipp *ipp,
819 struct exynos_drm_ipp_task *task)
820{
821 unsigned long flags;
822
823 spin_lock_irqsave(&ipp->lock, flags);
824 list_add(&task->head, &ipp->todo_list);
825 spin_unlock_irqrestore(&ipp->lock, flags);
826
827 exynos_drm_ipp_next_task(ipp);
828}
829
830static void exynos_drm_ipp_task_abort(struct exynos_drm_ipp *ipp,
831 struct exynos_drm_ipp_task *task)
832{
833 unsigned long flags;
834
835 spin_lock_irqsave(&ipp->lock, flags);
836 if (task->flags & DRM_EXYNOS_IPP_TASK_DONE) {
837 /* already completed task */
838 exynos_drm_ipp_task_cleanup(task);
839 } else if (ipp->task != task) {
840 /* task has not been scheduled for execution yet */
841 list_del_init(&task->head);
842 exynos_drm_ipp_task_cleanup(task);
843 } else {
844 /*
845 * currently processed task, call abort() and perform
846 * cleanup with async worker
847 */
848 task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC;
849 spin_unlock_irqrestore(&ipp->lock, flags);
850 if (ipp->funcs->abort)
851 ipp->funcs->abort(ipp, task);
852 return;
853 }
854 spin_unlock_irqrestore(&ipp->lock, flags);
855}
856
857/**
858 * exynos_drm_ipp_commit_ioctl - perform image processing operation
859 * @dev: DRM device
860 * @data: ioctl data
861 * @file_priv: DRM file info
862 *
863 * Construct a ipp task from the set of properties provided from the user
864 * and try to schedule it to framebuffer processor hardware.
865 *
866 * Called by the user via ioctl.
867 *
868 * Returns:
869 * Zero on success, negative errno on failure.
870 */
871int exynos_drm_ipp_commit_ioctl(struct drm_device *dev, void *data,
872 struct drm_file *file_priv)
873{
874 struct drm_exynos_ioctl_ipp_commit *arg = data;
875 struct exynos_drm_ipp *ipp;
876 struct exynos_drm_ipp_task *task;
877 int ret = 0;
878
879 if ((arg->flags & ~DRM_EXYNOS_IPP_FLAGS) || arg->reserved)
880 return -EINVAL;
881
882 /* can't test and expect an event at the same time */
883 if ((arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY) &&
884 (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT))
885 return -EINVAL;
886
887 ipp = __ipp_get(arg->ipp_id);
888 if (!ipp)
889 return -ENOENT;
890
891 task = exynos_drm_ipp_task_alloc(ipp);
892 if (!task)
893 return -ENOMEM;
894
895 ret = exynos_drm_ipp_task_set(task, arg);
896 if (ret)
897 goto free;
898
899 ret = exynos_drm_ipp_task_check(task);
900 if (ret)
901 goto free;
902
903 ret = exynos_drm_ipp_task_setup_buffers(task, file_priv);
904 if (ret || arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY)
905 goto free;
906
907 if (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT) {
908 ret = exynos_drm_ipp_event_create(task, file_priv,
909 arg->user_data);
910 if (ret)
911 goto free;
912 }
913
914 /*
915 * Queue task for processing on the hardware. task object will be
916 * then freed after exynos_drm_ipp_task_done()
917 */
918 if (arg->flags & DRM_EXYNOS_IPP_FLAG_NONBLOCK) {
919 DRM_DEV_DEBUG_DRIVER(ipp->dev,
920 "ipp: %d, nonblocking processing task %pK\n",
921 ipp->id, task);
922
923 task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC;
924 exynos_drm_ipp_schedule_task(task->ipp, task);
925 ret = 0;
926 } else {
927 DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, processing task %pK\n",
928 ipp->id, task);
929 exynos_drm_ipp_schedule_task(ipp, task);
930 ret = wait_event_interruptible(ipp->done_wq,
931 task->flags & DRM_EXYNOS_IPP_TASK_DONE);
932 if (ret)
933 exynos_drm_ipp_task_abort(ipp, task);
934 else
935 ret = exynos_drm_ipp_task_cleanup(task);
936 }
937 return ret;
938free:
939 exynos_drm_ipp_task_free(ipp, task);
940
941 return ret;
942}