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