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 /* platform device pointer for ipp device. */
  49 static struct platform_device *exynos_drm_ipp_pdev;
  50
  51 /*
  52  * A structure of event.
  53  *
  54  * @base: base of event.
  55  * @event: ipp event.
  56  */
  57 struct drm_exynos_ipp_send_event {
  58         struct drm_pending_event        base;
  59         struct drm_exynos_ipp_event     event;
  60 };
  61
  62 /*
  63  * A structure of memory node.
  64  *
  65  * @list: list head to memory queue information.
  66  * @ops_id: id of operations.
  67  * @prop_id: id of property.
  68  * @buf_id: id of buffer.
  69  * @buf_info: gem objects and dma address, size.
  70  * @filp: a pointer to drm_file.
  71  */
  72 struct drm_exynos_ipp_mem_node {
  73         struct list_head        list;
  74         enum drm_exynos_ops_id  ops_id;
  75         u32     prop_id;
  76         u32     buf_id;
  77         struct drm_exynos_ipp_buf_info  buf_info;
  78 };
  79
  80 /*
  81  * A structure of ipp context.
  82  *
  83  * @subdrv: prepare initialization using subdrv.
  84  * @ipp_lock: lock for synchronization of access to ipp_idr.
  85  * @prop_lock: lock for synchronization of access to prop_idr.
  86  * @ipp_idr: ipp driver idr.
  87  * @prop_idr: property idr.
  88  * @event_workq: event work queue.
  89  * @cmd_workq: command work queue.
  90  */
  91 struct ipp_context {
  92         struct exynos_drm_subdrv        subdrv;
  93         struct mutex    ipp_lock;
  94         struct mutex    prop_lock;
  95         struct idr      ipp_idr;
  96         struct idr      prop_idr;
  97         struct workqueue_struct *event_workq;
  98         struct workqueue_struct *cmd_workq;
  99 };
 100
 101 static LIST_HEAD(exynos_drm_ippdrv_list);
 102 static DEFINE_MUTEX(exynos_drm_ippdrv_lock);
 103 static BLOCKING_NOTIFIER_HEAD(exynos_drm_ippnb_list);
 104
 105 int exynos_platform_device_ipp_register(void)
 106 {
 107         struct platform_device *pdev;
 108
 109         if (exynos_drm_ipp_pdev)
 110                 return -EEXIST;
 111
 112         pdev = platform_device_register_simple("exynos-drm-ipp", -1, NULL, 0);
 113         if (IS_ERR(pdev))
 114                 return PTR_ERR(pdev);
 115
 116         exynos_drm_ipp_pdev = pdev;
 117
 118         return 0;
 119 }
 120
 121 void exynos_platform_device_ipp_unregister(void)
 122 {
 123         if (exynos_drm_ipp_pdev) {
 124                 platform_device_unregister(exynos_drm_ipp_pdev);
 125                 exynos_drm_ipp_pdev = NULL;
 126         }
 127 }
 128
 129 int exynos_drm_ippdrv_register(struct exynos_drm_ippdrv *ippdrv)
 130 {
 131         mutex_lock(&exynos_drm_ippdrv_lock);
 132         list_add_tail(&ippdrv->drv_list, &exynos_drm_ippdrv_list);
 133         mutex_unlock(&exynos_drm_ippdrv_lock);
 134
 135         return 0;
 136 }
 137
 138 int exynos_drm_ippdrv_unregister(struct exynos_drm_ippdrv *ippdrv)
 139 {
 140         mutex_lock(&exynos_drm_ippdrv_lock);
 141         list_del(&ippdrv->drv_list);
 142         mutex_unlock(&exynos_drm_ippdrv_lock);
 143
 144         return 0;
 145 }
 146
 147 static int ipp_create_id(struct idr *id_idr, struct mutex *lock, void *obj)
 148 {
 149         int ret;
 150
 151         mutex_lock(lock);
 152         ret = idr_alloc(id_idr, obj, 1, 0, GFP_KERNEL);
 153         mutex_unlock(lock);
 154
 155         return ret;
 156 }
 157
 158 static void ipp_remove_id(struct idr *id_idr, struct mutex *lock, u32 id)
 159 {
 160         mutex_lock(lock);
 161         idr_remove(id_idr, id);
 162         mutex_unlock(lock);
 163 }
 164
 165 static void *ipp_find_obj(struct idr *id_idr, struct mutex *lock, u32 id)
 166 {
 167         void *obj;
 168
 169         mutex_lock(lock);
 170         obj = idr_find(id_idr, id);
 171         mutex_unlock(lock);
 172
 173         return obj;
 174 }
 175
 176 static int ipp_check_driver(struct exynos_drm_ippdrv *ippdrv,
 177                             struct drm_exynos_ipp_property *property)
 178 {
 179         if (ippdrv->dedicated || (!ipp_is_m2m_cmd(property->cmd) &&
 180                                   !pm_runtime_suspended(ippdrv->dev)))
 181                 return -EBUSY;
 182
 183         if (ippdrv->check_property &&
 184             ippdrv->check_property(ippdrv->dev, property))
 185                 return -EINVAL;
 186
 187         return 0;
 188 }
 189
 190 static struct exynos_drm_ippdrv *ipp_find_driver(struct ipp_context *ctx,
 191                 struct drm_exynos_ipp_property *property)
 192 {
 193         struct exynos_drm_ippdrv *ippdrv;
 194         u32 ipp_id = property->ipp_id;
 195         int ret;
 196
 197         if (ipp_id) {
 198                 ippdrv = ipp_find_obj(&ctx->ipp_idr, &ctx->ipp_lock, ipp_id);
 199                 if (!ippdrv) {
 200                         DRM_DEBUG("ipp%d driver not found\n", ipp_id);
 201                         return ERR_PTR(-ENODEV);
 202                 }
 203
 204                 ret = ipp_check_driver(ippdrv, property);
 205                 if (ret < 0) {
 206                         DRM_DEBUG("ipp%d driver check error %d\n", ipp_id, ret);
 207                         return ERR_PTR(ret);
 208                 }
 209
 210                 return ippdrv;
 211         } else {
 212                 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
 213                         ret = ipp_check_driver(ippdrv, property);
 214                         if (ret == 0)
 215                                 return ippdrv;
 216                 }
 217
 218                 DRM_DEBUG("cannot find driver suitable for given property.\n");
 219         }
 220
 221         return ERR_PTR(-ENODEV);
 222 }
 223
 224 static struct exynos_drm_ippdrv *ipp_find_drv_by_handle(u32 prop_id)
 225 {
 226         struct exynos_drm_ippdrv *ippdrv;
 227         struct drm_exynos_ipp_cmd_node *c_node;
 228         int count = 0;
 229
 230         DRM_DEBUG_KMS("prop_id[%d]\n", prop_id);
 231
 232         /*
 233          * This case is search ipp driver by prop_id handle.
 234          * sometimes, ipp subsystem find driver by prop_id.
 235          * e.g PAUSE state, queue buf, command control.
 236          */
 237         list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
 238                 DRM_DEBUG_KMS("count[%d]ippdrv[0x%x]\n", count++, (int)ippdrv);
 239
 240                 mutex_lock(&ippdrv->cmd_lock);
 241                 list_for_each_entry(c_node, &ippdrv->cmd_list, list) {
 242                         if (c_node->property.prop_id == prop_id) {
 243                                 mutex_unlock(&ippdrv->cmd_lock);
 244                                 return ippdrv;
 245                         }
 246                 }
 247                 mutex_unlock(&ippdrv->cmd_lock);
 248         }
 249
 250         return ERR_PTR(-ENODEV);
 251 }
 252
 253 int exynos_drm_ipp_get_property(struct drm_device *drm_dev, void *data,
 254                 struct drm_file *file)
 255 {
 256         struct drm_exynos_file_private *file_priv = file->driver_priv;
 257         struct device *dev = file_priv->ipp_dev;
 258         struct ipp_context *ctx = get_ipp_context(dev);
 259         struct drm_exynos_ipp_prop_list *prop_list = data;
 260         struct exynos_drm_ippdrv *ippdrv;
 261         int count = 0;
 262
 263         if (!ctx) {
 264                 DRM_ERROR("invalid context.\n");
 265                 return -EINVAL;
 266         }
 267
 268         if (!prop_list) {
 269                 DRM_ERROR("invalid property parameter.\n");
 270                 return -EINVAL;
 271         }
 272
 273         DRM_DEBUG_KMS("ipp_id[%d]\n", prop_list->ipp_id);
 274
 275         if (!prop_list->ipp_id) {
 276                 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list)
 277                         count++;
 278
 279                 /*
 280                  * Supports ippdrv list count for user application.
 281                  * First step user application getting ippdrv count.
 282                  * and second step getting ippdrv capability using ipp_id.
 283                  */
 284                 prop_list->count = count;
 285         } else {
 286                 /*
 287                  * Getting ippdrv capability by ipp_id.
 288                  * some device not supported wb, output interface.
 289                  * so, user application detect correct ipp driver
 290                  * using this ioctl.
 291                  */
 292                 ippdrv = ipp_find_obj(&ctx->ipp_idr, &ctx->ipp_lock,
 293                                                 prop_list->ipp_id);
 294                 if (!ippdrv) {
 295                         DRM_ERROR("not found ipp%d driver.\n",
 296                                         prop_list->ipp_id);
 297                         return -ENODEV;
 298                 }
 299
 300                 *prop_list = ippdrv->prop_list;
 301         }
 302
 303         return 0;
 304 }
 305
 306 static void ipp_print_property(struct drm_exynos_ipp_property *property,
 307                 int idx)
 308 {
 309         struct drm_exynos_ipp_config *config = &property->config[idx];
 310         struct drm_exynos_pos *pos = &config->pos;
 311         struct drm_exynos_sz *sz = &config->sz;
 312
 313         DRM_DEBUG_KMS("prop_id[%d]ops[%s]fmt[0x%x]\n",
 314                 property->prop_id, idx ? "dst" : "src", config->fmt);
 315
 316         DRM_DEBUG_KMS("pos[%d %d %d %d]sz[%d %d]f[%d]r[%d]\n",
 317                 pos->x, pos->y, pos->w, pos->h,
 318                 sz->hsize, sz->vsize, config->flip, config->degree);
 319 }
 320
 321 static struct drm_exynos_ipp_cmd_work *ipp_create_cmd_work(void)
 322 {
 323         struct drm_exynos_ipp_cmd_work *cmd_work;
 324
 325         cmd_work = kzalloc(sizeof(*cmd_work), GFP_KERNEL);
 326         if (!cmd_work)
 327                 return ERR_PTR(-ENOMEM);
 328
 329         INIT_WORK((struct work_struct *)cmd_work, ipp_sched_cmd);
 330
 331         return cmd_work;
 332 }
 333
 334 static struct drm_exynos_ipp_event_work *ipp_create_event_work(void)
 335 {
 336         struct drm_exynos_ipp_event_work *event_work;
 337
 338         event_work = kzalloc(sizeof(*event_work), GFP_KERNEL);
 339         if (!event_work)
 340                 return ERR_PTR(-ENOMEM);
 341
 342         INIT_WORK(&event_work->work, ipp_sched_event);
 343
 344         return event_work;
 345 }
 346
 347 int exynos_drm_ipp_set_property(struct drm_device *drm_dev, void *data,
 348                 struct drm_file *file)
 349 {
 350         struct drm_exynos_file_private *file_priv = file->driver_priv;
 351         struct device *dev = file_priv->ipp_dev;
 352         struct ipp_context *ctx = get_ipp_context(dev);
 353         struct drm_exynos_ipp_property *property = data;
 354         struct exynos_drm_ippdrv *ippdrv;
 355         struct drm_exynos_ipp_cmd_node *c_node;
 356         u32 prop_id;
 357         int ret, i;
 358
 359         if (!ctx) {
 360                 DRM_ERROR("invalid context.\n");
 361                 return -EINVAL;
 362         }
 363
 364         if (!property) {
 365                 DRM_ERROR("invalid property parameter.\n");
 366                 return -EINVAL;
 367         }
 368
 369         prop_id = property->prop_id;
 370
 371         /*
 372          * This is log print for user application property.
 373          * user application set various property.
 374          */
 375         for_each_ipp_ops(i)
 376                 ipp_print_property(property, i);
 377
 378         /*
 379          * In case prop_id is not zero try to set existing property.
 380          */
 381         if (prop_id) {
 382                 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock, prop_id);
 383
 384                 if (!c_node || c_node->filp != file) {
 385                         DRM_DEBUG_KMS("prop_id[%d] not found\n", prop_id);
 386                         return -EINVAL;
 387                 }
 388
 389                 if (c_node->state != IPP_STATE_STOP) {
 390                         DRM_DEBUG_KMS("prop_id[%d] not stopped\n", prop_id);
 391                         return -EINVAL;
 392                 }
 393
 394                 c_node->property = *property;
 395
 396                 return 0;
 397         }
 398
 399         /* find ipp driver using ipp id */
 400         ippdrv = ipp_find_driver(ctx, property);
 401         if (IS_ERR(ippdrv)) {
 402                 DRM_ERROR("failed to get ipp driver.\n");
 403                 return -EINVAL;
 404         }
 405
 406         /* allocate command node */
 407         c_node = kzalloc(sizeof(*c_node), GFP_KERNEL);
 408         if (!c_node)
 409                 return -ENOMEM;
 410
 411         ret = ipp_create_id(&ctx->prop_idr, &ctx->prop_lock, c_node);
 412         if (ret < 0) {
 413                 DRM_ERROR("failed to create id.\n");
 414                 goto err_clear;
 415         }
 416         property->prop_id = ret;
 417
 418         DRM_DEBUG_KMS("created prop_id[%d]cmd[%d]ippdrv[0x%x]\n",
 419                 property->prop_id, property->cmd, (int)ippdrv);
 420
 421         /* stored property information and ippdrv in private data */
 422         c_node->property = *property;
 423         c_node->state = IPP_STATE_IDLE;
 424         c_node->filp = file;
 425
 426         c_node->start_work = ipp_create_cmd_work();
 427         if (IS_ERR(c_node->start_work)) {
 428                 DRM_ERROR("failed to create start work.\n");
 429                 ret = PTR_ERR(c_node->start_work);
 430                 goto err_remove_id;
 431         }
 432
 433         c_node->stop_work = ipp_create_cmd_work();
 434         if (IS_ERR(c_node->stop_work)) {
 435                 DRM_ERROR("failed to create stop work.\n");
 436                 ret = PTR_ERR(c_node->stop_work);
 437                 goto err_free_start;
 438         }
 439
 440         c_node->event_work = ipp_create_event_work();
 441         if (IS_ERR(c_node->event_work)) {
 442                 DRM_ERROR("failed to create event work.\n");
 443                 ret = PTR_ERR(c_node->event_work);
 444                 goto err_free_stop;
 445         }
 446
 447         mutex_init(&c_node->lock);
 448         mutex_init(&c_node->mem_lock);
 449         mutex_init(&c_node->event_lock);
 450
 451         init_completion(&c_node->start_complete);
 452         init_completion(&c_node->stop_complete);
 453
 454         for_each_ipp_ops(i)
 455                 INIT_LIST_HEAD(&c_node->mem_list[i]);
 456
 457         INIT_LIST_HEAD(&c_node->event_list);
 458         mutex_lock(&ippdrv->cmd_lock);
 459         list_add_tail(&c_node->list, &ippdrv->cmd_list);
 460         mutex_unlock(&ippdrv->cmd_lock);
 461
 462         /* make dedicated state without m2m */
 463         if (!ipp_is_m2m_cmd(property->cmd))
 464                 ippdrv->dedicated = true;
 465
 466         return 0;
 467
 468 err_free_stop:
 469         kfree(c_node->stop_work);
 470 err_free_start:
 471         kfree(c_node->start_work);
 472 err_remove_id:
 473         ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock, property->prop_id);
 474 err_clear:
 475         kfree(c_node);
 476         return ret;
 477 }
 478
 479 static int ipp_validate_mem_node(struct drm_device *drm_dev,
 480                                  struct drm_exynos_ipp_mem_node *m_node,
 481                                  struct drm_exynos_ipp_cmd_node *c_node)
 482 {
 483         struct drm_exynos_ipp_config *ipp_cfg;
 484         unsigned int num_plane;
 485         unsigned long min_size, size;
 486         unsigned int bpp;
 487         int i;
 488
 489         /* The property id should already be varified */
 490         ipp_cfg = &c_node->property.config[m_node->prop_id];
 491         num_plane = drm_format_num_planes(ipp_cfg->fmt);
 492
 493         /**
 494          * This is a rather simplified validation of a memory node.
 495          * It basically verifies provided gem object handles
 496          * and the buffer sizes with respect to current configuration.
 497          * This is not the best that can be done
 498          * but it seems more than enough
 499          */
 500         for (i = 0; i < num_plane; ++i) {
 501                 if (!m_node->buf_info.handles[i]) {
 502                         DRM_ERROR("invalid handle for plane %d\n", i);
 503                         return -EINVAL;
 504                 }
 505                 bpp = drm_format_plane_cpp(ipp_cfg->fmt, i);
 506                 min_size = (ipp_cfg->sz.hsize * ipp_cfg->sz.vsize * bpp) >> 3;
 507                 size = exynos_drm_gem_get_size(drm_dev,
 508                                                m_node->buf_info.handles[i],
 509                                                c_node->filp);
 510                 if (min_size > size) {
 511                         DRM_ERROR("invalid size for plane %d\n", i);
 512                         return -EINVAL;
 513                 }
 514         }
 515         return 0;
 516 }
 517
 518 static int ipp_put_mem_node(struct drm_device *drm_dev,
 519                 struct drm_exynos_ipp_cmd_node *c_node,
 520                 struct drm_exynos_ipp_mem_node *m_node)
 521 {
 522         int i;
 523
 524         DRM_DEBUG_KMS("node[0x%x]\n", (int)m_node);
 525
 526         if (!m_node) {
 527                 DRM_ERROR("invalid dequeue node.\n");
 528                 return -EFAULT;
 529         }
 530
 531         DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id);
 532
 533         /* put gem buffer */
 534         for_each_ipp_planar(i) {
 535                 unsigned long handle = m_node->buf_info.handles[i];
 536                 if (handle)
 537                         exynos_drm_gem_put_dma_addr(drm_dev, handle,
 538                                                         c_node->filp);
 539         }
 540
 541         list_del(&m_node->list);
 542         kfree(m_node);
 543
 544         return 0;
 545 }
 546
 547 static struct drm_exynos_ipp_mem_node
 548                 *ipp_get_mem_node(struct drm_device *drm_dev,
 549                 struct drm_exynos_ipp_cmd_node *c_node,
 550                 struct drm_exynos_ipp_queue_buf *qbuf)
 551 {
 552         struct drm_exynos_ipp_mem_node *m_node;
 553         struct drm_exynos_ipp_buf_info *buf_info;
 554         int i;
 555
 556         m_node = kzalloc(sizeof(*m_node), GFP_KERNEL);
 557         if (!m_node)
 558                 return ERR_PTR(-ENOMEM);
 559
 560         buf_info = &m_node->buf_info;
 561
 562         /* operations, buffer id */
 563         m_node->ops_id = qbuf->ops_id;
 564         m_node->prop_id = qbuf->prop_id;
 565         m_node->buf_id = qbuf->buf_id;
 566         INIT_LIST_HEAD(&m_node->list);
 567
 568         DRM_DEBUG_KMS("m_node[0x%x]ops_id[%d]\n", (int)m_node, qbuf->ops_id);
 569         DRM_DEBUG_KMS("prop_id[%d]buf_id[%d]\n", qbuf->prop_id, m_node->buf_id);
 570
 571         for_each_ipp_planar(i) {
 572                 DRM_DEBUG_KMS("i[%d]handle[0x%x]\n", i, qbuf->handle[i]);
 573
 574                 /* get dma address by handle */
 575                 if (qbuf->handle[i]) {
 576                         dma_addr_t *addr;
 577
 578                         addr = exynos_drm_gem_get_dma_addr(drm_dev,
 579                                         qbuf->handle[i], c_node->filp);
 580                         if (IS_ERR(addr)) {
 581                                 DRM_ERROR("failed to get addr.\n");
 582                                 ipp_put_mem_node(drm_dev, c_node, m_node);
 583                                 return ERR_PTR(-EFAULT);
 584                         }
 585
 586                         buf_info->handles[i] = qbuf->handle[i];
 587                         buf_info->base[i] = *addr;
 588                         DRM_DEBUG_KMS("i[%d]base[0x%x]hd[0x%lx]\n", i,
 589                                       buf_info->base[i], buf_info->handles[i]);
 590                 }
 591         }
 592
 593         mutex_lock(&c_node->mem_lock);
 594         if (ipp_validate_mem_node(drm_dev, m_node, c_node)) {
 595                 ipp_put_mem_node(drm_dev, c_node, m_node);
 596                 mutex_unlock(&c_node->mem_lock);
 597                 return ERR_PTR(-EFAULT);
 598         }
 599         list_add_tail(&m_node->list, &c_node->mem_list[qbuf->ops_id]);
 600         mutex_unlock(&c_node->mem_lock);
 601
 602         return m_node;
 603 }
 604
 605 static void ipp_clean_mem_nodes(struct drm_device *drm_dev,
 606                                struct drm_exynos_ipp_cmd_node *c_node, int ops)
 607 {
 608         struct drm_exynos_ipp_mem_node *m_node, *tm_node;
 609         struct list_head *head = &c_node->mem_list[ops];
 610
 611         mutex_lock(&c_node->mem_lock);
 612
 613         list_for_each_entry_safe(m_node, tm_node, head, list) {
 614                 int ret;
 615
 616                 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
 617                 if (ret)
 618                         DRM_ERROR("failed to put m_node.\n");
 619         }
 620
 621         mutex_unlock(&c_node->mem_lock);
 622 }
 623
 624 static void ipp_free_event(struct drm_pending_event *event)
 625 {
 626         kfree(event);
 627 }
 628
 629 static int ipp_get_event(struct drm_device *drm_dev,
 630                 struct drm_exynos_ipp_cmd_node *c_node,
 631                 struct drm_exynos_ipp_queue_buf *qbuf)
 632 {
 633         struct drm_exynos_ipp_send_event *e;
 634         unsigned long flags;
 635
 636         DRM_DEBUG_KMS("ops_id[%d]buf_id[%d]\n", qbuf->ops_id, qbuf->buf_id);
 637
 638         e = kzalloc(sizeof(*e), GFP_KERNEL);
 639         if (!e) {
 640                 spin_lock_irqsave(&drm_dev->event_lock, flags);
 641                 c_node->filp->event_space += sizeof(e->event);
 642                 spin_unlock_irqrestore(&drm_dev->event_lock, flags);
 643                 return -ENOMEM;
 644         }
 645
 646         /* make event */
 647         e->event.base.type = DRM_EXYNOS_IPP_EVENT;
 648         e->event.base.length = sizeof(e->event);
 649         e->event.user_data = qbuf->user_data;
 650         e->event.prop_id = qbuf->prop_id;
 651         e->event.buf_id[EXYNOS_DRM_OPS_DST] = qbuf->buf_id;
 652         e->base.event = &e->event.base;
 653         e->base.file_priv = c_node->filp;
 654         e->base.destroy = ipp_free_event;
 655         mutex_lock(&c_node->event_lock);
 656         list_add_tail(&e->base.link, &c_node->event_list);
 657         mutex_unlock(&c_node->event_lock);
 658
 659         return 0;
 660 }
 661
 662 static void ipp_put_event(struct drm_exynos_ipp_cmd_node *c_node,
 663                 struct drm_exynos_ipp_queue_buf *qbuf)
 664 {
 665         struct drm_exynos_ipp_send_event *e, *te;
 666         int count = 0;
 667
 668         mutex_lock(&c_node->event_lock);
 669         list_for_each_entry_safe(e, te, &c_node->event_list, base.link) {
 670                 DRM_DEBUG_KMS("count[%d]e[0x%x]\n", count++, (int)e);
 671
 672                 /*
 673                  * qbuf == NULL condition means all event deletion.
 674                  * stop operations want to delete all event list.
 675                  * another case delete only same buf id.
 676                  */
 677                 if (!qbuf) {
 678                         /* delete list */
 679                         list_del(&e->base.link);
 680                         kfree(e);
 681                 }
 682
 683                 /* compare buffer id */
 684                 if (qbuf && (qbuf->buf_id ==
 685                     e->event.buf_id[EXYNOS_DRM_OPS_DST])) {
 686                         /* delete list */
 687                         list_del(&e->base.link);
 688                         kfree(e);
 689                         goto out_unlock;
 690                 }
 691         }
 692
 693 out_unlock:
 694         mutex_unlock(&c_node->event_lock);
 695         return;
 696 }
 697
 698 static void ipp_clean_cmd_node(struct ipp_context *ctx,
 699                                 struct drm_exynos_ipp_cmd_node *c_node)
 700 {
 701         int i;
 702
 703         /* cancel works */
 704         cancel_work_sync(&c_node->start_work->work);
 705         cancel_work_sync(&c_node->stop_work->work);
 706         cancel_work_sync(&c_node->event_work->work);
 707
 708         /* put event */
 709         ipp_put_event(c_node, NULL);
 710
 711         for_each_ipp_ops(i)
 712                 ipp_clean_mem_nodes(ctx->subdrv.drm_dev, c_node, i);
 713
 714         /* delete list */
 715         list_del(&c_node->list);
 716
 717         ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock,
 718                         c_node->property.prop_id);
 719
 720         /* destroy mutex */
 721         mutex_destroy(&c_node->lock);
 722         mutex_destroy(&c_node->mem_lock);
 723         mutex_destroy(&c_node->event_lock);
 724
 725         /* free command node */
 726         kfree(c_node->start_work);
 727         kfree(c_node->stop_work);
 728         kfree(c_node->event_work);
 729         kfree(c_node);
 730 }
 731
 732 static bool ipp_check_mem_list(struct drm_exynos_ipp_cmd_node *c_node)
 733 {
 734         switch (c_node->property.cmd) {
 735         case IPP_CMD_WB:
 736                 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]);
 737         case IPP_CMD_OUTPUT:
 738                 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]);
 739         case IPP_CMD_M2M:
 740         default:
 741                 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]) &&
 742                        !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]);
 743         }
 744 }
 745
 746 static struct drm_exynos_ipp_mem_node
 747                 *ipp_find_mem_node(struct drm_exynos_ipp_cmd_node *c_node,
 748                 struct drm_exynos_ipp_queue_buf *qbuf)
 749 {
 750         struct drm_exynos_ipp_mem_node *m_node;
 751         struct list_head *head;
 752         int count = 0;
 753
 754         DRM_DEBUG_KMS("buf_id[%d]\n", qbuf->buf_id);
 755
 756         /* source/destination memory list */
 757         head = &c_node->mem_list[qbuf->ops_id];
 758
 759         /* find memory node from memory list */
 760         list_for_each_entry(m_node, head, list) {
 761                 DRM_DEBUG_KMS("count[%d]m_node[0x%x]\n", count++, (int)m_node);
 762
 763                 /* compare buffer id */
 764                 if (m_node->buf_id == qbuf->buf_id)
 765                         return m_node;
 766         }
 767
 768         return NULL;
 769 }
 770
 771 static int ipp_set_mem_node(struct exynos_drm_ippdrv *ippdrv,
 772                 struct drm_exynos_ipp_cmd_node *c_node,
 773                 struct drm_exynos_ipp_mem_node *m_node)
 774 {
 775         struct exynos_drm_ipp_ops *ops = NULL;
 776         int ret = 0;
 777
 778         DRM_DEBUG_KMS("node[0x%x]\n", (int)m_node);
 779
 780         if (!m_node) {
 781                 DRM_ERROR("invalid queue node.\n");
 782                 return -EFAULT;
 783         }
 784
 785         DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id);
 786
 787         /* get operations callback */
 788         ops = ippdrv->ops[m_node->ops_id];
 789         if (!ops) {
 790                 DRM_ERROR("not support ops.\n");
 791                 return -EFAULT;
 792         }
 793
 794         /* set address and enable irq */
 795         if (ops->set_addr) {
 796                 ret = ops->set_addr(ippdrv->dev, &m_node->buf_info,
 797                         m_node->buf_id, IPP_BUF_ENQUEUE);
 798                 if (ret) {
 799                         DRM_ERROR("failed to set addr.\n");
 800                         return ret;
 801                 }
 802         }
 803
 804         return ret;
 805 }
 806
 807 static void ipp_handle_cmd_work(struct device *dev,
 808                 struct exynos_drm_ippdrv *ippdrv,
 809                 struct drm_exynos_ipp_cmd_work *cmd_work,
 810                 struct drm_exynos_ipp_cmd_node *c_node)
 811 {
 812         struct ipp_context *ctx = get_ipp_context(dev);
 813
 814         cmd_work->ippdrv = ippdrv;
 815         cmd_work->c_node = c_node;
 816         queue_work(ctx->cmd_workq, &cmd_work->work);
 817 }
 818
 819 static int ipp_queue_buf_with_run(struct device *dev,
 820                 struct drm_exynos_ipp_cmd_node *c_node,
 821                 struct drm_exynos_ipp_mem_node *m_node,
 822                 struct drm_exynos_ipp_queue_buf *qbuf)
 823 {
 824         struct exynos_drm_ippdrv *ippdrv;
 825         struct drm_exynos_ipp_property *property;
 826         struct exynos_drm_ipp_ops *ops;
 827         int ret;
 828
 829         ippdrv = ipp_find_drv_by_handle(qbuf->prop_id);
 830         if (IS_ERR(ippdrv)) {
 831                 DRM_ERROR("failed to get ipp driver.\n");
 832                 return -EFAULT;
 833         }
 834
 835         ops = ippdrv->ops[qbuf->ops_id];
 836         if (!ops) {
 837                 DRM_ERROR("failed to get ops.\n");
 838                 return -EFAULT;
 839         }
 840
 841         property = &c_node->property;
 842
 843         if (c_node->state != IPP_STATE_START) {
 844                 DRM_DEBUG_KMS("bypass for invalid state.\n");
 845                 return 0;
 846         }
 847
 848         mutex_lock(&c_node->mem_lock);
 849         if (!ipp_check_mem_list(c_node)) {
 850                 mutex_unlock(&c_node->mem_lock);
 851                 DRM_DEBUG_KMS("empty memory.\n");
 852                 return 0;
 853         }
 854
 855         /*
 856          * If set destination buffer and enabled clock,
 857          * then m2m operations need start operations at queue_buf
 858          */
 859         if (ipp_is_m2m_cmd(property->cmd)) {
 860                 struct drm_exynos_ipp_cmd_work *cmd_work = c_node->start_work;
 861
 862                 cmd_work->ctrl = IPP_CTRL_PLAY;
 863                 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
 864         } else {
 865                 ret = ipp_set_mem_node(ippdrv, c_node, m_node);
 866                 if (ret) {
 867                         mutex_unlock(&c_node->mem_lock);
 868                         DRM_ERROR("failed to set m node.\n");
 869                         return ret;
 870                 }
 871         }
 872         mutex_unlock(&c_node->mem_lock);
 873
 874         return 0;
 875 }
 876
 877 static void ipp_clean_queue_buf(struct drm_device *drm_dev,
 878                 struct drm_exynos_ipp_cmd_node *c_node,
 879                 struct drm_exynos_ipp_queue_buf *qbuf)
 880 {
 881         struct drm_exynos_ipp_mem_node *m_node, *tm_node;
 882
 883         /* delete list */
 884         mutex_lock(&c_node->mem_lock);
 885         list_for_each_entry_safe(m_node, tm_node,
 886                 &c_node->mem_list[qbuf->ops_id], list) {
 887                 if (m_node->buf_id == qbuf->buf_id &&
 888                     m_node->ops_id == qbuf->ops_id)
 889                         ipp_put_mem_node(drm_dev, c_node, m_node);
 890         }
 891         mutex_unlock(&c_node->mem_lock);
 892 }
 893
 894 int exynos_drm_ipp_queue_buf(struct drm_device *drm_dev, void *data,
 895                 struct drm_file *file)
 896 {
 897         struct drm_exynos_file_private *file_priv = file->driver_priv;
 898         struct device *dev = file_priv->ipp_dev;
 899         struct ipp_context *ctx = get_ipp_context(dev);
 900         struct drm_exynos_ipp_queue_buf *qbuf = data;
 901         struct drm_exynos_ipp_cmd_node *c_node;
 902         struct drm_exynos_ipp_mem_node *m_node;
 903         int ret;
 904
 905         if (!qbuf) {
 906                 DRM_ERROR("invalid buf parameter.\n");
 907                 return -EINVAL;
 908         }
 909
 910         if (qbuf->ops_id >= EXYNOS_DRM_OPS_MAX) {
 911                 DRM_ERROR("invalid ops parameter.\n");
 912                 return -EINVAL;
 913         }
 914
 915         DRM_DEBUG_KMS("prop_id[%d]ops_id[%s]buf_id[%d]buf_type[%d]\n",
 916                 qbuf->prop_id, qbuf->ops_id ? "dst" : "src",
 917                 qbuf->buf_id, qbuf->buf_type);
 918
 919         /* find command node */
 920         c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock,
 921                 qbuf->prop_id);
 922         if (!c_node || c_node->filp != file) {
 923                 DRM_ERROR("failed to get command node.\n");
 924                 return -ENODEV;
 925         }
 926
 927         /* buffer control */
 928         switch (qbuf->buf_type) {
 929         case IPP_BUF_ENQUEUE:
 930                 /* get memory node */
 931                 m_node = ipp_get_mem_node(drm_dev, c_node, qbuf);
 932                 if (IS_ERR(m_node)) {
 933                         DRM_ERROR("failed to get m_node.\n");
 934                         return PTR_ERR(m_node);
 935                 }
 936
 937                 /*
 938                  * first step get event for destination buffer.
 939                  * and second step when M2M case run with destination buffer
 940                  * if needed.
 941                  */
 942                 if (qbuf->ops_id == EXYNOS_DRM_OPS_DST) {
 943                         /* get event for destination buffer */
 944                         ret = ipp_get_event(drm_dev, c_node, qbuf);
 945                         if (ret) {
 946                                 DRM_ERROR("failed to get event.\n");
 947                                 goto err_clean_node;
 948                         }
 949
 950                         /*
 951                          * M2M case run play control for streaming feature.
 952                          * other case set address and waiting.
 953                          */
 954                         ret = ipp_queue_buf_with_run(dev, c_node, m_node, qbuf);
 955                         if (ret) {
 956                                 DRM_ERROR("failed to run command.\n");
 957                                 goto err_clean_node;
 958                         }
 959                 }
 960                 break;
 961         case IPP_BUF_DEQUEUE:
 962                 mutex_lock(&c_node->lock);
 963
 964                 /* put event for destination buffer */
 965                 if (qbuf->ops_id == EXYNOS_DRM_OPS_DST)
 966                         ipp_put_event(c_node, qbuf);
 967
 968                 ipp_clean_queue_buf(drm_dev, c_node, qbuf);
 969
 970                 mutex_unlock(&c_node->lock);
 971                 break;
 972         default:
 973                 DRM_ERROR("invalid buffer control.\n");
 974                 return -EINVAL;
 975         }
 976
 977         return 0;
 978
 979 err_clean_node:
 980         DRM_ERROR("clean memory nodes.\n");
 981
 982         ipp_clean_queue_buf(drm_dev, c_node, qbuf);
 983         return ret;
 984 }
 985
 986 static bool exynos_drm_ipp_check_valid(struct device *dev,
 987                 enum drm_exynos_ipp_ctrl ctrl, enum drm_exynos_ipp_state state)
 988 {
 989         if (ctrl != IPP_CTRL_PLAY) {
 990                 if (pm_runtime_suspended(dev)) {
 991                         DRM_ERROR("pm:runtime_suspended.\n");
 992                         goto err_status;
 993                 }
 994         }
 995
 996         switch (ctrl) {
 997         case IPP_CTRL_PLAY:
 998                 if (state != IPP_STATE_IDLE)
 999                         goto err_status;
1000                 break;
1001         case IPP_CTRL_STOP:
1002                 if (state == IPP_STATE_STOP)
1003                         goto err_status;
1004                 break;
1005         case IPP_CTRL_PAUSE:
1006                 if (state != IPP_STATE_START)
1007                         goto err_status;
1008                 break;
1009         case IPP_CTRL_RESUME:
1010                 if (state != IPP_STATE_STOP)
1011                         goto err_status;
1012                 break;
1013         default:
1014                 DRM_ERROR("invalid state.\n");
1015                 goto err_status;
1016         }
1017
1018         return true;
1019
1020 err_status:
1021         DRM_ERROR("invalid status:ctrl[%d]state[%d]\n", ctrl, state);
1022         return false;
1023 }
1024
1025 int exynos_drm_ipp_cmd_ctrl(struct drm_device *drm_dev, void *data,
1026                 struct drm_file *file)
1027 {
1028         struct drm_exynos_file_private *file_priv = file->driver_priv;
1029         struct exynos_drm_ippdrv *ippdrv = NULL;
1030         struct device *dev = file_priv->ipp_dev;
1031         struct ipp_context *ctx = get_ipp_context(dev);
1032         struct drm_exynos_ipp_cmd_ctrl *cmd_ctrl = data;
1033         struct drm_exynos_ipp_cmd_work *cmd_work;
1034         struct drm_exynos_ipp_cmd_node *c_node;
1035
1036         if (!ctx) {
1037                 DRM_ERROR("invalid context.\n");
1038                 return -EINVAL;
1039         }
1040
1041         if (!cmd_ctrl) {
1042                 DRM_ERROR("invalid control parameter.\n");
1043                 return -EINVAL;
1044         }
1045
1046         DRM_DEBUG_KMS("ctrl[%d]prop_id[%d]\n",
1047                 cmd_ctrl->ctrl, cmd_ctrl->prop_id);
1048
1049         ippdrv = ipp_find_drv_by_handle(cmd_ctrl->prop_id);
1050         if (IS_ERR(ippdrv)) {
1051                 DRM_ERROR("failed to get ipp driver.\n");
1052                 return PTR_ERR(ippdrv);
1053         }
1054
1055         c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock,
1056                 cmd_ctrl->prop_id);
1057         if (!c_node || c_node->filp != file) {
1058                 DRM_ERROR("invalid command node list.\n");
1059                 return -ENODEV;
1060         }
1061
1062         if (!exynos_drm_ipp_check_valid(ippdrv->dev, cmd_ctrl->ctrl,
1063             c_node->state)) {
1064                 DRM_ERROR("invalid state.\n");
1065                 return -EINVAL;
1066         }
1067
1068         switch (cmd_ctrl->ctrl) {
1069         case IPP_CTRL_PLAY:
1070                 if (pm_runtime_suspended(ippdrv->dev))
1071                         pm_runtime_get_sync(ippdrv->dev);
1072
1073                 c_node->state = IPP_STATE_START;
1074
1075                 cmd_work = c_node->start_work;
1076                 cmd_work->ctrl = cmd_ctrl->ctrl;
1077                 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1078                 break;
1079         case IPP_CTRL_STOP:
1080                 cmd_work = c_node->stop_work;
1081                 cmd_work->ctrl = cmd_ctrl->ctrl;
1082                 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1083
1084                 if (!wait_for_completion_timeout(&c_node->stop_complete,
1085                     msecs_to_jiffies(300))) {
1086                         DRM_ERROR("timeout stop:prop_id[%d]\n",
1087                                 c_node->property.prop_id);
1088                 }
1089
1090                 c_node->state = IPP_STATE_STOP;
1091                 ippdrv->dedicated = false;
1092                 mutex_lock(&ippdrv->cmd_lock);
1093                 ipp_clean_cmd_node(ctx, c_node);
1094
1095                 if (list_empty(&ippdrv->cmd_list))
1096                         pm_runtime_put_sync(ippdrv->dev);
1097                 mutex_unlock(&ippdrv->cmd_lock);
1098                 break;
1099         case IPP_CTRL_PAUSE:
1100                 cmd_work = c_node->stop_work;
1101                 cmd_work->ctrl = cmd_ctrl->ctrl;
1102                 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1103
1104                 if (!wait_for_completion_timeout(&c_node->stop_complete,
1105                     msecs_to_jiffies(200))) {
1106                         DRM_ERROR("timeout stop:prop_id[%d]\n",
1107                                 c_node->property.prop_id);
1108                 }
1109
1110                 c_node->state = IPP_STATE_STOP;
1111                 break;
1112         case IPP_CTRL_RESUME:
1113                 c_node->state = IPP_STATE_START;
1114                 cmd_work = c_node->start_work;
1115                 cmd_work->ctrl = cmd_ctrl->ctrl;
1116                 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node);
1117                 break;
1118         default:
1119                 DRM_ERROR("could not support this state currently.\n");
1120                 return -EINVAL;
1121         }
1122
1123         DRM_DEBUG_KMS("done ctrl[%d]prop_id[%d]\n",
1124                 cmd_ctrl->ctrl, cmd_ctrl->prop_id);
1125
1126         return 0;
1127 }
1128
1129 int exynos_drm_ippnb_register(struct notifier_block *nb)
1130 {
1131         return blocking_notifier_chain_register(
1132                 &exynos_drm_ippnb_list, nb);
1133 }
1134
1135 int exynos_drm_ippnb_unregister(struct notifier_block *nb)
1136 {
1137         return blocking_notifier_chain_unregister(
1138                 &exynos_drm_ippnb_list, nb);
1139 }
1140
1141 int exynos_drm_ippnb_send_event(unsigned long val, void *v)
1142 {
1143         return blocking_notifier_call_chain(
1144                 &exynos_drm_ippnb_list, val, v);
1145 }
1146
1147 static int ipp_set_property(struct exynos_drm_ippdrv *ippdrv,
1148                 struct drm_exynos_ipp_property *property)
1149 {
1150         struct exynos_drm_ipp_ops *ops = NULL;
1151         bool swap = false;
1152         int ret, i;
1153
1154         if (!property) {
1155                 DRM_ERROR("invalid property parameter.\n");
1156                 return -EINVAL;
1157         }
1158
1159         DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1160
1161         /* reset h/w block */
1162         if (ippdrv->reset &&
1163             ippdrv->reset(ippdrv->dev)) {
1164                 return -EINVAL;
1165         }
1166
1167         /* set source,destination operations */
1168         for_each_ipp_ops(i) {
1169                 struct drm_exynos_ipp_config *config =
1170                         &property->config[i];
1171
1172                 ops = ippdrv->ops[i];
1173                 if (!ops || !config) {
1174                         DRM_ERROR("not support ops and config.\n");
1175                         return -EINVAL;
1176                 }
1177
1178                 /* set format */
1179                 if (ops->set_fmt) {
1180                         ret = ops->set_fmt(ippdrv->dev, config->fmt);
1181                         if (ret)
1182                                 return ret;
1183                 }
1184
1185                 /* set transform for rotation, flip */
1186                 if (ops->set_transf) {
1187                         ret = ops->set_transf(ippdrv->dev, config->degree,
1188                                 config->flip, &swap);
1189                         if (ret)
1190                                 return ret;
1191                 }
1192
1193                 /* set size */
1194                 if (ops->set_size) {
1195                         ret = ops->set_size(ippdrv->dev, swap, &config->pos,
1196                                 &config->sz);
1197                         if (ret)
1198                                 return ret;
1199                 }
1200         }
1201
1202         return 0;
1203 }
1204
1205 static int ipp_start_property(struct exynos_drm_ippdrv *ippdrv,
1206                 struct drm_exynos_ipp_cmd_node *c_node)
1207 {
1208         struct drm_exynos_ipp_mem_node *m_node;
1209         struct drm_exynos_ipp_property *property = &c_node->property;
1210         struct list_head *head;
1211         int ret, i;
1212
1213         DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1214
1215         /* store command info in ippdrv */
1216         ippdrv->c_node = c_node;
1217
1218         mutex_lock(&c_node->mem_lock);
1219         if (!ipp_check_mem_list(c_node)) {
1220                 DRM_DEBUG_KMS("empty memory.\n");
1221                 ret = -ENOMEM;
1222                 goto err_unlock;
1223         }
1224
1225         /* set current property in ippdrv */
1226         ret = ipp_set_property(ippdrv, property);
1227         if (ret) {
1228                 DRM_ERROR("failed to set property.\n");
1229                 ippdrv->c_node = NULL;
1230                 goto err_unlock;
1231         }
1232
1233         /* check command */
1234         switch (property->cmd) {
1235         case IPP_CMD_M2M:
1236                 for_each_ipp_ops(i) {
1237                         /* source/destination memory list */
1238                         head = &c_node->mem_list[i];
1239
1240                         m_node = list_first_entry(head,
1241                                 struct drm_exynos_ipp_mem_node, list);
1242
1243                         DRM_DEBUG_KMS("m_node[0x%x]\n", (int)m_node);
1244
1245                         ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1246                         if (ret) {
1247                                 DRM_ERROR("failed to set m node.\n");
1248                                 goto err_unlock;
1249                         }
1250                 }
1251                 break;
1252         case IPP_CMD_WB:
1253                 /* destination memory list */
1254                 head = &c_node->mem_list[EXYNOS_DRM_OPS_DST];
1255
1256                 list_for_each_entry(m_node, head, list) {
1257                         ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1258                         if (ret) {
1259                                 DRM_ERROR("failed to set m node.\n");
1260                                 goto err_unlock;
1261                         }
1262                 }
1263                 break;
1264         case IPP_CMD_OUTPUT:
1265                 /* source memory list */
1266                 head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC];
1267
1268                 list_for_each_entry(m_node, head, list) {
1269                         ret = ipp_set_mem_node(ippdrv, c_node, m_node);
1270                         if (ret) {
1271                                 DRM_ERROR("failed to set m node.\n");
1272                                 goto err_unlock;
1273                         }
1274                 }
1275                 break;
1276         default:
1277                 DRM_ERROR("invalid operations.\n");
1278                 ret = -EINVAL;
1279                 goto err_unlock;
1280         }
1281         mutex_unlock(&c_node->mem_lock);
1282
1283         DRM_DEBUG_KMS("cmd[%d]\n", property->cmd);
1284
1285         /* start operations */
1286         if (ippdrv->start) {
1287                 ret = ippdrv->start(ippdrv->dev, property->cmd);
1288                 if (ret) {
1289                         DRM_ERROR("failed to start ops.\n");
1290                         ippdrv->c_node = NULL;
1291                         return ret;
1292                 }
1293         }
1294
1295         return 0;
1296
1297 err_unlock:
1298         mutex_unlock(&c_node->mem_lock);
1299         ippdrv->c_node = NULL;
1300         return ret;
1301 }
1302
1303 static int ipp_stop_property(struct drm_device *drm_dev,
1304                 struct exynos_drm_ippdrv *ippdrv,
1305                 struct drm_exynos_ipp_cmd_node *c_node)
1306 {
1307         struct drm_exynos_ipp_property *property = &c_node->property;
1308         int i;
1309
1310         DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id);
1311
1312         /* stop operations */
1313         if (ippdrv->stop)
1314                 ippdrv->stop(ippdrv->dev, property->cmd);
1315
1316         /* check command */
1317         switch (property->cmd) {
1318         case IPP_CMD_M2M:
1319                 for_each_ipp_ops(i)
1320                         ipp_clean_mem_nodes(drm_dev, c_node, i);
1321                 break;
1322         case IPP_CMD_WB:
1323                 ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_DST);
1324                 break;
1325         case IPP_CMD_OUTPUT:
1326                 ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_SRC);
1327                 break;
1328         default:
1329                 DRM_ERROR("invalid operations.\n");
1330                 return -EINVAL;
1331         }
1332
1333         return 0;
1334 }
1335
1336 void ipp_sched_cmd(struct work_struct *work)
1337 {
1338         struct drm_exynos_ipp_cmd_work *cmd_work =
1339                 container_of(work, struct drm_exynos_ipp_cmd_work, work);
1340         struct exynos_drm_ippdrv *ippdrv;
1341         struct drm_exynos_ipp_cmd_node *c_node;
1342         struct drm_exynos_ipp_property *property;
1343         int ret;
1344
1345         ippdrv = cmd_work->ippdrv;
1346         if (!ippdrv) {
1347                 DRM_ERROR("invalid ippdrv list.\n");
1348                 return;
1349         }
1350
1351         c_node = cmd_work->c_node;
1352         if (!c_node) {
1353                 DRM_ERROR("invalid command node list.\n");
1354                 return;
1355         }
1356
1357         mutex_lock(&c_node->lock);
1358
1359         property = &c_node->property;
1360
1361         switch (cmd_work->ctrl) {
1362         case IPP_CTRL_PLAY:
1363         case IPP_CTRL_RESUME:
1364                 ret = ipp_start_property(ippdrv, c_node);
1365                 if (ret) {
1366                         DRM_ERROR("failed to start property:prop_id[%d]\n",
1367                                 c_node->property.prop_id);
1368                         goto err_unlock;
1369                 }
1370
1371                 /*
1372                  * M2M case supports wait_completion of transfer.
1373                  * because M2M case supports single unit operation
1374                  * with multiple queue.
1375                  * M2M need to wait completion of data transfer.
1376                  */
1377                 if (ipp_is_m2m_cmd(property->cmd)) {
1378                         if (!wait_for_completion_timeout
1379                             (&c_node->start_complete, msecs_to_jiffies(200))) {
1380                                 DRM_ERROR("timeout event:prop_id[%d]\n",
1381                                         c_node->property.prop_id);
1382                                 goto err_unlock;
1383                         }
1384                 }
1385                 break;
1386         case IPP_CTRL_STOP:
1387         case IPP_CTRL_PAUSE:
1388                 ret = ipp_stop_property(ippdrv->drm_dev, ippdrv,
1389                         c_node);
1390                 if (ret) {
1391                         DRM_ERROR("failed to stop property.\n");
1392                         goto err_unlock;
1393                 }
1394
1395                 complete(&c_node->stop_complete);
1396                 break;
1397         default:
1398                 DRM_ERROR("unknown control type\n");
1399                 break;
1400         }
1401
1402         DRM_DEBUG_KMS("ctrl[%d] done.\n", cmd_work->ctrl);
1403
1404 err_unlock:
1405         mutex_unlock(&c_node->lock);
1406 }
1407
1408 static int ipp_send_event(struct exynos_drm_ippdrv *ippdrv,
1409                 struct drm_exynos_ipp_cmd_node *c_node, int *buf_id)
1410 {
1411         struct drm_device *drm_dev = ippdrv->drm_dev;
1412         struct drm_exynos_ipp_property *property = &c_node->property;
1413         struct drm_exynos_ipp_mem_node *m_node;
1414         struct drm_exynos_ipp_queue_buf qbuf;
1415         struct drm_exynos_ipp_send_event *e;
1416         struct list_head *head;
1417         struct timeval now;
1418         unsigned long flags;
1419         u32 tbuf_id[EXYNOS_DRM_OPS_MAX] = {0, };
1420         int ret, i;
1421
1422         for_each_ipp_ops(i)
1423                 DRM_DEBUG_KMS("%s buf_id[%d]\n", i ? "dst" : "src", buf_id[i]);
1424
1425         if (!drm_dev) {
1426                 DRM_ERROR("failed to get drm_dev.\n");
1427                 return -EINVAL;
1428         }
1429
1430         if (!property) {
1431                 DRM_ERROR("failed to get property.\n");
1432                 return -EINVAL;
1433         }
1434
1435         mutex_lock(&c_node->event_lock);
1436         if (list_empty(&c_node->event_list)) {
1437                 DRM_DEBUG_KMS("event list is empty.\n");
1438                 ret = 0;
1439                 goto err_event_unlock;
1440         }
1441
1442         mutex_lock(&c_node->mem_lock);
1443         if (!ipp_check_mem_list(c_node)) {
1444                 DRM_DEBUG_KMS("empty memory.\n");
1445                 ret = 0;
1446                 goto err_mem_unlock;
1447         }
1448
1449         /* check command */
1450         switch (property->cmd) {
1451         case IPP_CMD_M2M:
1452                 for_each_ipp_ops(i) {
1453                         /* source/destination memory list */
1454                         head = &c_node->mem_list[i];
1455
1456                         m_node = list_first_entry(head,
1457                                 struct drm_exynos_ipp_mem_node, list);
1458
1459                         tbuf_id[i] = m_node->buf_id;
1460                         DRM_DEBUG_KMS("%s buf_id[%d]\n",
1461                                 i ? "dst" : "src", tbuf_id[i]);
1462
1463                         ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1464                         if (ret)
1465                                 DRM_ERROR("failed to put m_node.\n");
1466                 }
1467                 break;
1468         case IPP_CMD_WB:
1469                 /* clear buf for finding */
1470                 memset(&qbuf, 0x0, sizeof(qbuf));
1471                 qbuf.ops_id = EXYNOS_DRM_OPS_DST;
1472                 qbuf.buf_id = buf_id[EXYNOS_DRM_OPS_DST];
1473
1474                 /* get memory node entry */
1475                 m_node = ipp_find_mem_node(c_node, &qbuf);
1476                 if (!m_node) {
1477                         DRM_ERROR("empty memory node.\n");
1478                         ret = -ENOMEM;
1479                         goto err_mem_unlock;
1480                 }
1481
1482                 tbuf_id[EXYNOS_DRM_OPS_DST] = m_node->buf_id;
1483
1484                 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1485                 if (ret)
1486                         DRM_ERROR("failed to put m_node.\n");
1487                 break;
1488         case IPP_CMD_OUTPUT:
1489                 /* source memory list */
1490                 head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC];
1491
1492                 m_node = list_first_entry(head,
1493                         struct drm_exynos_ipp_mem_node, list);
1494
1495                 tbuf_id[EXYNOS_DRM_OPS_SRC] = m_node->buf_id;
1496
1497                 ret = ipp_put_mem_node(drm_dev, c_node, m_node);
1498                 if (ret)
1499                         DRM_ERROR("failed to put m_node.\n");
1500                 break;
1501         default:
1502                 DRM_ERROR("invalid operations.\n");
1503                 ret = -EINVAL;
1504                 goto err_mem_unlock;
1505         }
1506         mutex_unlock(&c_node->mem_lock);
1507
1508         if (tbuf_id[EXYNOS_DRM_OPS_DST] != buf_id[EXYNOS_DRM_OPS_DST])
1509                 DRM_ERROR("failed to match buf_id[%d %d]prop_id[%d]\n",
1510                         tbuf_id[1], buf_id[1], property->prop_id);
1511
1512         /*
1513          * command node have event list of destination buffer
1514          * If destination buffer enqueue to mem list,
1515          * then we make event and link to event list tail.
1516          * so, we get first event for first enqueued buffer.
1517          */
1518         e = list_first_entry(&c_node->event_list,
1519                 struct drm_exynos_ipp_send_event, base.link);
1520
1521         do_gettimeofday(&now);
1522         DRM_DEBUG_KMS("tv_sec[%ld]tv_usec[%ld]\n", now.tv_sec, now.tv_usec);
1523         e->event.tv_sec = now.tv_sec;
1524         e->event.tv_usec = now.tv_usec;
1525         e->event.prop_id = property->prop_id;
1526
1527         /* set buffer id about source destination */
1528         for_each_ipp_ops(i)
1529                 e->event.buf_id[i] = tbuf_id[i];
1530
1531         spin_lock_irqsave(&drm_dev->event_lock, flags);
1532         list_move_tail(&e->base.link, &e->base.file_priv->event_list);
1533         wake_up_interruptible(&e->base.file_priv->event_wait);
1534         spin_unlock_irqrestore(&drm_dev->event_lock, flags);
1535         mutex_unlock(&c_node->event_lock);
1536
1537         DRM_DEBUG_KMS("done cmd[%d]prop_id[%d]buf_id[%d]\n",
1538                 property->cmd, property->prop_id, tbuf_id[EXYNOS_DRM_OPS_DST]);
1539
1540         return 0;
1541
1542 err_mem_unlock:
1543         mutex_unlock(&c_node->mem_lock);
1544 err_event_unlock:
1545         mutex_unlock(&c_node->event_lock);
1546         return ret;
1547 }
1548
1549 void ipp_sched_event(struct work_struct *work)
1550 {
1551         struct drm_exynos_ipp_event_work *event_work =
1552                 container_of(work, struct drm_exynos_ipp_event_work, work);
1553         struct exynos_drm_ippdrv *ippdrv;
1554         struct drm_exynos_ipp_cmd_node *c_node;
1555         int ret;
1556
1557         if (!event_work) {
1558                 DRM_ERROR("failed to get event_work.\n");
1559                 return;
1560         }
1561
1562         DRM_DEBUG_KMS("buf_id[%d]\n", event_work->buf_id[EXYNOS_DRM_OPS_DST]);
1563
1564         ippdrv = event_work->ippdrv;
1565         if (!ippdrv) {
1566                 DRM_ERROR("failed to get ipp driver.\n");
1567                 return;
1568         }
1569
1570         c_node = ippdrv->c_node;
1571         if (!c_node) {
1572                 DRM_ERROR("failed to get command node.\n");
1573                 return;
1574         }
1575
1576         /*
1577          * IPP supports command thread, event thread synchronization.
1578          * If IPP close immediately from user land, then IPP make
1579          * synchronization with command thread, so make complete event.
1580          * or going out operations.
1581          */
1582         if (c_node->state != IPP_STATE_START) {
1583                 DRM_DEBUG_KMS("bypass state[%d]prop_id[%d]\n",
1584                         c_node->state, c_node->property.prop_id);
1585                 goto err_completion;
1586         }
1587
1588         ret = ipp_send_event(ippdrv, c_node, event_work->buf_id);
1589         if (ret) {
1590                 DRM_ERROR("failed to send event.\n");
1591                 goto err_completion;
1592         }
1593
1594 err_completion:
1595         if (ipp_is_m2m_cmd(c_node->property.cmd))
1596                 complete(&c_node->start_complete);
1597 }
1598
1599 static int ipp_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
1600 {
1601         struct ipp_context *ctx = get_ipp_context(dev);
1602         struct exynos_drm_ippdrv *ippdrv;
1603         int ret, count = 0;
1604
1605         /* get ipp driver entry */
1606         list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
1607                 ippdrv->drm_dev = drm_dev;
1608
1609                 ret = ipp_create_id(&ctx->ipp_idr, &ctx->ipp_lock, ippdrv);
1610                 if (ret < 0) {
1611                         DRM_ERROR("failed to create id.\n");
1612                         goto err;
1613                 }
1614                 ippdrv->prop_list.ipp_id = ret;
1615
1616                 DRM_DEBUG_KMS("count[%d]ippdrv[0x%x]ipp_id[%d]\n",
1617                         count++, (int)ippdrv, ret);
1618
1619                 /* store parent device for node */
1620                 ippdrv->parent_dev = dev;
1621
1622                 /* store event work queue and handler */
1623                 ippdrv->event_workq = ctx->event_workq;
1624                 ippdrv->sched_event = ipp_sched_event;
1625                 INIT_LIST_HEAD(&ippdrv->cmd_list);
1626                 mutex_init(&ippdrv->cmd_lock);
1627
1628                 if (is_drm_iommu_supported(drm_dev)) {
1629                         ret = drm_iommu_attach_device(drm_dev, ippdrv->dev);
1630                         if (ret) {
1631                                 DRM_ERROR("failed to activate iommu\n");
1632                                 goto err;
1633                         }
1634                 }
1635         }
1636
1637         return 0;
1638
1639 err:
1640         /* get ipp driver entry */
1641         list_for_each_entry_continue_reverse(ippdrv, &exynos_drm_ippdrv_list,
1642                                                 drv_list) {
1643                 if (is_drm_iommu_supported(drm_dev))
1644                         drm_iommu_detach_device(drm_dev, ippdrv->dev);
1645
1646                 ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock,
1647                                 ippdrv->prop_list.ipp_id);
1648         }
1649
1650         return ret;
1651 }
1652
1653 static void ipp_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
1654 {
1655         struct exynos_drm_ippdrv *ippdrv, *t;
1656         struct ipp_context *ctx = get_ipp_context(dev);
1657
1658         /* get ipp driver entry */
1659         list_for_each_entry_safe(ippdrv, t, &exynos_drm_ippdrv_list, drv_list) {
1660                 if (is_drm_iommu_supported(drm_dev))
1661                         drm_iommu_detach_device(drm_dev, ippdrv->dev);
1662
1663                 ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock,
1664                                 ippdrv->prop_list.ipp_id);
1665
1666                 ippdrv->drm_dev = NULL;
1667                 exynos_drm_ippdrv_unregister(ippdrv);
1668         }
1669 }
1670
1671 static int ipp_subdrv_open(struct drm_device *drm_dev, struct device *dev,
1672                 struct drm_file *file)
1673 {
1674         struct drm_exynos_file_private *file_priv = file->driver_priv;
1675
1676         file_priv->ipp_dev = dev;
1677
1678         DRM_DEBUG_KMS("done priv[0x%x]\n", (int)dev);
1679
1680         return 0;
1681 }
1682
1683 static void ipp_subdrv_close(struct drm_device *drm_dev, struct device *dev,
1684                 struct drm_file *file)
1685 {
1686         struct exynos_drm_ippdrv *ippdrv = NULL;
1687         struct ipp_context *ctx = get_ipp_context(dev);
1688         struct drm_exynos_ipp_cmd_node *c_node, *tc_node;
1689         int count = 0;
1690
1691         list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) {
1692                 mutex_lock(&ippdrv->cmd_lock);
1693                 list_for_each_entry_safe(c_node, tc_node,
1694                         &ippdrv->cmd_list, list) {
1695                         DRM_DEBUG_KMS("count[%d]ippdrv[0x%x]\n",
1696                                 count++, (int)ippdrv);
1697
1698                         if (c_node->filp == file) {
1699                                 /*
1700                                  * userland goto unnormal state. process killed.
1701                                  * and close the file.
1702                                  * so, IPP didn't called stop cmd ctrl.
1703                                  * so, we are make stop operation in this state.
1704                                  */
1705                                 if (c_node->state == IPP_STATE_START) {
1706                                         ipp_stop_property(drm_dev, ippdrv,
1707                                                 c_node);
1708                                         c_node->state = IPP_STATE_STOP;
1709                                 }
1710
1711                                 ippdrv->dedicated = false;
1712                                 ipp_clean_cmd_node(ctx, c_node);
1713                                 if (list_empty(&ippdrv->cmd_list))
1714                                         pm_runtime_put_sync(ippdrv->dev);
1715                         }
1716                 }
1717                 mutex_unlock(&ippdrv->cmd_lock);
1718         }
1719
1720         return;
1721 }
1722
1723 static int ipp_probe(struct platform_device *pdev)
1724 {
1725         struct device *dev = &pdev->dev;
1726         struct ipp_context *ctx;
1727         struct exynos_drm_subdrv *subdrv;
1728         int ret;
1729
1730         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
1731         if (!ctx)
1732                 return -ENOMEM;
1733
1734         mutex_init(&ctx->ipp_lock);
1735         mutex_init(&ctx->prop_lock);
1736
1737         idr_init(&ctx->ipp_idr);
1738         idr_init(&ctx->prop_idr);
1739
1740         /*
1741          * create single thread for ipp event
1742          * IPP supports event thread for IPP drivers.
1743          * IPP driver send event_work to this thread.
1744          * and IPP event thread send event to user process.
1745          */
1746         ctx->event_workq = create_singlethread_workqueue("ipp_event");
1747         if (!ctx->event_workq) {
1748                 dev_err(dev, "failed to create event workqueue\n");
1749                 return -EINVAL;
1750         }
1751
1752         /*
1753          * create single thread for ipp command
1754          * IPP supports command thread for user process.
1755          * user process make command node using set property ioctl.
1756          * and make start_work and send this work to command thread.
1757          * and then this command thread start property.
1758          */
1759         ctx->cmd_workq = create_singlethread_workqueue("ipp_cmd");
1760         if (!ctx->cmd_workq) {
1761                 dev_err(dev, "failed to create cmd workqueue\n");
1762                 ret = -EINVAL;
1763                 goto err_event_workq;
1764         }
1765
1766         /* set sub driver informations */
1767         subdrv = &ctx->subdrv;
1768         subdrv->dev = dev;
1769         subdrv->probe = ipp_subdrv_probe;
1770         subdrv->remove = ipp_subdrv_remove;
1771         subdrv->open = ipp_subdrv_open;
1772         subdrv->close = ipp_subdrv_close;
1773
1774         platform_set_drvdata(pdev, ctx);
1775
1776         ret = exynos_drm_subdrv_register(subdrv);
1777         if (ret < 0) {
1778                 DRM_ERROR("failed to register drm ipp device.\n");
1779                 goto err_cmd_workq;
1780         }
1781
1782         dev_info(dev, "drm ipp registered successfully.\n");
1783
1784         return 0;
1785
1786 err_cmd_workq:
1787         destroy_workqueue(ctx->cmd_workq);
1788 err_event_workq:
1789         destroy_workqueue(ctx->event_workq);
1790         return ret;
1791 }
1792
1793 static int ipp_remove(struct platform_device *pdev)
1794 {
1795         struct ipp_context *ctx = platform_get_drvdata(pdev);
1796
1797         /* unregister sub driver */
1798         exynos_drm_subdrv_unregister(&ctx->subdrv);
1799
1800         /* remove,destroy ipp idr */
1801         idr_destroy(&ctx->ipp_idr);
1802         idr_destroy(&ctx->prop_idr);
1803
1804         mutex_destroy(&ctx->ipp_lock);
1805         mutex_destroy(&ctx->prop_lock);
1806
1807         /* destroy command, event work queue */
1808         destroy_workqueue(ctx->cmd_workq);
1809         destroy_workqueue(ctx->event_workq);
1810
1811         return 0;
1812 }
1813
1814 struct platform_driver ipp_driver = {
1815         .probe          = ipp_probe,
1816         .remove         = ipp_remove,
1817         .driver         = {
1818                 .name   = "exynos-drm-ipp",
1819                 .owner  = THIS_MODULE,
1820         },
1821 };
1822