drivers/video/rockchip/rga/rga_mmu_info.c

   1 \r
   2 \r
   3 #include <linux/version.h>\r
   4 #include <linux/init.h>\r
   5 #include <linux/module.h>\r
   6 #include <linux/fs.h>\r
   7 #include <linux/sched.h>\r
   8 #include <linux/signal.h>\r
   9 #include <linux/pagemap.h>\r
  10 #include <linux/seq_file.h>\r
  11 #include <linux/mm.h>\r
  12 #include <linux/mman.h>\r
  13 #include <linux/sched.h>\r
  14 #include <linux/slab.h>\r
  15 #include <linux/memory.h>\r
  16 #include <linux/dma-mapping.h>\r
  17 #include <asm/memory.h>\r
  18 #include <asm/atomic.h>\r
  19 #include <asm/cacheflush.h>\r
  20 #include "rga_mmu_info.h"\r
  21 \r
  22 extern rga_service_info rga_service;\r
  23 //extern int mmu_buff_temp[1024];\r
  24 \r
  25 #define KERNEL_SPACE_VALID    0xc0000000\r
  26 \r
  27 #define V7_VATOPA_SUCESS_MASK   (0x1)\r
  28 #define V7_VATOPA_GET_PADDR(X)  (X & 0xFFFFF000)\r
  29 #define V7_VATOPA_GET_INER(X)           ((X>>4) & 7)\r
  30 #define V7_VATOPA_GET_OUTER(X)          ((X>>2) & 3)\r
  31 #define V7_VATOPA_GET_SH(X)             ((X>>7) & 1)\r
  32 #define V7_VATOPA_GET_NS(X)             ((X>>9) & 1)\r
  33 #define V7_VATOPA_GET_SS(X)             ((X>>1) & 1)\r
  34 \r
  35 static unsigned int armv7_va_to_pa(unsigned int v_addr)\r
  36 {\r
  37         unsigned int p_addr;\r
  38         __asm__ volatile (      "mcr p15, 0, %1, c7, c8, 0\n" \r
  39                                                 "isb\n"\r
  40                                                 "dsb\n"\r
  41                                                 "mrc p15, 0, %0, c7, c4, 0\n"\r
  42                                                 : "=r" (p_addr)\r
  43                                                 : "r" (v_addr)\r
  44                                                 : "cc");\r
  45 \r
  46         if (p_addr & V7_VATOPA_SUCESS_MASK)\r
  47                 return 0xFFFFFFFF;\r
  48         else\r
  49                 return (V7_VATOPA_GET_SS(p_addr) ? 0xFFFFFFFF : V7_VATOPA_GET_PADDR(p_addr));\r
  50 }\r
  51 \r
  52 static int rga_mem_size_cal(uint32_t Mem, uint32_t MemSize, uint32_t *StartAddr) \r
  53 {\r
  54     uint32_t start, end;\r
  55     uint32_t pageCount;\r
  56 \r
  57     end = (Mem + (MemSize + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
  58     start = Mem >> PAGE_SHIFT;\r
  59     pageCount = end - start;\r
  60     *StartAddr = start;\r
  61     return pageCount;    \r
  62 }\r
  63 \r
  64 static int rga_buf_size_cal(uint32_t yrgb_addr, uint32_t uv_addr, uint32_t v_addr, \r
  65                                         int format, uint32_t w, uint32_t h, uint32_t *StartAddr ) \r
  66 {\r
  67     uint32_t size_yrgb = 0;\r
  68     uint32_t size_uv = 0;\r
  69     uint32_t size_v = 0;\r
  70     uint32_t stride = 0;\r
  71     uint32_t start, end;\r
  72     uint32_t pageCount;\r
  73        \r
  74     switch(format)\r
  75     {\r
  76         case RK_FORMAT_RGBA_8888 :\r
  77             stride = (w * 4 + 3) & (~3);\r
  78             size_yrgb = stride*h;\r
  79             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
  80             start = yrgb_addr >> PAGE_SHIFT;\r
  81             pageCount = end - start;            \r
  82             break;\r
  83         case RK_FORMAT_RGBX_8888 :\r
  84             stride = (w * 4 + 3) & (~3);\r
  85             size_yrgb = stride*h;\r
  86             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
  87             start = yrgb_addr >> PAGE_SHIFT;\r
  88             pageCount = end - start;\r
  89             break;\r
  90         case RK_FORMAT_RGB_888 :\r
  91             stride = (w * 3 + 3) & (~3);\r
  92             size_yrgb = stride*h;\r
  93             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
  94             start = yrgb_addr >> PAGE_SHIFT;\r
  95             pageCount = end - start;\r
  96             break;\r
  97         case RK_FORMAT_BGRA_8888 :\r
  98             size_yrgb = w*h*4;\r
  99             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 100             start = yrgb_addr >> PAGE_SHIFT;\r
 101             pageCount = end - start;\r
 102             break;\r
 103         case RK_FORMAT_RGB_565 :\r
 104             stride = (w*2 + 3) & (~3);            \r
 105             size_yrgb = stride * h;\r
 106             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 107             start = yrgb_addr >> PAGE_SHIFT;\r
 108             pageCount = end - start;\r
 109             break;\r
 110         case RK_FORMAT_RGBA_5551 :\r
 111             stride = (w*2 + 3) & (~3);            \r
 112             size_yrgb = stride * h;\r
 113             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 114             start = yrgb_addr >> PAGE_SHIFT;\r
 115             pageCount = end - start;\r
 116             break;\r
 117         case RK_FORMAT_RGBA_4444 :\r
 118             stride = (w*2 + 3) & (~3);            \r
 119             size_yrgb = stride * h;\r
 120             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 121             start = yrgb_addr >> PAGE_SHIFT;\r
 122             pageCount = end - start;\r
 123             break;\r
 124         case RK_FORMAT_BGR_888 :\r
 125             stride = (w*3 + 3) & (~3);            \r
 126             size_yrgb = stride * h;\r
 127             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 128             start = yrgb_addr >> PAGE_SHIFT;\r
 129             pageCount = end - start;\r
 130             break;\r
 131 \r
 132         /* YUV FORMAT */\r
 133         case RK_FORMAT_YCbCr_422_SP :\r
 134             stride = (w + 3) & (~3);\r
 135             size_yrgb = stride * h;\r
 136             size_uv = stride * h;\r
 137             start = MIN(yrgb_addr, uv_addr);\r
 138             start >>= PAGE_SHIFT; \r
 139             end = MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv));\r
 140             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 141             pageCount = end - start;            \r
 142             break;\r
 143         case RK_FORMAT_YCbCr_422_P :\r
 144             stride = (w + 3) & (~3);\r
 145             size_yrgb = stride * h;\r
 146             size_uv = ((stride >> 1) * h);\r
 147             size_v = ((stride >> 1) * h);\r
 148             start = MIN(MIN(yrgb_addr, uv_addr), v_addr);\r
 149             start = start >> PAGE_SHIFT; \r
 150             end = MAX(MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv)), (v_addr + size_v));\r
 151             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 152             pageCount = end - start;            \r
 153             break;\r
 154         case RK_FORMAT_YCbCr_420_SP :\r
 155             stride = (w + 3) & (~3);\r
 156             size_yrgb = stride * h;\r
 157             size_uv = (stride * (h >> 1));            \r
 158             start = MIN(yrgb_addr, uv_addr);\r
 159             start >>= PAGE_SHIFT; \r
 160             end = MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv));\r
 161             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 162             pageCount = end - start;\r
 163             break;\r
 164         case RK_FORMAT_YCbCr_420_P :\r
 165             stride = (w + 3) & (~3);\r
 166             size_yrgb = stride * h;\r
 167             size_uv = ((stride >> 1) * (h >> 1));\r
 168             size_v = ((stride >> 1) * (h >> 1));\r
 169             start = MIN(MIN(yrgb_addr, uv_addr), v_addr);\r
 170             start >>= PAGE_SHIFT; \r
 171             end = MAX(MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv)), (v_addr + size_v));\r
 172             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 173             pageCount = end - start;            \r
 174             break;\r
 175 \r
 176         case RK_FORMAT_YCrCb_422_SP :\r
 177             stride = (w + 3) & (~3);\r
 178             size_yrgb = stride * h;\r
 179             size_uv = stride * h;\r
 180             start = MIN(yrgb_addr, uv_addr);\r
 181             start >>= PAGE_SHIFT; \r
 182             end = MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv));\r
 183             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 184             pageCount = end - start;\r
 185             break;\r
 186         case RK_FORMAT_YCrCb_422_P :\r
 187             stride = (w + 3) & (~3);\r
 188             size_yrgb = stride * h;\r
 189             size_uv = ((stride >> 1) * h);\r
 190             size_v = ((stride >> 1) * h);\r
 191             start = MIN(MIN(yrgb_addr, uv_addr), v_addr);\r
 192             start >>= PAGE_SHIFT; \r
 193             end = MAX(MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv)), (v_addr + size_v));\r
 194             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 195             pageCount = end - start;\r
 196             break;\r
 197             \r
 198         case RK_FORMAT_YCrCb_420_SP :\r
 199             stride = (w + 3) & (~3);\r
 200             size_yrgb = stride * h;\r
 201             size_uv = (stride * (h >> 1));            \r
 202             start = MIN(yrgb_addr, uv_addr);\r
 203             start >>= PAGE_SHIFT; \r
 204             end = MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv));\r
 205             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 206             pageCount = end - start;\r
 207             break;\r
 208         case RK_FORMAT_YCrCb_420_P :\r
 209             stride = (w + 3) & (~3);\r
 210             size_yrgb = stride * h;\r
 211             size_uv = ((stride >> 1) * (h >> 1));\r
 212             size_v = ((stride >> 1) * (h >> 1));\r
 213             start = MIN(MIN(yrgb_addr, uv_addr), v_addr);\r
 214             start >>= PAGE_SHIFT; \r
 215             end = MAX(MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv)), (v_addr + size_v));\r
 216             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 217             pageCount = end - start;\r
 218             break;\r
 219         #if 0    \r
 220         case RK_FORMAT_BPP1 :            \r
 221             break;\r
 222         case RK_FORMAT_BPP2 :\r
 223             break;\r
 224         case RK_FORMAT_BPP4 :\r
 225             break;\r
 226         case RK_FORMAT_BPP8 :\r
 227             break;\r
 228         #endif    \r
 229         default :\r
 230             pageCount = 0;\r
 231             start = 0;\r
 232             break;\r
 233     }\r
 234 \r
 235     *StartAddr = start;\r
 236     return pageCount;    \r
 237 }\r
 238 \r
 239 static int rga_MapUserMemory(struct page **pages, \r
 240                                             uint32_t *pageTable, \r
 241                                             uint32_t Memory, \r
 242                                             uint32_t pageCount)\r
 243 {\r
 244     int32_t result;\r
 245     uint32_t i;\r
 246     uint32_t status;\r
 247     uint32_t Address;\r
 248     uint32_t temp;\r
 249     status = 0;\r
 250     Address = 0;\r
 251 \r
 252     do\r
 253     {    \r
 254         down_read(&current->mm->mmap_sem);\r
 255         result = get_user_pages(current,\r
 256                 current->mm,\r
 257                 Memory << PAGE_SHIFT,\r
 258                 pageCount,\r
 259                 1,\r
 260                 0,\r
 261                 pages,\r
 262                 NULL\r
 263                 );\r
 264         up_read(&current->mm->mmap_sem);\r
 265                         \r
 266         if(result <= 0 || result < pageCount) \r
 267         {\r
 268             status = 0;\r
 269 \r
 270             for(i=0; i<pageCount; i++)\r
 271             {   \r
 272                 temp = armv7_va_to_pa((Memory + i) << PAGE_SHIFT);\r
 273                 if (temp == 0xffffffff)\r
 274                 {\r
 275                     printk("rga find mmu phy ddr error\n ");\r
 276                     status = RGA_OUT_OF_RESOURCES;\r
 277                     break;\r
 278                 }\r
 279                 \r
 280                 pageTable[i] = temp;                \r
 281             }\r
 282 \r
 283             return status;\r
 284         }\r
 285 \r
 286         for (i = 0; i < pageCount; i++)\r
 287         {\r
 288             /* Flush the data cache. */\r
 289 #ifdef ANDROID\r
 290             dma_sync_single_for_device(\r
 291                         NULL,\r
 292                         page_to_phys(pages[i]),\r
 293                         PAGE_SIZE,\r
 294                         DMA_TO_DEVICE);\r
 295 #else\r
 296             flush_dcache_page(pages[i]);\r
 297 #endif\r
 298         }\r
 299 \r
 300         /* Fill the page table. */\r
 301         for(i=0; i<pageCount; i++) \r
 302         {\r
 303             /* Get the physical address from page struct. */\r
 304             pageTable[i] = page_to_phys(pages[i]);\r
 305         }\r
 306 \r
 307         return 0;\r
 308     }\r
 309     while(0);\r
 310 \r
 311     if (rgaIS_ERROR(status))\r
 312     {\r
 313         /* Release page array. */\r
 314         if (result > 0 && pages != NULL)\r
 315         {\r
 316             for (i = 0; i < result; i++)\r
 317             {\r
 318                 if (pages[i] == NULL)\r
 319                 {\r
 320                     break;\r
 321                 }\r
 322 #ifdef ANDROID\r
 323                 dma_sync_single_for_device(\r
 324                             NULL,\r
 325                             page_to_phys(pages[i]),\r
 326                             PAGE_SIZE,\r
 327                             DMA_FROM_DEVICE);\r
 328 #endif\r
 329                 page_cache_release(pages[i]);\r
 330             }\r
 331         }\r
 332     }\r
 333 \r
 334     return status;\r
 335 }\r
 336 \r
 337 static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)\r
 338 {    \r
 339     int SrcMemSize, DstMemSize;\r
 340     uint32_t SrcStart, DstStart;   \r
 341     uint32_t i;\r
 342     uint32_t AllSize;\r
 343     uint32_t *MMU_Base, *MMU_p;\r
 344     int ret;\r
 345     int status;\r
 346     uint32_t uv_size, v_size;\r
 347 \r
 348     struct page **pages = NULL;\r
 349 \r
 350     MMU_Base = NULL;\r
 351     \r
 352     do\r
 353     {               \r
 354         /* cal src buf mmu info */                     \r
 355         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
 356                                         req->src.format, req->src.vir_w, req->src.act_h + req->src.y_offset,\r
 357                                         &SrcStart);\r
 358         if(SrcMemSize == 0) {\r
 359             return -EINVAL;                \r
 360         }\r
 361       \r
 362         /* cal dst buf mmu info */    \r
 363         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 364                                         req->dst.format, req->dst.vir_w, req->dst.act_h + req->dst.y_offset,\r
 365                                         &DstStart);        \r
 366         if(DstMemSize == 0) {\r
 367             return -EINVAL; \r
 368         }\r
 369                 \r
 370         /* Cal out the needed mem size */\r
 371         AllSize = SrcMemSize + DstMemSize;\r
 372                            \r
 373         pages = kmalloc((AllSize + 1)* sizeof(struct page *), GFP_KERNEL);\r
 374         if(pages == NULL) {\r
 375             pr_err("RGA MMU malloc pages mem failed\n");\r
 376             status = RGA_MALLOC_ERROR;\r
 377             break;                \r
 378         }\r
 379         \r
 380         MMU_Base = kmalloc((AllSize + 1) * sizeof(uint32_t), GFP_KERNEL);\r
 381         if(MMU_Base == NULL) {\r
 382             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 383             status = RGA_MALLOC_ERROR;\r
 384             break;                \r
 385         }\r
 386 \r
 387         if(req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 388         {            \r
 389             ret = rga_MapUserMemory(&pages[0], &MMU_Base[0], SrcStart, SrcMemSize);\r
 390             if (ret < 0) {\r
 391                 pr_err("rga map src memory failed\n");\r
 392                 status = ret;\r
 393                 break;\r
 394             }            \r
 395         }\r
 396         else\r
 397         {\r
 398             MMU_p = MMU_Base;\r
 399             \r
 400             if(req->src.yrgb_addr == (uint32_t)rga_service.pre_scale_buf)\r
 401             {\r
 402                 /* Down scale ratio over 2, Last prc    */\r
 403                 /* MMU table copy from pre scale table  */\r
 404                 \r
 405                 for(i=0; i<SrcMemSize; i++)\r
 406                 {\r
 407                     MMU_p[i] = rga_service.pre_scale_buf[i];\r
 408                 }                \r
 409             }\r
 410             else\r
 411             {                      \r
 412                 for(i=0; i<SrcMemSize; i++)\r
 413                 {\r
 414                     MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 415                 }                \r
 416             }            \r
 417         }\r
 418         \r
 419         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID)\r
 420         {     \r
 421             #if 0\r
 422             ktime_t start, end;\r
 423             start = ktime_get();\r
 424             #endif\r
 425             ret = rga_MapUserMemory(&pages[SrcMemSize], &MMU_Base[SrcMemSize], DstStart, DstMemSize);\r
 426             if (ret < 0) {\r
 427                 pr_err("rga map dst memory failed\n");\r
 428                 status = ret;\r
 429                 break;\r
 430             }\r
 431 \r
 432             #if 0\r
 433             end = ktime_get();\r
 434             end = ktime_sub(end, start);\r
 435             printk("dst mmu map time = %d\n", (int)ktime_to_us(end));\r
 436             #endif\r
 437         }\r
 438         else\r
 439         {\r
 440             MMU_p = MMU_Base + SrcMemSize;\r
 441             \r
 442             for(i=0; i<DstMemSize; i++)\r
 443             {\r
 444                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 445             }                   \r
 446         }\r
 447 \r
 448         MMU_Base[AllSize] = MMU_Base[AllSize - 1];\r
 449 \r
 450         /* zsq \r
 451          * change the buf address in req struct     \r
 452          */\r
 453         \r
 454         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);\r
 455 \r
 456         uv_size = (req->src.uv_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 457         v_size = (req->src.v_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 458         \r
 459         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK));\r
 460         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | (uv_size << PAGE_SHIFT);\r
 461         req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | (v_size << PAGE_SHIFT);\r
 462 \r
 463         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | (SrcMemSize << PAGE_SHIFT);\r
 464                 \r
 465         /*record the malloc buf for the cmd end to release*/\r
 466         reg->MMU_base = MMU_Base;\r
 467         \r
 468         /* flush data to DDR */\r
 469         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 470         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 471 \r
 472         status = 0;\r
 473                \r
 474         /* Free the page table */        \r
 475         if (pages != NULL) {\r
 476             kfree(pages);\r
 477         }\r
 478 \r
 479         return status;\r
 480     }\r
 481     while(0);\r
 482 \r
 483     \r
 484     /* Free the page table */        \r
 485     if (pages != NULL) {\r
 486         kfree(pages);\r
 487     }\r
 488 \r
 489     /* Free MMU table */\r
 490     if(MMU_Base != NULL) {\r
 491         kfree(MMU_Base);\r
 492     }\r
 493 \r
 494     return status;\r
 495 }\r
 496 \r
 497 static int rga_mmu_info_color_palette_mode(struct rga_reg *reg, struct rga_req *req)\r
 498 {\r
 499     int SrcMemSize, DstMemSize, CMDMemSize;\r
 500     uint32_t SrcStart, DstStart, CMDStart;\r
 501     struct page **pages = NULL;\r
 502     uint32_t i;\r
 503     uint32_t AllSize;\r
 504     uint32_t *MMU_Base = NULL;\r
 505     uint32_t *MMU_p;\r
 506     int ret, status;\r
 507     uint32_t stride;\r
 508 \r
 509     uint8_t shift;\r
 510     uint16_t sw, byte_num;\r
 511     \r
 512     shift = 3 - (req->palette_mode & 3);\r
 513     sw = req->src.vir_w;\r
 514     byte_num = sw >> shift;\r
 515     stride = (byte_num + 3) & (~3);\r
 516 \r
 517     do\r
 518     {\r
 519                          \r
 520         SrcMemSize = rga_mem_size_cal(req->src.yrgb_addr, stride, &SrcStart);\r
 521         if(SrcMemSize == 0) {\r
 522             return -EINVAL;                \r
 523         }\r
 524 \r
 525         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 526                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 527                                         &DstStart);\r
 528         if(DstMemSize == 0) {\r
 529             return -EINVAL; \r
 530         }\r
 531 \r
 532         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
 533         if(CMDMemSize == 0) {\r
 534             return -EINVAL; \r
 535         }\r
 536 \r
 537         AllSize = SrcMemSize + DstMemSize + CMDMemSize;\r
 538                    \r
 539         pages = kzalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 540         if(pages == NULL) {\r
 541             pr_err("RGA MMU malloc pages mem failed\n");\r
 542             return -EINVAL;                \r
 543         }\r
 544 \r
 545         MMU_Base = kzalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 546         if(MMU_Base == NULL) {\r
 547             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 548             break;            \r
 549         }\r
 550 \r
 551         /* map CMD addr */\r
 552         for(i=0; i<CMDMemSize; i++) \r
 553         {\r
 554             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i)<<PAGE_SHIFT));\r
 555         }\r
 556 \r
 557         /* map src addr */\r
 558         if (req->src.yrgb_addr < KERNEL_SPACE_VALID) \r
 559         {            \r
 560             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 561             if (ret < 0) \r
 562             {\r
 563                 pr_err("rga map src memory failed\n");\r
 564                 status = ret;\r
 565                 break;            \r
 566             }\r
 567         }\r
 568         else\r
 569         {\r
 570             MMU_p = MMU_Base + CMDMemSize;\r
 571             \r
 572             for(i=0; i<SrcMemSize; i++)\r
 573             {\r
 574                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 575             }\r
 576         }\r
 577 \r
 578         /* map dst addr */\r
 579         if (req->src.yrgb_addr < KERNEL_SPACE_VALID) \r
 580         {\r
 581             ret = rga_MapUserMemory(&pages[CMDMemSize + SrcMemSize], &MMU_Base[CMDMemSize + SrcMemSize], DstStart, DstMemSize);\r
 582             if (ret < 0) \r
 583             {\r
 584                 pr_err("rga map dst memory failed\n");\r
 585                 status = ret;\r
 586                 break;\r
 587             }\r
 588         }\r
 589         else\r
 590         {\r
 591             MMU_p = MMU_Base + CMDMemSize + SrcMemSize;\r
 592             \r
 593             for(i=0; i<DstMemSize; i++)\r
 594             {\r
 595                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 596             }\r
 597         }\r
 598         \r
 599 \r
 600         /* zsq \r
 601          * change the buf address in req struct\r
 602          * for the reason of lie to MMU \r
 603          */\r
 604         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);    \r
 605         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 606         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);\r
 607 \r
 608 \r
 609         /*record the malloc buf for the cmd end to release*/\r
 610         reg->MMU_base = MMU_Base;\r
 611 \r
 612         /* flush data to DDR */\r
 613         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 614         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 615 \r
 616         /* Free the page table */\r
 617         if (pages != NULL) {            \r
 618             kfree(pages);\r
 619         }\r
 620 \r
 621         return status;\r
 622 \r
 623     }\r
 624     while(0);\r
 625 \r
 626     /* Free the page table */\r
 627     if (pages != NULL) {            \r
 628         kfree(pages);\r
 629     }\r
 630 \r
 631     /* Free mmu table */\r
 632     if (MMU_Base != NULL) {\r
 633         kfree(MMU_Base);\r
 634     }\r
 635 \r
 636     return 0;\r
 637 }\r
 638 \r
 639 static int rga_mmu_info_color_fill_mode(struct rga_reg *reg, struct rga_req *req)\r
 640 {\r
 641     int DstMemSize;\r
 642     uint32_t DstStart;\r
 643     struct page **pages = NULL;\r
 644     uint32_t i;\r
 645     uint32_t AllSize;\r
 646     uint32_t *MMU_Base, *MMU_p;\r
 647     int ret;\r
 648     int status;\r
 649 \r
 650     MMU_Base = NULL;\r
 651 \r
 652     do\r
 653     {                         \r
 654         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 655                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 656                                         &DstStart);\r
 657         if(DstMemSize == 0) {\r
 658             return -EINVAL; \r
 659         }\r
 660 \r
 661         AllSize = DstMemSize;\r
 662                    \r
 663         pages = kzalloc((AllSize + 1)* sizeof(struct page *), GFP_KERNEL);\r
 664         if(pages == NULL) {\r
 665             pr_err("RGA MMU malloc pages mem failed\n");\r
 666             status = RGA_MALLOC_ERROR; \r
 667             break;\r
 668         }\r
 669         \r
 670         MMU_Base = kzalloc((AllSize + 1) * sizeof(uint32_t), GFP_KERNEL);\r
 671         if(pages == NULL) {\r
 672             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 673             status = RGA_MALLOC_ERROR;\r
 674             break;                \r
 675         }\r
 676 \r
 677         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID) \r
 678         {\r
 679             ret = rga_MapUserMemory(&pages[0], &MMU_Base[0], DstStart, DstMemSize);\r
 680             if (ret < 0) {\r
 681                 pr_err("rga map dst memory failed\n");\r
 682                 status = ret;\r
 683                 break;\r
 684             }\r
 685         }\r
 686         else\r
 687         {\r
 688             MMU_p = MMU_Base;\r
 689             \r
 690             for(i=0; i<DstMemSize; i++)\r
 691             {\r
 692                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 693             }\r
 694         }\r
 695 \r
 696         MMU_Base[AllSize] = MMU_Base[AllSize - 1];        \r
 697                             \r
 698         /* zsq \r
 699          * change the buf address in req struct \r
 700          */\r
 701          \r
 702         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);    \r
 703         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK));\r
 704                \r
 705         /*record the malloc buf for the cmd end to release*/\r
 706         reg->MMU_base = MMU_Base;\r
 707 \r
 708         /* flush data to DDR */\r
 709         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 710         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 711 \r
 712         /* Free the page table */\r
 713         if (pages != NULL)             \r
 714             kfree(pages);\r
 715 \r
 716         return 0;\r
 717     }\r
 718     while(0);\r
 719 \r
 720     if (pages != NULL)    \r
 721         kfree(pages);\r
 722 \r
 723     if (MMU_Base != NULL)\r
 724         kfree(MMU_Base);\r
 725     \r
 726     return status;\r
 727 }\r
 728 \r
 729 \r
 730 static int rga_mmu_info_line_point_drawing_mode(struct rga_reg *reg, struct rga_req *req)\r
 731 {\r
 732     int DstMemSize;\r
 733     uint32_t DstStart;\r
 734     struct page **pages = NULL;\r
 735     uint32_t i;\r
 736     uint32_t AllSize;\r
 737     uint32_t *MMU_Base, *MMU_p;\r
 738     int ret, status;\r
 739 \r
 740     MMU_Base = NULL;\r
 741 \r
 742     do\r
 743     {    \r
 744         /* cal dst buf mmu info */                     \r
 745         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 746                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 747                                         &DstStart);\r
 748         if(DstMemSize == 0) {\r
 749             return -EINVAL; \r
 750         }\r
 751 \r
 752         AllSize = DstMemSize;\r
 753                    \r
 754         pages = kzalloc((AllSize + 1) * sizeof(struct page *), GFP_KERNEL);\r
 755         if(pages == NULL) {\r
 756             pr_err("RGA MMU malloc pages mem failed\n");\r
 757             status = RGA_MALLOC_ERROR;\r
 758             break;\r
 759         }\r
 760         \r
 761         MMU_Base = kzalloc((AllSize + 1) * sizeof(uint32_t), GFP_KERNEL);\r
 762         if(pages == NULL) {\r
 763             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 764             status = RGA_MALLOC_ERROR;\r
 765             break;\r
 766         }\r
 767 \r
 768         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID)\r
 769         {\r
 770             ret = rga_MapUserMemory(&pages[0], &MMU_Base[0], DstStart, DstMemSize);\r
 771             if (ret < 0) {\r
 772                 pr_err("rga map dst memory failed\n");\r
 773                 status = ret;\r
 774                 break;\r
 775             }\r
 776         }\r
 777         else\r
 778         {\r
 779             MMU_p = MMU_Base;\r
 780             \r
 781             for(i=0; i<DstMemSize; i++)\r
 782             {\r
 783                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 784             }\r
 785         }\r
 786 \r
 787         /* zsq \r
 788          * change the buf address in req struct\r
 789          * for the reason of lie to MMU \r
 790          */\r
 791         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);    \r
 792         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK));\r
 793        \r
 794         \r
 795         /*record the malloc buf for the cmd end to release*/\r
 796         reg->MMU_base = MMU_Base;\r
 797 \r
 798         /* flush data to DDR */\r
 799         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 800         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 801 \r
 802         /* Free the page table */\r
 803         if (pages != NULL) {            \r
 804             kfree(pages);\r
 805         } \r
 806 \r
 807         return 0;\r
 808 \r
 809     }\r
 810     while(0);\r
 811 \r
 812     if (pages != NULL)\r
 813         kfree(pages);\r
 814 \r
 815     if (MMU_Base != NULL)\r
 816         kfree(MMU_Base);\r
 817 \r
 818     return status;\r
 819 }\r
 820 \r
 821 static int rga_mmu_info_blur_sharp_filter_mode(struct rga_reg *reg, struct rga_req *req)\r
 822 {\r
 823     int SrcMemSize, DstMemSize;\r
 824     uint32_t SrcStart, DstStart;\r
 825     struct page **pages = NULL;\r
 826     uint32_t i;\r
 827     uint32_t AllSize;\r
 828     uint32_t *MMU_Base, *MMU_p;\r
 829     int ret, status;\r
 830     uint32_t uv_size, v_size;\r
 831 \r
 832     MMU_Base = NULL;\r
 833     \r
 834     do\r
 835     {\r
 836         /* cal src buf mmu info */                     \r
 837         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
 838                                         req->src.format, req->src.vir_w, req->src.vir_h,\r
 839                                         &SrcStart);\r
 840         if(SrcMemSize == 0) {\r
 841             return -EINVAL;                \r
 842         }\r
 843 \r
 844         /* cal dst buf mmu info */    \r
 845         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 846                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 847                                         &DstStart);\r
 848         if(DstMemSize == 0) {\r
 849             return -EINVAL; \r
 850         }\r
 851 \r
 852         AllSize = SrcMemSize + DstMemSize;\r
 853                    \r
 854         pages = kzalloc((AllSize + 1) * sizeof(struct page *), GFP_KERNEL);\r
 855         if(pages == NULL) {\r
 856             pr_err("RGA MMU malloc pages mem failed\n");\r
 857             status = RGA_MALLOC_ERROR;\r
 858             break;    \r
 859         }\r
 860         \r
 861         MMU_Base = kzalloc((AllSize + 1)* sizeof(uint32_t), GFP_KERNEL);\r
 862         if(pages == NULL) {\r
 863             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 864             status = RGA_MALLOC_ERROR;\r
 865             break;   \r
 866         }\r
 867 \r
 868         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 869         {\r
 870             ret = rga_MapUserMemory(&pages[0], &MMU_Base[0], SrcStart, SrcMemSize);\r
 871             if (ret < 0) \r
 872             {\r
 873                 pr_err("rga map src memory failed\n");\r
 874                 status = ret;\r
 875                 break;\r
 876             }\r
 877         }\r
 878         else\r
 879         {\r
 880             MMU_p = MMU_Base;\r
 881             \r
 882             for(i=0; i<SrcMemSize; i++)\r
 883             {\r
 884                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 885             }            \r
 886         }\r
 887 \r
 888         \r
 889         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID)\r
 890         {\r
 891             ret = rga_MapUserMemory(&pages[SrcMemSize], &MMU_Base[SrcMemSize], DstStart, DstMemSize);\r
 892             if (ret < 0) \r
 893             {\r
 894                 pr_err("rga map dst memory failed\n");\r
 895                 status = ret;\r
 896                 break;\r
 897             }\r
 898         }\r
 899         else\r
 900         {\r
 901             MMU_p = MMU_Base + SrcMemSize;\r
 902             \r
 903             for(i=0; i<DstMemSize; i++)\r
 904             {\r
 905                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 906             }\r
 907         }\r
 908 \r
 909         MMU_Base[AllSize] = MMU_Base[AllSize - 1];\r
 910 \r
 911         /* zsq \r
 912          * change the buf address in req struct\r
 913          * for the reason of lie to MMU \r
 914          */\r
 915         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);\r
 916 \r
 917         uv_size = (req->src.uv_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 918         v_size = (req->src.v_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 919         \r
 920         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK));\r
 921         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | (uv_size << PAGE_SHIFT);\r
 922         req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | (v_size << PAGE_SHIFT);\r
 923 \r
 924         uv_size = (req->dst.uv_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 925         v_size = (req->dst.v_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 926 \r
 927         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | (SrcMemSize << PAGE_SHIFT);\r
 928         req->dst.uv_addr = (req->dst.uv_addr & (~PAGE_MASK)) | ((SrcMemSize + uv_size) << PAGE_SHIFT);\r
 929         req->dst.v_addr = (req->dst.v_addr & (~PAGE_MASK)) | ((SrcMemSize + v_size) << PAGE_SHIFT);\r
 930         \r
 931         \r
 932         /*record the malloc buf for the cmd end to release*/\r
 933         reg->MMU_base = MMU_Base;\r
 934 \r
 935         /* flush data to DDR */\r
 936         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 937         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 938 \r
 939         /* Free the page table */\r
 940         if (pages != NULL) {        \r
 941             kfree(pages);\r
 942         }  \r
 943 \r
 944         return 0;\r
 945     }\r
 946     while(0);\r
 947 \r
 948     if (pages != NULL)\r
 949         kfree(pages);\r
 950 \r
 951     if (MMU_Base != NULL)\r
 952         kfree(MMU_Base);\r
 953 \r
 954     return status;\r
 955 }\r
 956 \r
 957 \r
 958 \r
 959 static int rga_mmu_info_pre_scale_mode(struct rga_reg *reg, struct rga_req *req)\r
 960 {\r
 961     int SrcMemSize, DstMemSize;\r
 962     uint32_t SrcStart, DstStart;\r
 963     struct page **pages = NULL;\r
 964     uint32_t i;\r
 965     uint32_t AllSize;\r
 966     uint32_t *MMU_Base, *MMU_p;\r
 967     int ret;\r
 968     int status;\r
 969     uint32_t uv_size, v_size;\r
 970 \r
 971     MMU_Base = NULL;\r
 972 \r
 973     do\r
 974     {\r
 975         /* cal src buf mmu info */                     \r
 976         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
 977                                         req->src.format, req->src.vir_w, req->src.vir_h,\r
 978                                         &SrcStart);\r
 979         if(SrcMemSize == 0) {\r
 980             return -EINVAL;                \r
 981         }\r
 982 \r
 983         /* cal dst buf mmu info */    \r
 984         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 985                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 986                                         &DstStart);\r
 987         if(DstMemSize == 0) {\r
 988             return -EINVAL; \r
 989         }\r
 990 \r
 991         AllSize = SrcMemSize + DstMemSize;\r
 992                    \r
 993         pages = kzalloc((AllSize)* sizeof(struct page *), GFP_KERNEL);\r
 994         if(pages == NULL) \r
 995         {\r
 996             pr_err("RGA MMU malloc pages mem failed\n");\r
 997             status = RGA_MALLOC_ERROR;\r
 998             break;                \r
 999         }\r
