kernel/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[0x%x]\n", count++, (int)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[0x%x]\n",
 392                 property->prop_id, property->cmd, (int)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[0x%x]\n", (int)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[0x%x]ops_id[%d]\n", (int)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[0x%x]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[0x%x]\n", count++, (int)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[0x%x]\n", count++, (int)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[0x%x]\n", (int)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[0x%x]\n", (int)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[0x%x]ipp_id[%d]\n",
1614                         count++, (int)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[0x%x]\n", (int)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[0x%x]\n",
1689                                 count++, (int)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