drivers/video/rockchip/rga/rga_mmu_info.c

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