1000 \r
1001         /* \r
1002          * Allocate MMU Index mem\r
1003          * This mem release in run_to_done fun \r
1004          */\r
1005         MMU_Base = kzalloc((AllSize + 1) * sizeof(uint32_t), GFP_KERNEL);\r
1006         if(pages == NULL) {\r
1007             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
1008             status = RGA_MALLOC_ERROR;            \r
1009             break;                \r
1010         }\r
1011 \r
1012         /* map src pages */\r
1013         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
1014         {\r
1015             ret = rga_MapUserMemory(&pages[0], &MMU_Base[0], SrcStart, SrcMemSize);\r
1016             if (ret < 0) {\r
1017                 pr_err("rga map src memory failed\n");\r
1018                 status = ret;\r
1019                 break;\r
1020             }\r
1021         }\r
1022         else\r
1023         {\r
1024             MMU_p = MMU_Base;\r
1025             \r
1026             for(i=0; i<SrcMemSize; i++)\r
1027             {\r
1028                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
1029             } \r
1030         }\r
1031 \r
1032         \r
1033         if(req->dst.yrgb_addr >= KERNEL_SPACE_VALID) \r
1034         {   \r
1035             /* kernel space */\r
1036             MMU_p = MMU_Base + SrcMemSize;\r
1037 \r
1038             if(req->dst.yrgb_addr == (uint32_t)rga_service.pre_scale_buf)\r
1039             {\r
1040                 for(i=0; i<DstMemSize; i++)\r
1041                 {\r
1042                     MMU_p[i] = rga_service.pre_scale_buf[i];\r
1043                 }\r
1044             }\r
1045             else\r
1046             {\r
1047                 for(i=0; i<DstMemSize; i++) \r
1048                 {\r
1049                     MMU_p[i] = virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));        \r
1050                 }    \r
1051             }                                    \r
1052         }\r
1053         else \r
1054         {\r
1055             /* user space */\r
1056             ret = rga_MapUserMemory(&pages[SrcMemSize], &MMU_Base[SrcMemSize], DstStart, DstMemSize);\r
1057             if (ret < 0) \r
1058             {\r
1059                 pr_err("rga map dst memory failed\n");\r
1060                 status = ret;\r
1061                 break;\r
1062             }        \r
1063         }\r
1064 \r
1065         MMU_Base[AllSize] = MMU_Base[AllSize - 1];\r
1066 \r
1067         /* zsq \r
1068          * change the buf address in req struct\r
1069          * for the reason of lie to MMU \r
1070          */\r
1071         \r
1072         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);\r
1073 \r
1074         uv_size = (req->src.uv_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1075         v_size = (req->src.v_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1076 \r
1077         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK));\r
1078         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | (uv_size << PAGE_SHIFT);\r
1079         req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | (v_size << PAGE_SHIFT);\r
1080 \r
1081         uv_size = (req->dst.uv_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1082         v_size = (req->dst.v_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1083 \r
1084         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((SrcMemSize) << PAGE_SHIFT);\r
1085         req->dst.uv_addr = (req->dst.uv_addr & (~PAGE_MASK)) | ((SrcMemSize + uv_size) << PAGE_SHIFT);\r
1086         req->dst.v_addr = (req->dst.v_addr & (~PAGE_MASK)) | ((SrcMemSize + v_size) << PAGE_SHIFT);\r
1087 \r
1088         /*record the malloc buf for the cmd end to release*/\r
1089         reg->MMU_base = MMU_Base;\r
1090 \r
1091         /* flush data to DDR */\r
1092         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
1093         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
1094 \r
1095         /* Free the page table */\r
1096         if (pages != NULL) \r
1097         {            \r
1098             kfree(pages);\r
1099         }  \r
1100 \r
1101         return 0;\r
1102     }\r
1103     while(0);\r
1104 \r
1105     if (pages != NULL)\r
1106         kfree(pages);\r
1107 \r
1108     if (MMU_Base != NULL)\r
1109         kfree(MMU_Base);\r
1110 \r
1111     return status;\r
1112 }\r
1113 \r
1114 \r
1115 static int rga_mmu_info_update_palette_table_mode(struct rga_reg *reg, struct rga_req *req)\r
1116 {\r
1117     int SrcMemSize, CMDMemSize;\r
1118     uint32_t SrcStart, CMDStart;\r
1119     struct page **pages = NULL;\r
1120     uint32_t i;\r
1121     uint32_t AllSize;\r
1122     uint32_t *MMU_Base, *MMU_p;\r
1123     int ret, status;\r
1124 \r
1125     MMU_Base = NULL;\r
1126 \r
1127     do\r
1128     {    \r
1129         /* cal src buf mmu info */                     \r
1130         SrcMemSize = rga_mem_size_cal(req->src.yrgb_addr, req->src.vir_w * req->src.vir_h, &SrcStart);\r
1131         if(SrcMemSize == 0) {\r
1132             return -EINVAL;                \r
1133         }\r
1134 \r
1135         /* cal cmd buf mmu info */\r
1136         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
1137         if(CMDMemSize == 0) {\r
1138             return -EINVAL; \r
1139         }\r
1140 \r
1141         AllSize = SrcMemSize + CMDMemSize;\r
1142                    \r
1143         pages = kzalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
1144         if(pages == NULL) {\r
1145             pr_err("RGA MMU malloc pages mem failed\n");\r
1146             status = RGA_MALLOC_ERROR;\r
1147             break;    \r
1148         }\r
1149         \r
1150         MMU_Base = kzalloc((AllSize + 1)* sizeof(uint32_t), GFP_KERNEL);\r
1151         if(pages == NULL) {\r
1152             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
1153             status = RGA_MALLOC_ERROR;\r
1154             break;                \r
1155         }\r
1156 \r
1157         for(i=0; i<CMDMemSize; i++) {\r
1158             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
1159         }\r
1160 \r
1161         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
1162         {\r
1163             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
1164             if (ret < 0) {\r
1165                 pr_err("rga map src memory failed\n");\r
1166                 return -EINVAL;\r
1167             }\r
1168         }\r
1169         else\r
1170         {\r
1171             MMU_p = MMU_Base + CMDMemSize;\r
1172                 \r
1173                 for(i=0; i<SrcMemSize; i++)\r
1174                 {\r
1175                     MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
1176                 } \r
1177         }\r
1178 \r
1179         /* zsq \r
1180          * change the buf address in req struct\r
1181          * for the reason of lie to MMU \r
1182          */\r
1183         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);\r
1184         \r
1185         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);    \r
1186         \r
1187         /*record the malloc buf for the cmd end to release*/\r
1188         reg->MMU_base = MMU_Base;\r
1189 \r
1190         /* flush data to DDR */\r
1191         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
1192         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
1193 \r
1194         if (pages != NULL) {\r
1195             /* Free the page table */\r
1196             kfree(pages);\r
1197         }  \r
1198 \r
1199         return 0;\r
1200     }\r
1201     while(0);\r
1202 \r
1203     if (pages != NULL)\r
1204         kfree(pages);\r
1205 \r
1206     if (MMU_Base != NULL)\r
1207         kfree(MMU_Base);\r
1208 \r
1209     return status;\r
1210 }\r
1211 \r
1212 static int rga_mmu_info_update_patten_buff_mode(struct rga_reg *reg, struct rga_req *req)\r
1213 {\r
1214     int SrcMemSize, CMDMemSize;\r
1215     uint32_t SrcStart, CMDStart;\r
1216     struct page **pages = NULL;\r
1217     uint32_t i;\r
1218     uint32_t AllSize;\r
1219     uint32_t *MMU_Base, *MMU_p;\r
1220     int ret, status;\r
1221 \r
1222     MMU_Base = MMU_p = 0;\r
1223 \r
1224     do\r
1225     {\r
1226 \r
1227         /* cal src buf mmu info */                     \r
1228         SrcMemSize = rga_mem_size_cal(req->pat.yrgb_addr, req->pat.vir_w * req->pat.vir_h * 4, &SrcStart);\r
1229         if(SrcMemSize == 0) {\r
1230             return -EINVAL;                \r
1231         }\r
1232 \r
1233         /* cal cmd buf mmu info */\r
1234         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
1235         if(CMDMemSize == 0) {\r
1236             return -EINVAL; \r
1237         }\r
1238 \r
1239         AllSize = SrcMemSize + CMDMemSize;\r
1240                    \r
1241         pages = kzalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
1242         if(pages == NULL) {\r
1243             pr_err("RGA MMU malloc pages mem failed\n");\r
1244             status = RGA_MALLOC_ERROR;\r
1245             break;                \r
1246         }\r
1247         \r
1248         MMU_Base = kzalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
1249         if(pages == NULL) {\r
1250             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
1251             status = RGA_MALLOC_ERROR;\r
1252             break;                \r
1253         }\r
1254 \r
1255         for(i=0; i<CMDMemSize; i++) {\r
1256             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
1257         }\r
1258 \r
1259         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
1260         {\r
1261             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
1262             if (ret < 0) {\r
1263                 pr_err("rga map src memory failed\n");\r
1264                 status = ret;\r
1265                 break;\r
1266             }\r
1267         }\r
1268         else\r
1269         {\r
1270             MMU_p = MMU_Base + CMDMemSize;\r
1271                 \r
1272             for(i=0; i<SrcMemSize; i++)\r
1273             {\r
1274                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
1275             } \r
1276         }\r
1277 \r
1278         /* zsq \r
1279          * change the buf address in req struct\r
1280          * for the reason of lie to MMU \r
1281          */\r
1282         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);\r
1283         \r
1284         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);    \r
1285         \r
1286         /*record the malloc buf for the cmd end to release*/\r
1287         reg->MMU_base = MMU_Base;\r
1288 \r
1289         /* flush data to DDR */\r
1290         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
1291         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
1292 \r
1293         if (pages != NULL) {\r
1294             /* Free the page table */\r
1295             kfree(pages);\r
1296         }\r
1297 \r
1298         return 0;\r
1299 \r
1300     }\r
1301     while(0);\r
1302 \r
1303     if (pages != NULL)\r
1304         kfree(pages);\r
1305 \r
1306     if (MMU_Base != NULL)\r
1307         kfree(MMU_Base);\r
1308 \r
1309     return status;\r
1310 }\r
1311 \r
1312 int rga_set_mmu_info(struct rga_reg *reg, struct rga_req *req)\r
1313 {    \r
1314     int ret;\r
1315                \r
1316     switch (req->render_mode) {\r
1317         case bitblt_mode :            \r
1318             ret = rga_mmu_info_BitBlt_mode(reg, req);\r
1319             break;\r
1320         case color_palette_mode :\r
1321             ret = rga_mmu_info_color_palette_mode(reg, req);\r
1322             break;\r
1323         case color_fill_mode :\r
1324             ret = rga_mmu_info_color_fill_mode(reg, req);\r
1325             break;\r
1326         case line_point_drawing_mode :\r
1327             ret = rga_mmu_info_line_point_drawing_mode(reg, req);\r
1328             break;\r
1329         case blur_sharp_filter_mode :\r
1330             ret = rga_mmu_info_blur_sharp_filter_mode(reg, req);\r
1331             break;\r
1332         case pre_scaling_mode :\r
1333             ret = rga_mmu_info_pre_scale_mode(reg, req);\r
1334             break;\r
1335         case update_palette_table_mode :\r
1336             ret = rga_mmu_info_update_palette_table_mode(reg, req);\r
1337             break;\r
1338         case update_patten_buff_mode :\r
1339             ret = rga_mmu_info_update_patten_buff_mode(reg, req);\r
1340             break;\r
1341         default :\r
1342             ret = -1;\r
1343             break;\r
1344     }\r
1345 \r
1346     return ret;\r
1347 }\r
1348 \r