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