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