exynos/exynos_fimg2d.c

   1 /*
   2  * Copyright (C) 2013 Samsung Electronics Co.Ltd
   3  * Authors:
   4  *      Inki Dae <inki.dae@samsung.com>
   5  *
   6  * This program is free software; you can redistribute  it and/or modify it
   7  * under  the terms of  the GNU General  Public License as published by the
   8  * Free Software Foundation;  either version 2 of the  License, or (at your
   9  * option) any later version.
  10  *
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #include "config.h"
  15 #endif
  16
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <errno.h>
  21
  22 #include <sys/mman.h>
  23 #include <linux/stddef.h>
  24
  25 #include <xf86drm.h>
  26
  27 #include "libdrm.h"
  28 #include "exynos_drm.h"
  29 #include "fimg2d_reg.h"
  30 #include "fimg2d.h"
  31
  32 #define         SET_BF(val, sc, si, scsa, scda, dc, di, dcsa, dcda) \
  33                         val.data.src_coeff = sc;                \
  34                         val.data.inv_src_color_coeff = si;      \
  35                         val.data.src_coeff_src_a = scsa;        \
  36                         val.data.src_coeff_dst_a = scda;        \
  37                         val.data.dst_coeff = dc;                \
  38                         val.data.inv_dst_color_coeff = di;      \
  39                         val.data.dst_coeff_src_a = dcsa;        \
  40                         val.data.dst_coeff_dst_a = dcda;
  41
  42 #define MIN(a, b)       ((a) < (b) ? (a) : (b))
  43
  44 static unsigned int g2d_get_blend_op(enum e_g2d_op op)
  45 {
  46         union g2d_blend_func_val val;
  47
  48         val.val = 0;
  49
  50         switch (op) {
  51         case G2D_OP_CLEAR:
  52         case G2D_OP_DISJOINT_CLEAR:
  53         case G2D_OP_CONJOINT_CLEAR:
  54                 SET_BF(val, G2D_COEFF_MODE_ZERO, 0, 0, 0, G2D_COEFF_MODE_ZERO,
  55                                 0, 0, 0);
  56                 break;
  57         case G2D_OP_SRC:
  58         case G2D_OP_DISJOINT_SRC:
  59         case G2D_OP_CONJOINT_SRC:
  60                 SET_BF(val, G2D_COEFF_MODE_ONE, 0, 0, 0, G2D_COEFF_MODE_ZERO,
  61                                 0, 0, 0);
  62                 break;
  63         case G2D_OP_DST:
  64         case G2D_OP_DISJOINT_DST:
  65         case G2D_OP_CONJOINT_DST:
  66                 SET_BF(val, G2D_COEFF_MODE_ZERO, 0, 0, 0, G2D_COEFF_MODE_ONE,
  67                                 0, 0, 0);
  68                 break;
  69         case G2D_OP_OVER:
  70                 SET_BF(val, G2D_COEFF_MODE_ONE, 0, 0, 0,
  71                                 G2D_COEFF_MODE_SRC_ALPHA, 1, 0, 0);
  72                 break;
  73         default:
  74                 fprintf(stderr, "Not support operation(%d).\n", op);
  75                 SET_BF(val, G2D_COEFF_MODE_ONE, 0, 0, 0, G2D_COEFF_MODE_ZERO,
  76                                 0, 0, 0);
  77                 break;
  78         }
  79
  80         return val.val;
  81 }
  82
  83 /*
  84  * g2d_add_cmd - set given command and value to user side command buffer.
  85  *
  86  * @ctx: a pointer to g2d_context structure.
  87  * @cmd: command data.
  88  * @value: value data.
  89  */
  90 static int g2d_add_cmd(struct g2d_context *ctx, unsigned long cmd,
  91                         unsigned long value)
  92 {
  93         switch (cmd & ~(G2D_BUF_USERPTR)) {
  94         case SRC_BASE_ADDR_REG:
  95         case SRC_PLANE2_BASE_ADDR_REG:
  96         case DST_BASE_ADDR_REG:
  97         case DST_PLANE2_BASE_ADDR_REG:
  98         case PAT_BASE_ADDR_REG:
  99         case MASK_BASE_ADDR_REG:
 100                 if (ctx->cmd_buf_nr >= G2D_MAX_GEM_CMD_NR) {
 101                         fprintf(stderr, "Overflow cmd_gem size.\n");
 102                         return -EINVAL;
 103                 }
 104
 105                 ctx->cmd_buf[ctx->cmd_buf_nr].offset = cmd;
 106                 ctx->cmd_buf[ctx->cmd_buf_nr].data = value;
 107                 ctx->cmd_buf_nr++;
 108                 break;
 109         default:
 110                 if (ctx->cmd_nr >= G2D_MAX_CMD_NR) {
 111                         fprintf(stderr, "Overflow cmd size.\n");
 112                         return -EINVAL;
 113                 }
 114
 115                 ctx->cmd[ctx->cmd_nr].offset = cmd;
 116                 ctx->cmd[ctx->cmd_nr].data = value;
 117                 ctx->cmd_nr++;
 118                 break;
 119         }
 120
 121         return TRUE;
 122 }
 123
 124 /*
 125  * g2d_reset - reset fimg2d hardware.
 126  *
 127  * @ctx: a pointer to g2d_context structure.
 128  *
 129  */
 130 static void g2d_reset(struct g2d_context *ctx)
 131 {
 132         ctx->cmd_nr = 0;
 133         ctx->cmd_buf_nr = 0;
 134
 135         g2d_add_cmd(ctx, SOFT_RESET_REG, 0x01);
 136 }
 137
 138 /*
 139  * g2d_flush - summit all commands and values in user side command buffer
 140  *              to command queue aware of fimg2d dma.
 141  *
 142  * @ctx: a pointer to g2d_context structure.
 143  *
 144  * This function should be called after all commands and values to user
 145  * side command buffer is set to summit that buffer to kernel side driver.
 146  */
 147 static int g2d_flush(struct g2d_context *ctx)
 148 {
 149         int ret;
 150         struct drm_exynos_g2d_set_cmdlist cmdlist;
 151
 152         if (ctx->cmd_nr  == 0 && ctx->cmd_buf_nr == 0)
 153                 return FALSE;
 154
 155         if (ctx->cmdlist_nr >= G2D_MAX_CMD_LIST_NR) {
 156                 fprintf(stderr, "Overflow cmdlist.\n");
 157                 return -EINVAL;
 158         }
 159
 160         memset(&cmdlist, 0, sizeof(struct drm_exynos_g2d_set_cmdlist));
 161
 162         cmdlist.cmd = (uint64_t)(uintptr_t)&ctx->cmd[0];
 163         cmdlist.cmd_buf = (uint64_t)(uintptr_t)&ctx->cmd_buf[0];
 164         cmdlist.cmd_nr = ctx->cmd_nr;
 165         cmdlist.cmd_buf_nr = ctx->cmd_buf_nr;
 166         cmdlist.event_type = G2D_EVENT_NOT;
 167         cmdlist.user_data = 0;
 168
 169         ctx->cmd_nr = 0;
 170         ctx->cmd_buf_nr = 0;
 171
 172         ret = drmIoctl(ctx->fd, DRM_IOCTL_EXYNOS_G2D_SET_CMDLIST, &cmdlist);
 173         if (ret < 0) {
 174                 fprintf(stderr, "failed to set cmdlist.\n");
 175                 return ret;
 176         }
 177
 178         ctx->cmdlist_nr++;
 179
 180         return ret;
 181 }
 182
 183 /**
 184  * g2d_init - create a new g2d context and get hardware version.
 185  *
 186  * fd: a file descriptor to drm device driver opened.
 187  */
 188 drm_public struct g2d_context *g2d_init(int fd)
 189 {
 190         struct drm_exynos_g2d_get_ver ver;
 191         struct g2d_context *ctx;
 192         int ret;
 193
 194         ctx = calloc(1, sizeof(*ctx));
 195         if (!ctx) {
 196                 fprintf(stderr, "failed to allocate context.\n");
 197                 return NULL;
 198         }
 199
 200         ctx->fd = fd;
 201
 202         ret = drmIoctl(fd, DRM_IOCTL_EXYNOS_G2D_GET_VER, &ver);
 203         if (ret < 0) {
 204                 fprintf(stderr, "failed to get version.\n");
 205                 free(ctx);
 206                 return NULL;
 207         }
 208
 209         ctx->major = ver.major;
 210         ctx->minor = ver.minor;
 211
 212         printf("g2d version(%d.%d).\n", ctx->major, ctx->minor);
 213         return ctx;
 214 }
 215
 216 drm_public void g2d_fini(struct g2d_context *ctx)
 217 {
 218         if (ctx)
 219                 free(ctx);
 220 }
 221
 222 /**
 223  * g2d_exec - start the dma to process all commands summited by g2d_flush().
 224  *
 225  * @ctx: a pointer to g2d_context structure.
 226  */
 227 drm_public int g2d_exec(struct g2d_context *ctx)
 228 {
 229         struct drm_exynos_g2d_exec exec;
 230         int ret;
 231
 232         if (ctx->cmdlist_nr == 0)
 233                 return -EINVAL;
 234
 235         exec.async = 0;
 236
 237         ret = drmIoctl(ctx->fd, DRM_IOCTL_EXYNOS_G2D_EXEC, &exec);
 238         if (ret < 0) {
 239                 fprintf(stderr, "failed to execute.\n");
 240                 return ret;
 241         }
 242
 243         ctx->cmdlist_nr = 0;
 244
 245         return ret;
 246 }
 247
 248 /**
 249  * g2d_solid_fill - fill given buffer with given color data.
 250  *
 251  * @ctx: a pointer to g2d_context structure.
 252  * @img: a pointer to g2d_image structure including image and buffer
 253  *      information.
 254  * @x: x start position to buffer filled with given color data.
 255  * @y: y start position to buffer filled with given color data.
 256  * @w: width value to buffer filled with given color data.
 257  * @h: height value to buffer filled with given color data.
 258  */
 259 drm_public int
 260 g2d_solid_fill(struct g2d_context *ctx, struct g2d_image *img,
 261                         unsigned int x, unsigned int y, unsigned int w,
 262                         unsigned int h)
 263 {
 264         union g2d_bitblt_cmd_val bitblt;
 265         union g2d_point_val pt;
 266
 267         g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 268         g2d_add_cmd(ctx, DST_COLOR_MODE_REG, img->color_mode);
 269
 270         if (img->buf_type == G2D_IMGBUF_USERPTR)
 271                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
 272                                 (unsigned long)&img->user_ptr[0]);
 273         else
 274                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG, img->bo[0]);
 275
 276         g2d_add_cmd(ctx, DST_STRIDE_REG, img->stride);
 277
 278         if (x + w > img->width)
 279                 w = img->width - x;
 280         if (y + h > img->height)
 281                 h = img->height - y;
 282
 283         pt.val = 0;
 284         pt.data.x = x;
 285         pt.data.y = y;
 286         g2d_add_cmd(ctx, DST_LEFT_TOP_REG, pt.val);
 287
 288         pt.val = 0;
 289         pt.data.x = x + w;
 290         pt.data.y = y + h;
 291
 292         g2d_add_cmd(ctx, DST_RIGHT_BOTTOM_REG, pt.val);
 293
 294         g2d_add_cmd(ctx, SF_COLOR_REG, img->color);
 295
 296         bitblt.val = 0;
 297         bitblt.data.fast_solid_color_fill_en = 1;
 298         g2d_add_cmd(ctx, BITBLT_COMMAND_REG, bitblt.val);
 299
 300         g2d_flush(ctx);
 301
 302         return 0;
 303 }
 304
 305 /**
 306  * g2d_copy - copy contents in source buffer to destination buffer.
 307  *
 308  * @ctx: a pointer to g2d_context structure.
 309  * @src: a pointer to g2d_image structure including image and buffer
 310  *      information to source.
 311  * @dst: a pointer to g2d_image structure including image and buffer
 312  *      information to destination.
 313  * @src_x: x start position to source buffer.
 314  * @src_y: y start position to source buffer.
 315  * @dst_x: x start position to destination buffer.
 316  * @dst_y: y start position to destination buffer.
 317  * @w: width value to source and destination buffers.
 318  * @h: height value to source and destination buffers.
 319  */
 320 drm_public int
 321 g2d_copy(struct g2d_context *ctx, struct g2d_image *src,
 322                 struct g2d_image *dst, unsigned int src_x, unsigned int src_y,
 323                 unsigned int dst_x, unsigned dst_y, unsigned int w,
 324                 unsigned int h)
 325 {
 326         union g2d_rop4_val rop4;
 327         union g2d_point_val pt;
 328         unsigned int src_w = 0, src_h = 0, dst_w = 0, dst_h = 0;
 329
 330         g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
 331         g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
 332         if (dst->buf_type == G2D_IMGBUF_USERPTR)
 333                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
 334                                 (unsigned long)&dst->user_ptr[0]);
 335         else
 336                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
 337
 338         g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 339
 340         g2d_add_cmd(ctx, SRC_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 341         g2d_add_cmd(ctx, SRC_COLOR_MODE_REG, src->color_mode);
 342         if (src->buf_type == G2D_IMGBUF_USERPTR)
 343                 g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
 344                                 (unsigned long)&src->user_ptr[0]);
 345         else
 346                 g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
 347
 348         g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 349
 350         src_w = w;
 351         src_h = h;
 352         if (src_x + src->width > w)
 353                 src_w = src->width - src_x;
 354         if (src_y + src->height > h)
 355                 src_h = src->height - src_y;
 356
 357         dst_w = w;
 358         dst_h = w;
 359         if (dst_x + dst->width > w)
 360                 dst_w = dst->width - dst_x;
 361         if (dst_y + dst->height > h)
 362                 dst_h = dst->height - dst_y;
 363
 364         w = MIN(src_w, dst_w);
 365         h = MIN(src_h, dst_h);
 366
 367         if (w <= 0 || h <= 0) {
 368                 fprintf(stderr, "invalid width or height.\n");
 369                 g2d_reset(ctx);
 370                 return -EINVAL;
 371         }
 372
 373         pt.val = 0;
 374         pt.data.x = src_x;
 375         pt.data.y = src_y;
 376         g2d_add_cmd(ctx, SRC_LEFT_TOP_REG, pt.val);
 377         pt.val = 0;
 378         pt.data.x = src_x + w;
 379         pt.data.y = src_y + h;
 380         g2d_add_cmd(ctx, SRC_RIGHT_BOTTOM_REG, pt.val);
 381
 382         pt.val = 0;
 383         pt.data.x = dst_x;
 384         pt.data.y = dst_y;
 385         g2d_add_cmd(ctx, DST_LEFT_TOP_REG, pt.val);
 386         pt.val = 0;
 387         pt.data.x = dst_x + w;
 388         pt.data.y = dst_y + h;
 389         g2d_add_cmd(ctx, DST_RIGHT_BOTTOM_REG, pt.val);
 390
 391         rop4.val = 0;
 392         rop4.data.unmasked_rop3 = G2D_ROP3_SRC;
 393         g2d_add_cmd(ctx, ROP4_REG, rop4.val);
 394
 395         g2d_flush(ctx);
 396
 397         return 0;
 398 }
 399
 400 /**
 401  * g2d_copy_with_scale - copy contents in source buffer to destination buffer
 402  *      scaling up or down properly.
 403  *
 404  * @ctx: a pointer to g2d_context structure.
 405  * @src: a pointer to g2d_image structure including image and buffer
 406  *      information to source.
 407  * @dst: a pointer to g2d_image structure including image and buffer
 408  *      information to destination.
 409  * @src_x: x start position to source buffer.
 410  * @src_y: y start position to source buffer.
 411  * @src_w: width value to source buffer.
 412  * @src_h: height value to source buffer.
 413  * @dst_x: x start position to destination buffer.
 414  * @dst_y: y start position to destination buffer.
 415  * @dst_w: width value to destination buffer.
 416  * @dst_h: height value to destination buffer.
 417  * @negative: indicate that it uses color negative to source and
 418  *      destination buffers.
 419  */
 420 drm_public int
 421 g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 422                                 struct g2d_image *dst, unsigned int src_x,
 423                                 unsigned int src_y, unsigned int src_w,
 424                                 unsigned int src_h, unsigned int dst_x,
 425                                 unsigned int dst_y, unsigned int dst_w,
 426                                 unsigned int dst_h, unsigned int negative)
 427 {
 428         union g2d_rop4_val rop4;
 429         union g2d_point_val pt;
 430         unsigned int scale;
 431         double scale_x = 0.0f, scale_y = 0.0f;
 432
 433         g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
 434         g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
 435         if (dst->buf_type == G2D_IMGBUF_USERPTR)
 436                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
 437                                 (unsigned long)&dst->user_ptr[0]);
 438         else
 439                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
 440
 441         g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 442
 443         g2d_add_cmd(ctx, SRC_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 444         g2d_add_cmd(ctx, SRC_COLOR_MODE_REG, src->color_mode);
 445         if (src->buf_type == G2D_IMGBUF_USERPTR)
 446                 g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
 447                                 (unsigned long)&src->user_ptr[0]);
 448         else
 449                 g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
 450
 451         g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 452
 453         if (src_w == dst_w && src_h == dst_h)
 454                 scale = 0;
 455         else {
 456                 scale = 1;
 457                 scale_x = (double)src_w / (double)dst_w;
 458                 scale_y = (double)src_h / (double)dst_h;
 459         }
 460
 461         if (src_x + src_w > src->width)
 462                 src_w = src->width - src_x;
 463         if (src_y + src_h > src->height)
 464                 src_h = src->height - src_y;
 465
 466         if (dst_x + dst_w > dst->width)
 467                 dst_w = dst->width - dst_x;
 468         if (dst_y + dst_h > dst->height)
 469                 dst_h = dst->height - dst_y;
 470
 471         if (src_w <= 0 || src_h <= 0 || dst_w <= 0 || dst_h <= 0) {
 472                 fprintf(stderr, "invalid width or height.\n");
 473                 g2d_reset(ctx);
 474                 return -EINVAL;
 475         }
 476
 477         if (negative) {
 478                 g2d_add_cmd(ctx, BG_COLOR_REG, 0x00FFFFFF);
 479                 rop4.val = 0;
 480                 rop4.data.unmasked_rop3 = G2D_ROP3_SRC^G2D_ROP3_DST;
 481                 g2d_add_cmd(ctx, ROP4_REG, rop4.val);
 482         } else {
 483                 rop4.val = 0;
 484                 rop4.data.unmasked_rop3 = G2D_ROP3_SRC;
 485                 g2d_add_cmd(ctx, ROP4_REG, rop4.val);
 486         }
 487
 488         if (scale) {
 489                 g2d_add_cmd(ctx, SRC_SCALE_CTRL_REG, G2D_SCALE_MODE_BILINEAR);
 490                 g2d_add_cmd(ctx, SRC_XSCALE_REG, G2D_DOUBLE_TO_FIXED(scale_x));
 491                 g2d_add_cmd(ctx, SRC_YSCALE_REG, G2D_DOUBLE_TO_FIXED(scale_y));
 492         }
 493
 494         pt.val = 0;
 495         pt.data.x = src_x;
 496         pt.data.y = src_y;
 497         g2d_add_cmd(ctx, SRC_LEFT_TOP_REG, pt.val);
 498         pt.val = 0;
 499         pt.data.x = src_x + src_w;
 500         pt.data.y = src_y + src_h;
 501         g2d_add_cmd(ctx, SRC_RIGHT_BOTTOM_REG, pt.val);
 502
 503         pt.val = 0;
 504         pt.data.x = dst_x;
 505         pt.data.y = dst_y;
 506         g2d_add_cmd(ctx, DST_LEFT_TOP_REG, pt.val);
 507         pt.val = 0;
 508         pt.data.x = dst_x + dst_w;
 509         pt.data.y = dst_y + dst_h;
 510         g2d_add_cmd(ctx, DST_RIGHT_BOTTOM_REG, pt.val);
 511
 512         g2d_flush(ctx);
 513
 514         return 0;
 515 }
 516
 517 /**
 518  * g2d_blend - blend image data in source and destion buffers
 519  *
 520  * @ctx: a pointer to g2d_context structure.
 521  * @src: a pointer to g2d_image structure including image and buffer
 522  *      information to source.
 523  * @dst: a pointer to g2d_image structure including image and buffer
 524  *      information to destination.
 525  * @src_x: x start position to source buffer.
 526  * @src_y: y start position to source buffer.
 527  * @dst_x: x start position to destination buffer.
 528  * @dst_y: y start position to destination buffer.
 529  * @w: width value to source and destination buffer.
 530  * @h: height value to source and destination buffer.
 531  * @op: blend operation type.
 532  */
 533 drm_public int
 534 g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
 535                 struct g2d_image *dst, unsigned int src_x,
 536                 unsigned int src_y, unsigned int dst_x, unsigned int dst_y,
 537                 unsigned int w, unsigned int h, enum e_g2d_op op)
 538 {
 539         union g2d_point_val pt;
 540         union g2d_bitblt_cmd_val bitblt;
 541         union g2d_blend_func_val blend;
 542         unsigned int src_w = 0, src_h = 0, dst_w = 0, dst_h = 0;
 543
 544         bitblt.val = 0;
 545         blend.val = 0;
 546
 547         if (op == G2D_OP_SRC || op == G2D_OP_CLEAR)
 548                 g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
 549         else
 550                 g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 551
 552         g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
 553         if (dst->buf_type == G2D_IMGBUF_USERPTR)
 554                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
 555                                 (unsigned long)&dst->user_ptr[0]);
 556         else
 557                 g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
 558
 559         g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 560
 561         g2d_add_cmd(ctx, SRC_SELECT_REG, src->select_mode);
 562         g2d_add_cmd(ctx, SRC_COLOR_MODE_REG, src->color_mode);
 563
 564         switch (src->select_mode) {
 565         case G2D_SELECT_MODE_NORMAL:
 566                 if (src->buf_type == G2D_IMGBUF_USERPTR)
 567                         g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
 568                                         (unsigned long)&src->user_ptr[0]);
 569                 else
 570                         g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
 571
 572                 g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 573                 break;
 574         case G2D_SELECT_MODE_FGCOLOR:
 575                 g2d_add_cmd(ctx, FG_COLOR_REG, src->color);
 576                 break;
 577         case G2D_SELECT_MODE_BGCOLOR:
 578                 g2d_add_cmd(ctx, BG_COLOR_REG, src->color);
 579                 break;
 580         default:
 581                 fprintf(stderr , "failed to set src.\n");
 582                 return -EINVAL;
 583         }
 584
 585         src_w = w;
 586         src_h = h;
 587         if (src_x + w > src->width)
 588                 src_w = src->width - src_x;
 589         if (src_y + h > src->height)
 590                 src_h = src->height - src_y;
 591
 592         dst_w = w;
 593         dst_h = h;
 594         if (dst_x + w > dst->width)
 595                 dst_w = dst->width - dst_x;
 596         if (dst_y + h > dst->height)
 597                 dst_h = dst->height - dst_y;
 598
 599         w = MIN(src_w, dst_w);
 600         h = MIN(src_h, dst_h);
 601
 602         if (w <= 0 || h <= 0) {
 603                 fprintf(stderr, "invalid width or height.\n");
 604                 g2d_reset(ctx);
 605                 return -EINVAL;
 606         }
 607
 608         bitblt.data.alpha_blend_mode = G2D_ALPHA_BLEND_MODE_ENABLE;
 609         blend.val = g2d_get_blend_op(op);
 610         g2d_add_cmd(ctx, BITBLT_COMMAND_REG, bitblt.val);
 611         g2d_add_cmd(ctx, BLEND_FUNCTION_REG, blend.val);
 612
 613         pt.val = 0;
 614         pt.data.x = src_x;
 615         pt.data.y = src_y;
 616         g2d_add_cmd(ctx, SRC_LEFT_TOP_REG, pt.val);
 617         pt.val = 0;
 618         pt.data.x = src_x + w;
 619         pt.data.y = src_y + h;
 620         g2d_add_cmd(ctx, SRC_RIGHT_BOTTOM_REG, pt.val);
 621
 622         pt.val = 0;
 623         pt.data.x = dst_x;
 624         pt.data.y = dst_y;
 625         g2d_add_cmd(ctx, DST_LEFT_TOP_REG, pt.val);
 626         pt.val = 0;
 627         pt.data.x = dst_x + w;
 628         pt.data.y = dst_y + h;
 629         g2d_add_cmd(ctx, DST_RIGHT_BOTTOM_REG, pt.val);
 630
 631         g2d_flush(ctx);
 632
 633         return 0;
 634 }
 635