drivers/misc/mediatek/video/mt8127/mtkfb_pattern.c

   1 #include <generated/autoconf.h>
   2 #include <linux/module.h>
   3 #include <linux/mm.h>
   4 #include <linux/init.h>
   5 #include <linux/fb.h>
   6 #include <linux/delay.h>
   7 #include <linux/device.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/dma-mapping.h>
  10 #include <linux/earlysuspend.h>
  11 #include <linux/kthread.h>
  12 #include <linux/rtpm_prio.h>
  13 #include <linux/vmalloc.h>
  14 #include <linux/disp_assert_layer.h>
  15 #include <linux/semaphore.h>
  16 #include <linux/xlog.h>
  17 #include <linux/mutex.h>
  18 #include <linux/leds-mt65xx.h>
  19 #include <linux/file.h>
  20 #include <linux/ion_drv.h>
  21 #include <linux/list.h>
  22 #include <asm/uaccess.h>
  23 #include <asm/atomic.h>
  24 #include <asm/mach-types.h>
  25 #include <asm/cacheflush.h>
  26 #include <asm/io.h>
  27 #include <mach/dma.h>
  28 #include <mach/irqs.h>
  29 #include <mach/m4u_port.h>
  30 #include <linux/dma-mapping.h>
  31 #include "mach/mt_boot.h"
  32 #include "debug.h"
  33 #include "disp_drv.h"
  34 #include "ddp_hal.h"
  35 #include "disp_drv_log.h"
  36 #include "disp_hal.h"
  37 #include "mtkfb.h"
  38 #include "mtkfb_console.h"
  39 #include "mtkfb_info.h"
  40 #include "ddp_ovl.h"
  41 #include "mtkfb_priv.h"
  42 #include "disp_drv_platform.h"
  43
  44 #if defined(MTK_OVERLAY_ENGINE_SUPPORT)
  45 #include "disp_ovl_engine_api.h"
  46 #include "disp_ovl_engine_core.h"
  47 #endif
  48
  49 #ifdef MTK_SEC_VIDEO_PATH_SUPPORT
  50 #include "tz_cross/trustzone.h"
  51 #include "tz_cross/ta_mem.h"
  52 #include <tz_cross/tz_ddp.h>
  53 #include <mach/m4u_port.h>
  54 #include "trustzone/kree/system.h"
  55 #include "trustzone/kree/mem.h"
  56 #endif
  57
  58 #ifdef MTK_SEC_VIDEO_PATH_SUPPORT
  59 // these 2 APIs are used for accessing ddp_session / ddp_mem_session with TEE
  60 extern KREE_SESSION_HANDLE ddp_session_handle(void);
  61 extern KREE_SESSION_HANDLE ddp_mem_session_handle(void);
  62 #endif
  63
  64 extern int mtkfb_queue_overlay_config(struct mtkfb_device *fbdev, struct fb_overlay_config* config);
  65 extern void *disp_ovl_engine_hw_allocate_secure_memory(int size);
  66
  67 static int fill_buffer_rgb(void *addr, unsigned int size)
  68 {
  69     int i;
  70     char *buf_addr;
  71
  72     buf_addr = (char *)addr;
  73     for (i=0; i<size/3; i+=3)
  74     {
  75        buf_addr[i] = 0xff;
  76        buf_addr[i+1] = 0x0;
  77        buf_addr[i+2] = 0x0;
  78     }
  79     for (; i<size*2/3; i+=3)
  80     {
  81        buf_addr[i] = 0x0;
  82        buf_addr[i+1] = 0xff;
  83        buf_addr[i+2] = 0x0;
  84     }
  85     for (; i<size; i+=3)
  86     {
  87        buf_addr[i] = 0x0;
  88        buf_addr[i+1] = 0x0;
  89        buf_addr[i+2] = 0xff;
  90     }
  91
  92     return 0;
  93 }
  94
  95 static int alloc_buffer(M4U_PORT_ID_ENUM port, unsigned int size, unsigned int *pVa, unsigned int *pMva)
  96 {
  97     M4U_PORT_STRUCT m4uport;
  98     unsigned int mva, va;
  99
 100     if (size == 0)
 101         return -1;
 102
 103     va = (unsigned int) vmalloc(size);
 104     if (((void *)va) == NULL)
 105     {
 106         printk("vmalloc %d bytes fail!!!\n", size);
 107         return -1;
 108     }
 109
 110     memset((void *) va, 0, size);
 111
 112     fill_buffer_rgb(va, size);
 113
 114     if (m4u_alloc_mva(port, va, size, 0, 0, &mva))
 115     {
 116         printk("m4u_alloc_mva for hdmi_mva_r fail\n");
 117         vfree((void *) va);
 118         return -1;
 119     }
 120
 121     memset((void *) &m4uport, 0, sizeof(M4U_PORT_STRUCT));
 122     m4uport.ePortID = port;
 123     m4uport.Virtuality = 1;
 124     m4uport.domain = 3;
 125     m4uport.Security = 0;
 126     m4uport.Distance = 1;
 127     m4uport.Direction = 0;
 128     m4u_config_port(&m4uport);
 129
 130     *pMva = mva;
 131     *pVa = va;
 132
 133     printk("[Pattern] alloc_buffer va=0x%08x, mva=0x%08x\n", va, mva);
 134
 135     return 0;
 136 }
 137
 138 int free_buffer(M4U_PORT_ID_ENUM port, unsigned int size, unsigned int va, unsigned int mva)
 139 {
 140     printk("[Pattern] free_buffer va=0x%08x, mva=0x%08x\n", va, mva);
 141
 142     if (mva)
 143     {
 144         M4U_PORT_STRUCT m4uport;
 145         m4uport.ePortID =  port;
 146         m4uport.Virtuality = 1;
 147         m4uport.domain = 3;
 148         m4uport.Security = 0;
 149         m4uport.Distance = 1;
 150         m4uport.Direction = 0;
 151         m4u_config_port(&m4uport);
 152
 153         m4u_dealloc_mva(port, va, size, mva);
 154         mva = 0;
 155     }
 156
 157     if (va)
 158     {
 159         vfree((void *) va);
 160         va = 0;
 161     }
 162
 163     return 0;
 164 }
 165
 166 #ifdef MTK_SEC_VIDEO_PATH_SUPPORT
 167
 168 KREE_SESSION_HANDLE fb_pattern_secure_memory_session_handle(void)
 169 {
 170     static KREE_SESSION_HANDLE fb_pattern_secure_memory_session = NULL;
 171
 172     printk("fb_pattern_secure_memory_session_handle() acquire TEE session\n");
 173     if (NULL == fb_pattern_secure_memory_session)
 174     {
 175         TZ_RESULT ret;
 176         printk("fb_pattern_secure_memory_session_handle() create session\n");
 177         ret = KREE_CreateSession(TZ_TA_MEM_UUID, &fb_pattern_secure_memory_session);
 178         if (ret != TZ_RESULT_SUCCESS)
 179         {
 180             printk("KREE_CreateSession fail, ret=%d\n", ret);
 181             return NULL;
 182         }
 183     }
 184
 185     printk("fb_pattern_secure_memory_session_handle() session=%x\n",
 186         (unsigned int)fb_pattern_secure_memory_session);
 187     return fb_pattern_secure_memory_session;
 188 }
 189
 190
 191 void *fb_pattern_allocate_secure_memory(int size)
 192 {
 193     KREE_SECUREMEM_HANDLE mem_handle;
 194     TZ_RESULT ret;
 195     struct disp_mva_map mva_map_struct;
 196     MTEEC_PARAM param[4];
 197     unsigned int paramTypes;
 198
 199     // Allocate
 200     ret = KREE_AllocSecurechunkmem (fb_pattern_secure_memory_session_handle(), &mem_handle, 4096, size);
 201     if (ret != TZ_RESULT_SUCCESS)
 202     {
 203                 printk("KREE_AllocSecurechunkmem fail, ret=%d \n", ret);
 204         return NULL;
 205     }
 206
 207     printk("KREE_AllocSecurchunkemem handle=0x%x \n", mem_handle);
 208
 209         param[0].value.a = DISP_OVL_0;
 210         param[1].value.a = 0;
 211         param[2].value.a = (unsigned int)mem_handle;
 212         param[3].value.a = size;
 213         paramTypes = TZ_ParamTypes4(TZPT_VALUE_INPUT,TZPT_VALUE_INPUT,TZPT_VALUE_INPUT,TZPT_VALUE_INPUT);
 214         ret = KREE_TeeServiceCall(ddp_session_handle(), TZCMD_DDP_SECURE_MVA_MAP, paramTypes, param);
 215         if(ret!= TZ_RESULT_SUCCESS)
 216         {
 217                 DISP_OVL_ENGINE_ERR("KREE_TeeServiceCall(TZCMD_DDP_SECURE_MVA_MAP) fail, ret=%d \n", ret);
 218
 219                 return -1;
 220         }
 221
 222     return (void *)mem_handle;
 223 }
 224 #endif
 225
 226 extern struct fb_info *mtkfb_fbi;
 227 unsigned int g_fb_pattern_en = 0;
 228
 229 int fb_pattern_en(int enable)
 230 {
 231     g_fb_pattern_en = enable;
 232 }
 233
 234 int fb_pattern(struct mtkfb_device *fbdev, struct fb_overlay_config *fb_config)
 235 {
 236     static unsigned int mem_init = 0, pattern_va = 0, pattern_mva = 0, pattern_mva_sec = 0;
 237     unsigned int pattern_size = DISP_GetScreenWidth()*DISP_GetScreenHeight()*3;
 238     int ret, i, fd;
 239
 240     printk("================================ New frame ===============================\n");
 241     printk("[Pattern] fb_pattern\n");
 242
 243     printk("fb_pattern orgi input: fence:%d, time: 0x%x\n", fb_config->fence,fb_config->time);
 244     for (i=0; i<4; i++)
 245     {
 246         printk("fb_pattern orgi input: layer%d en%d, next_idx=0x%x, vaddr=0x%x, paddr=0x%x, fmt=%u,"
 247                 " d-link=%u, pitch=%u, xoff=%u, yoff=%u, w=%u, h=%u, alpha_en=%d, alpha=%d,"
 248                 " fence_fd=%d, ion_fd=%d, security=%d\n",
 249                 fb_config->layers[i].layer_id,
 250                 fb_config->layers[i].layer_enable,
 251                 fb_config->layers[i].next_buff_idx,
 252                 (unsigned int)(fb_config->layers[i].src_base_addr),
 253                 (unsigned int)(fb_config->layers[i].src_phy_addr),
 254                 fb_config->layers[i].src_fmt,
 255                 (unsigned int)(fb_config->layers[i].src_direct_link),
 256                 fb_config->layers[i].src_pitch,
 257                 fb_config->layers[i].src_offset_x,
 258                 fb_config->layers[i].src_offset_y,
 259                 fb_config->layers[i].src_width,
 260                 fb_config->layers[i].src_height,
 261                 fb_config->layers[i].alpha_enable,
 262                 fb_config->layers[i].alpha,
 263                 fb_config->layers[i].fence_fd,
 264                 fb_config->layers[i].ion_fd,
 265                 fb_config->layers[i].security);
 266     }
 267     printk("\n");
 268
 269     if (mem_init == 0)
 270     {
 271         if (pattern_mva == 0)       // normal mva
 272         {
 273             ret = alloc_buffer(DISP_OVL_0, pattern_size, &pattern_va, &pattern_mva);
 274             if (ret == -1)
 275                 return -1;
 276         }
 277         #ifdef MTK_SEC_VIDEO_PATH_SUPPORT
 278         if (pattern_mva_sec == 0)  // handle
 279         {
 280             pattern_mva_sec = (unsigned int)fb_pattern_allocate_secure_memory(pattern_size);
 281         }
 282         #endif
 283
 284         mem_init = 1;
 285     }
 286
 287     fb_config->layers[0].layer_id = 0;
 288     fb_config->layers[0].layer_enable = 1;
 289     fb_config->layers[0].src_width = DISP_GetScreenWidth();
 290     fb_config->layers[0].src_height = DISP_GetScreenHeight();
 291     fb_config->layers[0].src_pitch = DISP_GetScreenWidth();
 292     fb_config->layers[0].tgt_width = DISP_GetScreenWidth();
 293     fb_config->layers[0].tgt_height = DISP_GetScreenHeight();
 294     fb_config->layers[0].src_fmt = MTK_FB_FORMAT_RGB888;
 295     if (g_fb_pattern_en == 1)
 296     {
 297         fb_config->layers[0].src_phy_addr = pattern_mva;
 298         fb_config->layers[0].security = 0;
 299     }
 300     else if (g_fb_pattern_en == 2)
 301     {
 302         fb_config->layers[0].src_phy_addr = pattern_mva_sec;
 303         fb_config->layers[0].security = 1;
 304     }
 305
 306     fb_config->layers[1].layer_id = 1;
 307     fb_config->layers[1].layer_enable = 0;
 308
 309     fb_config->layers[2].layer_id = 2;
 310     fb_config->layers[2].layer_enable = 0;
 311
 312     fb_config->layers[3].layer_id = 3;
 313     fb_config->layers[3].layer_enable = 0;
 314
 315     mtkfb_queue_overlay_config(fbdev, fb_config);
 316
 317     //free_buffer(DISP_OVL_0, pattern_size, pattern_va, pattern_mva);
 318
 319     return 0;
 320
 321 }
 322