drivers/gpu/drm/exynos/exynos_drm_g2d.c

   1 /*
   2  * Copyright (C) 2012 Samsung Electronics Co.Ltd
   3  * Authors: Joonyoung Shim <jy0922.shim@samsung.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundationr
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/clk.h>
  13 #include <linux/err.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/io.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/slab.h>
  19 #include <linux/workqueue.h>
  20
  21 #include <drm/drmP.h>
  22 #include <drm/exynos_drm.h>
  23 #include "exynos_drm_drv.h"
  24 #include "exynos_drm_gem.h"
  25
  26 #define G2D_HW_MAJOR_VER                4
  27 #define G2D_HW_MINOR_VER                1
  28
  29 /* vaild register range set from user: 0x0104 ~ 0x0880 */
  30 #define G2D_VALID_START                 0x0104
  31 #define G2D_VALID_END                   0x0880
  32
  33 /* general registers */
  34 #define G2D_SOFT_RESET                  0x0000
  35 #define G2D_INTEN                       0x0004
  36 #define G2D_INTC_PEND                   0x000C
  37 #define G2D_DMA_SFR_BASE_ADDR           0x0080
  38 #define G2D_DMA_COMMAND                 0x0084
  39 #define G2D_DMA_STATUS                  0x008C
  40 #define G2D_DMA_HOLD_CMD                0x0090
  41
  42 /* command registers */
  43 #define G2D_BITBLT_START                0x0100
  44
  45 /* registers for base address */
  46 #define G2D_SRC_BASE_ADDR               0x0304
  47 #define G2D_SRC_PLANE2_BASE_ADDR        0x0318
  48 #define G2D_DST_BASE_ADDR               0x0404
  49 #define G2D_DST_PLANE2_BASE_ADDR        0x0418
  50 #define G2D_PAT_BASE_ADDR               0x0500
  51 #define G2D_MSK_BASE_ADDR               0x0520
  52
  53 /* G2D_SOFT_RESET */
  54 #define G2D_SFRCLEAR                    (1 << 1)
  55 #define G2D_R                           (1 << 0)
  56
  57 /* G2D_INTEN */
  58 #define G2D_INTEN_ACF                   (1 << 3)
  59 #define G2D_INTEN_UCF                   (1 << 2)
  60 #define G2D_INTEN_GCF                   (1 << 1)
  61 #define G2D_INTEN_SCF                   (1 << 0)
  62
  63 /* G2D_INTC_PEND */
  64 #define G2D_INTP_ACMD_FIN               (1 << 3)
  65 #define G2D_INTP_UCMD_FIN               (1 << 2)
  66 #define G2D_INTP_GCMD_FIN               (1 << 1)
  67 #define G2D_INTP_SCMD_FIN               (1 << 0)
  68
  69 /* G2D_DMA_COMMAND */
  70 #define G2D_DMA_HALT                    (1 << 2)
  71 #define G2D_DMA_CONTINUE                (1 << 1)
  72 #define G2D_DMA_START                   (1 << 0)
  73
  74 /* G2D_DMA_STATUS */
  75 #define G2D_DMA_LIST_DONE_COUNT         (0xFF << 17)
  76 #define G2D_DMA_BITBLT_DONE_COUNT       (0xFFFF << 1)
  77 #define G2D_DMA_DONE                    (1 << 0)
  78 #define G2D_DMA_LIST_DONE_COUNT_OFFSET  17
  79
  80 /* G2D_DMA_HOLD_CMD */
  81 #define G2D_USET_HOLD                   (1 << 2)
  82 #define G2D_LIST_HOLD                   (1 << 1)
  83 #define G2D_BITBLT_HOLD                 (1 << 0)
  84
  85 /* G2D_BITBLT_START */
  86 #define G2D_START_CASESEL               (1 << 2)
  87 #define G2D_START_NHOLT                 (1 << 1)
  88 #define G2D_START_BITBLT                (1 << 0)
  89
  90 #define G2D_CMDLIST_SIZE                (PAGE_SIZE / 4)
  91 #define G2D_CMDLIST_NUM                 64
  92 #define G2D_CMDLIST_POOL_SIZE           (G2D_CMDLIST_SIZE * G2D_CMDLIST_NUM)
  93 #define G2D_CMDLIST_DATA_NUM            (G2D_CMDLIST_SIZE / sizeof(u32) - 2)
  94
  95 /* cmdlist data structure */
  96 struct g2d_cmdlist {
  97         u32     head;
  98         u32     data[G2D_CMDLIST_DATA_NUM];
  99         u32     last;   /* last data offset */
 100 };
 101
 102 struct drm_exynos_pending_g2d_event {
 103         struct drm_pending_event        base;
 104         struct drm_exynos_g2d_event     event;
 105 };
 106
 107 struct g2d_gem_node {
 108         struct list_head        list;
 109         unsigned int            handle;
 110 };
 111
 112 struct g2d_cmdlist_node {
 113         struct list_head        list;
 114         struct g2d_cmdlist      *cmdlist;
 115         unsigned int            gem_nr;
 116         dma_addr_t              dma_addr;
 117
 118         struct drm_exynos_pending_g2d_event     *event;
 119 };
 120
 121 struct g2d_runqueue_node {
 122         struct list_head        list;
 123         struct list_head        run_cmdlist;
 124         struct list_head        event_list;
 125         pid_t                   pid;
 126         struct completion       complete;
 127         int                     async;
 128 };
 129
 130 struct g2d_data {
 131         struct device                   *dev;
 132         struct clk                      *gate_clk;
 133         void __iomem                    *regs;
 134         int                             irq;
 135         struct workqueue_struct         *g2d_workq;
 136         struct work_struct              runqueue_work;
 137         struct exynos_drm_subdrv        subdrv;
 138         bool                            suspended;
 139
 140         /* cmdlist */
 141         struct g2d_cmdlist_node         *cmdlist_node;
 142         struct list_head                free_cmdlist;
 143         struct mutex                    cmdlist_mutex;
 144         dma_addr_t                      cmdlist_pool;
 145         void                            *cmdlist_pool_virt;
 146
 147         /* runqueue*/
 148         struct g2d_runqueue_node        *runqueue_node;
 149         struct list_head                runqueue;
 150         struct mutex                    runqueue_mutex;
 151         struct kmem_cache               *runqueue_slab;
 152 };
 153
 154 static int g2d_init_cmdlist(struct g2d_data *g2d)
 155 {
 156         struct device *dev = g2d->dev;
 157         struct g2d_cmdlist_node *node = g2d->cmdlist_node;
 158         int nr;
 159         int ret;
 160
 161         g2d->cmdlist_pool_virt = dma_alloc_coherent(dev, G2D_CMDLIST_POOL_SIZE,
 162                                                 &g2d->cmdlist_pool, GFP_KERNEL);
 163         if (!g2d->cmdlist_pool_virt) {
 164                 dev_err(dev, "failed to allocate dma memory\n");
 165                 return -ENOMEM;
 166         }
 167
 168         node = kcalloc(G2D_CMDLIST_NUM, sizeof(*node), GFP_KERNEL);
 169         if (!node) {
 170                 dev_err(dev, "failed to allocate memory\n");
 171                 ret = -ENOMEM;
 172                 goto err;
 173         }
 174
 175         for (nr = 0; nr < G2D_CMDLIST_NUM; nr++) {
 176                 node[nr].cmdlist =
 177                         g2d->cmdlist_pool_virt + nr * G2D_CMDLIST_SIZE;
 178                 node[nr].dma_addr =
 179                         g2d->cmdlist_pool + nr * G2D_CMDLIST_SIZE;
 180
 181                 list_add_tail(&node[nr].list, &g2d->free_cmdlist);
 182         }
 183
 184         return 0;
 185
 186 err:
 187         dma_free_coherent(dev, G2D_CMDLIST_POOL_SIZE, g2d->cmdlist_pool_virt,
 188                         g2d->cmdlist_pool);
 189         return ret;
 190 }
 191
 192 static void g2d_fini_cmdlist(struct g2d_data *g2d)
 193 {
 194         struct device *dev = g2d->dev;
 195
 196         kfree(g2d->cmdlist_node);
 197         dma_free_coherent(dev, G2D_CMDLIST_POOL_SIZE, g2d->cmdlist_pool_virt,
 198                         g2d->cmdlist_pool);
 199 }
 200
 201 static struct g2d_cmdlist_node *g2d_get_cmdlist(struct g2d_data *g2d)
 202 {
 203         struct device *dev = g2d->dev;
 204         struct g2d_cmdlist_node *node;
 205
 206         mutex_lock(&g2d->cmdlist_mutex);
 207         if (list_empty(&g2d->free_cmdlist)) {
 208                 dev_err(dev, "there is no free cmdlist\n");
 209                 mutex_unlock(&g2d->cmdlist_mutex);
 210                 return NULL;
 211         }
 212
 213         node = list_first_entry(&g2d->free_cmdlist, struct g2d_cmdlist_node,
 214                                 list);
 215         list_del_init(&node->list);
 216         mutex_unlock(&g2d->cmdlist_mutex);
 217
 218         return node;
 219 }
 220
 221 static void g2d_put_cmdlist(struct g2d_data *g2d, struct g2d_cmdlist_node *node)
 222 {
 223         mutex_lock(&g2d->cmdlist_mutex);
 224         list_move_tail(&node->list, &g2d->free_cmdlist);
 225         mutex_unlock(&g2d->cmdlist_mutex);
 226 }
 227
 228 static void g2d_add_cmdlist_to_inuse(struct exynos_drm_g2d_private *g2d_priv,
 229                                      struct g2d_cmdlist_node *node)
 230 {
 231         struct g2d_cmdlist_node *lnode;
 232
 233         if (list_empty(&g2d_priv->inuse_cmdlist))
 234                 goto add_to_list;
 235
 236         /* this links to base address of new cmdlist */
 237         lnode = list_entry(g2d_priv->inuse_cmdlist.prev,
 238                                 struct g2d_cmdlist_node, list);
 239         lnode->cmdlist->data[lnode->cmdlist->last] = node->dma_addr;
 240
 241 add_to_list:
 242         list_add_tail(&node->list, &g2d_priv->inuse_cmdlist);
 243
 244         if (node->event)
 245                 list_add_tail(&node->event->base.link, &g2d_priv->event_list);
 246 }
 247
 248 static int g2d_get_cmdlist_gem(struct drm_device *drm_dev,
 249                                struct drm_file *file,
 250                                struct g2d_cmdlist_node *node)
 251 {
 252         struct drm_exynos_file_private *file_priv = file->driver_priv;
 253         struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
 254         struct g2d_cmdlist *cmdlist = node->cmdlist;
 255         dma_addr_t *addr;
 256         int offset;
 257         int i;
 258
 259         for (i = 0; i < node->gem_nr; i++) {
 260                 struct g2d_gem_node *gem_node;
 261
 262                 gem_node = kzalloc(sizeof(*gem_node), GFP_KERNEL);
 263                 if (!gem_node) {
 264                         dev_err(g2d_priv->dev, "failed to allocate gem node\n");
 265                         return -ENOMEM;
 266                 }
 267
 268                 offset = cmdlist->last - (i * 2 + 1);
 269                 gem_node->handle = cmdlist->data[offset];
 270
 271                 addr = exynos_drm_gem_get_dma_addr(drm_dev, gem_node->handle,
 272                                                    file);
 273                 if (IS_ERR(addr)) {
 274                         node->gem_nr = i;
 275                         kfree(gem_node);
 276                         return PTR_ERR(addr);
 277                 }
 278
 279                 cmdlist->data[offset] = *addr;
 280                 list_add_tail(&gem_node->list, &g2d_priv->gem_list);
 281                 g2d_priv->gem_nr++;
 282         }
 283
 284         return 0;
 285 }
 286
 287 static void g2d_put_cmdlist_gem(struct drm_device *drm_dev,
 288                                 struct drm_file *file,
 289                                 unsigned int nr)
 290 {
 291         struct drm_exynos_file_private *file_priv = file->driver_priv;
 292         struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
 293         struct g2d_gem_node *node, *n;
 294
 295         list_for_each_entry_safe_reverse(node, n, &g2d_priv->gem_list, list) {
 296                 if (!nr)
 297                         break;
 298
 299                 exynos_drm_gem_put_dma_addr(drm_dev, node->handle, file);
 300                 list_del_init(&node->list);
 301                 kfree(node);
 302                 nr--;
 303         }
 304 }
 305
 306 static void g2d_dma_start(struct g2d_data *g2d,
 307                           struct g2d_runqueue_node *runqueue_node)
 308 {
 309         struct g2d_cmdlist_node *node =
 310                                 list_first_entry(&runqueue_node->run_cmdlist,
 311                                                 struct g2d_cmdlist_node, list);
 312
 313         pm_runtime_get_sync(g2d->dev);
 314         clk_enable(g2d->gate_clk);
 315
 316         /* interrupt enable */
 317         writel_relaxed(G2D_INTEN_ACF | G2D_INTEN_UCF | G2D_INTEN_GCF,
 318                         g2d->regs + G2D_INTEN);
 319
 320         writel_relaxed(node->dma_addr, g2d->regs + G2D_DMA_SFR_BASE_ADDR);
 321         writel_relaxed(G2D_DMA_START, g2d->regs + G2D_DMA_COMMAND);
 322 }
 323
 324 static struct g2d_runqueue_node *g2d_get_runqueue_node(struct g2d_data *g2d)
 325 {
 326         struct g2d_runqueue_node *runqueue_node;
 327
 328         if (list_empty(&g2d->runqueue))
 329                 return NULL;
 330
 331         runqueue_node = list_first_entry(&g2d->runqueue,
 332                                          struct g2d_runqueue_node, list);
 333         list_del_init(&runqueue_node->list);
 334         return runqueue_node;
 335 }
 336
 337 static void g2d_free_runqueue_node(struct g2d_data *g2d,
 338                                    struct g2d_runqueue_node *runqueue_node)
 339 {
 340         if (!runqueue_node)
 341                 return;
 342
 343         mutex_lock(&g2d->cmdlist_mutex);
 344         list_splice_tail_init(&runqueue_node->run_cmdlist, &g2d->free_cmdlist);
 345         mutex_unlock(&g2d->cmdlist_mutex);
 346
 347         kmem_cache_free(g2d->runqueue_slab, runqueue_node);
 348 }
 349
 350 static void g2d_exec_runqueue(struct g2d_data *g2d)
 351 {
 352         g2d->runqueue_node = g2d_get_runqueue_node(g2d);
 353         if (g2d->runqueue_node)
 354                 g2d_dma_start(g2d, g2d->runqueue_node);
 355 }
 356
 357 static void g2d_runqueue_worker(struct work_struct *work)
 358 {
 359         struct g2d_data *g2d = container_of(work, struct g2d_data,
 360                                             runqueue_work);
 361
 362
 363         mutex_lock(&g2d->runqueue_mutex);
 364         clk_disable(g2d->gate_clk);
 365         pm_runtime_put_sync(g2d->dev);
 366
 367         complete(&g2d->runqueue_node->complete);
 368         if (g2d->runqueue_node->async)
 369                 g2d_free_runqueue_node(g2d, g2d->runqueue_node);
 370
 371         if (g2d->suspended)
 372                 g2d->runqueue_node = NULL;
 373         else
 374                 g2d_exec_runqueue(g2d);
 375         mutex_unlock(&g2d->runqueue_mutex);
 376 }
 377
 378 static void g2d_finish_event(struct g2d_data *g2d, u32 cmdlist_no)
 379 {
 380         struct drm_device *drm_dev = g2d->subdrv.drm_dev;
 381         struct g2d_runqueue_node *runqueue_node = g2d->runqueue_node;
 382         struct drm_exynos_pending_g2d_event *e;
 383         struct timeval now;
 384         unsigned long flags;
 385
 386         if (list_empty(&runqueue_node->event_list))
 387                 return;
 388
 389         e = list_first_entry(&runqueue_node->event_list,
 390                              struct drm_exynos_pending_g2d_event, base.link);
 391
 392         do_gettimeofday(&now);
 393         e->event.tv_sec = now.tv_sec;
 394         e->event.tv_usec = now.tv_usec;
 395         e->event.cmdlist_no = cmdlist_no;
 396
 397         spin_lock_irqsave(&drm_dev->event_lock, flags);
 398         list_move_tail(&e->base.link, &e->base.file_priv->event_list);
 399         wake_up_interruptible(&e->base.file_priv->event_wait);
 400         spin_unlock_irqrestore(&drm_dev->event_lock, flags);
 401 }
 402
 403 static irqreturn_t g2d_irq_handler(int irq, void *dev_id)
 404 {
 405         struct g2d_data *g2d = dev_id;
 406         u32 pending;
 407
 408         pending = readl_relaxed(g2d->regs + G2D_INTC_PEND);
 409         if (pending)
 410                 writel_relaxed(pending, g2d->regs + G2D_INTC_PEND);
 411
 412         if (pending & G2D_INTP_GCMD_FIN) {
 413                 u32 cmdlist_no = readl_relaxed(g2d->regs + G2D_DMA_STATUS);
 414
 415                 cmdlist_no = (cmdlist_no & G2D_DMA_LIST_DONE_COUNT) >>
 416                                                 G2D_DMA_LIST_DONE_COUNT_OFFSET;
 417
 418                 g2d_finish_event(g2d, cmdlist_no);
 419
 420                 writel_relaxed(0, g2d->regs + G2D_DMA_HOLD_CMD);
 421                 if (!(pending & G2D_INTP_ACMD_FIN)) {
 422                         writel_relaxed(G2D_DMA_CONTINUE,
 423                                         g2d->regs + G2D_DMA_COMMAND);
 424                 }
 425         }
 426
 427         if (pending & G2D_INTP_ACMD_FIN)
 428                 queue_work(g2d->g2d_workq, &g2d->runqueue_work);
 429
 430         return IRQ_HANDLED;
 431 }
 432
 433 static int g2d_check_reg_offset(struct device *dev, struct g2d_cmdlist *cmdlist,
 434                                 int nr, bool for_addr)
 435 {
 436         int reg_offset;
 437         int index;
 438         int i;
 439
 440         for (i = 0; i < nr; i++) {
 441                 index = cmdlist->last - 2 * (i + 1);
 442                 reg_offset = cmdlist->data[index] & ~0xfffff000;
 443
 444                 if (reg_offset < G2D_VALID_START || reg_offset > G2D_VALID_END)
 445                         goto err;
 446                 if (reg_offset % 4)
 447                         goto err;
 448
 449                 switch (reg_offset) {
 450                 case G2D_SRC_BASE_ADDR:
 451                 case G2D_SRC_PLANE2_BASE_ADDR:
 452                 case G2D_DST_BASE_ADDR:
 453                 case G2D_DST_PLANE2_BASE_ADDR:
 454                 case G2D_PAT_BASE_ADDR:
 455                 case G2D_MSK_BASE_ADDR:
 456                         if (!for_addr)
 457                                 goto err;
 458                         break;
 459                 default:
 460                         if (for_addr)
 461                                 goto err;
 462                         break;
 463                 }
 464         }
 465
 466         return 0;
 467
 468 err:
 469         dev_err(dev, "Bad register offset: 0x%x\n", cmdlist->data[index]);
 470         return -EINVAL;
 471 }
 472
 473 /* ioctl functions */
 474 int exynos_g2d_get_ver_ioctl(struct drm_device *drm_dev, void *data,
 475                              struct drm_file *file)
 476 {
 477         struct drm_exynos_g2d_get_ver *ver = data;
 478
 479         ver->major = G2D_HW_MAJOR_VER;
 480         ver->minor = G2D_HW_MINOR_VER;
 481
 482         return 0;
 483 }
 484 EXPORT_SYMBOL_GPL(exynos_g2d_get_ver_ioctl);
 485
 486 int exynos_g2d_set_cmdlist_ioctl(struct drm_device *drm_dev, void *data,
 487                                  struct drm_file *file)
 488 {
 489         struct drm_exynos_file_private *file_priv = file->driver_priv;
 490         struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
 491         struct device *dev = g2d_priv->dev;
 492         struct g2d_data *g2d;
 493         struct drm_exynos_g2d_set_cmdlist *req = data;
 494         struct drm_exynos_g2d_cmd *cmd;
 495         struct drm_exynos_pending_g2d_event *e;
 496         struct g2d_cmdlist_node *node;
 497         struct g2d_cmdlist *cmdlist;
 498         unsigned long flags;
 499         int size;
 500         int ret;
 501
 502         if (!dev)
 503                 return -ENODEV;
 504
 505         g2d = dev_get_drvdata(dev);
 506         if (!g2d)
 507                 return -EFAULT;
 508
 509         node = g2d_get_cmdlist(g2d);
 510         if (!node)
 511                 return -ENOMEM;
 512
 513         node->event = NULL;
 514
 515         if (req->event_type != G2D_EVENT_NOT) {
 516                 spin_lock_irqsave(&drm_dev->event_lock, flags);
 517                 if (file->event_space < sizeof(e->event)) {
 518                         spin_unlock_irqrestore(&drm_dev->event_lock, flags);
 519                         ret = -ENOMEM;
 520                         goto err;
 521                 }
 522                 file->event_space -= sizeof(e->event);
 523                 spin_unlock_irqrestore(&drm_dev->event_lock, flags);
 524
 525                 e = kzalloc(sizeof(*node->event), GFP_KERNEL);
 526                 if (!e) {
 527                         dev_err(dev, "failed to allocate event\n");
 528
 529                         spin_lock_irqsave(&drm_dev->event_lock, flags);
 530                         file->event_space += sizeof(e->event);
 531                         spin_unlock_irqrestore(&drm_dev->event_lock, flags);
 532
 533                         ret = -ENOMEM;
 534                         goto err;
 535                 }
 536
 537                 e->event.base.type = DRM_EXYNOS_G2D_EVENT;
 538                 e->event.base.length = sizeof(e->event);
 539                 e->event.user_data = req->user_data;
 540                 e->base.event = &e->event.base;
 541                 e->base.file_priv = file;
 542                 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
 543
 544                 node->event = e;
 545         }
 546
 547         cmdlist = node->cmdlist;
 548
 549         cmdlist->last = 0;
 550
 551         /*
 552          * If don't clear SFR registers, the cmdlist is affected by register
 553          * values of previous cmdlist. G2D hw executes SFR clear command and
 554          * a next command at the same time then the next command is ignored and
 555          * is executed rightly from next next command, so needs a dummy command
 556          * to next command of SFR clear command.
 557          */
 558         cmdlist->data[cmdlist->last++] = G2D_SOFT_RESET;
 559         cmdlist->data[cmdlist->last++] = G2D_SFRCLEAR;
 560         cmdlist->data[cmdlist->last++] = G2D_SRC_BASE_ADDR;
 561         cmdlist->data[cmdlist->last++] = 0;
 562
 563         if (node->event) {
 564                 cmdlist->data[cmdlist->last++] = G2D_DMA_HOLD_CMD;
 565                 cmdlist->data[cmdlist->last++] = G2D_LIST_HOLD;
 566         }
 567
 568         /* Check size of cmdlist: last 2 is about G2D_BITBLT_START */
 569         size = cmdlist->last + req->cmd_nr * 2 + req->cmd_gem_nr * 2 + 2;
 570         if (size > G2D_CMDLIST_DATA_NUM) {
 571                 dev_err(dev, "cmdlist size is too big\n");
 572                 ret = -EINVAL;
 573                 goto err_free_event;
 574         }
 575
 576         cmd = (struct drm_exynos_g2d_cmd *)(uint32_t)req->cmd;
 577
 578         if (copy_from_user(cmdlist->data + cmdlist->last,
 579                                 (void __user *)cmd,
 580                                 sizeof(*cmd) * req->cmd_nr)) {
 581                 ret = -EFAULT;
 582                 goto err_free_event;
 583         }
 584         cmdlist->last += req->cmd_nr * 2;
 585
 586         ret = g2d_check_reg_offset(dev, cmdlist, req->cmd_nr, false);
 587         if (ret < 0)
 588                 goto err_free_event;
 589
 590         node->gem_nr = req->cmd_gem_nr;
 591         if (req->cmd_gem_nr) {
 592                 struct drm_exynos_g2d_cmd *cmd_gem;
 593
 594                 cmd_gem = (struct drm_exynos_g2d_cmd *)(uint32_t)req->cmd_gem;
 595
 596                 if (copy_from_user(cmdlist->data + cmdlist->last,
 597                                         (void __user *)cmd_gem,
 598                                         sizeof(*cmd_gem) * req->cmd_gem_nr)) {
 599                         ret = -EFAULT;
 600                         goto err_free_event;
 601                 }
 602                 cmdlist->last += req->cmd_gem_nr * 2;
 603
 604                 ret = g2d_check_reg_offset(dev, cmdlist, req->cmd_gem_nr, true);
 605                 if (ret < 0)
 606                         goto err_free_event;
 607
 608                 ret = g2d_get_cmdlist_gem(drm_dev, file, node);
 609                 if (ret < 0)
 610                         goto err_unmap;
 611         }
 612
 613         cmdlist->data[cmdlist->last++] = G2D_BITBLT_START;
 614         cmdlist->data[cmdlist->last++] = G2D_START_BITBLT;
 615
 616         /* head */
 617         cmdlist->head = cmdlist->last / 2;
 618
 619         /* tail */
 620         cmdlist->data[cmdlist->last] = 0;
 621
 622         g2d_add_cmdlist_to_inuse(g2d_priv, node);
 623
 624         return 0;
 625
 626 err_unmap:
 627         g2d_put_cmdlist_gem(drm_dev, file, node->gem_nr);
 628 err_free_event:
 629         if (node->event) {
 630                 spin_lock_irqsave(&drm_dev->event_lock, flags);
 631                 file->event_space += sizeof(e->event);
 632                 spin_unlock_irqrestore(&drm_dev->event_lock, flags);
 633                 kfree(node->event);
 634         }
 635 err:
 636         g2d_put_cmdlist(g2d, node);
 637         return ret;
 638 }
 639 EXPORT_SYMBOL_GPL(exynos_g2d_set_cmdlist_ioctl);
 640
 641 int exynos_g2d_exec_ioctl(struct drm_device *drm_dev, void *data,
 642                           struct drm_file *file)
 643 {
 644         struct drm_exynos_file_private *file_priv = file->driver_priv;
 645         struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
 646         struct device *dev = g2d_priv->dev;
 647         struct g2d_data *g2d;
 648         struct drm_exynos_g2d_exec *req = data;
 649         struct g2d_runqueue_node *runqueue_node;
 650         struct list_head *run_cmdlist;
 651         struct list_head *event_list;
 652
 653         if (!dev)
 654                 return -ENODEV;
 655
 656         g2d = dev_get_drvdata(dev);
 657         if (!g2d)
 658                 return -EFAULT;
 659
 660         runqueue_node = kmem_cache_alloc(g2d->runqueue_slab, GFP_KERNEL);
 661         if (!runqueue_node) {
 662                 dev_err(dev, "failed to allocate memory\n");
 663                 return -ENOMEM;
 664         }
 665         run_cmdlist = &runqueue_node->run_cmdlist;
 666         event_list = &runqueue_node->event_list;
 667         INIT_LIST_HEAD(run_cmdlist);
 668         INIT_LIST_HEAD(event_list);
 669         init_completion(&runqueue_node->complete);
 670         runqueue_node->async = req->async;
 671
 672         list_splice_init(&g2d_priv->inuse_cmdlist, run_cmdlist);
 673         list_splice_init(&g2d_priv->event_list, event_list);
 674
 675         if (list_empty(run_cmdlist)) {
 676                 dev_err(dev, "there is no inuse cmdlist\n");
 677                 kmem_cache_free(g2d->runqueue_slab, runqueue_node);
 678                 return -EPERM;
 679         }
 680
 681         mutex_lock(&g2d->runqueue_mutex);
 682         runqueue_node->pid = current->pid;
 683         list_add_tail(&runqueue_node->list, &g2d->runqueue);
 684         if (!g2d->runqueue_node)
 685                 g2d_exec_runqueue(g2d);
 686         mutex_unlock(&g2d->runqueue_mutex);
 687
 688         if (runqueue_node->async)
 689                 goto out;
 690
 691         wait_for_completion(&runqueue_node->complete);
 692         g2d_free_runqueue_node(g2d, runqueue_node);
 693
 694 out:
 695         return 0;
 696 }
 697 EXPORT_SYMBOL_GPL(exynos_g2d_exec_ioctl);
 698
 699 static int g2d_open(struct drm_device *drm_dev, struct device *dev,
 700                         struct drm_file *file)
 701 {
 702         struct drm_exynos_file_private *file_priv = file->driver_priv;
 703         struct exynos_drm_g2d_private *g2d_priv;
 704
 705         g2d_priv = kzalloc(sizeof(*g2d_priv), GFP_KERNEL);
 706         if (!g2d_priv) {
 707                 dev_err(dev, "failed to allocate g2d private data\n");
 708                 return -ENOMEM;
 709         }
 710
 711         g2d_priv->dev = dev;
 712         file_priv->g2d_priv = g2d_priv;
 713
 714         INIT_LIST_HEAD(&g2d_priv->inuse_cmdlist);
 715         INIT_LIST_HEAD(&g2d_priv->event_list);
 716         INIT_LIST_HEAD(&g2d_priv->gem_list);
 717
 718         return 0;
 719 }
 720
 721 static void g2d_close(struct drm_device *drm_dev, struct device *dev,
 722                         struct drm_file *file)
 723 {
 724         struct drm_exynos_file_private *file_priv = file->driver_priv;
 725         struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
 726         struct g2d_data *g2d;
 727         struct g2d_cmdlist_node *node, *n;
 728
 729         if (!dev)
 730                 return;
 731
 732         g2d = dev_get_drvdata(dev);
 733         if (!g2d)
 734                 return;
 735
 736         mutex_lock(&g2d->cmdlist_mutex);
 737         list_for_each_entry_safe(node, n, &g2d_priv->inuse_cmdlist, list)
 738                 list_move_tail(&node->list, &g2d->free_cmdlist);
 739         mutex_unlock(&g2d->cmdlist_mutex);
 740
 741         g2d_put_cmdlist_gem(drm_dev, file, g2d_priv->gem_nr);
 742
 743         kfree(file_priv->g2d_priv);
 744 }
 745
 746 static int __devinit g2d_probe(struct platform_device *pdev)
 747 {
 748         struct device *dev = &pdev->dev;
 749         struct resource *res;
 750         struct g2d_data *g2d;
 751         struct exynos_drm_subdrv *subdrv;
 752         int ret;
 753
 754         g2d = devm_kzalloc(&pdev->dev, sizeof(*g2d), GFP_KERNEL);
 755         if (!g2d) {
 756                 dev_err(dev, "failed to allocate driver data\n");
 757                 return -ENOMEM;
 758         }
 759
 760         g2d->runqueue_slab = kmem_cache_create("g2d_runqueue_slab",
 761                         sizeof(struct g2d_runqueue_node), 0, 0, NULL);
 762         if (!g2d->runqueue_slab)
 763                 return -ENOMEM;
 764
 765         g2d->dev = dev;
 766
 767         g2d->g2d_workq = create_singlethread_workqueue("g2d");
 768         if (!g2d->g2d_workq) {
 769                 dev_err(dev, "failed to create workqueue\n");
 770                 ret = -EINVAL;
 771                 goto err_destroy_slab;
 772         }
 773
 774         INIT_WORK(&g2d->runqueue_work, g2d_runqueue_worker);
 775         INIT_LIST_HEAD(&g2d->free_cmdlist);
 776         INIT_LIST_HEAD(&g2d->runqueue);
 777
 778         mutex_init(&g2d->cmdlist_mutex);
 779         mutex_init(&g2d->runqueue_mutex);
 780
 781         ret = g2d_init_cmdlist(g2d);
 782         if (ret < 0)
 783                 goto err_destroy_workqueue;
 784
 785         g2d->gate_clk = clk_get(dev, "fimg2d");
 786         if (IS_ERR(g2d->gate_clk)) {
 787                 dev_err(dev, "failed to get gate clock\n");
 788                 ret = PTR_ERR(g2d->gate_clk);
 789                 goto err_fini_cmdlist;
 790         }
 791
 792         pm_runtime_enable(dev);
 793
 794         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 795
 796         g2d->regs = devm_request_and_ioremap(&pdev->dev, res);
 797         if (!g2d->regs) {
 798                 dev_err(dev, "failed to remap I/O memory\n");
 799                 ret = -ENXIO;
 800                 goto err_put_clk;
 801         }
 802
 803         g2d->irq = platform_get_irq(pdev, 0);
 804         if (g2d->irq < 0) {
 805                 dev_err(dev, "failed to get irq\n");
 806                 ret = g2d->irq;
 807                 goto err_put_clk;
 808         }
 809
 810         ret = devm_request_irq(&pdev->dev, g2d->irq, g2d_irq_handler, 0,
 811                                                                 "drm_g2d", g2d);
 812         if (ret < 0) {
 813                 dev_err(dev, "irq request failed\n");
 814                 goto err_put_clk;
 815         }
 816
 817         platform_set_drvdata(pdev, g2d);
 818
 819         subdrv = &g2d->subdrv;
 820         subdrv->dev = dev;
 821         subdrv->open = g2d_open;
 822         subdrv->close = g2d_close;
 823
 824         ret = exynos_drm_subdrv_register(subdrv);
 825         if (ret < 0) {
 826                 dev_err(dev, "failed to register drm g2d device\n");
 827                 goto err_put_clk;
 828         }
 829
 830         dev_info(dev, "The exynos g2d(ver %d.%d) successfully probed\n",
 831                         G2D_HW_MAJOR_VER, G2D_HW_MINOR_VER);
 832
 833         return 0;
 834
 835 err_put_clk:
 836         pm_runtime_disable(dev);
 837         clk_put(g2d->gate_clk);
 838 err_fini_cmdlist:
 839         g2d_fini_cmdlist(g2d);
 840 err_destroy_workqueue:
 841         destroy_workqueue(g2d->g2d_workq);
 842 err_destroy_slab:
 843         kmem_cache_destroy(g2d->runqueue_slab);
 844         return ret;
 845 }
 846
 847 static int __devexit g2d_remove(struct platform_device *pdev)
 848 {
 849         struct g2d_data *g2d = platform_get_drvdata(pdev);
 850
 851         cancel_work_sync(&g2d->runqueue_work);
 852         exynos_drm_subdrv_unregister(&g2d->subdrv);
 853
 854         while (g2d->runqueue_node) {
 855                 g2d_free_runqueue_node(g2d, g2d->runqueue_node);
 856                 g2d->runqueue_node = g2d_get_runqueue_node(g2d);
 857         }
 858
 859         pm_runtime_disable(&pdev->dev);
 860         clk_put(g2d->gate_clk);
 861
 862         g2d_fini_cmdlist(g2d);
 863         destroy_workqueue(g2d->g2d_workq);
 864         kmem_cache_destroy(g2d->runqueue_slab);
 865
 866         return 0;
 867 }
 868
 869 #ifdef CONFIG_PM_SLEEP
 870 static int g2d_suspend(struct device *dev)
 871 {
 872         struct g2d_data *g2d = dev_get_drvdata(dev);
 873
 874         mutex_lock(&g2d->runqueue_mutex);
 875         g2d->suspended = true;
 876         mutex_unlock(&g2d->runqueue_mutex);
 877
 878         while (g2d->runqueue_node)
 879                 /* FIXME: good range? */
 880                 usleep_range(500, 1000);
 881
 882         flush_work(&g2d->runqueue_work);
 883
 884         return 0;
 885 }
 886
 887 static int g2d_resume(struct device *dev)
 888 {
 889         struct g2d_data *g2d = dev_get_drvdata(dev);
 890
 891         g2d->suspended = false;
 892         g2d_exec_runqueue(g2d);
 893
 894         return 0;
 895 }
 896 #endif
 897
 898 static SIMPLE_DEV_PM_OPS(g2d_pm_ops, g2d_suspend, g2d_resume);
 899
 900 struct platform_driver g2d_driver = {
 901         .probe          = g2d_probe,
 902         .remove         = __devexit_p(g2d_remove),
 903         .driver         = {
 904                 .name   = "s5p-g2d",
 905                 .owner  = THIS_MODULE,
 906                 .pm     = &g2d_pm_ops,
 907         },
 908 };