Loading...
Note: File does not exist in v3.1.
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_file.h>
22#include <drm/drm_fourcc.h>
23#include <drm/drm_mode.h>
24#include <drm/exynos_drm.h>
25
26#include "exynos_drm_drv.h"
27#include "exynos_drm_gem.h"
28#include "exynos_drm_ipp.h"
29
30static int num_ipp;
31static LIST_HEAD(ipp_list);
32
33/**
34 * exynos_drm_ipp_register - Register a new picture processor hardware module
35 * @dev: DRM device
36 * @ipp: ipp module to init
37 * @funcs: callbacks for the new ipp object
38 * @caps: bitmask of ipp capabilities (%DRM_EXYNOS_IPP_CAP_*)
39 * @formats: array of supported formats
40 * @num_formats: size of the supported formats array
41 * @name: name (for debugging purposes)
42 *
43 * Initializes a ipp module.
44 *
45 * Returns:
46 * Zero on success, error code on failure.
47 */
48int exynos_drm_ipp_register(struct device *dev, struct exynos_drm_ipp *ipp,
49 const struct exynos_drm_ipp_funcs *funcs, unsigned int caps,
50 const struct exynos_drm_ipp_formats *formats,
51 unsigned int num_formats, const char *name)
52{
53 WARN_ON(!ipp);
54 WARN_ON(!funcs);
55 WARN_ON(!formats);
56 WARN_ON(!num_formats);
57
58 spin_lock_init(&ipp->lock);
59 INIT_LIST_HEAD(&ipp->todo_list);
60 init_waitqueue_head(&ipp->done_wq);
61 ipp->dev = dev;
62 ipp->funcs = funcs;
63 ipp->capabilities = caps;
64 ipp->name = name;
65 ipp->formats = formats;
66 ipp->num_formats = num_formats;
67
68 /* ipp_list modification is serialized by component framework */
69 list_add_tail(&ipp->head, &ipp_list);
70 ipp->id = num_ipp++;
71
72 DRM_DEV_DEBUG_DRIVER(dev, "Registered ipp %d\n", ipp->id);
73
74 return 0;
75}
76
77/**
78 * exynos_drm_ipp_unregister - Unregister the picture processor module
79 * @dev: DRM device
80 * @ipp: ipp module
81 */
82void exynos_drm_ipp_unregister(struct device *dev,
83 struct exynos_drm_ipp *ipp)
84{
85 WARN_ON(ipp->task);
86 WARN_ON(!list_empty(&ipp->todo_list));
87 list_del(&ipp->head);
88}
89
90/**
91 * exynos_drm_ipp_ioctl_get_res_ioctl - enumerate all ipp modules
92 * @dev: DRM device
93 * @data: ioctl data
94 * @file_priv: DRM file info
95 *
96 * Construct a list of ipp ids.
97 *
98 * Called by the user via ioctl.
99 *
100 * Returns:
101 * Zero on success, negative errno on failure.
102 */
103int exynos_drm_ipp_get_res_ioctl(struct drm_device *dev, void *data,
104 struct drm_file *file_priv)
105{
106 struct drm_exynos_ioctl_ipp_get_res *resp = data;
107 struct exynos_drm_ipp *ipp;
108 uint32_t __user *ipp_ptr = (uint32_t __user *)
109 (unsigned long)resp->ipp_id_ptr;
110 unsigned int count = num_ipp, copied = 0;
111
112 /*
113 * This ioctl is called twice, once to determine how much space is
114 * needed, and the 2nd time to fill it.
115 */
116 if (count && resp->count_ipps >= count) {
117 list_for_each_entry(ipp, &ipp_list, head) {
118 if (put_user(ipp->id, ipp_ptr + copied))
119 return -EFAULT;
120 copied++;
121 }
122 }
123 resp->count_ipps = count;
124
125 return 0;
126}
127
128static inline struct exynos_drm_ipp *__ipp_get(uint32_t id)
129{
130 struct exynos_drm_ipp *ipp;
131
132 list_for_each_entry(ipp, &ipp_list, head)
133 if (ipp->id == id)
134 return ipp;
135 return NULL;
136}
137
138/**
139 * exynos_drm_ipp_ioctl_get_caps - get ipp module capabilities and formats
140 * @dev: DRM device
141 * @data: ioctl data
142 * @file_priv: DRM file info
143 *
144 * Construct a structure describing ipp module capabilities.
145 *
146 * Called by the user via ioctl.
147 *
148 * Returns:
149 * Zero on success, negative errno on failure.
150 */
151int exynos_drm_ipp_get_caps_ioctl(struct drm_device *dev, void *data,
152 struct drm_file *file_priv)
153{
154 struct drm_exynos_ioctl_ipp_get_caps *resp = data;
155 void __user *ptr = (void __user *)(unsigned long)resp->formats_ptr;
156 struct exynos_drm_ipp *ipp;
157 int i;
158
159 ipp = __ipp_get(resp->ipp_id);
160 if (!ipp)
161 return -ENOENT;
162
163 resp->ipp_id = ipp->id;
164 resp->capabilities = ipp->capabilities;
165
166 /*
167 * This ioctl is called twice, once to determine how much space is
168 * needed, and the 2nd time to fill it.
169 */
170 if (resp->formats_count >= ipp->num_formats) {
171 for (i = 0; i < ipp->num_formats; i++) {
172 struct drm_exynos_ipp_format tmp = {
173 .fourcc = ipp->formats[i].fourcc,
174 .type = ipp->formats[i].type,
175 .modifier = ipp->formats[i].modifier,
176 };
177
178 if (copy_to_user(ptr, &tmp, sizeof(tmp)))
179 return -EFAULT;
180 ptr += sizeof(tmp);
181 }
182 }
183 resp->formats_count = ipp->num_formats;
184
185 return 0;
186}
187
188static inline const struct exynos_drm_ipp_formats *__ipp_format_get(
189 struct exynos_drm_ipp *ipp, uint32_t fourcc,
190 uint64_t mod, unsigned int type)
191{
192 int i;
193
194 for (i = 0; i < ipp->num_formats; i++) {
195 if ((ipp->formats[i].type & type) &&
196 ipp->formats[i].fourcc == fourcc &&
197 ipp->formats[i].modifier == mod)
198 return &ipp->formats[i];
199 }
200 return NULL;
201}
202
203/**
204 * exynos_drm_ipp_get_limits_ioctl - get ipp module limits
205 * @dev: DRM device
206 * @data: ioctl data
207 * @file_priv: DRM file info
208 *
209 * Construct a structure describing ipp module limitations for provided
210 * picture format.
211 *
212 * Called by the user via ioctl.
213 *
214 * Returns:
215 * Zero on success, negative errno on failure.
216 */
217int exynos_drm_ipp_get_limits_ioctl(struct drm_device *dev, void *data,
218 struct drm_file *file_priv)
219{
220 struct drm_exynos_ioctl_ipp_get_limits *resp = data;
221 void __user *ptr = (void __user *)(unsigned long)resp->limits_ptr;
222 const struct exynos_drm_ipp_formats *format;
223 struct exynos_drm_ipp *ipp;
224
225 if (resp->type != DRM_EXYNOS_IPP_FORMAT_SOURCE &&
226 resp->type != DRM_EXYNOS_IPP_FORMAT_DESTINATION)
227 return -EINVAL;
228
229 ipp = __ipp_get(resp->ipp_id);
230 if (!ipp)
231 return -ENOENT;
232
233 format = __ipp_format_get(ipp, resp->fourcc, resp->modifier,
234 resp->type);
235 if (!format)
236 return -EINVAL;
237
238 /*
239 * This ioctl is called twice, once to determine how much space is
240 * needed, and the 2nd time to fill it.
241 */
242 if (format->num_limits && resp->limits_count >= format->num_limits)
243 if (copy_to_user((void __user *)ptr, format->limits,
244 sizeof(*format->limits) * format->num_limits))
245 return -EFAULT;
246 resp->limits_count = format->num_limits;
247
248 return 0;
249}
250
251struct drm_pending_exynos_ipp_event {
252 struct drm_pending_event base;
253 struct drm_exynos_ipp_event event;
254};
255
256static inline struct exynos_drm_ipp_task *
257 exynos_drm_ipp_task_alloc(struct exynos_drm_ipp *ipp)
258{
259 struct exynos_drm_ipp_task *task;
260
261 task = kzalloc(sizeof(*task), GFP_KERNEL);
262 if (!task)
263 return NULL;
264
265 task->dev = ipp->dev;
266 task->ipp = ipp;
267
268 /* some defaults */
269 task->src.rect.w = task->dst.rect.w = UINT_MAX;
270 task->src.rect.h = task->dst.rect.h = UINT_MAX;
271 task->transform.rotation = DRM_MODE_ROTATE_0;
272
273 DRM_DEV_DEBUG_DRIVER(task->dev, "Allocated task %pK\n", task);
274
275 return task;
276}
277
278static const struct exynos_drm_param_map {
279 unsigned int id;
280 unsigned int size;
281 unsigned int offset;
282} exynos_drm_ipp_params_maps[] = {
283 {
284 DRM_EXYNOS_IPP_TASK_BUFFER | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE,
285 sizeof(struct drm_exynos_ipp_task_buffer),
286 offsetof(struct exynos_drm_ipp_task, src.buf),
287 }, {
288 DRM_EXYNOS_IPP_TASK_BUFFER |
289 DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION,
290 sizeof(struct drm_exynos_ipp_task_buffer),
291 offsetof(struct exynos_drm_ipp_task, dst.buf),
292 }, {
293 DRM_EXYNOS_IPP_TASK_RECTANGLE | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE,
294 sizeof(struct drm_exynos_ipp_task_rect),
295 offsetof(struct exynos_drm_ipp_task, src.rect),
296 }, {
297 DRM_EXYNOS_IPP_TASK_RECTANGLE |
298 DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION,
299 sizeof(struct drm_exynos_ipp_task_rect),
300 offsetof(struct exynos_drm_ipp_task, dst.rect),
301 }, {
302 DRM_EXYNOS_IPP_TASK_TRANSFORM,
303 sizeof(struct drm_exynos_ipp_task_transform),
304 offsetof(struct exynos_drm_ipp_task, transform),
305 }, {
306 DRM_EXYNOS_IPP_TASK_ALPHA,
307 sizeof(struct drm_exynos_ipp_task_alpha),
308 offsetof(struct exynos_drm_ipp_task, alpha),
309 },
310};
311
312static int exynos_drm_ipp_task_set(struct exynos_drm_ipp_task *task,
313 struct drm_exynos_ioctl_ipp_commit *arg)
314{
315 const struct exynos_drm_param_map *map = exynos_drm_ipp_params_maps;
316 void __user *params = (void __user *)(unsigned long)arg->params_ptr;
317 unsigned int size = arg->params_size;
318 uint32_t id;
319 int i;
320
321 while (size) {
322 if (get_user(id, (uint32_t __user *)params))
323 return -EFAULT;
324
325 for (i = 0; i < ARRAY_SIZE(exynos_drm_ipp_params_maps); i++)
326 if (map[i].id == id)
327 break;
328 if (i == ARRAY_SIZE(exynos_drm_ipp_params_maps) ||
329 map[i].size > size)
330 return -EINVAL;
331
332 if (copy_from_user((void *)task + map[i].offset, params,
333 map[i].size))
334 return -EFAULT;
335
336 params += map[i].size;
337 size -= map[i].size;
338 }
339
340 DRM_DEV_DEBUG_DRIVER(task->dev,
341 "Got task %pK configuration from userspace\n",
342 task);
343 return 0;
344}
345
346static int exynos_drm_ipp_task_setup_buffer(struct exynos_drm_ipp_buffer *buf,
347 struct drm_file *filp)
348{
349 int ret = 0;
350 int i;
351
352 /* get GEM buffers and check their size */
353 for (i = 0; i < buf->format->num_planes; i++) {
354 unsigned int height = (i == 0) ? buf->buf.height :
355 DIV_ROUND_UP(buf->buf.height, buf->format->vsub);
356 unsigned long size = height * buf->buf.pitch[i];
357 struct exynos_drm_gem *gem = exynos_drm_gem_get(filp,
358 buf->buf.gem_id[i]);
359 if (!gem) {
360 ret = -ENOENT;
361 goto gem_free;
362 }
363 buf->exynos_gem[i] = gem;
364
365 if (size + buf->buf.offset[i] > buf->exynos_gem[i]->size) {
366 i++;
367 ret = -EINVAL;
368 goto gem_free;
369 }
370 buf->dma_addr[i] = buf->exynos_gem[i]->dma_addr +
371 buf->buf.offset[i];
372 }
373
374 return 0;
375gem_free:
376 while (i--) {
377 exynos_drm_gem_put(buf->exynos_gem[i]);
378 buf->exynos_gem[i] = NULL;
379 }
380 return ret;
381}
382
383static void exynos_drm_ipp_task_release_buf(struct exynos_drm_ipp_buffer *buf)
384{
385 int i;
386
387 if (!buf->exynos_gem[0])
388 return;
389 for (i = 0; i < buf->format->num_planes; i++)
390 exynos_drm_gem_put(buf->exynos_gem[i]);
391}
392
393static void exynos_drm_ipp_task_free(struct exynos_drm_ipp *ipp,
394 struct exynos_drm_ipp_task *task)
395{
396 DRM_DEV_DEBUG_DRIVER(task->dev, "Freeing task %pK\n", task);
397
398 exynos_drm_ipp_task_release_buf(&task->src);
399 exynos_drm_ipp_task_release_buf(&task->dst);
400 if (task->event)
401 drm_event_cancel_free(ipp->drm_dev, &task->event->base);
402 kfree(task);
403}
404
405struct drm_ipp_limit {
406 struct drm_exynos_ipp_limit_val h;
407 struct drm_exynos_ipp_limit_val v;
408};
409
410enum drm_ipp_size_id {
411 IPP_LIMIT_BUFFER, IPP_LIMIT_AREA, IPP_LIMIT_ROTATED, IPP_LIMIT_MAX
412};
413
414static const enum drm_exynos_ipp_limit_type limit_id_fallback[IPP_LIMIT_MAX][4] = {
415 [IPP_LIMIT_BUFFER] = { DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER },
416 [IPP_LIMIT_AREA] = { DRM_EXYNOS_IPP_LIMIT_SIZE_AREA,
417 DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER },
418 [IPP_LIMIT_ROTATED] = { DRM_EXYNOS_IPP_LIMIT_SIZE_ROTATED,
419 DRM_EXYNOS_IPP_LIMIT_SIZE_AREA,
420 DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER },
421};
422
423static inline void __limit_set_val(unsigned int *ptr, unsigned int val)
424{
425 if (!*ptr)
426 *ptr = val;
427}
428
429static void __get_size_limit(const struct drm_exynos_ipp_limit *limits,
430 unsigned int num_limits, enum drm_ipp_size_id id,
431 struct drm_ipp_limit *res)
432{
433 const struct drm_exynos_ipp_limit *l = limits;
434 int i = 0;
435
436 memset(res, 0, sizeof(*res));
437 for (i = 0; limit_id_fallback[id][i]; i++)
438 for (l = limits; l - limits < num_limits; l++) {
439 if (((l->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) !=
440 DRM_EXYNOS_IPP_LIMIT_TYPE_SIZE) ||
441 ((l->type & DRM_EXYNOS_IPP_LIMIT_SIZE_MASK) !=
442 limit_id_fallback[id][i]))
443 continue;
444 __limit_set_val(&res->h.min, l->h.min);
445 __limit_set_val(&res->h.max, l->h.max);
446 __limit_set_val(&res->h.align, l->h.align);
447 __limit_set_val(&res->v.min, l->v.min);
448 __limit_set_val(&res->v.max, l->v.max);
449 __limit_set_val(&res->v.align, l->v.align);
450 }
451}
452
453static inline bool __align_check(unsigned int val, unsigned int align)
454{
455 if (align && (val & (align - 1))) {
456 DRM_DEBUG_DRIVER("Value %d exceeds HW limits (align %d)\n",
457 val, align);
458 return false;
459 }
460 return true;
461}
462
463static inline bool __size_limit_check(unsigned int val,
464 struct drm_exynos_ipp_limit_val *l)
465{
466 if ((l->min && val < l->min) || (l->max && val > l->max)) {
467 DRM_DEBUG_DRIVER("Value %d exceeds HW limits (min %d, max %d)\n",
468 val, l->min, l->max);
469 return false;
470 }
471 return __align_check(val, l->align);
472}
473
474static int exynos_drm_ipp_check_size_limits(struct exynos_drm_ipp_buffer *buf,
475 const struct drm_exynos_ipp_limit *limits, unsigned int num_limits,
476 bool rotate, bool swap)
477{
478 enum drm_ipp_size_id id = rotate ? IPP_LIMIT_ROTATED : IPP_LIMIT_AREA;
479 struct drm_ipp_limit l;
480 struct drm_exynos_ipp_limit_val *lh = &l.h, *lv = &l.v;
481 int real_width = buf->buf.pitch[0] / buf->format->cpp[0];
482
483 if (!limits)
484 return 0;
485
486 __get_size_limit(limits, num_limits, IPP_LIMIT_BUFFER, &l);
487 if (!__size_limit_check(real_width, &l.h) ||
488 !__size_limit_check(buf->buf.height, &l.v))
489 return -EINVAL;
490
491 if (swap) {
492 lv = &l.h;
493 lh = &l.v;
494 }
495 __get_size_limit(limits, num_limits, id, &l);
496 if (!__size_limit_check(buf->rect.w, lh) ||
497 !__align_check(buf->rect.x, lh->align) ||
498 !__size_limit_check(buf->rect.h, lv) ||
499 !__align_check(buf->rect.y, lv->align))
500 return -EINVAL;
501
502 return 0;
503}
504
505static inline bool __scale_limit_check(unsigned int src, unsigned int dst,
506 unsigned int min, unsigned int max)
507{
508 if ((max && (dst << 16) > src * max) ||
509 (min && (dst << 16) < src * min)) {
510 DRM_DEBUG_DRIVER("Scale from %d to %d exceeds HW limits (ratio min %d.%05d, max %d.%05d)\n",
511 src, dst,
512 min >> 16, 100000 * (min & 0xffff) / (1 << 16),
513 max >> 16, 100000 * (max & 0xffff) / (1 << 16));
514 return false;
515 }
516 return true;
517}
518
519static int exynos_drm_ipp_check_scale_limits(
520 struct drm_exynos_ipp_task_rect *src,
521 struct drm_exynos_ipp_task_rect *dst,
522 const struct drm_exynos_ipp_limit *limits,
523 unsigned int num_limits, bool swap)
524{
525 const struct drm_exynos_ipp_limit_val *lh, *lv;
526 int dw, dh;
527
528 for (; num_limits; limits++, num_limits--)
529 if ((limits->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) ==
530 DRM_EXYNOS_IPP_LIMIT_TYPE_SCALE)
531 break;
532 if (!num_limits)
533 return 0;
534
535 lh = (!swap) ? &limits->h : &limits->v;
536 lv = (!swap) ? &limits->v : &limits->h;
537 dw = (!swap) ? dst->w : dst->h;
538 dh = (!swap) ? dst->h : dst->w;
539
540 if (!__scale_limit_check(src->w, dw, lh->min, lh->max) ||
541 !__scale_limit_check(src->h, dh, lv->min, lv->max))
542 return -EINVAL;
543
544 return 0;
545}
546
547static int exynos_drm_ipp_check_format(struct exynos_drm_ipp_task *task,
548 struct exynos_drm_ipp_buffer *buf,
549 struct exynos_drm_ipp_buffer *src,
550 struct exynos_drm_ipp_buffer *dst,
551 bool rotate, bool swap)
552{
553 const struct exynos_drm_ipp_formats *fmt;
554 int ret, i;
555
556 fmt = __ipp_format_get(task->ipp, buf->buf.fourcc, buf->buf.modifier,
557 buf == src ? DRM_EXYNOS_IPP_FORMAT_SOURCE :
558 DRM_EXYNOS_IPP_FORMAT_DESTINATION);
559 if (!fmt) {
560 DRM_DEV_DEBUG_DRIVER(task->dev,
561 "Task %pK: %s format not supported\n",
562 task, buf == src ? "src" : "dst");
563 return -EINVAL;
564 }
565
566 /* basic checks */
567 if (buf->buf.width == 0 || buf->buf.height == 0)
568 return -EINVAL;
569
570 buf->format = drm_format_info(buf->buf.fourcc);
571 for (i = 0; i < buf->format->num_planes; i++) {
572 unsigned int width = (i == 0) ? buf->buf.width :
573 DIV_ROUND_UP(buf->buf.width, buf->format->hsub);
574
575 if (buf->buf.pitch[i] == 0)
576 buf->buf.pitch[i] = width * buf->format->cpp[i];
577 if (buf->buf.pitch[i] < width * buf->format->cpp[i])
578 return -EINVAL;
579 if (!buf->buf.gem_id[i])
580 return -ENOENT;
581 }
582
583 /* pitch for additional planes must match */
584 if (buf->format->num_planes > 2 &&
585 buf->buf.pitch[1] != buf->buf.pitch[2])
586 return -EINVAL;
587
588 /* check driver limits */
589 ret = exynos_drm_ipp_check_size_limits(buf, fmt->limits,
590 fmt->num_limits,
591 rotate,
592 buf == dst ? swap : false);
593 if (ret)
594 return ret;
595 ret = exynos_drm_ipp_check_scale_limits(&src->rect, &dst->rect,
596 fmt->limits,
597 fmt->num_limits, swap);
598 return ret;
599}
600
601static int exynos_drm_ipp_task_check(struct exynos_drm_ipp_task *task)
602{
603 struct exynos_drm_ipp *ipp = task->ipp;
604 struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst;
605 unsigned int rotation = task->transform.rotation;
606 int ret = 0;
607 bool swap = drm_rotation_90_or_270(rotation);
608 bool rotate = (rotation != DRM_MODE_ROTATE_0);
609 bool scale = false;
610
611 DRM_DEV_DEBUG_DRIVER(task->dev, "Checking task %pK\n", task);
612
613 if (src->rect.w == UINT_MAX)
614 src->rect.w = src->buf.width;
615 if (src->rect.h == UINT_MAX)
616 src->rect.h = src->buf.height;
617 if (dst->rect.w == UINT_MAX)
618 dst->rect.w = dst->buf.width;
619 if (dst->rect.h == UINT_MAX)
620 dst->rect.h = dst->buf.height;
621
622 if (src->rect.x + src->rect.w > (src->buf.width) ||
623 src->rect.y + src->rect.h > (src->buf.height) ||
624 dst->rect.x + dst->rect.w > (dst->buf.width) ||
625 dst->rect.y + dst->rect.h > (dst->buf.height)) {
626 DRM_DEV_DEBUG_DRIVER(task->dev,
627 "Task %pK: defined area is outside provided buffers\n",
628 task);
629 return -EINVAL;
630 }
631
632 if ((!swap && (src->rect.w != dst->rect.w ||
633 src->rect.h != dst->rect.h)) ||
634 (swap && (src->rect.w != dst->rect.h ||
635 src->rect.h != dst->rect.w)))
636 scale = true;
637
638 if ((!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CROP) &&
639 (src->rect.x || src->rect.y || dst->rect.x || dst->rect.y)) ||
640 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_ROTATE) && rotate) ||
641 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_SCALE) && scale) ||
642 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CONVERT) &&
643 src->buf.fourcc != dst->buf.fourcc)) {
644 DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: hw capabilities exceeded\n",
645 task);
646 return -EINVAL;
647 }
648
649 ret = exynos_drm_ipp_check_format(task, src, src, dst, rotate, swap);
650 if (ret)
651 return ret;
652
653 ret = exynos_drm_ipp_check_format(task, dst, src, dst, false, swap);
654 if (ret)
655 return ret;
656
657 DRM_DEV_DEBUG_DRIVER(ipp->dev, "Task %pK: all checks done.\n",
658 task);
659
660 return ret;
661}
662
663static int exynos_drm_ipp_task_setup_buffers(struct exynos_drm_ipp_task *task,
664 struct drm_file *filp)
665{
666 struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst;
667 int ret = 0;
668
669 DRM_DEV_DEBUG_DRIVER(task->dev, "Setting buffer for task %pK\n",
670 task);
671
672 ret = exynos_drm_ipp_task_setup_buffer(src, filp);
673 if (ret) {
674 DRM_DEV_DEBUG_DRIVER(task->dev,
675 "Task %pK: src buffer setup failed\n",
676 task);
677 return ret;
678 }
679 ret = exynos_drm_ipp_task_setup_buffer(dst, filp);
680 if (ret) {
681 DRM_DEV_DEBUG_DRIVER(task->dev,
682 "Task %pK: dst buffer setup failed\n",
683 task);
684 return ret;
685 }
686
687 DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: buffers prepared.\n",
688 task);
689
690 return ret;
691}
692
693
694static int exynos_drm_ipp_event_create(struct exynos_drm_ipp_task *task,
695 struct drm_file *file_priv, uint64_t user_data)
696{
697 struct drm_pending_exynos_ipp_event *e = NULL;
698 int ret;
699
700 e = kzalloc(sizeof(*e), GFP_KERNEL);
701 if (!e)
702 return -ENOMEM;
703
704 e->event.base.type = DRM_EXYNOS_IPP_EVENT;
705 e->event.base.length = sizeof(e->event);
706 e->event.user_data = user_data;
707
708 ret = drm_event_reserve_init(task->ipp->drm_dev, file_priv, &e->base,
709 &e->event.base);
710 if (ret)
711 goto free;
712
713 task->event = e;
714 return 0;
715free:
716 kfree(e);
717 return ret;
718}
719
720static void exynos_drm_ipp_event_send(struct exynos_drm_ipp_task *task)
721{
722 struct timespec64 now;
723
724 ktime_get_ts64(&now);
725 task->event->event.tv_sec = now.tv_sec;
726 task->event->event.tv_usec = now.tv_nsec / NSEC_PER_USEC;
727 task->event->event.sequence = atomic_inc_return(&task->ipp->sequence);
728
729 drm_send_event(task->ipp->drm_dev, &task->event->base);
730}
731
732static int exynos_drm_ipp_task_cleanup(struct exynos_drm_ipp_task *task)
733{
734 int ret = task->ret;
735
736 if (ret == 0 && task->event) {
737 exynos_drm_ipp_event_send(task);
738 /* ensure event won't be canceled on task free */
739 task->event = NULL;
740 }
741
742 exynos_drm_ipp_task_free(task->ipp, task);
743 return ret;
744}
745
746static void exynos_drm_ipp_cleanup_work(struct work_struct *work)
747{
748 struct exynos_drm_ipp_task *task = container_of(work,
749 struct exynos_drm_ipp_task, cleanup_work);
750
751 exynos_drm_ipp_task_cleanup(task);
752}
753
754static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp);
755
756/**
757 * exynos_drm_ipp_task_done - finish given task and set return code
758 * @task: ipp task to finish
759 * @ret: error code or 0 if operation has been performed successfully
760 */
761void exynos_drm_ipp_task_done(struct exynos_drm_ipp_task *task, int ret)
762{
763 struct exynos_drm_ipp *ipp = task->ipp;
764 unsigned long flags;
765
766 DRM_DEV_DEBUG_DRIVER(task->dev, "ipp: %d, task %pK done: %d\n",
767 ipp->id, task, ret);
768
769 spin_lock_irqsave(&ipp->lock, flags);
770 if (ipp->task == task)
771 ipp->task = NULL;
772 task->flags |= DRM_EXYNOS_IPP_TASK_DONE;
773 task->ret = ret;
774 spin_unlock_irqrestore(&ipp->lock, flags);
775
776 exynos_drm_ipp_next_task(ipp);
777 wake_up(&ipp->done_wq);
778
779 if (task->flags & DRM_EXYNOS_IPP_TASK_ASYNC) {
780 INIT_WORK(&task->cleanup_work, exynos_drm_ipp_cleanup_work);
781 schedule_work(&task->cleanup_work);
782 }
783}
784
785static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp)
786{
787 struct exynos_drm_ipp_task *task;
788 unsigned long flags;
789 int ret;
790
791 DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, try to run new task\n",
792 ipp->id);
793
794 spin_lock_irqsave(&ipp->lock, flags);
795
796 if (ipp->task || list_empty(&ipp->todo_list)) {
797 spin_unlock_irqrestore(&ipp->lock, flags);
798 return;
799 }
800
801 task = list_first_entry(&ipp->todo_list, struct exynos_drm_ipp_task,
802 head);
803 list_del_init(&task->head);
804 ipp->task = task;
805
806 spin_unlock_irqrestore(&ipp->lock, flags);
807
808 DRM_DEV_DEBUG_DRIVER(ipp->dev,
809 "ipp: %d, selected task %pK to run\n", ipp->id,
810 task);
811
812 ret = ipp->funcs->commit(ipp, task);
813 if (ret)
814 exynos_drm_ipp_task_done(task, ret);
815}
816
817static void exynos_drm_ipp_schedule_task(struct exynos_drm_ipp *ipp,
818 struct exynos_drm_ipp_task *task)
819{
820 unsigned long flags;
821
822 spin_lock_irqsave(&ipp->lock, flags);
823 list_add(&task->head, &ipp->todo_list);
824 spin_unlock_irqrestore(&ipp->lock, flags);
825
826 exynos_drm_ipp_next_task(ipp);
827}
828
829static void exynos_drm_ipp_task_abort(struct exynos_drm_ipp *ipp,
830 struct exynos_drm_ipp_task *task)
831{
832 unsigned long flags;
833
834 spin_lock_irqsave(&ipp->lock, flags);
835 if (task->flags & DRM_EXYNOS_IPP_TASK_DONE) {
836 /* already completed task */
837 exynos_drm_ipp_task_cleanup(task);
838 } else if (ipp->task != task) {
839 /* task has not been scheduled for execution yet */
840 list_del_init(&task->head);
841 exynos_drm_ipp_task_cleanup(task);
842 } else {
843 /*
844 * currently processed task, call abort() and perform
845 * cleanup with async worker
846 */
847 task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC;
848 spin_unlock_irqrestore(&ipp->lock, flags);
849 if (ipp->funcs->abort)
850 ipp->funcs->abort(ipp, task);
851 return;
852 }
853 spin_unlock_irqrestore(&ipp->lock, flags);
854}
855
856/**
857 * exynos_drm_ipp_commit_ioctl - perform image processing operation
858 * @dev: DRM device
859 * @data: ioctl data
860 * @file_priv: DRM file info
861 *
862 * Construct a ipp task from the set of properties provided from the user
863 * and try to schedule it to framebuffer processor hardware.
864 *
865 * Called by the user via ioctl.
866 *
867 * Returns:
868 * Zero on success, negative errno on failure.
869 */
870int exynos_drm_ipp_commit_ioctl(struct drm_device *dev, void *data,
871 struct drm_file *file_priv)
872{
873 struct drm_exynos_ioctl_ipp_commit *arg = data;
874 struct exynos_drm_ipp *ipp;
875 struct exynos_drm_ipp_task *task;
876 int ret = 0;
877
878 if ((arg->flags & ~DRM_EXYNOS_IPP_FLAGS) || arg->reserved)
879 return -EINVAL;
880
881 /* can't test and expect an event at the same time */
882 if ((arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY) &&
883 (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT))
884 return -EINVAL;
885
886 ipp = __ipp_get(arg->ipp_id);
887 if (!ipp)
888 return -ENOENT;
889
890 task = exynos_drm_ipp_task_alloc(ipp);
891 if (!task)
892 return -ENOMEM;
893
894 ret = exynos_drm_ipp_task_set(task, arg);
895 if (ret)
896 goto free;
897
898 ret = exynos_drm_ipp_task_check(task);
899 if (ret)
900 goto free;
901
902 ret = exynos_drm_ipp_task_setup_buffers(task, file_priv);
903 if (ret || arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY)
904 goto free;
905
906 if (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT) {
907 ret = exynos_drm_ipp_event_create(task, file_priv,
908 arg->user_data);
909 if (ret)
910 goto free;
911 }
912
913 /*
914 * Queue task for processing on the hardware. task object will be
915 * then freed after exynos_drm_ipp_task_done()
916 */
917 if (arg->flags & DRM_EXYNOS_IPP_FLAG_NONBLOCK) {
918 DRM_DEV_DEBUG_DRIVER(ipp->dev,
919 "ipp: %d, nonblocking processing task %pK\n",
920 ipp->id, task);
921
922 task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC;
923 exynos_drm_ipp_schedule_task(task->ipp, task);
924 ret = 0;
925 } else {
926 DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, processing task %pK\n",
927 ipp->id, task);
928 exynos_drm_ipp_schedule_task(ipp, task);
929 ret = wait_event_interruptible(ipp->done_wq,
930 task->flags & DRM_EXYNOS_IPP_TASK_DONE);
931 if (ret)
932 exynos_drm_ipp_task_abort(ipp, task);
933 else
934 ret = exynos_drm_ipp_task_cleanup(task);
935 }
936 return ret;
937free:
938 exynos_drm_ipp_task_free(ipp, task);
939
940 return ret;
941}