Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/gpu/drm/exynos/exynos_drm_ipp.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us