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  */
54 struct 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  */
69 struct 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  */
88 struct 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 
98 static LIST_HEAD(exynos_drm_ippdrv_list);
99 static DEFINE_MUTEX(exynos_drm_ippdrv_lock);
100 static BLOCKING_NOTIFIER_HEAD(exynos_drm_ippnb_list);
101 
102 int 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 
111 int 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 
120 static 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 
131 static 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 
138 static 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 
149 static 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 
163 static 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 
197 static 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 
226 int 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 
279 static 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 
294 static 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 
307 static 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 
320 int 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 
441 err_free_stop:
442 	kfree(c_node->stop_work);
443 err_free_start:
444 	kfree(c_node->start_work);
445 err_remove_id:
446 	ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock, property->prop_id);
447 err_clear:
448 	kfree(c_node);
449 	return ret;
450 }
451 
452 static 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 
515 static 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 
544 static 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 
602 static 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 
621 static void ipp_free_event(struct drm_pending_event *event)
622 {
623 	kfree(event);
624 }
625 
626 static int ipp_get_event(struct drm_device *drm_dev,
627 		struct drm_exynos_ipp_cmd_node *c_node,
628 		struct drm_exynos_ipp_queue_buf *qbuf)
629 {
630 	struct drm_exynos_ipp_send_event *e;
631 	unsigned long flags;
632 
633 	DRM_DEBUG_KMS("ops_id[%d]buf_id[%d]\n", qbuf->ops_id, qbuf->buf_id);
634 
635 	e = kzalloc(sizeof(*e), GFP_KERNEL);
636 	if (!e) {
637 		spin_lock_irqsave(&drm_dev->event_lock, flags);
638 		c_node->filp->event_space += sizeof(e->event);
639 		spin_unlock_irqrestore(&drm_dev->event_lock, flags);
640 		return -ENOMEM;
641 	}
642 
643 	/* make event */
644 	e->event.base.type = DRM_EXYNOS_IPP_EVENT;
645 	e->event.base.length = sizeof(e->event);
646 	e->event.user_data = qbuf->user_data;
647 	e->event.prop_id = qbuf->prop_id;
648 	e->event.buf_id[EXYNOS_DRM_OPS_DST] = qbuf->buf_id;
649 	e->base.event = &e->event.base;
650 	e->base.file_priv = c_node->filp;
651 	e->base.destroy = ipp_free_event;
652 	mutex_lock(&c_node->event_lock);
653 	list_add_tail(&e->base.link, &c_node->event_list);
654 	mutex_unlock(&c_node->event_lock);
655 
656 	return 0;
657 }
658 
659 static void ipp_put_event(struct drm_exynos_ipp_cmd_node *c_node,
660 		struct drm_exynos_ipp_queue_buf *qbuf)
661 {
662 	struct drm_exynos_ipp_send_event *e, *te;
663 	int count = 0;
664 
665 	mutex_lock(&c_node->event_lock);
666 	list_for_each_entry_safe(e, te, &c_node->event_list, base.link) {
667 		DRM_DEBUG_KMS("count[%d]e[%p]\n", count++, e);
668 
669 		/*
670 		 * qbuf == NULL condition means all event deletion.
671 		 * stop operations want to delete all event list.
672 		 * another case delete only same buf id.
673 		 */
674 		if (!qbuf) {
675 			/* delete list */
676 			list_del(&e->base.link);
677 			kfree(e);
678 		}
679 
680 		/* compare buffer id */
681 		if (qbuf && (qbuf->buf_id ==
682 		    e->event.buf_id[EXYNOS_DRM_OPS_DST])) {
683 			/* delete list */
684 			list_del(&e->base.link);
685 			kfree(e);
686 			goto out_unlock;
687 		}
688 	}
689 
690 out_unlock:
691 	mutex_unlock(&c_node->event_lock);
692 	return;
693 }
694 
695 static void ipp_clean_cmd_node(struct ipp_context *ctx,
696 				struct drm_exynos_ipp_cmd_node *c_node)
697 {
698 	int i;
699 
700 	/* cancel works */
701 	cancel_work_sync(&c_node->start_work->work);
702 	cancel_work_sync(&c_node->stop_work->work);
703 	cancel_work_sync(&c_node->event_work->work);
704 
705 	/* put event */
706 	ipp_put_event(c_node, NULL);
707 
708 	for_each_ipp_ops(i)
709 		ipp_clean_mem_nodes(ctx->subdrv.drm_dev, c_node, i);
710 
711 	/* delete list */
712 	list_del(&c_node->list);
713 
714 	ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock,
715 			c_node->property.prop_id);
716 
717 	/* destroy mutex */
718 	mutex_destroy(&c_node->lock);
719 	mutex_destroy(&c_node->mem_lock);
720 	mutex_destroy(&c_node->event_lock);
721 
722 	/* free command node */
723 	kfree(c_node->start_work);
724 	kfree(c_node->stop_work);
725 	kfree(c_node->event_work);
726 	kfree(c_node);
727 }
728 
729 static bool ipp_check_mem_list(struct drm_exynos_ipp_cmd_node *c_node)
730 {
731 	switch (c_node->property.cmd) {
732 	case IPP_CMD_WB:
733 		return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]);
734 	case IPP_CMD_OUTPUT:
735 		return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]);
736 	case IPP_CMD_M2M:
737 	default:
738 		return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]) &&
739 		       !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]);
740 	}
741 }
742 
743 static struct drm_exynos_ipp_mem_node
744 		*ipp_find_mem_node(struct drm_exynos_ipp_cmd_node *c_node,
745 		struct drm_exynos_ipp_queue_buf *qbuf)
746 {
747 	struct drm_exynos_ipp_mem_node *m_node;
748 	struct list_head *head;
749 	int count = 0;
750 
751 	DRM_DEBUG_KMS("buf_id[%d]\n", qbuf->buf_id);
752 
753 	/* source/destination memory list */
754 	head = &c_node->mem_list[qbuf->ops_id];
755 
756 	/* find memory node from memory list */
757 	list_for_each_entry(m_node, head, list) {
758 		DRM_DEBUG_KMS("count[%d]m_node[%p]\n", count++, m_node);
759 
760 		/* compare buffer id */
761 		if (m_node->buf_id == qbuf->buf_id)
762 			return m_node;
763 	}
764 
765 	return NULL;
766 }
767 
768 static int ipp_set_mem_node(struct exynos_drm_ippdrv *ippdrv,
769 		struct drm_exynos_ipp_cmd_node *c_node,
770 		struct drm_exynos_ipp_mem_node *m_node)
771 {
772 	struct exynos_drm_ipp_ops *ops = NULL;
773 	int ret = 0;
774 
775 	DRM_DEBUG_KMS("node[%p]\n", m_node);
776 
777 	if (!m_node) {
778 		DRM_ERROR("invalid queue node.\n");
779 		return -EFAULT;
780 	}
781 
782 	DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id);
783 
784 	/* get operations callback */
785 	ops = ippdrv->ops[m_node->ops_id];
786 	if (!ops) {
787 		DRM_ERROR("not support ops.\n");
788 		return -EFAULT;
789 	}
790 
791 	/* set address and enable irq */
792 	if (ops->set_addr) {
793 		ret = ops->set_addr(ippdrv->dev, &m_node->buf_info,
794 			m_node->buf_id, IPP_BUF_ENQUEUE);
795 		if (ret) {
796 			DRM_ERROR("failed to set addr.\n");
797 			return ret;
798 		}
799 	}
800 
801 	return ret;
802 }
803 
804 static void ipp_handle_cmd_work(struct device *dev,
805 		struct exynos_drm_ippdrv *ippdrv,
806 		struct drm_exynos_ipp_cmd_work *cmd_work,
807 		struct drm_exynos_ipp_cmd_node *c_node)
808 {
809 	struct ipp_context *ctx = get_ipp_context(dev);
810 
811 	cmd_work->ippdrv = ippdrv;
812 	cmd_work->c_node = c_node;
813 	queue_work(ctx->cmd_workq, &cmd_work->work);
814 }
815 
816 static int ipp_queue_buf_with_run(struct device *dev,
817 		struct drm_exynos_ipp_cmd_node *c_node,
818 		struct drm_exynos_ipp_mem_node *m_node,
819 		struct drm_exynos_ipp_queue_buf *qbuf)
820 {
821 	struct exynos_drm_ippdrv *ippdrv;
822 	struct drm_exynos_ipp_property *property;
823 	struct exynos_drm_ipp_ops *ops;
824 	int ret;
825 
826 	ippdrv = ipp_find_drv_by_handle(qbuf->prop_id);
827 	if (IS_ERR(ippdrv)) {
828 		DRM_ERROR("failed to get ipp driver.\n");
829 		return -EFAULT;
830 	}
831 
832 	ops = ippdrv->ops[qbuf->ops_id];
833 	if (!ops) {
834 		DRM_ERROR("failed to get ops.\n");
835 		return -EFAULT;
836 	}
837 
838 	property = &c_node->property;
839 
840 	if (c_node->state != IPP_STATE_START) {
841 		DRM_DEBUG_KMS("bypass for invalid state.\n");
842 		return 0;
843 	}
844 
845 	mutex_lock(&c_node->mem_lock);
846 	if (!ipp_check_mem_list(c_node)) {
847 		mutex_unlock(&c_node->mem_lock);
848 		DRM_DEBUG_KMS("empty memory.\n");
849 		return 0;
850 	}
851 
852 	/*
853 	 * If set destination buffer and enabled clock,
854 	 * then m2m operations need start operations at queue_buf
855 	 */
856 	if (ipp_is_m2m_cmd(property->cmd)) {
857 		struct drm_exynos_ipp_cmd_work *cmd_work = c_node->start_work;
858 
859 		cmd_work->ctrl = IPP_CTRL_PLAY;
860 		ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
861 	} else {
862 		ret = ipp_set_mem_node(ippdrv, c_node, m_node);
863 		if (ret) {
864 			mutex_unlock(&c_node->mem_lock);
865 			DRM_ERROR("failed to set m node.\n");
866 			return ret;
867 		}
868 	}
869 	mutex_unlock(&c_node->mem_lock);
870 
871 	return 0;
872 }
873 
874 static void ipp_clean_queue_buf(struct drm_device *drm_dev,
875 		struct drm_exynos_ipp_cmd_node *c_node,
876 		struct drm_exynos_ipp_queue_buf *qbuf)
877 {
878 	struct drm_exynos_ipp_mem_node *m_node, *tm_node;
879 
880 	/* delete list */
881 	mutex_lock(&c_node->mem_lock);
882 	list_for_each_entry_safe(m_node, tm_node,
883 		&c_node->mem_list[qbuf->ops_id], list) {
884 		if (m_node->buf_id == qbuf->buf_id &&
885 		    m_node->ops_id == qbuf->ops_id)
886 			ipp_put_mem_node(drm_dev, c_node, m_node);
887 	}
888 	mutex_unlock(&c_node->mem_lock);
889 }
890 
891 int exynos_drm_ipp_queue_buf(struct drm_device *drm_dev, void *data,
892 		struct drm_file *file)
893 {
894 	struct drm_exynos_file_private *file_priv = file->driver_priv;
895 	struct device *dev = file_priv->ipp_dev;
896 	struct ipp_context *ctx = get_ipp_context(dev);
897 	struct drm_exynos_ipp_queue_buf *qbuf = data;
898 	struct drm_exynos_ipp_cmd_node *c_node;
899 	struct drm_exynos_ipp_mem_node *m_node;
900 	int ret;
901 
902 	if (!qbuf) {
903 		DRM_ERROR("invalid buf parameter.\n");
904 		return -EINVAL;
905 	}
906 
907 	if (qbuf->ops_id >= EXYNOS_DRM_OPS_MAX) {
908 		DRM_ERROR("invalid ops parameter.\n");
909 		return -EINVAL;
910 	}
911 
912 	DRM_DEBUG_KMS("prop_id[%d]ops_id[%s]buf_id[%d]buf_type[%d]\n",
913 		qbuf->prop_id, qbuf->ops_id ? "dst" : "src",
914 		qbuf->buf_id, qbuf->buf_type);
915 
916 	/* find command node */
917 	c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock,
918 		qbuf->prop_id);
919 	if (!c_node || c_node->filp != file) {
920 		DRM_ERROR("failed to get command node.\n");
921 		return -ENODEV;
922 	}
923 
924 	/* buffer control */
925 	switch (qbuf->buf_type) {
926 	case IPP_BUF_ENQUEUE:
927 		/* get memory node */
928 		m_node = ipp_get_mem_node(drm_dev, c_node, qbuf);
929 		if (IS_ERR(m_node)) {
930 			DRM_ERROR("failed to get m_node.\n");
931 			return PTR_ERR(m_node);
932 		}
933 
934 		/*
935 		 * first step get event for destination buffer.
936 		 * and second step when M2M case run with destination buffer
937 		 * if needed.
938 		 */
939 		if (qbuf->ops_id == EXYNOS_DRM_OPS_DST) {
940 			/* get event for destination buffer */
941 			ret = ipp_get_event(drm_dev, c_node, qbuf);
942 			if (ret) {
943 				DRM_ERROR("failed to get event.\n");
944 				goto err_clean_node;
945 			}
946 
947 			/*
948 			 * M2M case run play control for streaming feature.
949 			 * other case set address and waiting.
950 			 */
951 			ret = ipp_queue_buf_with_run(dev, c_node, m_node, qbuf);
952 			if (ret) {
953 				DRM_ERROR("failed to run command.\n");
954 				goto err_clean_node;
955 			}
956 		}
957 		break;
958 	case IPP_BUF_DEQUEUE:
959 		mutex_lock(&c_node->lock);
960 
961 		/* put event for destination buffer */
962 		if (qbuf->ops_id == EXYNOS_DRM_OPS_DST)
963 			ipp_put_event(c_node, qbuf);
964 
965 		ipp_clean_queue_buf(drm_dev, c_node, qbuf);
966 
967 		mutex_unlock(&c_node->lock);
968 		break;
969 	default:
970 		DRM_ERROR("invalid buffer control.\n");
971 		return -EINVAL;
972 	}
973 
974 	return 0;
975 
976 err_clean_node:
977 	DRM_ERROR("clean memory nodes.\n");
978 
979 	ipp_clean_queue_buf(drm_dev, c_node, qbuf);
980 	return ret;
981 }
982 
983 static bool exynos_drm_ipp_check_valid(struct device *dev,
984 		enum drm_exynos_ipp_ctrl ctrl, enum drm_exynos_ipp_state state)
985 {
986 	if (ctrl != IPP_CTRL_PLAY) {
987 		if (pm_runtime_suspended(dev)) {
988 			DRM_ERROR("pm:runtime_suspended.\n");
989 			goto err_status;
990 		}
991 	}
992 
993 	switch (ctrl) {
994 	case IPP_CTRL_PLAY:
995 		if (state != IPP_STATE_IDLE)
996 			goto err_status;
997 		break;
998 	case IPP_CTRL_STOP:
999 		if (state == IPP_STATE_STOP)
1000 			goto err_status;
1001 		break;
1002 	case IPP_CTRL_PAUSE:
1003 		if (state != IPP_STATE_START)
1004 			goto err_status;
1005 		break;
1006 	case IPP_CTRL_RESUME:
1007 		if (state != IPP_STATE_STOP)
1008 			goto err_status;
1009 		break;
1010 	default:
1011 		DRM_ERROR("invalid state.\n");
1012 		goto err_status;
1013 	}
1014 
1015 	return true;
1016 
1017 err_status:
1018 	DRM_ERROR("invalid status:ctrl[%d]state[%d]\n", ctrl, state);
1019 	return false;
1020 }
1021 
1022 int exynos_drm_ipp_cmd_ctrl(struct drm_device *drm_dev, void *data,
1023 		struct drm_file *file)
1024 {
1025 	struct drm_exynos_file_private *file_priv = file->driver_priv;
1026 	struct exynos_drm_ippdrv *ippdrv = NULL;
1027 	struct device *dev = file_priv->ipp_dev;
1028 	struct ipp_context *ctx = get_ipp_context(dev);
1029 	struct drm_exynos_ipp_cmd_ctrl *cmd_ctrl = data;
1030 	struct drm_exynos_ipp_cmd_work *cmd_work;
1031 	struct drm_exynos_ipp_cmd_node *c_node;
1032 
1033 	if (!ctx) {
1034 		DRM_ERROR("invalid context.\n");
1035 		return -EINVAL;
1036 	}
1037 
1038 	if (!cmd_ctrl) {
1039 		DRM_ERROR("invalid control parameter.\n");
1040 		return -EINVAL;
1041 	}
1042 
1043 	DRM_DEBUG_KMS("ctrl[%d]prop_id[%d]\n",
1044 		cmd_ctrl->ctrl, cmd_ctrl->prop_id);
1045 
1046 	ippdrv = ipp_find_drv_by_handle(cmd_ctrl->prop_id);
1047 	if (IS_ERR(ippdrv)) {
1048 		DRM_ERROR("failed to get ipp driver.\n");
1049 		return PTR_ERR(ippdrv);
1050 	}
1051 
1052 	c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock,
1053 		cmd_ctrl->prop_id);
1054 	if (!c_node || c_node->filp != file) {
1055 		DRM_ERROR("invalid command node list.\n");
1056 		return -ENODEV;
1057 	}
1058 
1059 	if (!exynos_drm_ipp_check_valid(ippdrv->dev, cmd_ctrl->ctrl,
1060 	    c_node->state)) {
1061 		DRM_ERROR("invalid state.\n");
1062 		return -EINVAL;
1063 	}
1064 
1065 	switch (cmd_ctrl->ctrl) {
1066 	case IPP_CTRL_PLAY:
1067 		if (pm_runtime_suspended(ippdrv->dev))
1068 			pm_runtime_get_sync(ippdrv->dev);
1069 
1070 		c_node->state = IPP_STATE_START;
1071 
1072 		cmd_work = c_node->start_work;
1073 		cmd_work->ctrl = cmd_ctrl->ctrl;
1074 		ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1075 		break;
1076 	case IPP_CTRL_STOP:
1077 		cmd_work = c_node->stop_work;
1078 		cmd_work->ctrl = cmd_ctrl->ctrl;
1079 		ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1080 
1081 		if (!wait_for_completion_timeout(&c_node->stop_complete,
1082 		    msecs_to_jiffies(300))) {
1083 			DRM_ERROR("timeout stop:prop_id[%d]\n",
1084 				c_node->property.prop_id);
1085 		}
1086 
1087 		c_node->state = IPP_STATE_STOP;
1088 		ippdrv->dedicated = false;
1089 		mutex_lock(&ippdrv->cmd_lock);
1090 		ipp_clean_cmd_node(ctx, c_node);
1091 
1092 		if (list_empty(&ippdrv->cmd_list))
1093 			pm_runtime_put_sync(ippdrv->dev);
1094 		mutex_unlock(&ippdrv->cmd_lock);
1095 		break;
1096 	case IPP_CTRL_PAUSE:
1097 		cmd_work = c_node->stop_work;
1098 		cmd_work->ctrl = cmd_ctrl->ctrl;
1099 		ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1100 
1101 		if (!wait_for_completion_timeout(&c_node->stop_complete,
1102 		    msecs_to_jiffies(200))) {
1103 			DRM_ERROR("timeout stop:prop_id[%d]\n",
1104 				c_node->property.prop_id);
1105 		}
1106 
1107 		c_node->state = IPP_STATE_STOP;
1108 		break;
1109 	case IPP_CTRL_RESUME:
1110 		c_node->state = IPP_STATE_START;
1111 		cmd_work = c_node->start_work;
1112 		cmd_work->ctrl = cmd_ctrl->ctrl;
1113 		ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1114 		break;
1115 	default:
1116 		DRM_ERROR("could not support this state currently.\n");
1117 		return -EINVAL;
1118 	}
1119 
1120 	DRM_DEBUG_KMS("done ctrl[%d]prop_id[%d]\n",
1121 		cmd_ctrl->ctrl, cmd_ctrl->prop_id);
1122 
1123 	return 0;
1124 }
1125 
1126 int exynos_drm_ippnb_register(struct notifier_block *nb)
1127 {
1128 	return blocking_notifier_chain_register(
1129 		&exynos_drm_ippnb_list, nb);
1130 }
1131 
1132 int exynos_drm_ippnb_unregister(struct notifier_block *nb)
1133 {
1134 	return blocking_notifier_chain_unregister(
1135 		&exynos_drm_ippnb_list, nb);
1136 }
1137 
1138 int exynos_drm_ippnb_send_event(unsigned long val, void *v)
1139 {
1140 	return blocking_notifier_call_chain(
1141 		&exynos_drm_ippnb_list, val, v);
1142 }
1143 
1144 static int ipp_set_property(struct exynos_drm_ippdrv *ippdrv,
1145 		struct drm_exynos_ipp_property *property)
1146 {
1147 	struct exynos_drm_ipp_ops *ops = NULL;
1148 	bool swap = false;
1149 	int ret, i;
1150 
1151 	if (!property) {
1152 		DRM_ERROR("invalid property parameter.\n");
1153 		return -EINVAL;
1154 	}
1155 
1156 	DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1157 
1158 	/* reset h/w block */
1159 	if (ippdrv->reset &&
1160 	    ippdrv->reset(ippdrv->dev)) {
1161 		return -EINVAL;
1162 	}
1163 
1164 	/* set source,destination operations */
1165 	for_each_ipp_ops(i) {
1166 		struct drm_exynos_ipp_config *config =
1167 			&property->config[i];
1168 
1169 		ops = ippdrv->ops[i];
1170 		if (!ops || !config) {
1171 			DRM_ERROR("not support ops and config.\n");
1172 			return -EINVAL;
1173 		}
1174 
1175 		/* set format */
1176 		if (ops->set_fmt) {
1177 			ret = ops->set_fmt(ippdrv->dev, config->fmt);
1178 			if (ret)
1179 				return ret;
1180 		}
1181 
1182 		/* set transform for rotation, flip */
1183 		if (ops->set_transf) {
1184 			ret = ops->set_transf(ippdrv->dev, config->degree,
1185 				config->flip, &swap);
1186 			if (ret)
1187 				return ret;
1188 		}
1189 
1190 		/* set size */
1191 		if (ops->set_size) {
1192 			ret = ops->set_size(ippdrv->dev, swap, &config->pos,
1193 				&config->sz);
1194 			if (ret)
1195 				return ret;
1196 		}
1197 	}
1198 
1199 	return 0;
1200 }
1201 
1202 static int ipp_start_property(struct exynos_drm_ippdrv *ippdrv,
1203 		struct drm_exynos_ipp_cmd_node *c_node)
1204 {
1205 	struct drm_exynos_ipp_mem_node *m_node;
1206 	struct drm_exynos_ipp_property *property = &c_node->property;
1207 	struct list_head *head;
1208 	int ret, i;
1209 
1210 	DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1211 
1212 	/* store command info in ippdrv */
1213 	ippdrv->c_node = c_node;
1214 
1215 	mutex_lock(&c_node->mem_lock);
1216 	if (!ipp_check_mem_list(c_node)) {
1217 		DRM_DEBUG_KMS("empty memory.\n");
1218 		ret = -ENOMEM;
1219 		goto err_unlock;
1220 	}
1221 
1222 	/* set current property in ippdrv */
1223 	ret = ipp_set_property(ippdrv, property);
1224 	if (ret) {
1225 		DRM_ERROR("failed to set property.\n");
1226 		ippdrv->c_node = NULL;
1227 		goto err_unlock;
1228 	}
1229 
1230 	/* check command */
1231 	switch (property->cmd) {
1232 	case IPP_CMD_M2M:
1233 		for_each_ipp_ops(i) {
1234 			/* source/destination memory list */
1235 			head = &c_node->mem_list[i];
1236 
1237 			m_node = list_first_entry(head,
1238 				struct drm_exynos_ipp_mem_node, list);
1239 
1240 			DRM_DEBUG_KMS("m_node[%p]\n", m_node);
1241 
1242 			ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1243 			if (ret) {
1244 				DRM_ERROR("failed to set m node.\n");
1245 				goto err_unlock;
1246 			}
1247 		}
1248 		break;
1249 	case IPP_CMD_WB:
1250 		/* destination memory list */
1251 		head = &c_node->mem_list[EXYNOS_DRM_OPS_DST];
1252 
1253 		list_for_each_entry(m_node, head, list) {
1254 			ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1255 			if (ret) {
1256 				DRM_ERROR("failed to set m node.\n");
1257 				goto err_unlock;
1258 			}
1259 		}
1260 		break;
1261 	case IPP_CMD_OUTPUT:
1262 		/* source memory list */
1263 		head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC];
1264 
1265 		list_for_each_entry(m_node, head, list) {
1266 			ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1267 			if (ret) {
1268 				DRM_ERROR("failed to set m node.\n");
1269 				goto err_unlock;
1270 			}
1271 		}
1272 		break;
1273 	default:
1274 		DRM_ERROR("invalid operations.\n");
1275 		ret = -EINVAL;
1276 		goto err_unlock;
1277 	}
1278 	mutex_unlock(&c_node->mem_lock);
1279 
1280 	DRM_DEBUG_KMS("cmd[%d]\n", property->cmd);
1281 
1282 	/* start operations */
1283 	if (ippdrv->start) {
1284 		ret = ippdrv->start(ippdrv->dev, property->cmd);
1285 		if (ret) {
1286 			DRM_ERROR("failed to start ops.\n");
1287 			ippdrv->c_node = NULL;
1288 			return ret;
1289 		}
1290 	}
1291 
1292 	return 0;
1293 
1294 err_unlock:
1295 	mutex_unlock(&c_node->mem_lock);
1296 	ippdrv->c_node = NULL;
1297 	return ret;
1298 }
1299 
1300 static int ipp_stop_property(struct drm_device *drm_dev,
1301 		struct exynos_drm_ippdrv *ippdrv,
1302 		struct drm_exynos_ipp_cmd_node *c_node)
1303 {
1304 	struct drm_exynos_ipp_property *property = &c_node->property;
1305 	int i;
1306 
1307 	DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1308 
1309 	/* stop operations */
1310 	if (ippdrv->stop)
1311 		ippdrv->stop(ippdrv->dev, property->cmd);
1312 
1313 	/* check command */
1314 	switch (property->cmd) {
1315 	case IPP_CMD_M2M:
1316 		for_each_ipp_ops(i)
1317 			ipp_clean_mem_nodes(drm_dev, c_node, i);
1318 		break;
1319 	case IPP_CMD_WB:
1320 		ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_DST);
1321 		break;
1322 	case IPP_CMD_OUTPUT:
1323 		ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_SRC);
1324 		break;
1325 	default:
1326 		DRM_ERROR("invalid operations.\n");
1327 		return -EINVAL;
1328 	}
1329 
1330 	return 0;
1331 }
1332 
1333 void ipp_sched_cmd(struct work_struct *work)
1334 {
1335 	struct drm_exynos_ipp_cmd_work *cmd_work =
1336 		container_of(work, struct drm_exynos_ipp_cmd_work, work);
1337 	struct exynos_drm_ippdrv *ippdrv;
1338 	struct drm_exynos_ipp_cmd_node *c_node;
1339 	struct drm_exynos_ipp_property *property;
1340 	int ret;
1341 
1342 	ippdrv = cmd_work->ippdrv;
1343 	if (!ippdrv) {
1344 		DRM_ERROR("invalid ippdrv list.\n");
1345 		return;
1346 	}
1347 
1348 	c_node = cmd_work->c_node;
1349 	if (!c_node) {
1350 		DRM_ERROR("invalid command node list.\n");
1351 		return;
1352 	}
1353 
1354 	mutex_lock(&c_node->lock);
1355 
1356 	property = &c_node->property;
1357 
1358 	switch (cmd_work->ctrl) {
1359 	case IPP_CTRL_PLAY:
1360 	case IPP_CTRL_RESUME:
1361 		ret = ipp_start_property(ippdrv, c_node);
1362 		if (ret) {
1363 			DRM_ERROR("failed to start property:prop_id[%d]\n",
1364 				c_node->property.prop_id);
1365 			goto err_unlock;
1366 		}
1367 
1368 		/*
1369 		 * M2M case supports wait_completion of transfer.
1370 		 * because M2M case supports single unit operation
1371 		 * with multiple queue.
1372 		 * M2M need to wait completion of data transfer.
1373 		 */
1374 		if (ipp_is_m2m_cmd(property->cmd)) {
1375 			if (!wait_for_completion_timeout
1376 			    (&c_node->start_complete, msecs_to_jiffies(200))) {
1377 				DRM_ERROR("timeout event:prop_id[%d]\n",
1378 					c_node->property.prop_id);
1379 				goto err_unlock;
1380 			}
1381 		}
1382 		break;
1383 	case IPP_CTRL_STOP:
1384 	case IPP_CTRL_PAUSE:
1385 		ret = ipp_stop_property(ippdrv->drm_dev, ippdrv,
1386 			c_node);
1387 		if (ret) {
1388 			DRM_ERROR("failed to stop property.\n");
1389 			goto err_unlock;
1390 		}
1391 
1392 		complete(&c_node->stop_complete);
1393 		break;
1394 	default:
1395 		DRM_ERROR("unknown control type\n");
1396 		break;
1397 	}
1398 
1399 	DRM_DEBUG_KMS("ctrl[%d] done.\n", cmd_work->ctrl);
1400 
1401 err_unlock:
1402 	mutex_unlock(&c_node->lock);
1403 }
1404 
1405 static int ipp_send_event(struct exynos_drm_ippdrv *ippdrv,
1406 		struct drm_exynos_ipp_cmd_node *c_node, int *buf_id)
1407 {
1408 	struct drm_device *drm_dev = ippdrv->drm_dev;
1409 	struct drm_exynos_ipp_property *property = &c_node->property;
1410 	struct drm_exynos_ipp_mem_node *m_node;
1411 	struct drm_exynos_ipp_queue_buf qbuf;
1412 	struct drm_exynos_ipp_send_event *e;
1413 	struct list_head *head;
1414 	struct timeval now;
1415 	unsigned long flags;
1416 	u32 tbuf_id[EXYNOS_DRM_OPS_MAX] = {0, };
1417 	int ret, i;
1418 
1419 	for_each_ipp_ops(i)
1420 		DRM_DEBUG_KMS("%s buf_id[%d]\n", i ? "dst" : "src", buf_id[i]);
1421 
1422 	if (!drm_dev) {
1423 		DRM_ERROR("failed to get drm_dev.\n");
1424 		return -EINVAL;
1425 	}
1426 
1427 	if (!property) {
1428 		DRM_ERROR("failed to get property.\n");
1429 		return -EINVAL;
1430 	}
1431 
1432 	mutex_lock(&c_node->event_lock);
1433 	if (list_empty(&c_node->event_list)) {
1434 		DRM_DEBUG_KMS("event list is empty.\n");
1435 		ret = 0;
1436 		goto err_event_unlock;
1437 	}
1438 
1439 	mutex_lock(&c_node->mem_lock);
1440 	if (!ipp_check_mem_list(c_node)) {
1441 		DRM_DEBUG_KMS("empty memory.\n");
1442 		ret = 0;
1443 		goto err_mem_unlock;
1444 	}
1445 
1446 	/* check command */
1447 	switch (property->cmd) {
1448 	case IPP_CMD_M2M:
1449 		for_each_ipp_ops(i) {
1450 			/* source/destination memory list */
1451 			head = &c_node->mem_list[i];
1452 
1453 			m_node = list_first_entry(head,
1454 				struct drm_exynos_ipp_mem_node, list);
1455 
1456 			tbuf_id[i] = m_node->buf_id;
1457 			DRM_DEBUG_KMS("%s buf_id[%d]\n",
1458 				i ? "dst" : "src", tbuf_id[i]);
1459 
1460 			ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1461 			if (ret)
1462 				DRM_ERROR("failed to put m_node.\n");
1463 		}
1464 		break;
1465 	case IPP_CMD_WB:
1466 		/* clear buf for finding */
1467 		memset(&qbuf, 0x0, sizeof(qbuf));
1468 		qbuf.ops_id = EXYNOS_DRM_OPS_DST;
1469 		qbuf.buf_id = buf_id[EXYNOS_DRM_OPS_DST];
1470 
1471 		/* get memory node entry */
1472 		m_node = ipp_find_mem_node(c_node, &qbuf);
1473 		if (!m_node) {
1474 			DRM_ERROR("empty memory node.\n");
1475 			ret = -ENOMEM;
1476 			goto err_mem_unlock;
1477 		}
1478 
1479 		tbuf_id[EXYNOS_DRM_OPS_DST] = m_node->buf_id;
1480 
1481 		ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1482 		if (ret)
1483 			DRM_ERROR("failed to put m_node.\n");
1484 		break;
1485 	case IPP_CMD_OUTPUT:
1486 		/* source memory list */
1487 		head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC];
1488 
1489 		m_node = list_first_entry(head,
1490 			struct drm_exynos_ipp_mem_node, list);
1491 
1492 		tbuf_id[EXYNOS_DRM_OPS_SRC] = m_node->buf_id;
1493 
1494 		ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1495 		if (ret)
1496 			DRM_ERROR("failed to put m_node.\n");
1497 		break;
1498 	default:
1499 		DRM_ERROR("invalid operations.\n");
1500 		ret = -EINVAL;
1501 		goto err_mem_unlock;
1502 	}
1503 	mutex_unlock(&c_node->mem_lock);
1504 
1505 	if (tbuf_id[EXYNOS_DRM_OPS_DST] != buf_id[EXYNOS_DRM_OPS_DST])
1506 		DRM_ERROR("failed to match buf_id[%d %d]prop_id[%d]\n",
1507 			tbuf_id[1], buf_id[1], property->prop_id);
1508 
1509 	/*
1510 	 * command node have event list of destination buffer
1511 	 * If destination buffer enqueue to mem list,
1512 	 * then we make event and link to event list tail.
1513 	 * so, we get first event for first enqueued buffer.
1514 	 */
1515 	e = list_first_entry(&c_node->event_list,
1516 		struct drm_exynos_ipp_send_event, base.link);
1517 
1518 	do_gettimeofday(&now);
1519 	DRM_DEBUG_KMS("tv_sec[%ld]tv_usec[%ld]\n", now.tv_sec, now.tv_usec);
1520 	e->event.tv_sec = now.tv_sec;
1521 	e->event.tv_usec = now.tv_usec;
1522 	e->event.prop_id = property->prop_id;
1523 
1524 	/* set buffer id about source destination */
1525 	for_each_ipp_ops(i)
1526 		e->event.buf_id[i] = tbuf_id[i];
1527 
1528 	spin_lock_irqsave(&drm_dev->event_lock, flags);
1529 	list_move_tail(&e->base.link, &e->base.file_priv->event_list);
1530 	wake_up_interruptible(&e->base.file_priv->event_wait);
1531 	spin_unlock_irqrestore(&drm_dev->event_lock, flags);
1532 	mutex_unlock(&c_node->event_lock);
1533 
1534 	DRM_DEBUG_KMS("done cmd[%d]prop_id[%d]buf_id[%d]\n",
1535 		property->cmd, property->prop_id, tbuf_id[EXYNOS_DRM_OPS_DST]);
1536 
1537 	return 0;
1538 
1539 err_mem_unlock:
1540 	mutex_unlock(&c_node->mem_lock);
1541 err_event_unlock:
1542 	mutex_unlock(&c_node->event_lock);
1543 	return ret;
1544 }
1545 
1546 void ipp_sched_event(struct work_struct *work)
1547 {
1548 	struct drm_exynos_ipp_event_work *event_work =
1549 		container_of(work, struct drm_exynos_ipp_event_work, work);
1550 	struct exynos_drm_ippdrv *ippdrv;
1551 	struct drm_exynos_ipp_cmd_node *c_node;
1552 	int ret;
1553 
1554 	if (!event_work) {
1555 		DRM_ERROR("failed to get event_work.\n");
1556 		return;
1557 	}
1558 
1559 	DRM_DEBUG_KMS("buf_id[%d]\n", event_work->buf_id[EXYNOS_DRM_OPS_DST]);
1560 
1561 	ippdrv = event_work->ippdrv;
1562 	if (!ippdrv) {
1563 		DRM_ERROR("failed to get ipp driver.\n");
1564 		return;
1565 	}
1566 
1567 	c_node = ippdrv->c_node;
1568 	if (!c_node) {
1569 		DRM_ERROR("failed to get command node.\n");
1570 		return;
1571 	}
1572 
1573 	/*
1574 	 * IPP supports command thread, event thread synchronization.
1575 	 * If IPP close immediately from user land, then IPP make
1576 	 * synchronization with command thread, so make complete event.
1577 	 * or going out operations.
1578 	 */
1579 	if (c_node->state != IPP_STATE_START) {
1580 		DRM_DEBUG_KMS("bypass state[%d]prop_id[%d]\n",
1581 			c_node->state, c_node->property.prop_id);
1582 		goto err_completion;
1583 	}
1584 
1585 	ret = ipp_send_event(ippdrv, c_node, event_work->buf_id);
1586 	if (ret) {
1587 		DRM_ERROR("failed to send event.\n");
1588 		goto err_completion;
1589 	}
1590 
1591 err_completion:
1592 	if (ipp_is_m2m_cmd(c_node->property.cmd))
1593 		complete(&c_node->start_complete);
1594 }
1595 
1596 static int ipp_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
1597 {
1598 	struct ipp_context *ctx = get_ipp_context(dev);
1599 	struct exynos_drm_ippdrv *ippdrv;
1600 	int ret, count = 0;
1601 
1602 	/* get ipp driver entry */
1603 	list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
1604 		ippdrv->drm_dev = drm_dev;
1605 
1606 		ret = ipp_create_id(&ctx->ipp_idr, &ctx->ipp_lock, ippdrv);
1607 		if (ret < 0) {
1608 			DRM_ERROR("failed to create id.\n");
1609 			goto err;
1610 		}
1611 		ippdrv->prop_list.ipp_id = ret;
1612 
1613 		DRM_DEBUG_KMS("count[%d]ippdrv[%p]ipp_id[%d]\n",
1614 			count++, ippdrv, ret);
1615 
1616 		/* store parent device for node */
1617 		ippdrv->parent_dev = dev;
1618 
1619 		/* store event work queue and handler */
1620 		ippdrv->event_workq = ctx->event_workq;
1621 		ippdrv->sched_event = ipp_sched_event;
1622 		INIT_LIST_HEAD(&ippdrv->cmd_list);
1623 		mutex_init(&ippdrv->cmd_lock);
1624 
1625 		ret = drm_iommu_attach_device(drm_dev, ippdrv->dev);
1626 		if (ret) {
1627 			DRM_ERROR("failed to activate iommu\n");
1628 			goto err;
1629 		}
1630 	}
1631 
1632 	return 0;
1633 
1634 err:
1635 	/* get ipp driver entry */
1636 	list_for_each_entry_continue_reverse(ippdrv, &exynos_drm_ippdrv_list,
1637 						drv_list) {
1638 		drm_iommu_detach_device(drm_dev, ippdrv->dev);
1639 
1640 		ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock,
1641 				ippdrv->prop_list.ipp_id);
1642 	}
1643 
1644 	return ret;
1645 }
1646 
1647 static void ipp_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
1648 {
1649 	struct exynos_drm_ippdrv *ippdrv, *t;
1650 	struct ipp_context *ctx = get_ipp_context(dev);
1651 
1652 	/* get ipp driver entry */
1653 	list_for_each_entry_safe(ippdrv, t, &exynos_drm_ippdrv_list, drv_list) {
1654 		drm_iommu_detach_device(drm_dev, ippdrv->dev);
1655 
1656 		ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock,
1657 				ippdrv->prop_list.ipp_id);
1658 
1659 		ippdrv->drm_dev = NULL;
1660 		exynos_drm_ippdrv_unregister(ippdrv);
1661 	}
1662 }
1663 
1664 static int ipp_subdrv_open(struct drm_device *drm_dev, struct device *dev,
1665 		struct drm_file *file)
1666 {
1667 	struct drm_exynos_file_private *file_priv = file->driver_priv;
1668 
1669 	file_priv->ipp_dev = dev;
1670 
1671 	DRM_DEBUG_KMS("done priv[%p]\n", dev);
1672 
1673 	return 0;
1674 }
1675 
1676 static void ipp_subdrv_close(struct drm_device *drm_dev, struct device *dev,
1677 		struct drm_file *file)
1678 {
1679 	struct exynos_drm_ippdrv *ippdrv = NULL;
1680 	struct ipp_context *ctx = get_ipp_context(dev);
1681 	struct drm_exynos_ipp_cmd_node *c_node, *tc_node;
1682 	int count = 0;
1683 
1684 	list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
1685 		mutex_lock(&ippdrv->cmd_lock);
1686 		list_for_each_entry_safe(c_node, tc_node,
1687 			&ippdrv->cmd_list, list) {
1688 			DRM_DEBUG_KMS("count[%d]ippdrv[%p]\n",
1689 				count++, ippdrv);
1690 
1691 			if (c_node->filp == file) {
1692 				/*
1693 				 * userland goto unnormal state. process killed.
1694 				 * and close the file.
1695 				 * so, IPP didn't called stop cmd ctrl.
1696 				 * so, we are make stop operation in this state.
1697 				 */
1698 				if (c_node->state == IPP_STATE_START) {
1699 					ipp_stop_property(drm_dev, ippdrv,
1700 						c_node);
1701 					c_node->state = IPP_STATE_STOP;
1702 				}
1703 
1704 				ippdrv->dedicated = false;
1705 				ipp_clean_cmd_node(ctx, c_node);
1706 				if (list_empty(&ippdrv->cmd_list))
1707 					pm_runtime_put_sync(ippdrv->dev);
1708 			}
1709 		}
1710 		mutex_unlock(&ippdrv->cmd_lock);
1711 	}
1712 
1713 	return;
1714 }
1715 
1716 static int ipp_probe(struct platform_device *pdev)
1717 {
1718 	struct device *dev = &pdev->dev;
1719 	struct ipp_context *ctx;
1720 	struct exynos_drm_subdrv *subdrv;
1721 	int ret;
1722 
1723 	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
1724 	if (!ctx)
1725 		return -ENOMEM;
1726 
1727 	mutex_init(&ctx->ipp_lock);
1728 	mutex_init(&ctx->prop_lock);
1729 
1730 	idr_init(&ctx->ipp_idr);
1731 	idr_init(&ctx->prop_idr);
1732 
1733 	/*
1734 	 * create single thread for ipp event
1735 	 * IPP supports event thread for IPP drivers.
1736 	 * IPP driver send event_work to this thread.
1737 	 * and IPP event thread send event to user process.
1738 	 */
1739 	ctx->event_workq = create_singlethread_workqueue("ipp_event");
1740 	if (!ctx->event_workq) {
1741 		dev_err(dev, "failed to create event workqueue\n");
1742 		return -EINVAL;
1743 	}
1744 
1745 	/*
1746 	 * create single thread for ipp command
1747 	 * IPP supports command thread for user process.
1748 	 * user process make command node using set property ioctl.
1749 	 * and make start_work and send this work to command thread.
1750 	 * and then this command thread start property.
1751 	 */
1752 	ctx->cmd_workq = create_singlethread_workqueue("ipp_cmd");
1753 	if (!ctx->cmd_workq) {
1754 		dev_err(dev, "failed to create cmd workqueue\n");
1755 		ret = -EINVAL;
1756 		goto err_event_workq;
1757 	}
1758 
1759 	/* set sub driver informations */
1760 	subdrv = &ctx->subdrv;
1761 	subdrv->dev = dev;
1762 	subdrv->probe = ipp_subdrv_probe;
1763 	subdrv->remove = ipp_subdrv_remove;
1764 	subdrv->open = ipp_subdrv_open;
1765 	subdrv->close = ipp_subdrv_close;
1766 
1767 	platform_set_drvdata(pdev, ctx);
1768 
1769 	ret = exynos_drm_subdrv_register(subdrv);
1770 	if (ret < 0) {
1771 		DRM_ERROR("failed to register drm ipp device.\n");
1772 		goto err_cmd_workq;
1773 	}
1774 
1775 	dev_info(dev, "drm ipp registered successfully.\n");
1776 
1777 	return 0;
1778 
1779 err_cmd_workq:
1780 	destroy_workqueue(ctx->cmd_workq);
1781 err_event_workq:
1782 	destroy_workqueue(ctx->event_workq);
1783 	return ret;
1784 }
1785 
1786 static int ipp_remove(struct platform_device *pdev)
1787 {
1788 	struct ipp_context *ctx = platform_get_drvdata(pdev);
1789 
1790 	/* unregister sub driver */
1791 	exynos_drm_subdrv_unregister(&ctx->subdrv);
1792 
1793 	/* remove,destroy ipp idr */
1794 	idr_destroy(&ctx->ipp_idr);
1795 	idr_destroy(&ctx->prop_idr);
1796 
1797 	mutex_destroy(&ctx->ipp_lock);
1798 	mutex_destroy(&ctx->prop_lock);
1799 
1800 	/* destroy command, event work queue */
1801 	destroy_workqueue(ctx->cmd_workq);
1802 	destroy_workqueue(ctx->event_workq);
1803 
1804 	return 0;
1805 }
1806 
1807 struct platform_driver ipp_driver = {
1808 	.probe		= ipp_probe,
1809 	.remove		= ipp_remove,
1810 	.driver		= {
1811 		.name	= "exynos-drm-ipp",
1812 		.owner	= THIS_MODULE,
1813 	},
1814 };
1815 
1816