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