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