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;\r
 247                 \r
 248                 vma = find_vma(current->mm, (t_mem) << PAGE_SHIFT);\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)<< PAGE_SHIFT));\r
 259                         pud_t * pud = pud_offset(pgd, ((t_mem) << PAGE_SHIFT));\r
 260                         if (pud)\r
 261                         {\r
 262                             pmd_t * pmd = pmd_offset(pud, ((t_mem) << PAGE_SHIFT));\r
 263                             if (pmd)\r
 264                             {\r
 265                                 pte = pte_offset_map_lock(current->mm, pmd, ((t_mem)<< PAGE_SHIFT), &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_SHIFT)) & ~PAGE_MASK));                        \r
 283                         pte_unmap_unlock(pte, ptl);\r
 284                         \r
 285                         #if 0\r
 286                         /* Free the page table. */\r
 287                         if (pages != NULL)\r
 288                         {\r
 289                             /* Release the pages if any. */\r
 290                             if (result > 0)\r
 291                             {\r
 292                                 for (i = 0; i < result; i++)\r
 293                                 {\r
 294                                     if (pages[i] == NULL)\r
 295                                     {\r
 296                                         break;\r
 297                                     }\r
 298 \r
 299                                     page_cache_release(pages[i]);\r
 300                                 }\r
 301                             }\r
 302                         }\r
 303                         #endif\r
 304                         \r
 305                         pageTable[i] = Address;\r
 306                     }\r
 307                     while (0);\r
 308                 }\r
 309                 else\r
 310                 {\r
 311                     status = RGA_OUT_OF_RESOURCES;\r
 312                     break;\r
 313                 }     \r
 314             }\r
 315 \r
 316             return 0;\r
 317         }\r
 318 \r
 319         for (i = 0; i < pageCount; i++)\r
 320         {\r
 321             /* Flush the data cache. */\r
 322 #ifdef ANDROID\r
 323             dma_sync_single_for_device(\r
 324                         NULL,\r
 325                         page_to_phys(pages[i]),\r
 326                         PAGE_SIZE,\r
 327                         DMA_TO_DEVICE);\r
 328 #else\r
 329             flush_dcache_page(pages[i]);\r
 330 #endif\r
 331         }\r
 332 \r
 333         /* Fill the page table. */\r
 334         for(i=0; i<pageCount; i++) \r
 335         {\r
 336             /* Get the physical address from page struct. */\r
 337             pageTable[i] = page_to_phys(pages[i]);\r
 338         }\r
 339 \r
 340         return 0;\r
 341     }\r
 342     while(0);\r
 343 \r
 344     if (rgaIS_ERROR(status))\r
 345     {\r
 346         /* Release page array. */\r
 347         if (result > 0 && pages != NULL)\r
 348         {\r
 349             for (i = 0; i < result; i++)\r
 350             {\r
 351                 if (pages[i] == NULL)\r
 352                 {\r
 353                     break;\r
 354                 }\r
 355 #ifdef ANDROID\r
 356                 dma_sync_single_for_device(\r
 357                             NULL,\r
 358                             page_to_phys(pages[i]),\r
 359                             PAGE_SIZE,\r
 360                             DMA_FROM_DEVICE);\r
 361 #endif\r
 362                 page_cache_release(pages[i]);\r
 363             }\r
 364         }\r
 365     }\r
 366 \r
 367     return status;\r
 368 }\r
 369 \r
 370 static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)\r
 371 {    \r
 372     int SrcMemSize, DstMemSize, CMDMemSize;\r
 373     uint32_t SrcStart, DstStart, CMDStart;   \r
 374     uint32_t i;\r
 375     uint32_t AllSize;\r
 376     uint32_t *MMU_Base, *MMU_p;\r
 377     int ret;\r
 378     int status;\r
 379     uint32_t uv_size, v_size;\r
 380 \r
 381     struct page **pages = NULL;\r
 382 \r
 383     MMU_Base = NULL;\r
 384 \r
 385     if(req->src.act_w == 360 && req->src.act_h == 64)\r
 386         mmu_flag = 1;\r
 387     else\r
 388         mmu_flag = 0;\r
 389 \r
 390     do\r
 391     {               \r
 392         /* cal src buf mmu info */                     \r
 393         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
 394                                         req->src.format, req->src.vir_w, req->src.vir_h,\r
 395                                         &SrcStart);\r
 396         if(SrcMemSize == 0) {\r
 397             return -EINVAL;                \r
 398         }\r
 399         \r
 400 \r
 401         /* cal dst buf mmu info */    \r
 402         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 403                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 404                                         &DstStart);        \r
 405         if(DstMemSize == 0) {\r
 406             return -EINVAL; \r
 407         }\r
 408 \r
 409         /* cal cmd buf mmu info */\r
 410         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
 411         if(CMDMemSize == 0) {\r
 412             return -EINVAL; \r
 413         }\r
 414         \r
 415         /* Cal out the needed mem size */\r
 416         AllSize = SrcMemSize + DstMemSize + CMDMemSize;\r
 417                    \r
 418         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 419         if(pages == NULL) {\r
 420             pr_err("RGA MMU malloc pages mem failed\n");\r
 421             status = RGA_MALLOC_ERROR;\r
 422             break;                \r
 423         }\r
 424         \r
 425         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);      \r
 426         if(MMU_Base == NULL) {\r
 427             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 428             status = RGA_MALLOC_ERROR;\r
 429             break;                \r
 430         }\r
 431 \r
 432         for(i=0; i<CMDMemSize; i++) {\r
 433             MMU_Base[i] = (uint32_t)virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));            \r
 434         }\r
 435 \r
 436         if(req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 437         {            \r
 438             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 439             if (ret < 0) {\r
 440                 pr_err("rga map src memory failed\n");\r
 441                 status = ret;\r
 442                 break;\r
 443             }            \r
 444         }\r
 445         else\r
 446         {\r
 447             MMU_p = MMU_Base + CMDMemSize;\r
 448             \r
 449             if(req->src.yrgb_addr == (uint32_t)rga_service.pre_scale_buf)\r
 450             {\r
 451                 /* Down scale ratio over 2, Last prc    */\r
 452                 /* MMU table copy from pre scale table  */\r
 453                 \r
 454                 for(i=0; i<SrcMemSize; i++)\r
 455                 {\r
 456                     MMU_p[i] = rga_service.pre_scale_buf[i];\r
 457                 }                \r
 458             }\r
 459             else\r
 460             {                           \r
 461                 for(i=0; i<SrcMemSize; i++)\r
 462                 {\r
 463                     MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 464                 }\r
 465             }            \r
 466         }\r
 467         \r
 468         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID)\r
 469         {\r
 470             #if 0\r
 471             ktime_t start, end;\r
 472             start = ktime_get();\r
 473             #endif\r
 474             ret = rga_MapUserMemory(&pages[CMDMemSize + SrcMemSize], &MMU_Base[CMDMemSize + SrcMemSize], DstStart, DstMemSize);\r
 475             if (ret < 0) {\r
 476                 pr_err("rga map dst memory failed\n");\r
 477                 status = ret;\r
 478                 break;\r
 479             }\r
 480 \r
 481             #if 0\r
 482             end = ktime_get();\r
 483             end = ktime_sub(end, start);\r
 484             printk("dst mmu map time = %d\n", (int)ktime_to_us(end));\r
 485             #endif\r
 486         }\r
 487         else\r
 488         {\r
 489             MMU_p = MMU_Base + CMDMemSize + SrcMemSize;\r
 490             \r
 491             for(i=0; i<DstMemSize; i++)\r
 492             {\r
 493                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 494             }       \r
 495         }\r
 496 \r
 497         /* zsq \r
 498          * change the buf address in req struct     \r
 499          */\r
 500         \r
 501         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);\r
 502 \r
 503         uv_size = (req->src.uv_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 504         v_size = (req->src.v_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 505         \r
 506         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 507         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | ((CMDMemSize + uv_size) << PAGE_SHIFT);\r
 508         req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | ((CMDMemSize + v_size) << PAGE_SHIFT);\r
 509 \r
 510         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);\r
 511                 \r
 512         /*record the malloc buf for the cmd end to release*/\r
 513         reg->MMU_base = MMU_Base;\r
 514 \r
 515         /* flush data to DDR */\r
 516         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 517         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 518         \r
 519         status = 0;\r
 520 \r
 521         /* Free the page table */        \r
 522         if (pages != NULL) {\r
 523             kfree(pages);\r
 524         }\r
 525 \r
 526         return status;\r
 527     }\r
 528     while(0);\r
 529 \r
 530     \r
 531     /* Free the page table */        \r
 532     if (pages != NULL) {\r
 533         kfree(pages);\r
 534     }\r
 535 \r
 536     /* Free MMU table */\r
 537     if(MMU_Base != NULL) {\r
 538         kfree(MMU_Base);\r
 539     }\r
 540 \r
 541     return status;\r
 542 }\r
 543 \r
 544 static int rga_mmu_info_color_palette_mode(struct rga_reg *reg, struct rga_req *req)\r
 545 {\r
 546     int SrcMemSize, DstMemSize, CMDMemSize;\r
 547     uint32_t SrcStart, DstStart, CMDStart;\r
 548     struct page **pages = NULL;\r
 549     uint32_t i;\r
 550     uint32_t AllSize;\r
 551     uint32_t *MMU_Base = NULL;\r
 552     uint32_t *MMU_p;\r
 553     int ret, status;\r
 554     uint32_t stride;\r
 555 \r
 556     uint8_t shift;\r
 557     uint16_t sw, byte_num;\r
 558     \r
 559     shift = 3 - (req->palette_mode & 3);\r
 560     sw = req->src.vir_w;\r
 561     byte_num = sw >> shift;\r
 562     stride = (byte_num + 3) & (~3);\r
 563 \r
 564     do\r
 565     {\r
 566                          \r
 567         SrcMemSize = rga_mem_size_cal(req->src.yrgb_addr, stride, &SrcStart);\r
 568         if(SrcMemSize == 0) {\r
 569             return -EINVAL;                \r
 570         }\r
 571 \r
 572         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 573                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 574                                         &DstStart);\r
 575         if(DstMemSize == 0) {\r
 576             return -EINVAL; \r
 577         }\r
 578 \r
 579         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
 580         if(CMDMemSize == 0) {\r
 581             return -EINVAL; \r
 582         }\r
 583 \r
 584         AllSize = SrcMemSize + DstMemSize + CMDMemSize;\r
 585                    \r
 586         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 587         if(pages == NULL) {\r
 588             pr_err("RGA MMU malloc pages mem failed\n");\r
 589             return -EINVAL;                \r
 590         }\r
 591 \r
 592         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 593         if(MMU_Base == NULL) {\r
 594             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 595             break;            \r
 596         }\r
 597 \r
 598         /* map CMD addr */\r
 599         for(i=0; i<CMDMemSize; i++) \r
 600         {\r
 601             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i)<<PAGE_SHIFT));\r
 602         }\r
 603 \r
 604         /* map src addr */\r
 605         if (req->src.yrgb_addr < KERNEL_SPACE_VALID) \r
 606         {            \r
 607             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 608             if (ret < 0) \r
 609             {\r
 610                 pr_err("rga map src memory failed\n");\r
 611                 status = ret;\r
 612                 break;            \r
 613             }\r
 614         }\r
 615         else\r
 616         {\r
 617             MMU_p = MMU_Base + CMDMemSize;\r
 618             \r
 619             for(i=0; i<SrcMemSize; i++)\r
 620             {\r
 621                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 622             }\r
 623         }\r
 624 \r
 625         /* map dst addr */\r
 626         if (req->src.yrgb_addr < KERNEL_SPACE_VALID) \r
 627         {\r
 628             ret = rga_MapUserMemory(&pages[CMDMemSize + SrcMemSize], &MMU_Base[CMDMemSize + SrcMemSize], DstStart, DstMemSize);\r
 629             if (ret < 0) \r
 630             {\r
 631                 pr_err("rga map dst memory failed\n");\r
 632                 status = ret;\r
 633                 break;\r
 634             }\r
 635         }\r
 636         else\r
 637         {\r
 638             MMU_p = MMU_Base + CMDMemSize + SrcMemSize;\r
 639             \r
 640             for(i=0; i<DstMemSize; i++)\r
 641             {\r
 642                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 643             }\r
 644         }\r
 645         \r
 646 \r
 647         /* zsq \r
 648          * change the buf address in req struct\r
 649          * for the reason of lie to MMU \r
 650          */\r
 651         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);    \r
 652         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 653         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);\r
 654 \r
 655 \r
 656         /*record the malloc buf for the cmd end to release*/\r
 657         reg->MMU_base = MMU_Base;\r
 658 \r
 659         /* flush data to DDR */\r
 660         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 661         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 662 \r
 663         /* Free the page table */\r
 664         if (pages != NULL) {            \r
 665             kfree(pages);\r
 666         }\r
 667 \r
 668         return status;\r
 669 \r
 670     }\r
 671     while(0);\r
 672 \r
 673     /* Free the page table */\r
 674     if (pages != NULL) {            \r
 675         kfree(pages);\r
 676     }\r
 677 \r
 678     /* Free mmu table */\r
 679     if (MMU_Base != NULL) {\r
 680         kfree(MMU_Base);\r
 681     }\r
 682 \r
 683     return 0;\r
 684 }\r
 685 \r
 686 static int rga_mmu_info_color_fill_mode(struct rga_reg *reg, struct rga_req *req)\r
 687 {\r
 688     int DstMemSize, CMDMemSize;\r
 689     uint32_t DstStart, CMDStart;\r
 690     struct page **pages = NULL;\r
 691     uint32_t i;\r
 692     uint32_t AllSize;\r
 693     uint32_t *MMU_Base, *MMU_p;\r
 694     int ret;\r
 695     int status;\r
 696 \r
 697     MMU_Base = NULL;\r
 698 \r
 699     do\r
 700     {                         \r
 701         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 702                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 703                                         &DstStart);\r
 704         if(DstMemSize == 0) {\r
 705             return -EINVAL; \r
 706         }\r
 707 \r
 708         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
 709         if(CMDMemSize == 0) {\r
 710             return -EINVAL; \r
 711         }\r
 712 \r
 713         AllSize = DstMemSize + CMDMemSize;\r
 714                    \r
 715         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 716         if(pages == NULL) {\r
 717             pr_err("RGA MMU malloc pages mem failed\n");\r
 718             status = RGA_MALLOC_ERROR; \r
 719             break;\r
 720         }\r
 721         \r
 722         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 723         if(pages == NULL) {\r
 724             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 725             status = RGA_MALLOC_ERROR;\r
 726             break;                \r
 727         }\r
 728 \r
 729         for(i=0; i<CMDMemSize; i++) {\r
 730             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart+i)<<PAGE_SHIFT));\r
 731         }\r
 732 \r
 733         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID) \r
 734         {\r
 735             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], DstStart, DstMemSize);\r
 736             if (ret < 0) {\r
 737                 pr_err("rga map dst memory failed\n");\r
 738                 status = ret;\r
 739                 break;\r
 740             }\r
 741         }\r
 742         else\r
 743         {\r
 744             MMU_p = MMU_Base + CMDMemSize;\r
 745             \r
 746             for(i=0; i<DstMemSize; i++)\r
 747             {\r
 748                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 749             }\r
 750         }\r
 751         \r
 752                             \r
 753         /* zsq \r
 754          * change the buf address in req struct \r
 755          */\r
 756          \r
 757         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);    \r
 758         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize) << PAGE_SHIFT);\r
 759                \r
 760         /*record the malloc buf for the cmd end to release*/\r
 761         reg->MMU_base = MMU_Base;\r
 762 \r
 763         /* flush data to DDR */\r
 764         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 765         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 766 \r
 767         /* Free the page table */\r
 768         if (pages != NULL)             \r
 769             kfree(pages);\r
 770 \r
 771         return 0;\r
 772     }\r
 773     while(0);\r
 774 \r
 775     if (pages != NULL)    \r
 776         kfree(pages);\r
 777 \r
 778     if (MMU_Base != NULL)\r
 779         kfree(MMU_Base);\r
 780     \r
 781     return status;\r
 782 }\r
 783 \r
 784 \r
 785 static int rga_mmu_info_line_point_drawing_mode(struct rga_reg *reg, struct rga_req *req)\r
 786 {\r
 787     int DstMemSize, CMDMemSize;\r
 788     uint32_t DstStart, CMDStart;\r
 789     struct page **pages = NULL;\r
 790     uint32_t i;\r
 791     uint32_t AllSize;\r
 792     uint32_t *MMU_Base, *MMU_p;\r
 793     int ret, status;\r
 794 \r
 795     MMU_Base = NULL;\r
 796 \r
 797     do\r
 798     {    \r
 799         /* cal dst buf mmu info */                     \r
 800         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 801                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 802                                         &DstStart);\r
 803         if(DstMemSize == 0) {\r
 804             return -EINVAL; \r
 805         }\r
 806 \r
 807         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
 808         if(CMDMemSize == 0) {\r
 809             return -EINVAL; \r
 810         }\r
 811 \r
 812         AllSize = DstMemSize + CMDMemSize;\r
 813                    \r
 814         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 815         if(pages == NULL) {\r
 816             pr_err("RGA MMU malloc pages mem failed\n");\r
 817             status = RGA_MALLOC_ERROR;\r
 818             break;\r
 819         }\r
 820         \r
 821         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 822         if(pages == NULL) {\r
 823             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 824             status = RGA_MALLOC_ERROR;\r
 825             break;\r
 826         }\r
 827 \r
 828         for(i=0; i<CMDMemSize; i++) {\r
 829             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart+i)<<PAGE_SHIFT));\r
 830         }\r
 831 \r
 832         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID)\r
 833         {\r
 834             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], DstStart, DstMemSize);\r
 835             if (ret < 0) {\r
 836                 pr_err("rga map dst memory failed\n");\r
 837                 status = ret;\r
 838                 break;\r
 839             }\r
 840         }\r
 841         else\r
 842         {\r
 843             MMU_p = MMU_Base + CMDMemSize;\r
 844             \r
 845             for(i=0; i<DstMemSize; i++)\r
 846             {\r
 847                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 848             }\r
 849         }\r
 850 \r
 851         /* zsq \r
 852          * change the buf address in req struct\r
 853          * for the reason of lie to MMU \r
 854          */\r
 855         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);    \r
 856         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize) << PAGE_SHIFT);\r
 857        \r
 858         \r
 859         /*record the malloc buf for the cmd end to release*/\r
 860         reg->MMU_base = MMU_Base;\r
 861 \r
 862         /* flush data to DDR */\r
 863         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 864         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 865 \r
 866         /* Free the page table */\r
 867         if (pages != NULL) {            \r
 868             kfree(pages);\r
 869         } \r
 870 \r
 871         return 0;\r
 872 \r
 873     }\r
 874     while(0);\r
 875 \r
 876     if (pages != NULL)\r
 877         kfree(pages);\r
 878 \r
 879     if (MMU_Base != NULL)\r
 880         kfree(MMU_Base);\r
 881 \r
 882     return status;\r
 883 }\r
 884 \r
 885 static int rga_mmu_info_blur_sharp_filter_mode(struct rga_reg *reg, struct rga_req *req)\r
 886 {\r
 887     int SrcMemSize, DstMemSize, CMDMemSize;\r
 888     uint32_t SrcStart, DstStart, CMDStart;\r
 889     struct page **pages = NULL;\r
 890     uint32_t i;\r
 891     uint32_t AllSize;\r
 892     uint32_t *MMU_Base, *MMU_p;\r
 893     int ret, status;\r
 894     uint32_t uv_size, v_size;\r
 895 \r
 896     MMU_Base = NULL;\r
 897     \r
 898     do\r
 899     {\r
 900         /* cal src buf mmu info */                     \r
 901         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
 902                                         req->src.format, req->src.vir_w, req->src.vir_h,\r
 903                                         &SrcStart);\r
 904         if(SrcMemSize == 0) {\r
 905             return -EINVAL;                \r
 906         }\r
 907 \r
 908         /* cal dst buf mmu info */    \r
 909         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 910                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 911                                         &DstStart);\r
 912         if(DstMemSize == 0) {\r
 913             return -EINVAL; \r
 914         }\r
 915 \r
 916         /* cal cmd buf mmu info */\r
 917         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
 918         if(CMDMemSize == 0) {\r
 919             return -EINVAL; \r
 920         }\r
 921 \r
 922         AllSize = SrcMemSize + DstMemSize + CMDMemSize;\r
 923                    \r
 924         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 925         if(pages == NULL) {\r
 926             pr_err("RGA MMU malloc pages mem failed\n");\r
 927             status = RGA_MALLOC_ERROR;\r
 928             break;    \r
 929         }\r
 930         \r
 931         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 932         if(pages == NULL) {\r
 933             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 934             status = RGA_MALLOC_ERROR;\r
 935             break;   \r
 936         }\r
 937 \r
 938         for(i=0; i<CMDMemSize; i++) {\r
 939             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i)<< PAGE_SHIFT));\r
 940         }\r
 941 \r
 942         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 943         {\r
 944             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 945             if (ret < 0) \r
 946             {\r
 947                 pr_err("rga map src memory failed\n");\r
 948                 status = ret;\r
 949                 break;\r
 950             }\r
 951         }\r
 952         else\r
 953         {\r
 954             MMU_p = MMU_Base + CMDMemSize;\r
 955             \r
 956             for(i=0; i<SrcMemSize; i++)\r
 957             {\r
 958                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 959             }            \r
 960         }\r
 961 \r
 962         \r
 963         if (req->dst.yrgb_addr < KERNEL_SPACE_VALID)\r
 964         {\r
 965             ret = rga_MapUserMemory(&pages[CMDMemSize + SrcMemSize], &MMU_Base[CMDMemSize + SrcMemSize], DstStart, DstMemSize);\r
 966             if (ret < 0) \r
 967             {\r
 968                 pr_err("rga map dst memory failed\n");\r
 969                 status = ret;\r
 970                 break;\r
 971             }\r
 972         }\r
 973         else\r
 974         {\r
 975             MMU_p = MMU_Base + CMDMemSize + SrcMemSize;\r
 976             \r
 977             for(i=0; i<DstMemSize; i++)\r
 978             {\r
 979                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 980             }\r
 981         }\r
 982 \r
 983         /* zsq \r
 984          * change the buf address in req struct\r
 985          * for the reason of lie to MMU \r
 986          */\r
 987         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);\r
 988 \r
 989         uv_size = (req->src.uv_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 990         v_size = (req->src.v_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 991         \r
 992         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 993         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | ((CMDMemSize + uv_size) << PAGE_SHIFT);\r
 994         req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | ((CMDMemSize + v_size) << PAGE_SHIFT);\r
 995 \r
 996         uv_size = (req->dst.uv_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 997         v_size = (req->dst.v_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 998 \r
 999         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);\r
1000         req->dst.uv_addr = (req->dst.uv_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize + uv_size) << PAGE_SHIFT);\r
1001         req->dst.v_addr = (req->dst.v_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize + v_size) << PAGE_SHIFT);\r
1002         \r
1003         \r
1004         /*record the malloc buf for the cmd end to release*/\r
1005         reg->MMU_base = MMU_Base;\r
1006 \r
1007         /* flush data to DDR */\r
1008         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
1009         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
1010 \r
1011         /* Free the page table */\r
1012         if (pages != NULL) {        \r
1013             kfree(pages);\r
1014         }  \r
1015 \r
1016         return 0;\r
1017     }\r
1018     while(0);\r
1019 \r
1020     if (pages != NULL)\r
1021         kfree(pages);\r
1022 \r
1023     if (MMU_Base != NULL)\r
1024         kfree(MMU_Base);\r
1025 \r
1026     return status;\r
1027 }\r
1028 \r
1029 \r
1030 \r
1031 static int rga_mmu_info_pre_scale_mode(struct rga_reg *reg, struct rga_req *req)\r
1032 {\r
1033     int SrcMemSize, DstMemSize, CMDMemSize;\r
1034     uint32_t SrcStart, DstStart, CMDStart;\r
1035     struct page **pages = NULL;\r
1036     uint32_t i;\r
1037     uint32_t AllSize;\r
1038     uint32_t *MMU_Base, *MMU_p;\r
1039     int ret;\r
1040     int status;\r
1041     uint32_t uv_size, v_size;\r
1042 \r
1043     MMU_Base = NULL;\r
1044 \r
1045     do\r
1046     {\r
1047         /* cal src buf mmu info */                     \r
1048         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
1049                                         req->src.format, req->src.vir_w, req->src.vir_h,\r
1050                                         &SrcStart);\r
1051         if(SrcMemSize == 0) {\r
1052             return -EINVAL;                \r
1053         }\r
1054 \r
1055         /* cal dst buf mmu info */    \r
1056         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
1057                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
1058                                         &DstStart);\r
1059         if(DstMemSize == 0) {\r
1060             return -EINVAL; \r
1061         }\r
1062 \r
1063         /* cal cmd buf mmu info */\r
1064         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
1065         if(CMDMemSize == 0) {\r
1066             return -EINVAL; \r
1067         }\r
1068 \r
1069         AllSize = SrcMemSize + DstMemSize + CMDMemSize;\r
1070                    \r
1071         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
1072         if(pages == NULL) \r
1073         {\r
1074             pr_err("RGA MMU malloc pages mem failed\n");\r
1075             status = RGA_MALLOC_ERROR;\r
1076             break;                \r
1077         }\r
1078 \r
1079         /* \r
1080          * Allocate MMU Index mem\r
1081          * This mem release in run_to_done fun \r
1082          */\r
1083         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
1084         if(pages == NULL) {\r
1085             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
1086             status = RGA_MALLOC_ERROR;            \r
1087             break;                \r
1088         }\r
1089 \r
1090         for(i=0; i<CMDMemSize; i++) {\r
1091             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
1092         }\r
1093 \r
1094 \r
1095         /* map src pages */\r
1096         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
1097         {\r
1098             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
1099             if (ret < 0) {\r
1100                 pr_err("rga map src memory failed\n");\r
1101                 status = ret;\r
1102                 break;\r
1103             }\r
1104         }\r
1105         else\r
1106         {\r
1107             MMU_p = MMU_Base + CMDMemSize;\r
1108             \r
1109             for(i=0; i<SrcMemSize; i++)\r
1110             {\r
1111                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
1112             } \r
1113         }\r
1114 \r
1115         \r
1116         if(req->dst.yrgb_addr >= KERNEL_SPACE_VALID) \r
1117         {   \r
1118             /* kernel space */\r
1119             MMU_p = MMU_Base + CMDMemSize + SrcMemSize;\r
1120 \r
1121             if(req->dst.yrgb_addr == (uint32_t)rga_service.pre_scale_buf)\r
1122             {\r
1123                 for(i=0; i<DstMemSize; i++)\r
1124                 {\r
1125                     MMU_p[i] = rga_service.pre_scale_buf[i];\r
1126                 }\r
1127             }\r
1128             else\r
1129             {\r
1130                 for(i=0; i<DstMemSize; i++) \r
1131                 {\r
1132                     MMU_p[i] = virt_to_phys((uint32_t *)((DstStart + i)<< PAGE_SHIFT));        \r
1133                 }    \r
1134             }                                    \r
1135         }\r
1136         else \r
1137         {\r
1138             /* user space */\r
1139             ret = rga_MapUserMemory(&pages[CMDMemSize + SrcMemSize], &MMU_Base[CMDMemSize + SrcMemSize], DstStart, DstMemSize);\r
1140             if (ret < 0) \r
1141             {\r
1142                 pr_err("rga map dst memory failed\n");\r
1143                 status = ret;\r
1144                 break;\r
1145             }        \r
1146         }\r
1147 \r
1148         /* zsq \r
1149          * change the buf address in req struct\r
1150          * for the reason of lie to MMU \r
1151          */\r
1152         \r
1153         req->mmu_info.base_addr = (virt_to_phys(MMU_Base)>>2);\r
1154 \r
1155         uv_size = (req->src.uv_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1156         v_size = (req->src.v_addr - (SrcStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1157 \r
1158         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
1159         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | ((CMDMemSize + uv_size) << PAGE_SHIFT);\r
1160         req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | ((CMDMemSize + v_size) << PAGE_SHIFT);\r
1161 \r
1162         uv_size = (req->dst.uv_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1163         v_size = (req->dst.v_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
1164 \r
1165         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);\r
1166         req->dst.uv_addr = (req->dst.uv_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize + uv_size) << PAGE_SHIFT);\r
1167         req->dst.v_addr = (req->dst.v_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize + v_size) << PAGE_SHIFT);\r
1168 \r
1169         /*record the malloc buf for the cmd end to release*/\r
1170         reg->MMU_base = MMU_Base;\r
1171 \r
1172         /* flush data to DDR */\r
1173         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
1174         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
1175 \r
1176         /* Free the page table */\r
1177         if (pages != NULL) \r
1178         {            \r
1179             kfree(pages);\r
1180         }  \r
1181 \r
1182         return 0;\r
1183     }\r
1184     while(0);\r
1185 \r
1186     if (pages != NULL)\r
1187         kfree(pages);\r
1188 \r
1189     if (MMU_Base != NULL)\r
1190         kfree(MMU_Base);\r
1191 \r
1192     return status;\r
1193 }\r
1194 \r
1195 \r
1196 static int rga_mmu_info_update_palette_table_mode(struct rga_reg *reg, struct rga_req *req)\r
1197 {\r
1198     int SrcMemSize, CMDMemSize;\r
1199     uint32_t SrcStart, CMDStart;\r
1200     struct page **pages = NULL;\r
1201     uint32_t i;\r
1202     uint32_t AllSize;\r
1203     uint32_t *MMU_Base, *MMU_p;\r
1204     int ret, status;\r
1205 \r
1206     MMU_Base = NULL;\r
1207 \r
1208     do\r
1209     {    \r
1210         /* cal src buf mmu info */                     \r
1211         SrcMemSize = rga_mem_size_cal(req->src.yrgb_addr, req->src.vir_w * req->src.vir_h, &SrcStart);\r
1212         if(SrcMemSize == 0) {\r
1213             return -EINVAL;                \r
1214         }\r
1215 \r
1216         /* cal cmd buf mmu info */\r
1217         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
1218         if(CMDMemSize == 0) {\r
1219             return -EINVAL; \r
1220         }\r
1221 \r
1222         AllSize = SrcMemSize + CMDMemSize;\r
1223                    \r
1224         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
1225         if(pages == NULL) {\r
1226             pr_err("RGA MMU malloc pages mem failed\n");\r
1227             status = RGA_MALLOC_ERROR;\r
1228             break;    \r
1229         }\r
1230         \r
1231         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
1232         if(pages == NULL) {\r
1233             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
1234             status = RGA_MALLOC_ERROR;\r
1235             break;                \r
1236         }\r
1237 \r
1238         for(i=0; i<CMDMemSize; i++) {\r
1239             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
1240         }\r
1241 \r
1242         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
1243         {\r
1244             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
1245             if (ret < 0) {\r
1246                 pr_err("rga map src memory failed\n");\r
1247                 return -EINVAL;\r
1248             }\r
1249         }\r
1250         else\r
1251         {\r
1252             MMU_p = MMU_Base + CMDMemSize;\r
1253                 \r
1254                 for(i=0; i<SrcMemSize; i++)\r
1255                 {\r
1256                     MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
1257                 } \r
1258         }\r
1259 \r
1260         /* zsq \r
1261          * change the buf address in req struct\r
1262          * for the reason of lie to MMU \r
1263          */\r
1264         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);\r
1265         \r
1266         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);    \r
1267         \r
1268         /*record the malloc buf for the cmd end to release*/\r
1269         reg->MMU_base = MMU_Base;\r
1270 \r
1271         /* flush data to DDR */\r
1272         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
1273         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
1274 \r
1275         if (pages != NULL) {\r
1276             /* Free the page table */\r
1277             kfree(pages);\r
1278         }  \r
1279 \r
1280         return 0;\r
1281     }\r
1282     while(0);\r
1283 \r
1284     if (pages != NULL)\r
1285         kfree(pages);\r
1286 \r
1287     if (MMU_Base != NULL)\r
1288         kfree(MMU_Base);\r
1289 \r
1290     return status;\r
1291 }\r
1292 \r
1293 static int rga_mmu_info_update_patten_buff_mode(struct rga_reg *reg, struct rga_req *req)\r
1294 {\r
1295     int SrcMemSize, CMDMemSize;\r
1296     uint32_t SrcStart, CMDStart;\r
1297     struct page **pages = NULL;\r
1298     uint32_t i;\r
1299     uint32_t AllSize;\r
1300     uint32_t *MMU_Base, *MMU_p;\r
1301     int ret, status;\r
1302 \r
1303     MMU_Base = MMU_p = 0;\r
1304 \r
1305     do\r
1306     {\r
1307 \r
1308         /* cal src buf mmu info */                     \r
1309         SrcMemSize = rga_mem_size_cal(req->pat.yrgb_addr, req->pat.vir_w * req->pat.vir_h * 4, &SrcStart);\r
1310         if(SrcMemSize == 0) {\r
1311             return -EINVAL;                \r
1312         }\r
1313 \r
1314         /* cal cmd buf mmu info */\r
1315         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
1316         if(CMDMemSize == 0) {\r
1317             return -EINVAL; \r
1318         }\r
1319 \r
1320         AllSize = SrcMemSize + CMDMemSize;\r
1321                    \r
1322         pages = (struct page **)kmalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
1323         if(pages == NULL) {\r
1324             pr_err("RGA MMU malloc pages mem failed\n");\r
1325             status = RGA_MALLOC_ERROR;\r
1326             break;                \r
1327         }\r
1328         \r
1329         MMU_Base = (uint32_t *)kmalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
1330         if(pages == NULL) {\r
1331             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
1332             status = RGA_MALLOC_ERROR;\r
1333             break;                \r
1334         }\r
1335 \r
1336         for(i=0; i<CMDMemSize; i++) {\r
1337             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
1338         }\r
1339 \r
1340         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
1341         {\r
1342             ret = rga_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
1343             if (ret < 0) {\r
1344                 pr_err("rga map src memory failed\n");\r
1345                 status = ret;\r
1346                 break;\r
1347             }\r
1348         }\r
1349         else\r
1350         {\r
1351             MMU_p = MMU_Base + CMDMemSize;\r
1352                 \r
1353             for(i=0; i<SrcMemSize; i++)\r
1354             {\r
1355                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
1356             } \r
1357         }\r
1358 \r
1359         /* zsq \r
1360          * change the buf address in req struct\r
1361          * for the reason of lie to MMU \r
1362          */\r
1363         req->mmu_info.base_addr = (virt_to_phys(MMU_Base) >> 2);\r
1364         \r
1365         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);    \r
1366         \r
1367         /*record the malloc buf for the cmd end to release*/\r
1368         reg->MMU_base = MMU_Base;\r
1369 \r
1370         /* flush data to DDR */\r
1371         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
1372         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
1373 \r
1374         if (pages != NULL) {\r
1375             /* Free the page table */\r
1376             kfree(pages);\r
1377         }\r
1378 \r
1379         return 0;\r
1380 \r
1381     }\r
1382     while(0);\r
1383 \r
1384     if (pages != NULL)\r
1385         kfree(pages);\r
1386 \r
1387     if (MMU_Base != NULL)\r
1388         kfree(MMU_Base);\r
1389 \r
1390     return status;\r
1391 }\r
1392 \r
1393 int rga_set_mmu_info(struct rga_reg *reg, struct rga_req *req)\r
1394 {    \r
1395     int ret;\r
1396                \r
1397     switch (req->render_mode) {\r
1398         case bitblt_mode :            \r
1399             ret = rga_mmu_info_BitBlt_mode(reg, req);\r
1400             break;\r
1401         case color_palette_mode :\r
1402             ret = rga_mmu_info_color_palette_mode(reg, req);\r
1403             break;\r
1404         case color_fill_mode :\r
1405             ret = rga_mmu_info_color_fill_mode(reg, req);\r
1406             break;\r
1407         case line_point_drawing_mode :\r
1408             ret = rga_mmu_info_line_point_drawing_mode(reg, req);\r
1409             break;\r
1410         case blur_sharp_filter_mode :\r
1411             ret = rga_mmu_info_blur_sharp_filter_mode(reg, req);\r
1412             break;\r
1413         case pre_scaling_mode :\r
1414             ret = rga_mmu_info_pre_scale_mode(reg, req);\r
1415             break;\r
1416         case update_palette_table_mode :\r
1417             ret = rga_mmu_info_update_palette_table_mode(reg, req);\r
1418             break;\r
1419         case update_patten_buff_mode :\r
1420             ret = rga_mmu_info_update_patten_buff_mode(reg, req);\r
1421             break;\r
1422         default :\r
1423             ret = -1;\r
1424             break;\r
1425     }\r
1426 \r
1427     return ret;\r
1428 }\r
1429 \r