drivers/video/rockchip/rga/rga_drv.c

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