drivers/video/rockchip/rga/rga_drv.c

   1 /*
   2  * Copyright (C) 2012 ROCKCHIP, Inc.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  */
  14
  15 #define pr_fmt(fmt) "rga: " fmt
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/sched.h>
  21 #include <linux/mutex.h>
  22 #include <linux/err.h>
  23 #include <linux/clk.h>
  24 #include <asm/delay.h>
  25 #include <linux/dma-mapping.h>
  26 #include <linux/delay.h>
  27 #include <asm/io.h>
  28 #include <linux/irq.h>
  29 #include <linux/interrupt.h>
  30 //#include <mach/io.h>
  31 //#include <mach/irqs.h>
  32 #include <linux/fs.h>
  33 #include <asm/uaccess.h>
  34 #include <linux/miscdevice.h>
  35 #include <linux/poll.h>
  36 #include <linux/delay.h>
  37 #include <linux/wait.h>
  38 #include <linux/syscalls.h>
  39 #include <linux/timer.h>
  40 #include <linux/time.h>
  41 #include <asm/cacheflush.h>
  42 #include <linux/slab.h>
  43 #include <linux/fb.h>
  44 #include <linux/wakelock.h>
  45
  46 #if defined(CONFIG_ION_ROCKCHIP)
  47 #include <linux/rockchip_ion.h>
  48 #endif
  49
  50
  51 #include "rga.h"
  52 #include "rga_reg_info.h"
  53 #include "rga_mmu_info.h"
  54 #include "RGA_API.h"
  55
  56 #define RGA_TEST_CASE 0
  57
  58 #define RGA_TEST 0
  59 #define RGA_TEST_TIME 0
  60 #define RGA_TEST_FLUSH_TIME 0
  61 #define RGA_INFO_BUS_ERROR 1
  62
  63 #define PRE_SCALE_BUF_SIZE  2048*1024*4
  64
  65 #define RGA_POWER_OFF_DELAY     4*HZ /* 4s */
  66 #define RGA_TIMEOUT_DELAY       2*HZ /* 2s */
  67
  68 #define RGA_MAJOR               255
  69
  70 #if defined(CONFIG_ARCH_RK2928) || defined(CONFIG_ARCH_RK3026)
  71 #define RK30_RGA_PHYS           RK2928_RGA_PHYS
  72 #define RK30_RGA_SIZE           RK2928_RGA_SIZE
  73 #endif
  74 #define RGA_RESET_TIMEOUT       1000
  75
  76 /* Driver information */
  77 #define DRIVER_DESC             "RGA Device Driver"
  78 #define DRIVER_NAME             "rga"
  79
  80 #define RGA_VERSION   "1.003"
  81
  82 ktime_t rga_start;
  83 ktime_t rga_end;
  84
  85 rga_session rga_session_global;
  86
  87 long (*rga_ioctl_kernel_p)(struct rga_req *);
  88
  89
  90 struct rga_drvdata {
  91         struct miscdevice miscdev;
  92         struct device dev;
  93         void *rga_base;
  94         int irq;
  95
  96         struct delayed_work power_off_work;
  97         void (*rga_irq_callback)(int rga_retval);   //callback function used by aync call
  98         struct wake_lock wake_lock;
  99
 100     struct clk *pd_rga;
 101         struct clk *aclk_rga;
 102     struct clk *hclk_rga;
 103
 104     //#if defined(CONFIG_ION_ROCKCHIP)
 105     struct ion_client * ion_client;
 106     //#endif
 107 };
 108
 109 static struct rga_drvdata *drvdata;
 110 rga_service_info rga_service;
 111 struct rga_mmu_buf_t rga_mmu_buf;
 112
 113
 114 #if defined(CONFIG_ION_ROCKCHIP)
 115 extern struct ion_client *rockchip_ion_client_create(const char * name);
 116 #endif
 117
 118 static int rga_blit_async(rga_session *session, struct rga_req *req);
 119 static void rga_del_running_list(void);
 120 static void rga_del_running_list_timeout(void);
 121 static void rga_try_set_reg(void);
 122
 123
 124 /* Logging */
 125 #define RGA_DEBUG 1
 126 #if RGA_DEBUG
 127 #define DBG(format, args...) printk(KERN_DEBUG "%s: " format, DRIVER_NAME, ## args)
 128 #define ERR(format, args...) printk(KERN_ERR "%s: " format, DRIVER_NAME, ## args)
 129 #define WARNING(format, args...) printk(KERN_WARN "%s: " format, DRIVER_NAME, ## args)
 130 #define INFO(format, args...) printk(KERN_INFO "%s: " format, DRIVER_NAME, ## args)
 131 #else
 132 #define DBG(format, args...)
 133 #define ERR(format, args...)
 134 #define WARNING(format, args...)
 135 #define INFO(format, args...)
 136 #endif
 137
 138 #if RGA_TEST
 139 static void print_info(struct rga_req *req)
 140 {
 141     printk("src : yrgb_addr = %.8x, src.uv_addr = %.8x, src.v_addr = %.8x, format = %d\n",
 142             req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr, req->src.format);
 143     printk("src : act_w = %d, act_h = %d, vir_w = %d, vir_h = %d\n",
 144         req->src.act_w, req->src.act_h, req->src.vir_w, req->src.vir_h);
 145     printk("src : x_off = %.8x y_off = %.8x\n", req->src.x_offset, req->src.y_offset);
 146
 147     printk("dst : yrgb_addr = %.8x, dst.uv_addr = %.8x, dst.v_addr = %.8x, format = %d\n",
 148             req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr, req->dst.format);
 149     printk("dst : x_off = %.8x y_off = %.8x\n", req->dst.x_offset, req->dst.y_offset);
 150     printk("dst : act_w = %d, act_h = %d, vir_w = %d, vir_h = %d\n",
 151         req->dst.act_w, req->dst.act_h, req->dst.vir_w, req->dst.vir_h);
 152
 153     printk("clip.xmin = %d, clip.xmax = %d. clip.ymin = %d, clip.ymax = %d\n",
 154         req->clip.xmin, req->clip.xmax, req->clip.ymin, req->clip.ymax);
 155
 156     printk("mmu_flag = %.8x\n", req->mmu_info.mmu_flag);
 157
 158     //printk("alpha_rop_flag = %.8x\n", req->alpha_rop_flag);
 159     //printk("alpha_rop_mode = %.8x\n", req->alpha_rop_mode);
 160     //printk("PD_mode = %.8x\n", req->PD_mode);
 161 }
 162 #endif
 163
 164
 165 static inline void rga_write(u32 b, u32 r)
 166 {
 167         __raw_writel(b, drvdata->rga_base + r);
 168 }
 169
 170 static inline u32 rga_read(u32 r)
 171 {
 172         return __raw_readl(drvdata->rga_base + r);
 173 }
 174
 175 static void rga_soft_reset(void)
 176 {
 177         u32 i;
 178         u32 reg;
 179
 180         rga_write(1, RGA_SYS_CTRL); //RGA_SYS_CTRL
 181
 182         for(i = 0; i < RGA_RESET_TIMEOUT; i++)
 183         {
 184                 reg = rga_read(RGA_SYS_CTRL) & 1; //RGA_SYS_CTRL
 185
 186                 if(reg == 0)
 187                         break;
 188
 189                 udelay(1);
 190         }
 191
 192         if(i == RGA_RESET_TIMEOUT)
 193                 ERR("soft reset timeout.\n");
 194 }
 195
 196 static void rga_dump(void)
 197 {
 198         int running;
 199     struct rga_reg *reg, *reg_tmp;
 200     rga_session *session, *session_tmp;
 201
 202         running = atomic_read(&rga_service.total_running);
 203         printk("rga total_running %d\n", running);
 204
 205     #if 0
 206
 207     /* Dump waiting list info */
 208     if (!list_empty(&rga_service.waiting))
 209     {
 210         list_head       *next;
 211
 212         next = &rga_service.waiting;
 213
 214         printk("rga_service dump waiting list\n");
 215
 216         do
 217         {
 218             reg = list_entry(next->next, struct rga_reg, status_link);
 219             running = atomic_read(&reg->session->task_running);
 220             num_done = atomic_read(&reg->session->num_done);
 221             printk("rga session pid %d, done %d, running %d\n", reg->session->pid, num_done, running);
 222             next = next->next;
 223         }
 224         while(!list_empty(next));
 225     }
 226
 227     /* Dump running list info */
 228     if (!list_empty(&rga_service.running))
 229     {
 230         printk("rga_service dump running list\n");
 231
 232         list_head       *next;
 233
 234         next = &rga_service.running;
 235         do
 236         {
 237             reg = list_entry(next->next, struct rga_reg, status_link);
 238             running = atomic_read(&reg->session->task_running);
 239             num_done = atomic_read(&reg->session->num_done);
 240             printk("rga session pid %d, done %d, running %d:\n", reg->session->pid, num_done, running);
 241             next = next->next;
 242         }
 243         while(!list_empty(next));
 244     }
 245     #endif
 246
 247         list_for_each_entry_safe(session, session_tmp, &rga_service.session, list_session)
 248     {
 249                 printk("session pid %d:\n", session->pid);
 250                 running = atomic_read(&session->task_running);
 251                 printk("task_running %d\n", running);
 252                 list_for_each_entry_safe(reg, reg_tmp, &session->waiting, session_link)
 253         {
 254                         printk("waiting register set 0x%.8x\n", (unsigned int)reg);
 255                 }
 256                 list_for_each_entry_safe(reg, reg_tmp, &session->running, session_link)
 257         {
 258                         printk("running register set 0x%.8x\n", (unsigned int)reg);
 259                 }
 260         }
 261 }
 262
 263 static inline void rga_queue_power_off_work(void)
 264 {
 265         queue_delayed_work(system_nrt_wq, &drvdata->power_off_work, RGA_POWER_OFF_DELAY);
 266 }
 267
 268 /* Caller must hold rga_service.lock */
 269 static void rga_power_on(void)
 270 {
 271         static ktime_t last;
 272         ktime_t now = ktime_get();
 273
 274         if (ktime_to_ns(ktime_sub(now, last)) > NSEC_PER_SEC) {
 275                 cancel_delayed_work_sync(&drvdata->power_off_work);
 276                 rga_queue_power_off_work();
 277                 last = now;
 278         }
 279         if (rga_service.enable)
 280                 return;
 281
 282         clk_prepare_enable(drvdata->aclk_rga);
 283         clk_prepare_enable(drvdata->hclk_rga);
 284         //clk_prepare_enable(drvdata->pd_rga);
 285         wake_lock(&drvdata->wake_lock);
 286         rga_service.enable = true;
 287 }
 288
 289 /* Caller must hold rga_service.lock */
 290 static void rga_power_off(void)
 291 {
 292         int total_running;
 293
 294         if (!rga_service.enable) {
 295                 return;
 296         }
 297
 298         total_running = atomic_read(&rga_service.total_running);
 299         if (total_running) {
 300                 pr_err("power off when %d task running!!\n", total_running);
 301                 mdelay(50);
 302                 pr_err("delay 50 ms for running task\n");
 303                 rga_dump();
 304         }
 305
 306         //clk_disable_unprepare(drvdata->pd_rga);
 307         clk_disable_unprepare(drvdata->aclk_rga);
 308         clk_disable_unprepare(drvdata->hclk_rga);
 309         wake_unlock(&drvdata->wake_lock);
 310         rga_service.enable = false;
 311 }
 312
 313 static void rga_power_off_work(struct work_struct *work)
 314 {
 315         if (mutex_trylock(&rga_service.lock)) {
 316                 rga_power_off();
 317                 mutex_unlock(&rga_service.lock);
 318         } else {
 319                 /* Come back later if the device is busy... */
 320                 rga_queue_power_off_work();
 321         }
 322 }
 323
 324 static int rga_flush(rga_session *session, unsigned long arg)
 325 {
 326     int ret = 0;
 327     int ret_timeout;
 328
 329     #if RGA_TEST_FLUSH_TIME
 330     ktime_t start;
 331     ktime_t end;
 332     start = ktime_get();
 333     #endif
 334
 335     ret_timeout = wait_event_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);
 336
 337         if (unlikely(ret_timeout < 0)) {
 338                 //pr_err("flush pid %d wait task ret %d\n", session->pid, ret);
 339         mutex_lock(&rga_service.lock);
 340         rga_del_running_list();
 341         mutex_unlock(&rga_service.lock);
 342         ret = ret_timeout;
 343         } else if (0 == ret_timeout) {
 344                 //pr_err("flush pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));
 345         //printk("bus  = %.8x\n", rga_read(RGA_INT));
 346         mutex_lock(&rga_service.lock);
 347         rga_del_running_list_timeout();
 348         rga_try_set_reg();
 349         mutex_unlock(&rga_service.lock);
 350                 ret = -ETIMEDOUT;
 351         }
 352
 353     #if RGA_TEST_FLUSH_TIME
 354     end = ktime_get();
 355     end = ktime_sub(end, start);
 356     printk("one flush wait time %d\n", (int)ktime_to_us(end));
 357     #endif
 358
 359         return ret;
 360 }
 361
 362
 363 static int rga_get_result(rga_session *session, unsigned long arg)
 364 {
 365         //printk("rga_get_result %d\n",drvdata->rga_result);
 366
 367     int ret = 0;
 368
 369     int num_done;
 370
 371     num_done = atomic_read(&session->num_done);
 372
 373         if (unlikely(copy_to_user((void __user *)arg, &num_done, sizeof(int)))) {
 374                         printk("copy_to_user failed\n");
 375                         ret =  -EFAULT;
 376                 }
 377         return ret;
 378 }
 379
 380
 381 static int rga_check_param(const struct rga_req *req)
 382 {
 383         /*RGA can support up to 8192*8192 resolution in RGB format,but we limit the image size to 8191*8191 here*/
 384         //check src width and height
 385
 386     if(!((req->render_mode == color_fill_mode) || (req->render_mode == line_point_drawing_mode)))
 387     {
 388         if (unlikely((req->src.act_w <= 0) || (req->src.act_w > 8191) || (req->src.act_h <= 0) || (req->src.act_h > 8191)))
 389         {
 390                 printk("invalid source resolution act_w = %d, act_h = %d\n", req->src.act_w, req->src.act_h);
 391                 return  -EINVAL;
 392         }
 393     }
 394
 395     if(!((req->render_mode == color_fill_mode) || (req->render_mode == line_point_drawing_mode)))
 396     {
 397         if (unlikely((req->src.vir_w <= 0) || (req->src.vir_w > 8191) || (req->src.vir_h <= 0) || (req->src.vir_h > 8191)))
 398         {
 399                 printk("invalid source resolution vir_w = %d, vir_h = %d\n", req->src.vir_w, req->src.vir_h);
 400                 return  -EINVAL;
 401         }
 402     }
 403
 404         //check dst width and height
 405         if (unlikely((req->dst.act_w <= 0) || (req->dst.act_w > 2048) || (req->dst.act_h <= 0) || (req->dst.act_h > 2048)))
 406     {
 407                 printk("invalid destination resolution act_w = %d, act_h = %d\n", req->dst.act_w, req->dst.act_h);
 408                 return  -EINVAL;
 409         }
 410
 411     if (unlikely((req->dst.vir_w <= 0) || (req->dst.vir_w > 4096) || (req->dst.vir_h <= 0) || (req->dst.vir_h > 2048)))
 412     {
 413                 printk("invalid destination resolution vir_w = %d, vir_h = %d\n", req->dst.vir_w, req->dst.vir_h);
 414                 return  -EINVAL;
 415         }
 416
 417         //check src_vir_w
 418         if(unlikely(req->src.vir_w < req->src.act_w)){
 419                 printk("invalid src_vir_w act_w = %d, vir_w = %d\n", req->src.act_w, req->src.vir_w);
 420                 return  -EINVAL;
 421         }
 422
 423         //check dst_vir_w
 424         if(unlikely(req->dst.vir_w < req->dst.act_w)){
 425         if(req->rotate_mode != 1)
 426         {
 427                     printk("invalid dst_vir_w act_h = %d, vir_h = %d\n", req->dst.act_w, req->dst.vir_w);
 428                     return      -EINVAL;
 429         }
 430         }
 431
 432         return 0;
 433 }
 434
 435 static void rga_copy_reg(struct rga_reg *reg, uint32_t offset)
 436 {
 437     uint32_t i;
 438     uint32_t *cmd_buf;
 439     uint32_t *reg_p;
 440
 441     if(atomic_read(&reg->session->task_running) != 0)
 442     {
 443         printk(KERN_ERR "task_running is no zero\n");
 444     }
 445
 446     atomic_add(1, &rga_service.cmd_num);
 447         atomic_add(1, &reg->session->task_running);
 448
 449     cmd_buf = (uint32_t *)rga_service.cmd_buff + offset*32;
 450     reg_p = (uint32_t *)reg->cmd_reg;
 451
 452     for(i=0; i<32; i++)
 453     {
 454         cmd_buf[i] = reg_p[i];
 455     }
 456
 457     dsb();
 458 }
 459
 460
 461 static struct rga_reg * rga_reg_init(rga_session *session, struct rga_req *req)
 462 {
 463     int32_t ret;
 464         struct rga_reg *reg = kzalloc(sizeof(struct rga_reg), GFP_KERNEL);
 465         if (NULL == reg) {
 466                 pr_err("kmalloc fail in rga_reg_init\n");
 467                 return NULL;
 468         }
 469
 470     reg->session = session;
 471         INIT_LIST_HEAD(&reg->session_link);
 472         INIT_LIST_HEAD(&reg->status_link);
 473
 474     reg->MMU_base = NULL;
 475
 476     if (req->mmu_info.mmu_en)
 477     {
 478         ret = rga_set_mmu_info(reg, req);
 479         if(ret < 0)
 480         {
 481             printk("%s, [%d] set mmu info error \n", __FUNCTION__, __LINE__);
 482             if(reg != NULL)
 483             {
 484                 kfree(reg);
 485             }
 486             return NULL;
 487         }
 488     }
 489
 490     if(RGA_gen_reg_info(req, (uint8_t *)reg->cmd_reg) == -1)
 491     {
 492         printk("gen reg info error\n");
 493         if(reg != NULL)
 494         {
 495             kfree(reg);
 496         }
 497         return NULL;
 498     }
 499
 500     mutex_lock(&rga_service.lock);
 501         list_add_tail(&reg->status_link, &rga_service.waiting);
 502         list_add_tail(&reg->session_link, &session->waiting);
 503         mutex_unlock(&rga_service.lock);
 504
 505     return reg;
 506 }
 507
 508 static struct rga_reg * rga_reg_init_2(rga_session *session, struct rga_req *req0, struct rga_req *req1)
 509 {
 510     int32_t ret;
 511
 512     struct rga_reg *reg0, *reg1;
 513
 514     reg0 = NULL;
 515     reg1 = NULL;
 516
 517     do
 518     {
 519         reg0 = kzalloc(sizeof(struct rga_reg), GFP_KERNEL);
 520         if (NULL == reg0) {
 521                 pr_err("%s [%d] kmalloc fail in rga_reg_init\n", __FUNCTION__, __LINE__);
 522             break;
 523         }
 524
 525         reg1 = kzalloc(sizeof(struct rga_reg), GFP_KERNEL);
 526         if (NULL == reg1) {
 527                 pr_err("%s [%d] kmalloc fail in rga_reg_init\n", __FUNCTION__, __LINE__);
 528             break;
 529         }
 530
 531         reg0->session = session;
 532         INIT_LIST_HEAD(&reg0->session_link);
 533         INIT_LIST_HEAD(&reg0->status_link);
 534
 535         reg1->session = session;
 536         INIT_LIST_HEAD(&reg1->session_link);
 537         INIT_LIST_HEAD(&reg1->status_link);
 538
 539         req0->mmu_info.mmu_flag &= (~(1 << 10));
 540
 541         if(req0->mmu_info.mmu_en)
 542         {
 543             ret = rga_set_mmu_info(reg0, req0);
 544             if(ret < 0) {
 545                 printk("%s, [%d] set mmu info error \n", __FUNCTION__, __LINE__);
 546                 break;
 547             }
 548         }
 549
 550         RGA_gen_reg_info(req0, (uint8_t *)reg0->cmd_reg);
 551
 552         req1->mmu_info.mmu_flag &= (~(1 << 8));
 553
 554         if(req1->mmu_info.mmu_en)
 555         {
 556             ret = rga_set_mmu_info(reg1, req1);
 557             if(ret < 0) {
 558                 printk("%s, [%d] set mmu info error \n", __FUNCTION__, __LINE__);
 559                 break;
 560             }
 561         }
 562
 563         RGA_gen_reg_info(req1, (uint8_t *)reg1->cmd_reg);
 564
 565         mutex_lock(&rga_service.lock);
 566         list_add_tail(&reg0->status_link, &rga_service.waiting);
 567         list_add_tail(&reg0->session_link, &session->waiting);
 568         list_add_tail(&reg1->status_link, &rga_service.waiting);
 569         list_add_tail(&reg1->session_link, &session->waiting);
 570         mutex_unlock(&rga_service.lock);
 571
 572         return reg1;
 573     }
 574     while(0);
 575
 576     if(reg0 != NULL) {
 577         kfree(reg0);
 578     }
 579
 580     if(reg1 != NULL) {
 581         kfree(reg1);
 582     }
 583
 584     return NULL;
 585 }
 586
 587 /* Caller must hold rga_service.lock */
 588 static void rga_reg_deinit(struct rga_reg *reg)
 589 {
 590         list_del_init(&reg->session_link);
 591         list_del_init(&reg->status_link);
 592         kfree(reg);
 593 }
 594
 595 /* Caller must hold rga_service.lock */
 596 static void rga_reg_from_wait_to_run(struct rga_reg *reg)
 597 {
 598         list_del_init(&reg->status_link);
 599         list_add_tail(&reg->status_link, &rga_service.running);
 600
 601         list_del_init(&reg->session_link);
 602         list_add_tail(&reg->session_link, &reg->session->running);
 603 }
 604
 605 /* Caller must hold rga_service.lock */
 606 static void rga_service_session_clear(rga_session *session)
 607 {
 608         struct rga_reg *reg, *n;
 609
 610     list_for_each_entry_safe(reg, n, &session->waiting, session_link)
 611     {
 612                 rga_reg_deinit(reg);
 613         }
 614
 615     list_for_each_entry_safe(reg, n, &session->running, session_link)
 616     {
 617                 rga_reg_deinit(reg);
 618         }
 619 }
 620
 621 /* Caller must hold rga_service.lock */
 622 static void rga_try_set_reg(void)
 623 {
 624     struct rga_reg *reg ;
 625
 626     if (list_empty(&rga_service.running))
 627     {
 628         if (!list_empty(&rga_service.waiting))
 629         {
 630             /* RGA is idle */
 631             reg = list_entry(rga_service.waiting.next, struct rga_reg, status_link);
 632
 633             rga_power_on();
 634             udelay(1);
 635
 636             rga_copy_reg(reg, 0);
 637             rga_reg_from_wait_to_run(reg);
 638
 639             dmac_flush_range(&rga_service.cmd_buff[0], &rga_service.cmd_buff[28]);
 640             outer_flush_range(virt_to_phys(&rga_service.cmd_buff[0]),virt_to_phys(&rga_service.cmd_buff[28]));
 641
 642             #if 1
 643             rga_soft_reset();
 644             #endif
 645
 646             rga_write(0x0, RGA_SYS_CTRL);
 647             rga_write(0, RGA_MMU_CTRL);
 648
 649             /* CMD buff */
 650             rga_write(virt_to_phys(rga_service.cmd_buff), RGA_CMD_ADDR);
 651
 652 #if RGA_TEST
 653             {
 654                 //printk(KERN_DEBUG "cmd_addr = %.8x\n", rga_read(RGA_CMD_ADDR));
 655                 uint32_t i;
 656                 uint32_t *p;
 657                 p = rga_service.cmd_buff;
 658                 printk("CMD_REG\n");
 659                 for (i=0; i<7; i++)
 660                     printk("%.8x %.8x %.8x %.8x\n", p[0 + i*4], p[1+i*4], p[2 + i*4], p[3 + i*4]);
 661                 printk("%.8x %.8x\n", p[0 + i*4], p[1+i*4]);
 662             }
 663 #endif
 664
 665             /* master mode */
 666             rga_write((0x1<<2)|(0x1<<3), RGA_SYS_CTRL);
 667
 668             /* All CMD finish int */
 669             rga_write(rga_read(RGA_INT)|(0x1<<10)|(0x1<<8), RGA_INT);
 670
 671             #if RGA_TEST_TIME
 672             rga_start = ktime_get();
 673             #endif
 674
 675             /* Start proc */
 676             atomic_set(&reg->session->done, 0);
 677             rga_write(0x1, RGA_CMD_CTRL);
 678
 679 #if RGA_TEST
 680             {
 681                 uint32_t i;
 682                 printk("CMD_READ_BACK_REG\n");
 683                 for (i=0; i<7; i++)
 684                     printk("%.8x %.8x %.8x %.8x\n", rga_read(0x100 + i*16 + 0),
 685                             rga_read(0x100 + i*16 + 4), rga_read(0x100 + i*16 + 8), rga_read(0x100 + i*16 + 12));
 686                 printk("%.8x %.8x\n", rga_read(0x100 + i*16 + 0), rga_read(0x100 + i*16 + 4));
 687             }
 688 #endif
 689         }
 690     }
 691 }
 692
 693
 694
 695
 696 /* Caller must hold rga_service.lock */
 697 static void rga_del_running_list(void)
 698 {
 699     struct rga_reg *reg;
 700
 701     while(!list_empty(&rga_service.running))
 702     {
 703         reg = list_entry(rga_service.running.next, struct rga_reg, status_link);
 704
 705         if(reg->MMU_len != 0)
 706         {
 707             if (rga_mmu_buf.back + reg->MMU_len > 2*rga_mmu_buf.size)
 708                 rga_mmu_buf.back = reg->MMU_len + rga_mmu_buf.size;
 709             else
 710                 rga_mmu_buf.back += reg->MMU_len;
 711         }
 712
 713         atomic_sub(1, &reg->session->task_running);
 714         atomic_sub(1, &rga_service.total_running);
 715
 716         if(list_empty(&reg->session->waiting))
 717         {
 718             atomic_set(&reg->session->done, 1);
 719             wake_up(&reg->session->wait);
 720         }
 721
 722         rga_reg_deinit(reg);
 723     }
 724 }
 725
 726 /* Caller must hold rga_service.lock */
 727 static void rga_del_running_list_timeout(void)
 728 {
 729     struct rga_reg *reg;
 730
 731     while(!list_empty(&rga_service.running))
 732     {
 733         reg = list_entry(rga_service.running.next, struct rga_reg, status_link);
 734
 735         if(reg->MMU_base != NULL)
 736         {
 737             kfree(reg->MMU_base);
 738         }
 739
 740         atomic_sub(1, &reg->session->task_running);
 741         atomic_sub(1, &rga_service.total_running);
 742
 743         //printk("RGA soft reset for timeout process\n");
 744         rga_soft_reset();
 745
 746
 747         #if 0
 748         printk("RGA_INT is %.8x\n", rga_read(RGA_INT));
 749         printk("reg->session->task_running = %d\n", atomic_read(&reg->session->task_running));
 750         printk("rga_service.total_running  = %d\n", atomic_read(&rga_service.total_running));
 751
 752         print_info(&reg->req);
 753
 754         {
 755             uint32_t *p, i;
 756             p = reg->cmd_reg;
 757             for (i=0; i<7; i++)
 758                 printk("%.8x %.8x %.8x %.8x\n", p[0 + i*4], p[1+i*4], p[2 + i*4], p[3 + i*4]);
 759
 760         }
 761         #endif
 762
 763         if(list_empty(&reg->session->waiting))
 764         {
 765             atomic_set(&reg->session->done, 1);
 766             wake_up(&reg->session->wait);
 767         }
 768
 769         rga_reg_deinit(reg);
 770     }
 771 }
 772
 773
 774 static void rga_mem_addr_sel(struct rga_req *req)
 775 {
 776     switch(req->src.format)
 777     {
 778         case RK_FORMAT_YCbCr_422_SP:
 779             break;
 780         case RK_FORMAT_YCbCr_422_P :
 781             break;
 782         case RK_FORMAT_YCbCr_420_SP :
 783             if((req->src.yrgb_addr > 0xc0000000) && (req->src.uv_addr > 0xc0000000)
 784                 && (req->dst.yrgb_addr > 0xc0000000))
 785             {
 786                 req->src.yrgb_addr = req->src.yrgb_addr - 0x60000000;
 787                 req->src.uv_addr = req->src.uv_addr - 0x60000000;
 788                 req->dst.yrgb_addr = req->dst.yrgb_addr - 0x60000000;
 789                 req->mmu_info.mmu_en = 0;
 790                 req->mmu_info.mmu_flag &= 0xfffe;
 791             }
 792             break;
 793         case RK_FORMAT_YCbCr_420_P :
 794             break;
 795         case RK_FORMAT_YCrCb_422_SP :
 796             break;
 797         case RK_FORMAT_YCrCb_422_P :
 798             break;
 799         case RK_FORMAT_YCrCb_420_SP :
 800             break;
 801         case RK_FORMAT_YCrCb_420_P :
 802             break;
 803         default :
 804             break;
 805     }
 806
 807 }
 808
 809 static int rga_convert_dma_buf(struct rga_req *req)
 810 {
 811         struct ion_handle *hdl;
 812         ion_phys_addr_t phy_addr;
 813         size_t len;
 814     int ret;
 815     uint32_t src_offset, dst_offset;
 816
 817     req->sg_src  = NULL;
 818     req->sg_dst  = NULL;
 819
 820           src_offset = req->line_draw_info.flag;
 821           dst_offset = req->line_draw_info.line_width;
 822
 823     if(req->src.yrgb_addr) {
 824         hdl = ion_import_dma_buf(drvdata->ion_client, req->src.yrgb_addr);
 825         if (IS_ERR(hdl)) {
 826             ret = PTR_ERR(hdl);
 827             printk("RGA2 ERROR ion buf handle\n");
 828             return ret;
 829         }
 830         if ((req->mmu_info.mmu_flag >> 8) & 1) {
 831             req->sg_src = ion_sg_table(drvdata->ion_client, hdl);
 832             req->src.yrgb_addr = req->src.uv_addr;
 833             req->src.uv_addr = req->src.yrgb_addr + (req->src.vir_w * req->src.vir_h);
 834             req->src.v_addr = req->src.uv_addr + (req->src.vir_w * req->src.vir_h)/4;
 835         }
 836         else {
 837             ion_phys(drvdata->ion_client, hdl, &phy_addr, &len);
 838             req->src.yrgb_addr = phy_addr + src_offset;
 839             req->src.uv_addr = req->src.yrgb_addr + (req->src.vir_w * req->src.vir_h);
 840             req->src.v_addr = req->src.uv_addr + (req->src.vir_w * req->src.vir_h)/4;
 841         }
 842         ion_free(drvdata->ion_client, hdl);
 843     }
 844     else {
 845         req->src.yrgb_addr = req->src.uv_addr;
 846         req->src.uv_addr = req->src.yrgb_addr + (req->src.vir_w * req->src.vir_h);
 847         req->src.v_addr = req->src.uv_addr + (req->src.vir_w * req->src.vir_h)/4;
 848     }
 849
 850     if(req->dst.yrgb_addr) {
 851         hdl = ion_import_dma_buf(drvdata->ion_client, req->dst.yrgb_addr);
 852         if (IS_ERR(hdl)) {
 853             ret = PTR_ERR(hdl);
 854             printk("RGA2 ERROR ion buf handle\n");
 855             return ret;
 856         }
 857         if ((req->mmu_info.mmu_flag >> 10) & 1) {
 858             req->sg_dst = ion_sg_table(drvdata->ion_client, hdl);
 859             req->dst.yrgb_addr = req->dst.uv_addr;
 860             req->dst.uv_addr = req->dst.yrgb_addr + (req->dst.vir_w * req->dst.vir_h);
 861             req->dst.v_addr = req->dst.uv_addr + (req->dst.vir_w * req->dst.vir_h)/4;
 862         }
 863         else {
 864             ion_phys(drvdata->ion_client, hdl, &phy_addr, &len);
 865             req->dst.yrgb_addr = phy_addr + dst_offset;
 866             req->dst.uv_addr = req->dst.yrgb_addr + (req->dst.vir_w * req->dst.vir_h);
 867             req->dst.v_addr = req->dst.uv_addr + (req->dst.vir_w * req->dst.vir_h)/4;
 868         }
 869         ion_free(drvdata->ion_client, hdl);
 870     }
 871     else {
 872         req->dst.yrgb_addr = req->dst.uv_addr;
 873         req->dst.uv_addr = req->dst.yrgb_addr + (req->dst.vir_w * req->dst.vir_h);
 874         req->dst.v_addr = req->dst.uv_addr + (req->dst.vir_w * req->dst.vir_h)/4;
 875     }
 876
 877     return 0;
 878 }
 879
 880
 881 static int rga_blit(rga_session *session, struct rga_req *req)
 882 {
 883     int ret = -1;
 884     int num = 0;
 885     struct rga_reg *reg;
 886     struct rga_req req2;
 887
 888     uint32_t saw, sah, daw, dah;
 889
 890     saw = req->src.act_w;
 891     sah = req->src.act_h;
 892     daw = req->dst.act_w;
 893     dah = req->dst.act_h;
 894
 895     #if RGA_TEST
 896     print_info(req);
 897     #endif
 898
 899     if(rga_convert_dma_buf(req)) {
 900         printk("RGA : DMA buf copy error\n");
 901         return -EFAULT;
 902     }
 903
 904     do {
 905         if((req->render_mode == bitblt_mode) && (((saw>>1) >= daw) || ((sah>>1) >= dah))) {
 906             /* generate 2 cmd for pre scale */
 907
 908             ret = rga_check_param(req);
 909                 if(ret == -EINVAL) {
 910                 printk("req 0 argument is inval\n");
 911                 break;
 912                 }
 913
 914             ret = RGA_gen_two_pro(req, &req2);
 915             if(ret == -EINVAL) {
 916                 break;
 917             }
 918
 919             ret = rga_check_param(req);
 920                 if(ret == -EINVAL) {
 921                 printk("req 1 argument is inval\n");
 922                 break;
 923                 }
 924
 925             ret = rga_check_param(&req2);
 926                 if(ret == -EINVAL) {
 927                 printk("req 2 argument is inval\n");
 928                 break;
 929                 }
 930
 931             reg = rga_reg_init_2(session, req, &req2);
 932             if(reg == NULL) {
 933                 break;
 934             }
 935             num = 2;
 936
 937         }
 938         else {
 939             /* check value if legal */
 940             ret = rga_check_param(req);
 941                 if(ret == -EINVAL) {
 942                 printk("req argument is inval\n");
 943                 break;
 944                 }
 945
 946             if(req->render_mode == bitblt_mode)
 947                 rga_mem_addr_sel(req);
 948
 949             reg = rga_reg_init(session, req);
 950             if(reg == NULL) {
 951                 break;
 952             }
 953             num = 1;
 954         }
 955
 956         mutex_lock(&rga_service.lock);
 957         atomic_add(num, &rga_service.total_running);
 958         rga_try_set_reg();
 959         mutex_unlock(&rga_service.lock);
 960
 961         return 0;
 962     }
 963     while(0);
 964
 965     return -EFAULT;
 966 }
 967
 968 static int rga_blit_async(rga_session *session, struct rga_req *req)
 969 {
 970         int ret = -1;
 971
 972     #if RGA_TEST
 973     printk("*** rga_blit_async proc ***\n");
 974     #endif
 975
 976     atomic_set(&session->done, 0);
 977     ret = rga_blit(session, req);
 978     return ret;
 979 }
 980
 981 static int rga_blit_sync(rga_session *session, struct rga_req *req)
 982 {
 983     int ret = -1;
 984     int ret_timeout = 0;
 985
 986     #if RGA_TEST
 987     printk("*** rga_blit_sync proc ***\n");
 988     #endif
 989
 990     atomic_set(&session->done, 0);
 991     ret = rga_blit(session, req);
 992     if(ret < 0)
 993         return ret;
 994
 995     ret_timeout = wait_event_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);
 996
 997     if (unlikely(ret_timeout< 0)) {
 998         mutex_lock(&rga_service.lock);
 999         rga_del_running_list();
1000         mutex_unlock(&rga_service.lock);
1001         ret = ret_timeout;
1002         }
1003     else if (0 == ret_timeout) {
1004         mutex_lock(&rga_service.lock);
1005         rga_del_running_list_timeout();
1006         rga_try_set_reg();
1007         mutex_unlock(&rga_service.lock);
1008                 ret = -ETIMEDOUT;
1009         }
1010
1011     #if RGA_TEST_TIME
1012     rga_end = ktime_get();
1013     rga_end = ktime_sub(rga_end, rga_start);
1014     printk("sync one cmd end time %d\n", (int)ktime_to_us(rga_end));
1015     #endif
1016
1017     return ret;
1018 }
1019
1020
1021 static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
1022 {
1023     struct rga_req req;
1024         int ret = 0;
1025     rga_session *session;
1026
1027     mutex_lock(&rga_service.mutex);
1028
1029     session = (rga_session *)file->private_data;
1030
1031         if (NULL == session) {
1032         printk("%s [%d] rga thread session is null\n",__FUNCTION__,__LINE__);
1033         mutex_unlock(&rga_service.mutex);
1034                 return -EINVAL;
1035         }
1036
1037     memset(&req, 0x0, sizeof(req));
1038
1039         switch (cmd) {
1040                 case RGA_BLIT_SYNC:
1041                 if (unlikely(copy_from_user(&req, (struct rga_req*)arg, sizeof(struct rga_req))))
1042             {
1043                         ERR("copy_from_user failed\n");
1044                         ret = -EFAULT;
1045                 break;
1046                 }
1047             ret = rga_blit_sync(session, &req);
1048             break;
1049                 case RGA_BLIT_ASYNC:
1050                 if (unlikely(copy_from_user(&req, (struct rga_req*)arg, sizeof(struct rga_req))))
1051             {
1052                         ERR("copy_from_user failed\n");
1053                         ret = -EFAULT;
1054                 break;
1055                 }
1056
1057             if((atomic_read(&rga_service.total_running) > 16))
1058             {
1059                             ret = rga_blit_sync(session, &req);
1060             }
1061             else
1062             {
1063                 ret = rga_blit_async(session, &req);
1064             }
1065                         break;
1066                 case RGA_FLUSH:
1067                         ret = rga_flush(session, arg);
1068                         break;
1069         case RGA_GET_RESULT:
1070             ret = rga_get_result(session, arg);
1071             break;
1072         case RGA_GET_VERSION:
1073             ret = copy_to_user((void *)arg, RGA_VERSION, sizeof(RGA_VERSION));
1074             //ret = 0;
1075             break;
1076                 default:
1077                         ERR("unknown ioctl cmd!\n");
1078                         ret = -EINVAL;
1079                         break;
1080         }
1081
1082         mutex_unlock(&rga_service.mutex);
1083
1084         return ret;
1085 }
1086
1087
1088 long rga_ioctl_kernel(struct rga_req *req)
1089 {
1090         int ret = 0;
1091     if (!rga_ioctl_kernel_p) {
1092         printk("rga_ioctl_kernel_p is NULL\n");
1093         return -1;
1094     }
1095     else {
1096         ret = (*rga_ioctl_kernel_p)(req);
1097             return ret;
1098     }
1099 }
1100
1101
1102 long rga_ioctl_kernel_imp(struct rga_req *req)
1103 {
1104         int ret = 0;
1105     rga_session *session;
1106
1107     mutex_lock(&rga_service.mutex);
1108
1109     session = &rga_session_global;
1110
1111         if (NULL == session) {
1112         printk("%s [%d] rga thread session is null\n",__FUNCTION__,__LINE__);
1113         mutex_unlock(&rga_service.mutex);
1114                 return -EINVAL;
1115         }
1116
1117     ret = rga_blit_sync(session, req);
1118
1119         mutex_unlock(&rga_service.mutex);
1120
1121         return ret;
1122 }
1123
1124
1125 static int rga_open(struct inode *inode, struct file *file)
1126 {
1127     rga_session *session = kzalloc(sizeof(rga_session), GFP_KERNEL);
1128         if (NULL == session) {
1129                 pr_err("unable to allocate memory for rga_session.");
1130                 return -ENOMEM;
1131         }
1132
1133         session->pid = current->pid;
1134     //printk(KERN_DEBUG  "+");
1135
1136         INIT_LIST_HEAD(&session->waiting);
1137         INIT_LIST_HEAD(&session->running);
1138         INIT_LIST_HEAD(&session->list_session);
1139         init_waitqueue_head(&session->wait);
1140         mutex_lock(&rga_service.lock);
1141         list_add_tail(&session->list_session, &rga_service.session);
1142         mutex_unlock(&rga_service.lock);
1143         atomic_set(&session->task_running, 0);
1144     atomic_set(&session->num_done, 0);
1145
1146         file->private_data = (void *)session;
1147
1148     //DBG("*** rga dev opened by pid %d *** \n", session->pid);
1149         return nonseekable_open(inode, file);
1150
1151 }
1152
1153 static int rga_release(struct inode *inode, struct file *file)
1154 {
1155     int task_running;
1156         rga_session *session = (rga_session *)file->private_data;
1157         if (NULL == session)
1158                 return -EINVAL;
1159     //printk(KERN_DEBUG  "-");
1160         task_running = atomic_read(&session->task_running);
1161
1162     if (task_running)
1163     {
1164                 pr_err("rga_service session %d still has %d task running when closing\n", session->pid, task_running);
1165                 msleep(100);
1166         /*Í¬²½*/
1167         }
1168
1169         wake_up(&session->wait);
1170         mutex_lock(&rga_service.lock);
1171         list_del(&session->list_session);
1172         rga_service_session_clear(session);
1173         kfree(session);
1174         mutex_unlock(&rga_service.lock);
1175
1176     //DBG("*** rga dev close ***\n");
1177         return 0;
1178 }
1179
1180 static irqreturn_t rga_irq_thread(int irq, void *dev_id)
1181 {
1182         mutex_lock(&rga_service.lock);
1183         if (rga_service.enable) {
1184                 rga_del_running_list();
1185                 rga_try_set_reg();
1186         }
1187         mutex_unlock(&rga_service.lock);
1188
1189         return IRQ_HANDLED;
1190 }
1191
1192 static irqreturn_t rga_irq(int irq,  void *dev_id)
1193 {
1194         /*clear INT */
1195         rga_write(rga_read(RGA_INT) | (0x1<<6) | (0x1<<7) | (0x1<<4), RGA_INT);
1196
1197         return IRQ_WAKE_THREAD;
1198 }
1199
1200 struct file_operations rga_fops = {
1201         .owner          = THIS_MODULE,
1202         .open           = rga_open,
1203         .release        = rga_release,
1204         .unlocked_ioctl         = rga_ioctl,
1205 };
1206
1207 static struct miscdevice rga_dev ={
1208     .minor = RGA_MAJOR,
1209     .name  = "rga",
1210     .fops  = &rga_fops,
1211 };
1212
1213
1214 #if defined(CONFIG_OF)
1215 static const struct of_device_id rockchip_rga_dt_ids[] = {
1216         { .compatible = "rockchip,rk312x-rga", },
1217         {},
1218 };
1219 #endif
1220
1221 static int rga_drv_probe(struct platform_device *pdev)
1222 {
1223         struct rga_drvdata *data;
1224     struct resource *res;
1225     //struct device_node *np = pdev->dev.of_node;
1226         int ret = 0;
1227
1228         mutex_init(&rga_service.lock);
1229         mutex_init(&rga_service.mutex);
1230         atomic_set(&rga_service.total_running, 0);
1231         rga_service.enable = false;
1232
1233     rga_ioctl_kernel_p = rga_ioctl_kernel_imp;
1234
1235         data = devm_kzalloc(&pdev->dev, sizeof(struct rga_drvdata), GFP_KERNEL);
1236         if(! data) {
1237                 ERR("failed to allocate driver data.\n");
1238                 return -ENOMEM;
1239         }
1240
1241         INIT_DELAYED_WORK(&data->power_off_work, rga_power_off_work);
1242         wake_lock_init(&data->wake_lock, WAKE_LOCK_SUSPEND, "rga");
1243
1244         //data->pd_rga = devm_clk_get(&pdev->dev, "pd_rga");
1245     data->aclk_rga = devm_clk_get(&pdev->dev, "aclk_rga");
1246     data->hclk_rga = devm_clk_get(&pdev->dev, "hclk_rga");
1247
1248     /* map the registers */
1249         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1250         data->rga_base = devm_ioremap_resource(&pdev->dev, res);
1251         if (!data->rga_base) {
1252                 ERR("rga ioremap failed\n");
1253                 ret = -ENOENT;
1254                 goto err_ioremap;
1255         }
1256
1257         /* get the IRQ */
1258         data->irq = ret = platform_get_irq(pdev, 0);
1259         if (ret <= 0) {
1260                 ERR("failed to get rga irq resource (%d).\n", data->irq);
1261                 ret = data->irq;
1262                 goto err_irq;
1263         }
1264
1265         /* request the IRQ */
1266         //ret = request_threaded_irq(data->irq, rga_irq, rga_irq_thread, 0, "rga", pdev);
1267     ret = devm_request_threaded_irq(&pdev->dev, data->irq, rga_irq, rga_irq_thread, 0, "rga", data);
1268         if (ret)
1269         {
1270                 ERR("rga request_irq failed (%d).\n", ret);
1271                 goto err_irq;
1272         }
1273
1274         platform_set_drvdata(pdev, data);
1275         drvdata = data;
1276
1277     #if defined(CONFIG_ION_ROCKCHIP)
1278         data->ion_client = rockchip_ion_client_create("rga");
1279         if (IS_ERR(data->ion_client)) {
1280                 dev_err(&pdev->dev, "failed to create ion client for rga");
1281                 return PTR_ERR(data->ion_client);
1282         } else {
1283                 dev_info(&pdev->dev, "rga ion client create success!\n");
1284         }
1285     #endif
1286
1287         ret = misc_register(&rga_dev);
1288         if(ret)
1289         {
1290                 ERR("cannot register miscdev (%d)\n", ret);
1291                 goto err_misc_register;
1292         }
1293
1294         pr_info("Driver loaded succesfully\n");
1295
1296         return 0;
1297
1298 err_misc_register:
1299         free_irq(data->irq, pdev);
1300 err_irq:
1301         iounmap(data->rga_base);
1302 err_ioremap:
1303         wake_lock_destroy(&data->wake_lock);
1304         //kfree(data);
1305
1306         return ret;
1307 }
1308
1309 static int rga_drv_remove(struct platform_device *pdev)
1310 {
1311         struct rga_drvdata *data = platform_get_drvdata(pdev);
1312         DBG("%s [%d]\n",__FUNCTION__,__LINE__);
1313
1314         wake_lock_destroy(&data->wake_lock);
1315         misc_deregister(&(data->miscdev));
1316         free_irq(data->irq, &data->miscdev);
1317         iounmap((void __iomem *)(data->rga_base));
1318
1319         //clk_put(data->pd_rga);
1320         devm_clk_put(&pdev->dev, data->aclk_rga);
1321         devm_clk_put(&pdev->dev, data->hclk_rga);
1322
1323         //kfree(data);
1324         return 0;
1325 }
1326
1327 static struct platform_driver rga_driver = {
1328         .probe          = rga_drv_probe,
1329         .remove         = rga_drv_remove,
1330         .driver         = {
1331                 .owner  = THIS_MODULE,
1332                 .name   = "rga",
1333                 .of_match_table = of_match_ptr(rockchip_rga_dt_ids),
1334         },
1335 };
1336
1337
1338 void rga_test_0(void);
1339 void rga_test_1(void);
1340
1341
1342 static int __init rga_init(void)
1343 {
1344         int ret;
1345     uint32_t *mmu_buf;
1346     uint32_t i;
1347     uint32_t *buf_p;
1348
1349     /* malloc pre scale mid buf mmu table */
1350     mmu_buf = kzalloc(1024*8, GFP_KERNEL);
1351     if(mmu_buf == NULL) {
1352         printk(KERN_ERR "RGA get Pre Scale buff failed. \n");
1353         return -1;
1354     }
1355
1356     /* malloc 4 M buf */
1357     for(i=0; i<1024; i++) {
1358         buf_p = (uint32_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
1359         if(buf_p == NULL) {
1360             printk(KERN_ERR "RGA init pre scale buf falied\n");
1361             return -ENOMEM;
1362         }
1363         mmu_buf[i] = virt_to_phys((void *)((uint32_t)buf_p));
1364     }
1365
1366     rga_service.pre_scale_buf = (uint32_t *)mmu_buf;
1367
1368     buf_p = kmalloc(1024*256, GFP_KERNEL);
1369     rga_mmu_buf.buf_virtual = buf_p;
1370     rga_mmu_buf.buf = (uint32_t *)virt_to_phys((void *)((uint32_t)buf_p));
1371     rga_mmu_buf.front = 0;
1372     rga_mmu_buf.back = 64*1024;
1373     rga_mmu_buf.size = 64*1024;
1374
1375     rga_mmu_buf.pages = kmalloc((32768)* sizeof(struct page *), GFP_KERNEL);
1376
1377         if ((ret = platform_driver_register(&rga_driver)) != 0)
1378         {
1379         printk(KERN_ERR "Platform device register failed (%d).\n", ret);
1380                         return ret;
1381         }
1382
1383     {
1384         rga_session_global.pid = 0x0000ffff;
1385         INIT_LIST_HEAD(&rga_session_global.waiting);
1386         INIT_LIST_HEAD(&rga_session_global.running);
1387         INIT_LIST_HEAD(&rga_session_global.list_session);
1388
1389         INIT_LIST_HEAD(&rga_service.waiting);
1390             INIT_LIST_HEAD(&rga_service.running);
1391             INIT_LIST_HEAD(&rga_service.done);
1392             INIT_LIST_HEAD(&rga_service.session);
1393
1394         init_waitqueue_head(&rga_session_global.wait);
1395         //mutex_lock(&rga_service.lock);
1396         list_add_tail(&rga_session_global.list_session, &rga_service.session);
1397         //mutex_unlock(&rga_service.lock);
1398         atomic_set(&rga_session_global.task_running, 0);
1399         atomic_set(&rga_session_global.num_done, 0);
1400     }
1401
1402
1403
1404     #if RGA_TEST_CASE
1405     rga_test_0();
1406     #endif
1407
1408         INFO("Module initialized.\n");
1409
1410         return 0;
1411 }
1412
1413 static void __exit rga_exit(void)
1414 {
1415     uint32_t i;
1416
1417     rga_power_off();
1418
1419     for(i=0; i<1024; i++)
1420     {
1421         if((uint32_t *)rga_service.pre_scale_buf[i] != NULL)
1422         {
1423             __free_page((void *)rga_service.pre_scale_buf[i]);
1424         }
1425     }
1426
1427     if(rga_service.pre_scale_buf != NULL) {
1428         kfree((uint8_t *)rga_service.pre_scale_buf);
1429     }
1430
1431     if (rga_mmu_buf.buf_virtual)
1432         kfree(rga_mmu_buf.buf_virtual);
1433
1434     if (rga_mmu_buf.pages)
1435         kfree(rga_mmu_buf.pages);
1436
1437         platform_driver_unregister(&rga_driver);
1438 }
1439
1440
1441 #if RGA_TEST_CASE
1442
1443 extern struct fb_info * rk_get_fb(int fb_id);
1444 EXPORT_SYMBOL(rk_get_fb);
1445
1446 extern void rk_direct_fb_show(struct fb_info * fbi);
1447 EXPORT_SYMBOL(rk_direct_fb_show);
1448
1449 unsigned int src_buf[1920*1080];
1450 unsigned int dst_buf[1920*1080];
1451 //unsigned int tmp_buf[1920*1080 * 2];
1452
1453 void rga_test_0(void)
1454 {
1455     struct rga_req req;
1456     rga_session session;
1457     unsigned int *src, *dst;
1458     uint32_t i, j;
1459     uint8_t *p;
1460     uint8_t t;
1461     uint32_t *dst0, *dst1, *dst2;
1462
1463     struct fb_info *fb;
1464
1465     session.pid = current->pid;
1466         INIT_LIST_HEAD(&session.waiting);
1467         INIT_LIST_HEAD(&session.running);
1468         INIT_LIST_HEAD(&session.list_session);
1469         init_waitqueue_head(&session.wait);
1470         /* no need to protect */
1471         list_add_tail(&session.list_session, &rga_service.session);
1472         atomic_set(&session.task_running, 0);
1473     atomic_set(&session.num_done, 0);
1474         //file->private_data = (void *)session;
1475
1476     fb = rk_get_fb(0);
1477
1478     memset(&req, 0, sizeof(struct rga_req));
1479     src = src_buf;
1480     dst = dst_buf;
1481
1482     memset(src_buf, 0x80, 1024*600*4);
1483
1484     dmac_flush_range(&src_buf[0], &src_buf[1024*600]);
1485     outer_flush_range(virt_to_phys(&src_buf[0]),virt_to_phys(&src_buf[1024*600]));
1486
1487
1488     #if 0
1489     memset(src_buf, 0x80, 800*480*4);
1490     memset(dst_buf, 0xcc, 800*480*4);
1491
1492     dmac_flush_range(&dst_buf[0], &dst_buf[800*480]);
1493     outer_flush_range(virt_to_phys(&dst_buf[0]),virt_to_phys(&dst_buf[800*480]));
1494     #endif
1495
1496     dst0 = &dst_buf[0];
1497     //dst1 = &dst_buf[1280*800*4];
1498     //dst2 = &dst_buf[1280*800*4*2];
1499
1500     i = j = 0;
1501
1502     printk("\n********************************\n");
1503     printk("************ RGA_TEST ************\n");
1504     printk("********************************\n\n");
1505
1506     req.src.act_w = 1024;
1507     req.src.act_h = 600;
1508
1509     req.src.vir_w = 1024;
1510     req.src.vir_h = 600;
1511     req.src.yrgb_addr = (uint32_t)virt_to_phys(src);
1512     req.src.uv_addr = (uint32_t)(req.src.yrgb_addr + 1080*1920);
1513     req.src.v_addr = (uint32_t)virt_to_phys(src);
1514     req.src.format = RK_FORMAT_RGBA_8888;
1515
1516     req.dst.act_w = 600;
1517     req.dst.act_h = 352;
1518
1519     req.dst.vir_w = 1280;
1520     req.dst.vir_h = 800;
1521     req.dst.x_offset = 600;
1522     req.dst.y_offset = 0;
1523
1524     dst = dst0;
1525
1526     req.dst.yrgb_addr = ((uint32_t)virt_to_phys(dst));
1527
1528     //req.dst.format = RK_FORMAT_RGB_565;
1529
1530     req.clip.xmin = 0;
1531     req.clip.xmax = 1279;
1532     req.clip.ymin = 0;
1533     req.clip.ymax = 799;
1534
1535     //req.render_mode = color_fill_mode;
1536     //req.fg_color = 0x80ffffff;
1537
1538     req.rotate_mode = 1;
1539     //req.scale_mode = 2;
1540
1541     //req.alpha_rop_flag = 0;
1542     //req.alpha_rop_mode = 0x19;
1543     //req.PD_mode = 3;
1544
1545     req.sina = 65536;
1546     req.cosa = 0;
1547
1548     //req.mmu_info.mmu_flag = 0x21;
1549     //req.mmu_info.mmu_en = 1;
1550
1551     //printk("src = %.8x\n", req.src.yrgb_addr);
1552     //printk("src = %.8x\n", req.src.uv_addr);
1553     //printk("dst = %.8x\n", req.dst.yrgb_addr);
1554
1555
1556     rga_blit_sync(&session, &req);
1557
1558     #if 1
1559     fb->var.bits_per_pixel = 32;
1560
1561     fb->var.xres = 1280;
1562     fb->var.yres = 800;
1563
1564     fb->var.red.length = 8;
1565     fb->var.red.offset = 0;
1566     fb->var.red.msb_right = 0;
1567
1568     fb->var.green.length = 8;
1569     fb->var.green.offset = 8;
1570     fb->var.green.msb_right = 0;
1571
1572     fb->var.blue.length = 8;
1573
1574     fb->var.blue.offset = 16;
1575     fb->var.blue.msb_right = 0;
1576
1577     fb->var.transp.length = 8;
1578     fb->var.transp.offset = 24;
1579     fb->var.transp.msb_right = 0;
1580
1581     fb->var.nonstd &= (~0xff);
1582     fb->var.nonstd |= 1;
1583
1584     fb->fix.smem_start = virt_to_phys(dst);
1585
1586     rk_direct_fb_show(fb);
1587     #endif
1588
1589 }
1590
1591 #endif
1592 module_init(rga_init);
1593 module_exit(rga_exit);
1594
1595 /* Module information */
1596 MODULE_AUTHOR("zsq@rock-chips.com");
1597 MODULE_DESCRIPTION("Driver for rga device");
1598 MODULE_LICENSE("GPL");