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 
30 static int num_ipp;
31 static 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  */
48 int 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  */
82 void 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_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  */
103 int 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 
128 static 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_get_caps_ioctl - 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  */
151 int 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 
188 static 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  */
217 int 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 
251 struct drm_pending_exynos_ipp_event {
252 	struct drm_pending_event base;
253 	struct drm_exynos_ipp_event event;
254 };
255 
256 static 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 
278 static 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 
312 static 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 
346 static 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;
375 gem_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 
383 static 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 
393 static 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 
405 struct drm_ipp_limit {
406 	struct drm_exynos_ipp_limit_val h;
407 	struct drm_exynos_ipp_limit_val v;
408 };
409 
410 enum drm_ipp_size_id {
411 	IPP_LIMIT_BUFFER, IPP_LIMIT_AREA, IPP_LIMIT_ROTATED, IPP_LIMIT_MAX
412 };
413 
414 static 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 
423 static inline void __limit_set_val(unsigned int *ptr, unsigned int val)
424 {
425 	if (!*ptr)
426 		*ptr = val;
427 }
428 
429 static 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 
453 static 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 
463 static 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 
474 static 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 
505 static 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 
519 static 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 
547 static 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 
601 static 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 
663 static 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 
694 static 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;
715 free:
716 	kfree(e);
717 	return ret;
718 }
719 
720 static 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 
732 static 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 
746 static 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 
754 static 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  */
761 void 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 
785 static 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 
817 static 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 
829 static 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  */
870 int 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;
937 free:
938 	exynos_drm_ipp_task_free(ipp, task);
939 
940 	return ret;
941 }
942