drivers/video/rockchip/rga2/rga2_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 "rga2_mmu_info.h"\r
  21 \r
  22 extern struct rga2_service_info rga2_service;\r
  23 extern struct rga2_mmu_buf_t rga2_mmu_buf;\r
  24 \r
  25 //extern int mmu_buff_temp[1024];\r
  26 \r
  27 #define KERNEL_SPACE_VALID    0xc0000000\r
  28 \r
  29 #define V7_VATOPA_SUCESS_MASK   (0x1)\r
  30 #define V7_VATOPA_GET_PADDR(X)  (X & 0xFFFFF000)\r
  31 #define V7_VATOPA_GET_INER(X)           ((X>>4) & 7)\r
  32 #define V7_VATOPA_GET_OUTER(X)          ((X>>2) & 3)\r
  33 #define V7_VATOPA_GET_SH(X)             ((X>>7) & 1)\r
  34 #define V7_VATOPA_GET_NS(X)             ((X>>9) & 1)\r
  35 #define V7_VATOPA_GET_SS(X)             ((X>>1) & 1)\r
  36 \r
  37 #if 0\r
  38 static 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 #endif\r
  55 \r
  56 static int rga2_mmu_buf_get(struct rga2_mmu_buf_t *t, uint32_t size)\r
  57 {\r
  58     mutex_lock(&rga2_service.lock);\r
  59     t->front += size;\r
  60     mutex_unlock(&rga2_service.lock);\r
  61 \r
  62     return 0;\r
  63 }\r
  64 \r
  65 static int rga2_mmu_buf_get_try(struct rga2_mmu_buf_t *t, uint32_t size)\r
  66 {\r
  67     mutex_lock(&rga2_service.lock);\r
  68     if((t->back - t->front) > t->size) {\r
  69         if(t->front + size > t->back - t->size)\r
  70             return -1;\r
  71     }\r
  72     else {\r
  73         if((t->front + size) > t->back)\r
  74             return -1;\r
  75 \r
  76         if(t->front + size > t->size) {\r
  77             if (size > (t->back - t->size)) {\r
  78                 return -1;\r
  79             }\r
  80             t->front = 0;\r
  81         }\r
  82     }\r
  83     mutex_unlock(&rga2_service.lock);\r
  84 \r
  85     return 0;\r
  86 }\r
  87 \r
  88 #if 0\r
  89 static int rga2_mmu_buf_cal(struct rga2_mmu_buf_t *t, uint32_t size)\r
  90 {\r
  91     if((t->front + size) > t->back) {\r
  92         return -1;\r
  93     }\r
  94     else {\r
  95         return 0;\r
  96     }\r
  97 }\r
  98 #endif\r
  99 \r
 100 \r
 101 \r
 102 static int rga2_mem_size_cal(uint32_t Mem, uint32_t MemSize, uint32_t *StartAddr)\r
 103 {\r
 104     uint32_t start, end;\r
 105     uint32_t pageCount;\r
 106 \r
 107     end = (Mem + (MemSize + PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 108     start = Mem >> PAGE_SHIFT;\r
 109     pageCount = end - start;\r
 110     *StartAddr = start;\r
 111     return pageCount;\r
 112 }\r
 113 \r
 114 static int rga2_buf_size_cal(uint32_t yrgb_addr, uint32_t uv_addr, uint32_t v_addr,\r
 115                                         int format, uint32_t w, uint32_t h, uint32_t *StartAddr )\r
 116 {\r
 117     uint32_t size_yrgb = 0;\r
 118     uint32_t size_uv = 0;\r
 119     uint32_t size_v = 0;\r
 120     uint32_t stride = 0;\r
 121     uint32_t start, end;\r
 122     uint32_t pageCount;\r
 123 \r
 124     switch(format)\r
 125     {\r
 126         case RGA2_FORMAT_RGBA_8888 :\r
 127             stride = (w * 4 + 3) & (~3);\r
 128             size_yrgb = stride*h;\r
 129             start = yrgb_addr >> PAGE_SHIFT;\r
 130             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 131             break;\r
 132         case RGA2_FORMAT_RGBX_8888 :\r
 133             stride = (w * 4 + 3) & (~3);\r
 134             size_yrgb = stride*h;\r
 135             start = yrgb_addr >> PAGE_SHIFT;\r
 136             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 137             break;\r
 138         case RGA2_FORMAT_RGB_888 :\r
 139             stride = (w * 3 + 3) & (~3);\r
 140             size_yrgb = stride*h;\r
 141             start = yrgb_addr >> PAGE_SHIFT;\r
 142             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 143             break;\r
 144         case RGA2_FORMAT_BGRA_8888 :\r
 145             size_yrgb = w*h*4;\r
 146             start = yrgb_addr >> PAGE_SHIFT;\r
 147             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 148             break;\r
 149         case RGA2_FORMAT_RGB_565 :\r
 150             stride = (w*2 + 3) & (~3);\r
 151             size_yrgb = stride * h;\r
 152             start = yrgb_addr >> PAGE_SHIFT;\r
 153             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 154             break;\r
 155         case RGA2_FORMAT_RGBA_5551 :\r
 156             stride = (w*2 + 3) & (~3);\r
 157             size_yrgb = stride * h;\r
 158             start = yrgb_addr >> PAGE_SHIFT;\r
 159             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 160             break;\r
 161         case RGA2_FORMAT_RGBA_4444 :\r
 162             stride = (w*2 + 3) & (~3);\r
 163             size_yrgb = stride * h;\r
 164             start = yrgb_addr >> PAGE_SHIFT;\r
 165             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 166             break;\r
 167         case RGA2_FORMAT_BGR_888 :\r
 168             stride = (w*3 + 3) & (~3);\r
 169             size_yrgb = stride * h;\r
 170             start = yrgb_addr >> PAGE_SHIFT;\r
 171             pageCount = (size_yrgb + PAGE_SIZE - 1) >> PAGE_SHIFT;\r
 172             break;\r
 173 \r
 174         /* YUV FORMAT */\r
 175         case RGA2_FORMAT_YCbCr_422_SP :\r
 176         case RGA2_FORMAT_YCrCb_422_SP :\r
 177             stride = (w + 3) & (~3);\r
 178             size_yrgb = stride * h;\r
 179             size_uv = stride * h;\r
 180             start = MIN(yrgb_addr, uv_addr);\r
 181 \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 RGA2_FORMAT_YCbCr_422_P :\r
 188         case RGA2_FORMAT_YCrCb_422_P :\r
 189             stride = (w + 3) & (~3);\r
 190             size_yrgb = stride * h;\r
 191             size_uv = ((stride >> 1) * h);\r
 192             size_v = ((stride >> 1) * h);\r
 193             start = MIN(MIN(yrgb_addr, uv_addr), v_addr);\r
 194             start = start >> PAGE_SHIFT;\r
 195             end = MAX(MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv)), (v_addr + size_v));\r
 196             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 197             pageCount = end - start;\r
 198             break;\r
 199         case RGA2_FORMAT_YCbCr_420_SP :\r
 200         case RGA2_FORMAT_YCrCb_420_SP :\r
 201             stride = (w + 3) & (~3);\r
 202             size_yrgb = stride * h;\r
 203             size_uv = (stride * (h >> 1));\r
 204             start = MIN(yrgb_addr, uv_addr);\r
 205             start >>= PAGE_SHIFT;\r
 206             end = MAX((yrgb_addr + size_yrgb), (uv_addr + size_uv));\r
 207             end = (end + (PAGE_SIZE - 1)) >> PAGE_SHIFT;\r
 208             pageCount = end - start;\r
 209             break;\r
 210         case RGA2_FORMAT_YCbCr_420_P :\r
 211         case RGA2_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 rga2_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 \r
 253     status = 0;\r
 254     Address = 0;\r
 255 \r
 256     do\r
 257     {\r
 258         down_read(&current->mm->mmap_sem);\r
 259         result = get_user_pages(current,\r
 260                 current->mm,\r
 261                 Memory << PAGE_SHIFT,\r
 262                 pageCount,\r
 263                 1,\r
 264                 0,\r
 265                 pages,\r
 266                 NULL\r
 267                 );\r
 268         up_read(&current->mm->mmap_sem);\r
 269 \r
 270         #if 0\r
 271         if(result <= 0 || result < pageCount)\r
 272         {\r
 273             status = 0;\r
 274 \r
 275             for(i=0; i<pageCount; i++)\r
 276             {\r
 277                 temp = armv7_va_to_pa((Memory + i) << PAGE_SHIFT);\r
 278                 if (temp == 0xffffffff)\r
 279                 {\r
 280                     printk("rga find mmu phy ddr error\n ");\r
 281                     status = RGA_OUT_OF_RESOURCES;\r
 282                     break;\r
 283                 }\r
 284 \r
 285                 pageTable[i] = temp;\r
 286             }\r
 287 \r
 288             return status;\r
 289         }\r
 290         #else\r
 291         if(result <= 0 || result < pageCount)\r
 292         {\r
 293             struct vm_area_struct *vma;\r
 294 \r
 295             for(i=0; i<pageCount; i++)\r
 296             {\r
 297                 vma = find_vma(current->mm, (Memory + i) << PAGE_SHIFT);\r
 298 \r
 299                 if (vma)//&& (vma->vm_flags & VM_PFNMAP) )\r
 300                 {\r
 301                     #if 1\r
 302                     do\r
 303                     {\r
 304                         pte_t       * pte;\r
 305                         spinlock_t  * ptl;\r
 306                         unsigned long pfn;\r
 307                         pgd_t * pgd;\r
 308                         pud_t * pud;\r
 309 \r
 310                         pgd = pgd_offset(current->mm, (Memory + i) << PAGE_SHIFT);\r
 311 \r
 312                         if(pgd_val(*pgd) == 0)\r
 313                         {\r
 314                             //printk("rga pgd value is zero \n");\r
 315                             break;\r
 316                         }\r
 317 \r
 318                         pud = pud_offset(pgd, (Memory + i) << PAGE_SHIFT);\r
 319                         if (pud)\r
 320                         {\r
 321                             pmd_t * pmd = pmd_offset(pud, (Memory + i) << PAGE_SHIFT);\r
 322                             if (pmd)\r
 323                             {\r
 324                                 pte = pte_offset_map_lock(current->mm, pmd, (Memory + i) << PAGE_SHIFT, &ptl);\r
 325                                 if (!pte)\r
 326                                 {\r
 327                                     pte_unmap_unlock(pte, ptl);\r
 328                                     break;\r
 329                                 }\r
 330                             }\r
 331                             else\r
 332                             {\r
 333                                 break;\r
 334                             }\r
 335                         }\r
 336                         else\r
 337                         {\r
 338                             break;\r
 339                         }\r
 340 \r
 341                         pfn = pte_pfn(*pte);\r
 342                         Address = ((pfn << PAGE_SHIFT) | (((unsigned long)((Memory + i) << PAGE_SHIFT)) & ~PAGE_MASK));\r
 343                         pte_unmap_unlock(pte, ptl);\r
 344                     }\r
 345                     while (0);\r
 346 \r
 347                     #else\r
 348                     do\r
 349                     {\r
 350                         pte_t       * pte;\r
 351                         spinlock_t  * ptl;\r
 352                         unsigned long pfn;\r
 353                         pgd_t * pgd;\r
 354                         pud_t * pud;\r
 355                         pmd_t * pmd;\r
 356 \r
 357                         pgd = pgd_offset(current->mm, (Memory + i) << PAGE_SHIFT);\r
 358                         pud = pud_offset(pgd, (Memory + i) << PAGE_SHIFT);\r
 359                         pmd = pmd_offset(pud, (Memory + i) << PAGE_SHIFT);\r
 360                         pte = pte_offset_map_lock(current->mm, pmd, (Memory + i) << PAGE_SHIFT, &ptl);\r
 361 \r
 362                         pfn = pte_pfn(*pte);\r
 363                         Address = ((pfn << PAGE_SHIFT) | (((unsigned long)((Memory + i) << PAGE_SHIFT)) & ~PAGE_MASK));\r
 364                         pte_unmap_unlock(pte, ptl);\r
 365                     }\r
 366                     while (0);\r
 367                     #endif\r
 368 \r
 369                     pageTable[i] = Address;\r
 370                 }\r
 371                 else\r
 372                 {\r
 373                     status = RGA2_OUT_OF_RESOURCES;\r
 374                     break;\r
 375                 }\r
 376             }\r
 377 \r
 378             return status;\r
 379         }\r
 380         #endif\r
 381 \r
 382         /* Fill the page table. */\r
 383         for(i=0; i<pageCount; i++)\r
 384         {\r
 385             /* Get the physical address from page struct. */\r
 386             pageTable[i] = page_to_phys(pages[i]);\r
 387         }\r
 388 \r
 389         return 0;\r
 390     }\r
 391     while(0);\r
 392 \r
 393     return status;\r
 394 }\r
 395 \r
 396 static int rga2_mmu_info_BitBlt_mode(struct rga2_reg *reg, struct rga2_req *req)\r
 397 {\r
 398     int Src0MemSize, DstMemSize, Src1MemSize;\r
 399     uint32_t Src0Start, Src1Start, DstStart;\r
 400     uint32_t AllSize;\r
 401     uint32_t *MMU_Base, *MMU_Base_phys;\r
 402     int ret;\r
 403     int status;\r
 404     uint32_t uv_size, v_size;\r
 405 \r
 406     struct page **pages = NULL;\r
 407 \r
 408     MMU_Base = NULL;\r
 409 \r
 410     Src0MemSize = 0;\r
 411     Src1MemSize = 0;\r
 412     DstMemSize  = 0;\r
 413 \r
 414     do\r
 415     {\r
 416         /* cal src0 buf mmu info */\r
 417         if(req->mmu_info.src0_mmu_flag & 1) {\r
 418             Src0MemSize = rga2_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,\r
 419                                         req->src.format, req->src.vir_w,\r
 420                                         (req->src.vir_h),\r
 421                                         &Src0Start);\r
 422             if (Src0MemSize == 0) {\r
 423                 return -EINVAL;\r
 424             }\r
 425         }\r
 426 \r
 427         /* cal src1 buf mmu info */\r
 428         if(req->mmu_info.src1_mmu_flag & 1) {\r
 429             Src1MemSize = rga2_buf_size_cal(req->src1.yrgb_addr, req->src1.uv_addr, req->src1.v_addr,\r
 430                                         req->src1.format, req->src1.vir_w,\r
 431                                         (req->src1.vir_h),\r
 432                                         &Src1Start);\r
 433             Src0MemSize = (Src0MemSize + 3) & (~3);\r
 434             if (Src1MemSize == 0) {\r
 435                 return -EINVAL;\r
 436             }\r
 437         }\r
 438 \r
 439 \r
 440         /* cal dst buf mmu info */\r
 441         if(req->mmu_info.dst_mmu_flag & 1) {\r
 442             DstMemSize = rga2_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 443                                             req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 444                                             &DstStart);\r
 445             if(DstMemSize == 0) {\r
 446                 return -EINVAL;\r
 447             }\r
 448         }\r
 449 \r
 450         /* Cal out the needed mem size */\r
 451         Src0MemSize = (Src0MemSize+15)&(~15);\r
 452         Src1MemSize = (Src1MemSize+15)&(~15);\r
 453         DstMemSize  = (DstMemSize+15)&(~15);\r
 454         AllSize = Src0MemSize + Src1MemSize + DstMemSize;\r
 455 \r
 456         pages = kzalloc((AllSize)* sizeof(struct page *), GFP_KERNEL);\r
 457         if(pages == NULL) {\r
 458             pr_err("RGA MMU malloc pages mem failed\n");\r
 459             status = RGA2_MALLOC_ERROR;\r
 460             break;\r
 461         }\r
 462 \r
 463         if (rga2_mmu_buf_get_try(&rga2_mmu_buf, AllSize)) {\r
 464             pr_err("RGA2 Get MMU mem failed\n");\r
 465             status = RGA2_MALLOC_ERROR;\r
 466             break;\r
 467         }\r
 468 \r
 469         mutex_lock(&rga2_service.lock);\r
 470         MMU_Base = rga2_mmu_buf.buf_virtual + (rga2_mmu_buf.front & (rga2_mmu_buf.size - 1));\r
 471         MMU_Base_phys = rga2_mmu_buf.buf + (rga2_mmu_buf.front & (rga2_mmu_buf.size - 1));\r
 472         mutex_unlock(&rga2_service.lock);\r
 473 \r
 474         if(Src0MemSize) {\r
 475             ret = rga2_MapUserMemory(&pages[0], &MMU_Base[0], Src0Start, Src0MemSize);\r
 476             if (ret < 0) {\r
 477                 pr_err("rga2 map src0 memory failed\n");\r
 478                 status = ret;\r
 479                 break;\r
 480             }\r
 481 \r
 482             /* change the buf address in req struct */\r
 483             req->mmu_info.src0_base_addr = (((uint32_t)MMU_Base_phys));\r
 484             uv_size = (req->src.uv_addr - (Src0Start << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 485             v_size = (req->src.v_addr - (Src0Start << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 486 \r
 487             req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK));\r
 488             req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | (uv_size << PAGE_SHIFT);\r
 489             req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | (v_size << PAGE_SHIFT);\r
 490         }\r
 491 \r
 492         if(Src1MemSize) {\r
 493             ret = rga2_MapUserMemory(&pages[0], MMU_Base + Src0MemSize, Src1Start, Src1MemSize);\r
 494             if (ret < 0) {\r
 495                 pr_err("rga2 map src1 memory failed\n");\r
 496                 status = ret;\r
 497                 break;\r
 498             }\r
 499 \r
 500             /* change the buf address in req struct */\r
 501             req->mmu_info.src1_base_addr = ((uint32_t)(MMU_Base_phys + Src0MemSize));\r
 502             req->src1.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK));\r
 503         }\r
 504 \r
 505         if(DstMemSize) {\r
 506             ret = rga2_MapUserMemory(&pages[0], MMU_Base + Src0MemSize + Src1MemSize, DstStart, DstMemSize);\r
 507             if (ret < 0) {\r
 508                 pr_err("rga2 map dst memory failed\n");\r
 509                 status = ret;\r
 510                 break;\r
 511             }\r
 512 \r
 513             /* change the buf address in req struct */\r
 514             req->mmu_info.dst_base_addr  = ((uint32_t)(MMU_Base_phys + Src0MemSize + Src1MemSize));\r
 515             req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK));\r
 516             uv_size = (req->dst.uv_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 517             v_size = (req->dst.v_addr - (DstStart << PAGE_SHIFT)) >> PAGE_SHIFT;\r
 518             req->dst.uv_addr = (req->dst.uv_addr & (~PAGE_MASK)) | ((uv_size) << PAGE_SHIFT);\r
 519             req->dst.v_addr = (req->dst.v_addr & (~PAGE_MASK)) | ((v_size) << PAGE_SHIFT);\r
 520         }\r
 521 \r
 522         /* flush data to DDR */\r
 523         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 524         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 525 \r
 526         rga2_mmu_buf_get(&rga2_mmu_buf, AllSize);\r
 527         reg->MMU_len = AllSize;\r
 528 \r
 529         status = 0;\r
 530 \r
 531         /* Free the page table */\r
 532         if (pages != NULL) {\r
 533             kfree(pages);\r
 534         }\r
 535 \r
 536         return status;\r
 537     }\r
 538     while(0);\r
 539 \r
 540 \r
 541     /* Free the page table */\r
 542     if (pages != NULL) {\r
 543         kfree(pages);\r
 544     }\r
 545 \r
 546     /* Free MMU table */\r
 547     if(MMU_Base != NULL) {\r
 548         kfree(MMU_Base);\r
 549     }\r
 550 \r
 551     return status;\r
 552 }\r
 553 \r
 554 static int rga2_mmu_info_color_palette_mode(struct rga2_reg *reg, struct rga2_req *req)\r
 555 {\r
 556     int SrcMemSize, DstMemSize, CMDMemSize;\r
 557     uint32_t SrcStart, DstStart, CMDStart;\r
 558     struct page **pages = NULL;\r
 559     uint32_t i;\r
 560     uint32_t AllSize;\r
 561     uint32_t *MMU_Base = NULL;\r
 562     uint32_t *MMU_p;\r
 563     int ret, status;\r
 564     uint32_t stride;\r
 565 \r
 566     uint8_t shift;\r
 567     uint16_t sw, byte_num;\r
 568 \r
 569     shift = 3 - (req->palette_mode & 3);\r
 570     sw = req->src.vir_w;\r
 571     byte_num = sw >> shift;\r
 572     stride = (byte_num + 3) & (~3);\r
 573 \r
 574     do\r
 575     {\r
 576 \r
 577         SrcMemSize = rga2_mem_size_cal(req->src.yrgb_addr, stride, &SrcStart);\r
 578         if(SrcMemSize == 0) {\r
 579             return -EINVAL;\r
 580         }\r
 581 \r
 582         DstMemSize = rga2_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 583                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 584                                         &DstStart);\r
 585         if(DstMemSize == 0) {\r
 586             return -EINVAL;\r
 587         }\r
 588 \r
 589         CMDMemSize = rga2_mem_size_cal((uint32_t)rga2_service.cmd_buff, RGA2_CMD_BUF_SIZE, &CMDStart);\r
 590         if(CMDMemSize == 0) {\r
 591             return -EINVAL;\r
 592         }\r
 593 \r
 594         AllSize = SrcMemSize + DstMemSize + CMDMemSize;\r
 595 \r
 596         pages = kzalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 597         if(pages == NULL) {\r
 598             pr_err("RGA MMU malloc pages mem failed\n");\r
 599             return -EINVAL;\r
 600         }\r
 601 \r
 602         MMU_Base = kzalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 603         if(MMU_Base == NULL) {\r
 604             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 605             break;\r
 606         }\r
 607 \r
 608         /* map CMD addr */\r
 609         for(i=0; i<CMDMemSize; i++)\r
 610         {\r
 611             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i)<<PAGE_SHIFT));\r
 612         }\r
 613 \r
 614         /* map src addr */\r
 615         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 616         {\r
 617             ret = rga2_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 618             if (ret < 0)\r
 619             {\r
 620                 pr_err("rga map src memory failed\n");\r
 621                 status = ret;\r
 622                 break;\r
 623             }\r
 624         }\r
 625         else\r
 626         {\r
 627             MMU_p = MMU_Base + CMDMemSize;\r
 628 \r
 629             for(i=0; i<SrcMemSize; i++)\r
 630             {\r
 631                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 632             }\r
 633         }\r
 634 \r
 635         /* map dst addr */\r
 636         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 637         {\r
 638             ret = rga2_MapUserMemory(&pages[CMDMemSize + SrcMemSize], &MMU_Base[CMDMemSize + SrcMemSize], DstStart, DstMemSize);\r
 639             if (ret < 0)\r
 640             {\r
 641                 pr_err("rga map dst memory failed\n");\r
 642                 status = ret;\r
 643                 break;\r
 644             }\r
 645         }\r
 646         else\r
 647         {\r
 648             MMU_p = MMU_Base + CMDMemSize + SrcMemSize;\r
 649 \r
 650             for(i=0; i<DstMemSize; i++)\r
 651             {\r
 652                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((DstStart + i) << PAGE_SHIFT));\r
 653             }\r
 654         }\r
 655 \r
 656 \r
 657         /* zsq\r
 658          * change the buf address in req struct\r
 659          * for the reason of lie to MMU\r
 660          */\r
 661         req->mmu_info.src0_base_addr = (virt_to_phys(MMU_Base)>>2);\r
 662         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 663         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);\r
 664 \r
 665 \r
 666         /*record the malloc buf for the cmd end to release*/\r
 667         reg->MMU_base = MMU_Base;\r
 668 \r
 669         /* flush data to DDR */\r
 670         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 671         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 672 \r
 673         /* Free the page table */\r
 674         if (pages != NULL) {\r
 675             kfree(pages);\r
 676         }\r
 677 \r
 678         return status;\r
 679 \r
 680     }\r
 681     while(0);\r
 682 \r
 683     /* Free the page table */\r
 684     if (pages != NULL) {\r
 685         kfree(pages);\r
 686     }\r
 687 \r
 688     /* Free mmu table */\r
 689     if (MMU_Base != NULL) {\r
 690         kfree(MMU_Base);\r
 691     }\r
 692 \r
 693     return 0;\r
 694 }\r
 695 \r
 696 static int rga2_mmu_info_color_fill_mode(struct rga2_reg *reg, struct rga2_req *req)\r
 697 {\r
 698     int DstMemSize;\r
 699     uint32_t DstStart;\r
 700     struct page **pages = NULL;\r
 701     uint32_t AllSize;\r
 702     uint32_t *MMU_Base, *MMU_Base_phys;\r
 703     int ret;\r
 704     int status;\r
 705 \r
 706     MMU_Base = NULL;\r
 707 \r
 708     do\r
 709     {\r
 710         if(req->mmu_info.dst_mmu_flag & 1) {\r
 711             DstMemSize = rga2_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,\r
 712                                         req->dst.format, req->dst.vir_w, req->dst.vir_h,\r
 713                                         &DstStart);\r
 714             if(DstMemSize == 0) {\r
 715                 return -EINVAL;\r
 716             }\r
 717         }\r
 718 \r
 719         AllSize = (DstMemSize + 3) & (~3);\r
 720 \r
 721         pages = kzalloc((AllSize)* sizeof(struct page *), GFP_KERNEL);\r
 722         if(pages == NULL) {\r
 723             pr_err("RGA2 MMU malloc pages mem failed\n");\r
 724             status = RGA2_MALLOC_ERROR;\r
 725             break;\r
 726         }\r
 727 \r
 728         if(rga2_mmu_buf_get_try(&rga2_mmu_buf, AllSize)) {\r
 729            pr_err("RGA2 Get MMU mem failed\n");\r
 730            status = RGA2_MALLOC_ERROR;\r
 731            break;\r
 732         }\r
 733 \r
 734         mutex_lock(&rga2_service.lock);\r
 735         MMU_Base_phys = rga2_mmu_buf.buf + (rga2_mmu_buf.front & (rga2_mmu_buf.size - 1));\r
 736         MMU_Base = rga2_mmu_buf.buf_virtual + (rga2_mmu_buf.front & (rga2_mmu_buf.size - 1));\r
 737         mutex_unlock(&rga2_service.lock);\r
 738 \r
 739         if (DstMemSize)\r
 740         {\r
 741             ret = rga2_MapUserMemory(&pages[0], &MMU_Base[0], DstStart, DstMemSize);\r
 742             if (ret < 0) {\r
 743                 pr_err("rga2 map dst memory failed\n");\r
 744                 status = ret;\r
 745                 break;\r
 746             }\r
 747 \r
 748             /* change the buf address in req struct */\r
 749             req->mmu_info.src0_base_addr = (((uint32_t)MMU_Base_phys)>>4);\r
 750             req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK));\r
 751         }\r
 752 \r
 753         /* flush data to DDR */\r
 754         dmac_flush_range(MMU_Base, (MMU_Base + AllSize + 1));\r
 755         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize + 1));\r
 756 \r
 757         rga2_mmu_buf_get_try(&rga2_mmu_buf, AllSize);\r
 758 \r
 759         /* Free the page table */\r
 760         if (pages != NULL)\r
 761             kfree(pages);\r
 762 \r
 763         return 0;\r
 764     }\r
 765     while(0);\r
 766 \r
 767     if (pages != NULL)\r
 768         kfree(pages);\r
 769 \r
 770     if (MMU_Base != NULL)\r
 771         kfree(MMU_Base);\r
 772 \r
 773     return status;\r
 774 }\r
 775 \r
 776 \r
 777 static int rga2_mmu_info_update_palette_table_mode(struct rga2_reg *reg, struct rga2_req *req)\r
 778 {\r
 779     int SrcMemSize, CMDMemSize;\r
 780     uint32_t SrcStart, CMDStart;\r
 781     struct page **pages = NULL;\r
 782     uint32_t i;\r
 783     uint32_t AllSize;\r
 784     uint32_t *MMU_Base, *MMU_p;\r
 785     int ret, status;\r
 786 \r
 787     MMU_Base = NULL;\r
 788 \r
 789     do\r
 790     {\r
 791         /* cal src buf mmu info */\r
 792         SrcMemSize = rga2_mem_size_cal(req->src.yrgb_addr, req->src.vir_w * req->src.vir_h, &SrcStart);\r
 793         if(SrcMemSize == 0) {\r
 794             return -EINVAL;\r
 795         }\r
 796 \r
 797         /* cal cmd buf mmu info */\r
 798         CMDMemSize = rga2_mem_size_cal((uint32_t)rga2_service.cmd_buff, RGA2_CMD_BUF_SIZE, &CMDStart);\r
 799         if(CMDMemSize == 0) {\r
 800             return -EINVAL;\r
 801         }\r
 802 \r
 803         AllSize = SrcMemSize + CMDMemSize;\r
 804 \r
 805         pages = kzalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 806         if(pages == NULL) {\r
 807             pr_err("RGA MMU malloc pages mem failed\n");\r
 808             status = RGA2_MALLOC_ERROR;\r
 809             break;\r
 810         }\r
 811 \r
 812         MMU_Base = kzalloc((AllSize + 1)* sizeof(uint32_t), GFP_KERNEL);\r
 813         if(pages == NULL) {\r
 814             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 815             status = RGA2_MALLOC_ERROR;\r
 816             break;\r
 817         }\r
 818 \r
 819         for(i=0; i<CMDMemSize; i++) {\r
 820             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
 821         }\r
 822 \r
 823         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 824         {\r
 825             ret = rga2_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 826             if (ret < 0) {\r
 827                 pr_err("rga map src memory failed\n");\r
 828                 return -EINVAL;\r
 829             }\r
 830         }\r
 831         else\r
 832         {\r
 833             MMU_p = MMU_Base + CMDMemSize;\r
 834 \r
 835                 for(i=0; i<SrcMemSize; i++)\r
 836                 {\r
 837                     MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 838                 }\r
 839         }\r
 840 \r
 841         /* zsq\r
 842          * change the buf address in req struct\r
 843          * for the reason of lie to MMU\r
 844          */\r
 845         req->mmu_info.src0_base_addr = (virt_to_phys(MMU_Base) >> 2);\r
 846 \r
 847         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 848 \r
 849         /*record the malloc buf for the cmd end to release*/\r
 850         reg->MMU_base = MMU_Base;\r
 851 \r
 852         /* flush data to DDR */\r
 853         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 854         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 855 \r
 856         if (pages != NULL) {\r
 857             /* Free the page table */\r
 858             kfree(pages);\r
 859         }\r
 860 \r
 861         return 0;\r
 862     }\r
 863     while(0);\r
 864 \r
 865     if (pages != NULL)\r
 866         kfree(pages);\r
 867 \r
 868     if (MMU_Base != NULL)\r
 869         kfree(MMU_Base);\r
 870 \r
 871     return status;\r
 872 }\r
 873 \r
 874 static int rga2_mmu_info_update_patten_buff_mode(struct rga2_reg *reg, struct rga2_req *req)\r
 875 {\r
 876     int SrcMemSize, CMDMemSize;\r
 877     uint32_t SrcStart, CMDStart;\r
 878     struct page **pages = NULL;\r
 879     uint32_t i;\r
 880     uint32_t AllSize;\r
 881     uint32_t *MMU_Base, *MMU_p;\r
 882     int ret, status;\r
 883 \r
 884     MMU_Base = MMU_p = 0;\r
 885 \r
 886     do\r
 887     {\r
 888 \r
 889         /* cal src buf mmu info */\r
 890         SrcMemSize = rga2_mem_size_cal(req->pat.yrgb_addr, req->pat.act_w * req->pat.act_h * 4, &SrcStart);\r
 891         if(SrcMemSize == 0) {\r
 892             return -EINVAL;\r
 893         }\r
 894 \r
 895         /* cal cmd buf mmu info */\r
 896         CMDMemSize = rga2_mem_size_cal((uint32_t)rga2_service.cmd_buff, RGA2_CMD_BUF_SIZE, &CMDStart);\r
 897         if(CMDMemSize == 0) {\r
 898             return -EINVAL;\r
 899         }\r
 900 \r
 901         AllSize = SrcMemSize + CMDMemSize;\r
 902 \r
 903         pages = kzalloc(AllSize * sizeof(struct page *), GFP_KERNEL);\r
 904         if(pages == NULL) {\r
 905             pr_err("RGA MMU malloc pages mem failed\n");\r
 906             status = RGA2_MALLOC_ERROR;\r
 907             break;\r
 908         }\r
 909 \r
 910         MMU_Base = kzalloc(AllSize * sizeof(uint32_t), GFP_KERNEL);\r
 911         if(pages == NULL) {\r
 912             pr_err("RGA MMU malloc MMU_Base point failed\n");\r
 913             status = RGA2_MALLOC_ERROR;\r
 914             break;\r
 915         }\r
 916 \r
 917         for(i=0; i<CMDMemSize; i++) {\r
 918             MMU_Base[i] = virt_to_phys((uint32_t *)((CMDStart + i) << PAGE_SHIFT));\r
 919         }\r
 920 \r
 921         if (req->src.yrgb_addr < KERNEL_SPACE_VALID)\r
 922         {\r
 923             ret = rga2_MapUserMemory(&pages[CMDMemSize], &MMU_Base[CMDMemSize], SrcStart, SrcMemSize);\r
 924             if (ret < 0) {\r
 925                 pr_err("rga map src memory failed\n");\r
 926                 status = ret;\r
 927                 break;\r
 928             }\r
 929         }\r
 930         else\r
 931         {\r
 932             MMU_p = MMU_Base + CMDMemSize;\r
 933 \r
 934             for(i=0; i<SrcMemSize; i++)\r
 935             {\r
 936                 MMU_p[i] = (uint32_t)virt_to_phys((uint32_t *)((SrcStart + i) << PAGE_SHIFT));\r
 937             }\r
 938         }\r
 939 \r
 940         /* zsq\r
 941          * change the buf address in req struct\r
 942          * for the reason of lie to MMU\r
 943          */\r
 944         req->mmu_info.src0_base_addr = (virt_to_phys(MMU_Base) >> 2);\r
 945 \r
 946         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);\r
 947 \r
 948         /*record the malloc buf for the cmd end to release*/\r
 949         reg->MMU_base = MMU_Base;\r
 950 \r
 951         /* flush data to DDR */\r
 952         dmac_flush_range(MMU_Base, (MMU_Base + AllSize));\r
 953         outer_flush_range(virt_to_phys(MMU_Base),virt_to_phys(MMU_Base + AllSize));\r
 954 \r
 955         if (pages != NULL) {\r
 956             /* Free the page table */\r
 957             kfree(pages);\r
 958         }\r
 959 \r
 960         return 0;\r
 961 \r
 962     }\r
 963     while(0);\r
 964 \r
 965     if (pages != NULL)\r
 966         kfree(pages);\r
 967 \r
 968     if (MMU_Base != NULL)\r
 969         kfree(MMU_Base);\r
 970 \r
 971     return status;\r
 972 }\r
 973 \r
 974 int rga2_set_mmu_info(struct rga2_reg *reg, struct rga2_req *req)\r
 975 {\r
 976     int ret;\r
 977 \r
 978     switch (req->render_mode) {\r
 979         case bitblt_mode :\r
 980             ret = rga2_mmu_info_BitBlt_mode(reg, req);\r
 981             break;\r
 982         case color_palette_mode :\r
 983             ret = rga2_mmu_info_color_palette_mode(reg, req);\r
 984             break;\r
 985         case color_fill_mode :\r
 986             ret = rga2_mmu_info_color_fill_mode(reg, req);\r
 987             break;\r
 988         case update_palette_table_mode :\r
 989             ret = rga2_mmu_info_update_palette_table_mode(reg, req);\r
 990             break;\r
 991         case update_patten_buff_mode :\r
 992             ret = rga2_mmu_info_update_patten_buff_mode(reg, req);\r
 993             break;\r
 994         default :\r
 995             ret = -1;\r
 996             break;\r
 997     }\r
 998 \r
 999     return ret;\r
1000 }\r
1001 \r