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

   1 #include <linux/string.h>
   2 #include <linux/time.h>
   3 #include <linux/uaccess.h>
   4 #include <linux/fb.h>
   5 #include <linux/vmalloc.h>
   6 #include <linux/sched.h>
   7 #include <linux/debugfs.h>
   8 #include <linux/wait.h>
   9 #include <mach/mt_typedefs.h>
  10 #include "disp_hal.h"
  11 #include "disp_drv_log.h"
  12 #include "mtkfb.h"
  13 #include "debug.h"
  14 #include "lcm_drv.h"
  15 #include "ddp_ovl.h"
  16 #include "ddp_path.h"
  17 #include "disp_drv.h"
  18
  19 struct MTKFB_MMP_Events_t MTKFB_MMP_Events;
  20
  21 extern LCM_DRIVER *lcm_drv;
  22 extern unsigned int EnableVSyncLog;
  23
  24 #define MTKFB_DEBUG_FS_CAPTURE_LAYER_CONTENT_SUPPORT
  25
  26 // ---------------------------------------------------------------------------
  27 //  External variable declarations
  28 // ---------------------------------------------------------------------------
  29
  30 extern long tpd_last_down_time;
  31 extern int  tpd_start_profiling;
  32 extern void mtkfb_log_enable(int enable);
  33 extern void disp_log_enable(int enable);
  34 extern void mtkfb_vsync_log_enable(int enable);
  35 extern void mtkfb_capture_fb_only(bool enable);
  36 extern void esd_recovery_pause(BOOL en);
  37 extern int mtkfb_set_backlight_mode(unsigned int mode);
  38 extern void mtkfb_pan_disp_test(void);
  39 extern void mtkfb_show_sem_cnt(void);
  40 extern void mtkfb_hang_test(bool en);
  41 extern void mtkfb_switch_normal_to_factory(void);
  42 extern void mtkfb_switch_factory_to_normal(void);
  43 extern void set_ovlengine_debug_level(int level);
  44 extern int fb_pattern_en(int enable);
  45
  46 extern unsigned int gCaptureLayerEnable;
  47 extern unsigned int gCaptureLayerDownX;
  48 extern unsigned int gCaptureLayerDownY;
  49
  50 extern unsigned int gCaptureOvlThreadEnable;
  51 extern unsigned int gCaptureOvlDownX;
  52 extern unsigned int gCaptureOvlDownY;
  53 extern struct task_struct *captureovl_task;
  54
  55 extern unsigned int gCaptureFBEnable;
  56 extern unsigned int gCaptureFBDownX;
  57 extern unsigned int gCaptureFBDownY;
  58 extern unsigned int gCaptureFBPeriod;
  59 extern struct task_struct *capturefb_task;
  60 extern wait_queue_head_t gCaptureFBWQ;
  61
  62 #ifdef MTKFB_DEBUG_FS_CAPTURE_LAYER_CONTENT_SUPPORT
  63 struct dentry *mtkfb_layer_dbgfs[DDP_OVL_LAYER_MUN];
  64
  65 extern OVL_CONFIG_STRUCT cached_layer_config[DDP_OVL_LAYER_MUN];
  66
  67 typedef struct {
  68     UINT32 layer_index;
  69     UINT32 working_buf;
  70     UINT32 working_size;
  71 } MTKFB_LAYER_DBG_OPTIONS;
  72
  73 MTKFB_LAYER_DBG_OPTIONS mtkfb_layer_dbg_opt[DDP_OVL_LAYER_MUN];
  74
  75 #endif
  76 extern LCM_DRIVER *lcm_drv;
  77
  78 static char debug_buffer[2048];
  79
  80 #if defined(MTK_OVERLAY_ENGINE_SUPPORT)
  81 extern unsigned int gDumpOVLEnable;
  82 #endif
  83
  84 // ---------------------------------------------------------------------------
  85 //  Debug Options
  86 // ---------------------------------------------------------------------------
  87
  88 static const long int DEFAULT_LOG_FPS_WND_SIZE = 30;
  89
  90 typedef struct {
  91     unsigned int en_fps_log;
  92     unsigned int en_touch_latency_log;
  93     unsigned int log_fps_wnd_size;
  94     unsigned int force_dis_layers;
  95 } DBG_OPTIONS;
  96
  97 static DBG_OPTIONS dbg_opt = {0};
  98
  99 static char STR_HELP[] =
 100     "\n"
 101     "USAGE\n"
 102     "        echo [ACTION]... > /d/mtkfb\n"
 103     "\n"
 104     "ACTION\n"
 105         "        mtkfblog:[on|off]\n"
 106         "             enable/disable [MTKFB] log\n"
 107         "\n"
 108         "        displog:[on|off]\n"
 109         "             enable/disable [DISP] log\n"
 110         "\n"
 111         "        mtkfb_vsynclog:[on|off]\n"
 112         "             enable/disable [VSYNC] log\n"
 113         "\n"
 114         "        log:[on|off]\n"
 115         "             enable/disable above all log\n"
 116         "\n"
 117     "        fps:[on|off]\n"
 118     "             enable fps and lcd update time log\n"
 119         "\n"
 120     "        tl:[on|off]\n"
 121     "             enable touch latency log\n"
 122     "\n"
 123     "        layer\n"
 124     "             dump lcd layer information\n"
 125     "\n"
 126     "        suspend\n"
 127     "             enter suspend mode\n"
 128     "\n"
 129     "        resume\n"
 130     "             leave suspend mode\n"
 131     "\n"
 132     "        lcm:[on|off|init]\n"
 133     "             power on/off lcm\n"
 134     "\n"
 135     "        cabc:[ui|mov|still]\n"
 136     "             cabc mode, UI/Moving picture/Still picture\n"
 137     "\n"
 138     "        lcd:[on|off]\n"
 139     "             power on/off display engine\n"
 140     "\n"
 141     "        te:[on|off]\n"
 142     "             turn on/off tearing-free control\n"
 143     "\n"
 144     "        tv:[on|off]\n"
 145     "             turn on/off tv-out\n"
 146     "\n"
 147     "        tvsys:[ntsc|pal]\n"
 148     "             switch tv system\n"
 149     "\n"
 150     "        reg:[lcd|dpi|dsi|tvc|tve]\n"
 151     "             dump hw register values\n"
 152     "\n"
 153     "       cpfbonly:[on|off]\n"
 154     "             capture UI layer only on/off\n"
 155     "\n"
 156     "       esd:[on|off]\n"
 157     "             esd kthread on/off\n"
 158     "       HQA:[NormalToFactory|FactoryToNormal]\n"
 159     "             for HQA requirement\n"
 160     "\n"
 161     "       mmp\n"
 162     "             Register MMProfile events\n"
 163         "\n"
 164         "       dump_fb:[on|off[,down_sample_x[,down_sample_y,[delay]]]]\n"
 165         "             Start/end to capture framebuffer every delay(ms)\n"
 166         "\n"
 167         "       dsc:rd:Addr           ex. dsc:rd:0x11        read  lcm addr=0x11 \n"
 168         "       dsc:wt:addr:val       ex. dsc:wt:0x11:0x22   write lcm addr|cmd =0x11 value|paramer = 0x22\n"
 169         "       dsc:rw:addr:val:loop  ex. dsc:wt:0x11:0x22   write lcm addr =0x11 value = 0x22,and then read back\n"
 170         "                                                           compare the value and the value read back  \n"
 171         "                                                           if different, break,and print the current times. \n"
 172         "\n"
 173         "       dump_ovl:[on|off[,down_sample_x[,down_sample_y]]]\n"
 174         "             Start to capture OVL only once\n"
 175         "\n"
 176         "       dump_layer:[on|off[,down_sample_x[,down_sample_y]]]\n"
 177         "             Start/end to capture current enabled OVL layer every frame\n"
 178     ;
 179
 180
 181 // ---------------------------------------------------------------------------
 182 //  Information Dump Routines
 183 // ---------------------------------------------------------------------------
 184
 185 void init_mtkfb_mmp_events(void)
 186 {
 187     if (MTKFB_MMP_Events.MTKFB == 0)
 188     {
 189         MTKFB_MMP_Events.MTKFB = MMProfileRegisterEvent(MMP_RootEvent, "MTKFB");
 190         MTKFB_MMP_Events.PanDisplay = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "PanDisplay");
 191         MTKFB_MMP_Events.SetOverlayLayer = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "SetOverlayLayer");
 192         MTKFB_MMP_Events.SetOverlayLayers = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "SetOverlayLayers");
 193         MTKFB_MMP_Events.TrigOverlayOut = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "TrigOverlayOut");
 194         MTKFB_MMP_Events.UpdateScreenImpl = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "UpdateScreenImpl");
 195         MTKFB_MMP_Events.VSync = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "VSync");
 196         MTKFB_MMP_Events.UpdateConfig = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "UpdateConfig");
 197         MTKFB_MMP_Events.EsdCheck = MMProfileRegisterEvent(MTKFB_MMP_Events.UpdateConfig, "EsdCheck");
 198         MTKFB_MMP_Events.ConfigOVL = MMProfileRegisterEvent(MTKFB_MMP_Events.UpdateConfig, "ConfigOVL");
 199         MTKFB_MMP_Events.ConfigAAL = MMProfileRegisterEvent(MTKFB_MMP_Events.UpdateConfig, "ConfigAAL");
 200         MTKFB_MMP_Events.ConfigMemOut = MMProfileRegisterEvent(MTKFB_MMP_Events.UpdateConfig, "ConfigMemOut");
 201         MTKFB_MMP_Events.ScreenUpdate = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "ScreenUpdate");
 202         MTKFB_MMP_Events.CaptureFramebuffer = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "CaptureFB");
 203         MTKFB_MMP_Events.RegUpdate = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "RegUpdate");
 204         MTKFB_MMP_Events.EarlySuspend = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "EarlySuspend");
 205         MTKFB_MMP_Events.DispDone = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "DispDone");
 206         MTKFB_MMP_Events.DSICmd = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "DSICmd");
 207         MTKFB_MMP_Events.DSIIRQ = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "DSIIrq");
 208         MTKFB_MMP_Events.WaitVSync = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "WaitVSync");
 209         MTKFB_MMP_Events.LayerDump = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "LayerDump");
 210         MTKFB_MMP_Events.Layer[0] = MMProfileRegisterEvent(MTKFB_MMP_Events.LayerDump, "Layer0");
 211         MTKFB_MMP_Events.Layer[1] = MMProfileRegisterEvent(MTKFB_MMP_Events.LayerDump, "Layer1");
 212         MTKFB_MMP_Events.Layer[2] = MMProfileRegisterEvent(MTKFB_MMP_Events.LayerDump, "Layer2");
 213         MTKFB_MMP_Events.Layer[3] = MMProfileRegisterEvent(MTKFB_MMP_Events.LayerDump, "Layer3");
 214         MTKFB_MMP_Events.OvlDump = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "OvlDump");
 215         MTKFB_MMP_Events.FBDump = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "FBDump");
 216         MTKFB_MMP_Events.DSIRead = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "DSIRead");
 217         MTKFB_MMP_Events.GetLayerInfo = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "GetLayerInfo");
 218         MTKFB_MMP_Events.LayerInfo[0] = MMProfileRegisterEvent(MTKFB_MMP_Events.GetLayerInfo, "LayerInfo0");
 219         MTKFB_MMP_Events.LayerInfo[1] = MMProfileRegisterEvent(MTKFB_MMP_Events.GetLayerInfo, "LayerInfo1");
 220         MTKFB_MMP_Events.LayerInfo[2] = MMProfileRegisterEvent(MTKFB_MMP_Events.GetLayerInfo, "LayerInfo2");
 221         MTKFB_MMP_Events.LayerInfo[3] = MMProfileRegisterEvent(MTKFB_MMP_Events.GetLayerInfo, "LayerInfo3");
 222         MTKFB_MMP_Events.IOCtrl = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "IOCtrl");
 223         MTKFB_MMP_Events.Debug = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "Debug");
 224
 225         MTKFB_MMP_Events.QueueWork = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "QueueWork");
 226         MTKFB_MMP_Events.WrokHandler = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "WrokHandler");
 227         MTKFB_MMP_Events.FenceContrl = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "FenceContrl");
 228         MTKFB_MMP_Events.HWCFence[0] = MMProfileRegisterEvent(MTKFB_MMP_Events.FenceContrl, "HWCFence0");
 229         MTKFB_MMP_Events.HWCFence[1] = MMProfileRegisterEvent(MTKFB_MMP_Events.FenceContrl, "HWCFence1");
 230         MTKFB_MMP_Events.HWCFence[2] = MMProfileRegisterEvent(MTKFB_MMP_Events.FenceContrl, "HWCFence2");
 231         MTKFB_MMP_Events.HWCFence[3] = MMProfileRegisterEvent(MTKFB_MMP_Events.FenceContrl, "HWCFence3");
 232         MTKFB_MMP_Events.FBFence = MMProfileRegisterEvent(MTKFB_MMP_Events.FenceContrl, "FBFence");
 233         MTKFB_MMP_Events.FBTimeline = MMProfileRegisterEvent(MTKFB_MMP_Events.FenceContrl, "FBTimeline");
 234
 235         MTKFB_MMP_Events.OVLEngine = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "OVLEngine");
 236         MTKFB_MMP_Events.Instance_status[0] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance0_status");
 237         MTKFB_MMP_Events.Instance_status[1] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance1_status");
 238         MTKFB_MMP_Events.Instance_status[2] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance2_status");
 239         MTKFB_MMP_Events.OVLEngine_ovlwdma_status = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_ovlwdma_status");
 240         MTKFB_MMP_Events.OVLEngine_rdma_status = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_rdma_status");
 241         MTKFB_MMP_Events.OVLEngine_rdma_hang = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_rdma_hang");
 242         MTKFB_MMP_Events.OVLEngine_fence[0] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance0_fence");
 243         MTKFB_MMP_Events.OVLEngine_fence[1] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance1_fence");
 244         MTKFB_MMP_Events.OVLEngine_fence[2] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance2_fence");
 245         MTKFB_MMP_Events.OVLEngine_timeline[0] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance0_timeline");
 246         MTKFB_MMP_Events.OVLEngine_timeline[1] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance1_timeline");
 247         MTKFB_MMP_Events.OVLEngine_timeline[2] = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "Instance2_timeline");
 248         MTKFB_MMP_Events.OVLEngine_API = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_API");
 249         MTKFB_MMP_Events.OVLEngine_CORE = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_CORE");
 250         MTKFB_MMP_Events.OVLEngine_HW = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_HW");
 251         MTKFB_MMP_Events.OVLEngine_IOCTL = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine, "OVLEngine_IOCTL");
 252
 253         MTKFB_MMP_Events.GetInstance = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "GetInstance");
 254         MTKFB_MMP_Events.ReleaseInstance = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "ReleaseInstance");
 255         MTKFB_MMP_Events.Get_layer_info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Get_layer_info");
 256         MTKFB_MMP_Events.Set_layer_info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Set_layer_info");
 257         MTKFB_MMP_Events.Get_Ovl_layer_info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Get_Ovl_layer_info");
 258         MTKFB_MMP_Events.Set_Overlayed_Buffer = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Set_Overlayed_Buffer");
 259         MTKFB_MMP_Events.Trigger_Overlay = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Trigger_Overlay");
 260         MTKFB_MMP_Events.Get_Dirty_info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Get_Dirty_info");
 261         MTKFB_MMP_Events.Set_Path_Info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Set_Path_Info");
 262         MTKFB_MMP_Events.Sync_Captured_layer_info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Sync_Captured_layer_info");
 263         MTKFB_MMP_Events.Dump_layer_info = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Dump_layer_info");
 264         MTKFB_MMP_Events.Trigger_Overlay_Handler = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Trigger_Overlay_Handler");
 265         MTKFB_MMP_Events.Trigger_Overlay_Fence = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Trigger_Overlay_Fence");
 266         MTKFB_MMP_Events.Get_Fence_Fd = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_API, "Get_Fence_Fd");
 267
 268         MTKFB_MMP_Events.Update_kthread = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_CORE, "Update_kthread");
 269         MTKFB_MMP_Events.wake_up_ovl_engine_thread = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_CORE, "wake_up_ovl_engine_thread");
 270         MTKFB_MMP_Events.interrupt_handler = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_CORE, "interrupt_handler");
 271
 272         MTKFB_MMP_Events.hw_set_params = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "hw_set_params");
 273         MTKFB_MMP_Events.hw_ovl_wdma_irq_handler = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "hw_ovl_wdma_irq_handler");
 274         MTKFB_MMP_Events.hw_ovl_rdma_irq_handler = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "hw_ovl_rdma_irq_handler");
 275         MTKFB_MMP_Events.rdma0_irq_handler = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "rdma0_irq_handler");
 276         MTKFB_MMP_Events.trigger_hw_overlay = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "trigger_hw_overlay");
 277         MTKFB_MMP_Events.trigger_hw_overlay_decouple = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "trigger_hw_overlay_decouple");
 278         MTKFB_MMP_Events.trigger_hw_overlay_couple = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "trigger_hw_overlay_couple");
 279         MTKFB_MMP_Events.config_overlay = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "config_overlay");
 280         MTKFB_MMP_Events.direct_link_overlay = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "direct_link_overlay");
 281         MTKFB_MMP_Events.indirect_link_overlay = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "indirect_link_overlay");
 282         MTKFB_MMP_Events.set_overlay_to_buffer = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "set_overlay_to_buffer");
 283         MTKFB_MMP_Events.dumpallinfo = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "dumpallinfo");
 284         MTKFB_MMP_Events.hw_mva_map = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "hw_mva_map");
 285         MTKFB_MMP_Events.hw_mva_unmap = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "hw_mva_unmap");
 286         MTKFB_MMP_Events.hw_reset = MMProfileRegisterEvent(MTKFB_MMP_Events.OVLEngine_HW, "hw_reset");
 287
 288         MTKFB_MMP_Events.Svp = MMProfileRegisterEvent(MTKFB_MMP_Events.MTKFB, "Svp");
 289         MTKFB_MMP_Events.OVL_WDMA_IRQ_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "OVL_WDMA_IRQ_InTEE");
 290         MTKFB_MMP_Events.OVL_WDMA_M4U_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "OVL_WDMA_M4U_InTEE");
 291         MTKFB_MMP_Events.OVL_WDMA_ADDR_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "OVL_WDMA_ADDR_InTEE");
 292         MTKFB_MMP_Events.RDMA0_IRQ_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "RDMA0_IRQ_InTEE");
 293         MTKFB_MMP_Events.RDMA0_M4U_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "RDMA0_M4U_InTEE");
 294         MTKFB_MMP_Events.RDMA0_ADDR_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "RDMA0_ADDR_InTEE");
 295         MTKFB_MMP_Events.RDMA1_IRQ_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "RDMA1_IRQ_InTEE");
 296         MTKFB_MMP_Events.RDMA1_M4U_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "RDMA1_M4U_InTEE");
 297         MTKFB_MMP_Events.RDMA1_ADDR_InTEE = MMProfileRegisterEvent(MTKFB_MMP_Events.Svp, "RDMA1_ADDR_InTEE");
 298
 299         MMProfileEnableEventRecursive(MTKFB_MMP_Events.MTKFB, 1);
 300     }
 301 }
 302
 303 static __inline int is_layer_enable(unsigned int roi_ctl, unsigned int layer)
 304 {
 305     return (roi_ctl >> (31 - layer)) & 0x1;
 306 }
 307
 308 static void dump_layer_info(void)
 309 {
 310         unsigned int i;
 311         for(i=0;i<4;i++){
 312                 pr_info("LayerInfo in LCD driver, layer=%d,layer_en=%d, source=%d, fmt=%d, addr=0x%x, x=%d, y=%d \n\
 313                 w=%d, h=%d, pitch=%d, keyEn=%d, key=%d, aen=%d, alpha=%d \n ",
 314             cached_layer_config[i].layer,   // layer
 315             cached_layer_config[i].layer_en,
 316             cached_layer_config[i].source,   // data source (0=memory)
 317             cached_layer_config[i].fmt,
 318             cached_layer_config[i].addr, // addr
 319             cached_layer_config[i].dst_x,  // x
 320             cached_layer_config[i].dst_y,  // y
 321             cached_layer_config[i].dst_w, // width
 322             cached_layer_config[i].dst_h, // height
 323             cached_layer_config[i].src_pitch, //pitch, pixel number
 324             cached_layer_config[i].keyEn,  //color key
 325             cached_layer_config[i].key,  //color key
 326             cached_layer_config[i].aen, // alpha enable
 327             cached_layer_config[i].alpha);
 328         }
 329 }
 330
 331
 332 // ---------------------------------------------------------------------------
 333 //  FPS Log
 334 // ---------------------------------------------------------------------------
 335
 336 typedef struct {
 337     long int current_lcd_time_us;
 338     long int current_te_delay_time_us;
 339     long int total_lcd_time_us;
 340     long int total_te_delay_time_us;
 341     long int start_time_us;
 342     long int trigger_lcd_time_us;
 343     unsigned int trigger_lcd_count;
 344
 345     long int current_hdmi_time_us;
 346     long int total_hdmi_time_us;
 347     long int hdmi_start_time_us;
 348     long int trigger_hdmi_time_us;
 349     unsigned int trigger_hdmi_count;
 350 } FPS_LOGGER;
 351
 352 static FPS_LOGGER fps = {0};
 353 static FPS_LOGGER hdmi_fps = {0};
 354
 355 static long int get_current_time_us(void)
 356 {
 357     struct timeval t;
 358     do_gettimeofday(&t);
 359     return (t.tv_sec & 0xFFF) * 1000000 + t.tv_usec;
 360 }
 361
 362
 363 static void __inline reset_fps_logger(void)
 364 {
 365     memset(&fps, 0, sizeof(fps));
 366 }
 367
 368 static void __inline reset_hdmi_fps_logger(void)
 369 {
 370     memset(&hdmi_fps, 0, sizeof(hdmi_fps));
 371 }
 372
 373 void DBG_OnTriggerLcd(void)
 374 {
 375     if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
 376
 377     fps.trigger_lcd_time_us = get_current_time_us();
 378     if (fps.trigger_lcd_count == 0) {
 379         fps.start_time_us = fps.trigger_lcd_time_us;
 380     }
 381 }
 382
 383 void DBG_OnTriggerHDMI(void)
 384 {
 385     if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
 386
 387     hdmi_fps.trigger_hdmi_time_us = get_current_time_us();
 388     if (hdmi_fps.trigger_hdmi_count == 0) {
 389         hdmi_fps.hdmi_start_time_us = hdmi_fps.trigger_hdmi_time_us;
 390     }
 391 }
 392
 393 void DBG_OnTeDelayDone(void)
 394 {
 395     long int time;
 396
 397     if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
 398
 399     time = get_current_time_us();
 400     fps.current_te_delay_time_us = (time - fps.trigger_lcd_time_us);
 401     fps.total_te_delay_time_us += fps.current_te_delay_time_us;
 402 }
 403
 404
 405 void DBG_OnLcdDone(void)
 406 {
 407     long int time;
 408
 409     if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
 410
 411     // deal with touch latency log
 412
 413     time = get_current_time_us();
 414     fps.current_lcd_time_us = (time - fps.trigger_lcd_time_us);
 415
 416 #if 0   // FIXME
 417     if (dbg_opt.en_touch_latency_log && tpd_start_profiling) {
 418
 419         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "Touch Latency: %ld ms\n",
 420                (time - tpd_last_down_time) / 1000);
 421
 422         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "LCD update time %ld ms (TE delay %ld ms + LCD %ld ms)\n",
 423                fps.current_lcd_time_us / 1000,
 424                fps.current_te_delay_time_us / 1000,
 425                (fps.current_lcd_time_us - fps.current_te_delay_time_us) / 1000);
 426
 427         tpd_start_profiling = 0;
 428     }
 429 #endif
 430
 431     if (!dbg_opt.en_fps_log) return;
 432
 433     // deal with fps log
 434
 435     fps.total_lcd_time_us += fps.current_lcd_time_us;
 436     ++ fps.trigger_lcd_count;
 437
 438     if (fps.trigger_lcd_count >= dbg_opt.log_fps_wnd_size) {
 439
 440         long int f = fps.trigger_lcd_count * 100 * 1000 * 1000
 441                      / (time - fps.start_time_us);
 442
 443         long int update = fps.total_lcd_time_us * 100
 444                           / (1000 * fps.trigger_lcd_count);
 445
 446         long int te = fps.total_te_delay_time_us * 100
 447                       / (1000 * fps.trigger_lcd_count);
 448
 449         long int lcd = (fps.total_lcd_time_us - fps.total_te_delay_time_us) * 100
 450                        / (1000 * fps.trigger_lcd_count);
 451
 452         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "MTKFB FPS: %ld.%02ld, Avg. update time: %ld.%02ld ms "
 453                "(TE delay %ld.%02ld ms, LCD %ld.%02ld ms)\n",
 454                f / 100, f % 100,
 455                update / 100, update % 100,
 456                te / 100, te % 100,
 457                lcd / 100, lcd % 100);
 458                 reset_fps_logger();
 459         }
 460 }
 461
 462 void DBG_OnHDMIDone(void)
 463 {
 464     long int time;
 465
 466     if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
 467
 468     // deal with touch latency log
 469
 470     time = get_current_time_us();
 471     hdmi_fps.current_hdmi_time_us = (time - hdmi_fps.trigger_hdmi_time_us);
 472
 473
 474     if (!dbg_opt.en_fps_log) return;
 475
 476     // deal with fps log
 477
 478     hdmi_fps.total_hdmi_time_us += hdmi_fps.current_hdmi_time_us;
 479     ++ hdmi_fps.trigger_hdmi_count;
 480
 481     if (hdmi_fps.trigger_hdmi_count >= dbg_opt.log_fps_wnd_size) {
 482
 483         long int f = hdmi_fps.trigger_hdmi_count * 100 * 1000 * 1000
 484                      / (time - hdmi_fps.hdmi_start_time_us);
 485
 486         long int update = hdmi_fps.total_hdmi_time_us * 100
 487                           / (1000 * hdmi_fps.trigger_hdmi_count);
 488
 489         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "[HDMI] FPS: %ld.%02ld, Avg. update time: %ld.%02ld ms\n",
 490                f / 100, f % 100,
 491                update / 100, update % 100);
 492
 493         reset_hdmi_fps_logger();
 494     }
 495 }
 496
 497 // ---------------------------------------------------------------------------
 498 //  Command Processor
 499 // ---------------------------------------------------------------------------
 500 extern void mtkfb_clear_lcm(void);
 501 extern void hdmi_force_init(void);
 502
 503 static void process_dbg_opt(const char *opt)
 504 {
 505
 506     char *buf = debug_buffer + strlen(debug_buffer);
 507
 508     if (0 == strncmp(opt, "hdmion", 6))
 509     {
 510 //      hdmi_force_init();
 511     }
 512     else if (0 == strncmp(opt, "fps:", 4))
 513     {
 514         if (0 == strncmp(opt + 4, "on", 2)) {
 515             dbg_opt.en_fps_log = 1;
 516         } else if (0 == strncmp(opt + 4, "off", 3)) {
 517             dbg_opt.en_fps_log = 0;
 518         } else {
 519             goto Error;
 520         }
 521         reset_fps_logger();
 522     }
 523     else if (0 == strncmp(opt, "tl:", 3))
 524     {
 525         if (0 == strncmp(opt + 3, "on", 2)) {
 526             dbg_opt.en_touch_latency_log = 1;
 527         } else if (0 == strncmp(opt + 3, "off", 3)) {
 528             dbg_opt.en_touch_latency_log = 0;
 529         } else {
 530             goto Error;
 531         }
 532     }
 533     else if (0 == strncmp(opt, "black", 5))
 534     {
 535         mtkfb_clear_lcm();
 536     }
 537     else if (0 == strncmp(opt, "suspend", 4))
 538     {
 539         DISP_PanelEnable(FALSE);
 540         DISP_PowerEnable(FALSE);
 541     }
 542     else if (0 == strncmp(opt, "resume", 4))
 543     {
 544         DISP_PowerEnable(TRUE);
 545         DISP_PanelEnable(TRUE);
 546     }
 547     else if (0 == strncmp(opt, "lcm:", 4))
 548     {
 549         if (0 == strncmp(opt + 4, "on", 2)) {
 550             DISP_PanelEnable(TRUE);
 551         } else if (0 == strncmp(opt + 4, "off", 3)) {
 552             DISP_PanelEnable(FALSE);
 553         }
 554                 else if (0 == strncmp(opt + 4, "init", 4)) {
 555                         if (NULL != lcm_drv && NULL != lcm_drv->init) {
 556                         lcm_drv->init();
 557                 }
 558         }else {
 559             goto Error;
 560         }
 561     }
 562     else if (0 == strncmp(opt, "cabc:", 5))
 563     {
 564         if (0 == strncmp(opt + 5, "ui", 2)) {
 565                         mtkfb_set_backlight_mode(1);
 566         }else if (0 == strncmp(opt + 5, "mov", 3)) {
 567                         mtkfb_set_backlight_mode(3);
 568         }else if (0 == strncmp(opt + 5, "still", 5)) {
 569                         mtkfb_set_backlight_mode(2);
 570         }else {
 571             goto Error;
 572         }
 573     }
 574     else if (0 == strncmp(opt, "lcd:", 4))
 575     {
 576         if (0 == strncmp(opt + 4, "on", 2)) {
 577             DISP_PowerEnable(TRUE);
 578         } else if (0 == strncmp(opt + 4, "off", 3)) {
 579             DISP_PowerEnable(FALSE);
 580         } else {
 581             goto Error;
 582         }
 583     }
 584     else if (0 == strncmp(opt, "vsynclog:", 9))
 585     {
 586         if (0 == strncmp(opt + 9, "on", 2))
 587         {
 588             EnableVSyncLog = 1;
 589         } else if (0 == strncmp(opt + 9, "off", 3))
 590         {
 591             EnableVSyncLog = 0;
 592         } else {
 593             goto Error;
 594         }
 595     }
 596     else if (0 == strncmp(opt, "layer", 5))
 597     {
 598         dump_layer_info();
 599     }
 600     else if(0 == strncmp(opt, "bkl:", 4))
 601     {
 602         char *p = (char *)opt + 4;
 603         unsigned int level = (unsigned int) simple_strtoul(p, &p, 10);
 604
 605         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "process_dbg_opt(), set backlight level = %d\n", level);
 606         DISP_SetBacklight(level);
 607     }
 608     else if(0 == strncmp(opt, "dither:", 7))
 609     {
 610         unsigned lrs, lgs, lbs, dbr, dbg, dbb;
 611         char *p = (char *)opt + 7;
 612
 613         lrs = (unsigned int) simple_strtoul(p, &p, 16);
 614         p++;
 615         lgs = (unsigned int) simple_strtoul(p, &p, 16);
 616         p++;
 617         lbs = (unsigned int) simple_strtoul(p, &p, 16);
 618         p++;
 619         dbr = (unsigned int) simple_strtoul(p, &p, 16);
 620         p++;
 621         dbg = (unsigned int) simple_strtoul(p, &p, 16);
 622         p++;
 623         dbb = (unsigned int) simple_strtoul(p, &p, 16);
 624
 625         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "process_dbg_opt(), %d %d %d %d %d %d\n", lrs, lgs, lbs, dbr, dbg, dbb);
 626     }
 627     else if (0 == strncmp(opt, "mtkfblog:", 9))
 628     {
 629         if (0 == strncmp(opt + 9, "on", 2)) {
 630             mtkfb_log_enable(true);
 631         } else if (0 == strncmp(opt + 9, "off", 3)) {
 632             mtkfb_log_enable(false);
 633         } else {
 634             goto Error;
 635         }
 636     }
 637     else if (0 == strncmp(opt, "displog:", 8))
 638     {
 639         if (0 == strncmp(opt + 8, "on", 2)) {
 640             disp_log_enable(true);
 641         } else if (0 == strncmp(opt + 8, "off", 3)) {
 642             disp_log_enable(false);
 643         } else {
 644             goto Error;
 645         }
 646     }
 647     else if (0 == strncmp(opt, "mtkfb_vsynclog:", 15))
 648     {
 649         if (0 == strncmp(opt + 15, "on", 2)) {
 650             mtkfb_vsync_log_enable(true);
 651         } else if (0 == strncmp(opt + 15, "off", 3)) {
 652             mtkfb_vsync_log_enable(false);
 653         } else {
 654             goto Error;
 655         }
 656     }
 657     else if (0 == strncmp(opt, "log:", 4))
 658     {
 659         if (0 == strncmp(opt + 4, "on", 2)) {
 660                         mtkfb_log_enable(true);
 661                         disp_log_enable(true);
 662         } else if (0 == strncmp(opt + 4, "off", 3)) {
 663             mtkfb_log_enable(false);
 664                         disp_log_enable(false);
 665         } else {
 666             goto Error;
 667         }
 668     }
 669     #if defined(MTK_OVERLAY_ENGINE_SUPPORT)
 670     else if (0 == strncmp(opt, "ovlengine_log:", 14))
 671     {
 672
 673         char *p = (char *)opt + 14;
 674         unsigned int level = (unsigned int) simple_strtoul(p, &p, 10);
 675
 676         set_ovlengine_debug_level(level);
 677     }
 678     #endif
 679     else if (0 == strncmp(opt, "update", 6))
 680     {
 681                 DISP_UpdateScreen(0, 0, DISP_GetScreenWidth(), DISP_GetScreenHeight());
 682     }
 683     else if (0 == strncmp(opt, "pan_disp", 8))
 684     {
 685                 mtkfb_pan_disp_test();
 686     }
 687     else if (0 == strncmp(opt, "sem_cnt", 7))
 688     {
 689                 mtkfb_show_sem_cnt();
 690     }
 691     else if (0 == strncmp(opt, "hang:", 5))
 692     {
 693         if (0 == strncmp(opt + 5, "on", 2)) {
 694             mtkfb_hang_test(true);
 695         } else if (0 == strncmp(opt + 5, "off", 3)) {
 696             mtkfb_hang_test(false);
 697         } else{
 698             goto Error;
 699         }
 700     }
 701     else if (0 == strncmp(opt, "cpfbonly:", 9))
 702     {
 703         if (0 == strncmp(opt + 9, "on", 2))
 704         {
 705             mtkfb_capture_fb_only(true);
 706         }
 707         else if (0 == strncmp(opt + 9, "off", 3))
 708         {
 709             mtkfb_capture_fb_only(false);
 710         }
 711     }
 712     else if (0 == strncmp(opt, "esd:", 4))
 713     {
 714         if (0 == strncmp(opt + 4, "on", 2))
 715         {
 716             esd_recovery_pause(FALSE);
 717         }
 718         else if (0 == strncmp(opt + 4, "off", 3))
 719         {
 720             esd_recovery_pause(TRUE);
 721         }
 722     }
 723     else if (0 == strncmp(opt, "HQA:", 4))
 724     {
 725         if (0 == strncmp(opt + 4, "NormalToFactory", 15))
 726         {
 727             mtkfb_switch_normal_to_factory();
 728         }
 729         else if (0 == strncmp(opt + 4, "FactoryToNormal", 15))
 730         {
 731             mtkfb_switch_factory_to_normal();
 732         }
 733     }
 734     else if (0 == strncmp(opt, "mmp", 3))
 735     {
 736         init_mtkfb_mmp_events();
 737     }
 738     else if (0 == strncmp(opt, "dump_layer:", 11))
 739     {
 740         if (0 == strncmp(opt + 11, "on", 2))
 741         {
 742             char *p = (char *)opt + 14;
 743             gCaptureLayerDownX = simple_strtoul(p, &p, 10);
 744             gCaptureLayerDownY = simple_strtoul(p+1, &p, 10);
 745
 746             if (gCaptureLayerDownX<=0 || gCaptureLayerDownX>100
 747                 || gCaptureLayerDownY<=0 || gCaptureLayerDownY>100)
 748             {
 749                 gCaptureLayerDownX = 10;
 750                 gCaptureLayerDownY = 10;
 751             }
 752
 753             gCaptureLayerEnable = 1;
 754         }
 755         else if (0 == strncmp(opt + 11, "off", 3))
 756         {
 757             gCaptureLayerEnable = 0;
 758         }
 759     }
 760     else if (0 == strncmp(opt, "dump_ovl:", 9))
 761     {
 762         if (0 == strncmp(opt + 9, "on", 2))
 763         {
 764             char *p = (char *)opt + 12;
 765             gCaptureOvlDownX = simple_strtoul(p, &p, 10);
 766             gCaptureOvlDownY = simple_strtoul(p+1, &p, 10);
 767
 768             if (gCaptureOvlDownX<=0 || gCaptureOvlDownX>100
 769                 || gCaptureOvlDownY<=0 || gCaptureOvlDownY>100)
 770             {
 771                 gCaptureOvlDownX = 10;
 772                 gCaptureOvlDownY = 10;
 773             }
 774
 775             #ifndef MTK_OVERLAY_ENGINE_SUPPORT
 776             gCaptureOvlThreadEnable = 1;
 777                         wake_up_process(captureovl_task);
 778             #else
 779             gDumpOVLEnable = 1;
 780             #endif
 781         }
 782         else if (0 == strncmp(opt + 9, "off", 3))
 783         {
 784             #ifndef MTK_OVERLAY_ENGINE_SUPPORT
 785             gCaptureOvlThreadEnable = 0;
 786             #else
 787             gDumpOVLEnable = 0;
 788             #endif
 789         }
 790     }
 791     else if (0 == strncmp(opt, "dump_fb:", 8))
 792     {
 793         if (0 == strncmp(opt + 8, "on", 2))
 794         {
 795             char *p = (char *)opt + 11;
 796             gCaptureFBDownX = simple_strtoul(p, &p, 10);
 797             gCaptureFBDownY = simple_strtoul(p+1, &p, 10);
 798             gCaptureFBPeriod = simple_strtoul(p+1, &p, 10);
 799             gCaptureFBEnable = 1;
 800                         wake_up_interruptible(&gCaptureFBWQ);
 801         }
 802         else if (0 == strncmp(opt + 8, "off", 3))
 803         {
 804             gCaptureFBEnable = 0;
 805         }
 806     }
 807     else if (0 == strncmp(opt, "fb_pattern:", 11))
 808     {
 809         if (0 == strncmp(opt + 11, "on", 2))
 810         {
 811             fb_pattern_en(1);
 812         }
 813         else if (0 == strncmp(opt + 11, "off", 3))
 814         {
 815             fb_pattern_en(0);
 816         }
 817         else if (0 == strncmp(opt + 11, "svp", 3))
 818         {
 819             fb_pattern_en(2);
 820         }
 821     }
 822     else
 823         {
 824             if (disphal_process_dbg_opt(opt))
 825                 goto Error;
 826         }
 827
 828     return;
 829
 830 Error:
 831     DISP_LOG_PRINT(ANDROID_LOG_INFO, "ERROR", "parse command error!\n\n%s", STR_HELP);
 832 }
 833
 834
 835 static void process_dbg_cmd(char *cmd)
 836 {
 837     char *tok;
 838
 839     DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "[mtkfb_dbg] %s\n", cmd);
 840     memset(debug_buffer, 0, sizeof(debug_buffer));
 841     while ((tok = strsep(&cmd, " ")) != NULL)
 842     {
 843         process_dbg_opt(tok);
 844     }
 845 }
 846
 847
 848 // ---------------------------------------------------------------------------
 849 //  Debug FileSystem Routines
 850 // ---------------------------------------------------------------------------
 851
 852 struct dentry *mtkfb_dbgfs = NULL;
 853
 854
 855 static ssize_t debug_open(struct inode *inode, struct file *file)
 856 {
 857     file->private_data = inode->i_private;
 858     return 0;
 859 }
 860
 861
 862
 863
 864 static ssize_t debug_read(struct file *file,
 865                           char __user *ubuf, size_t count, loff_t *ppos)
 866 {
 867    // const int debug_bufmax = sizeof(debug_buffer) - 1;
 868     //int n = 0;
 869
 870     //n += scnprintf(debug_buffer + n, debug_bufmax - n, STR_HELP);
 871     //debug_buffer[n++] = 0;
 872
 873     //return simple_read_from_buffer(ubuf, count, ppos, debug_buffer, n);
 874
 875
 876     if (strlen(debug_buffer))
 877         return simple_read_from_buffer(ubuf, count, ppos, debug_buffer, strlen(debug_buffer));
 878     else
 879         return simple_read_from_buffer(ubuf, count, ppos, STR_HELP, strlen(STR_HELP));
 880
 881
 882 }
 883
 884
 885 static char dis_cmd_buf[512];
 886 static ssize_t debug_write(struct file *file,
 887                            const char __user *ubuf, size_t count, loff_t *ppos)
 888 {
 889     const int debug_bufmax = sizeof(dis_cmd_buf) - 1;
 890         size_t ret;
 891
 892         ret = count;
 893
 894         if (count > debug_bufmax)
 895         count = debug_bufmax;
 896
 897         if (copy_from_user(&dis_cmd_buf, ubuf, count))
 898                 return -EFAULT;
 899
 900         dis_cmd_buf[count] = 0;
 901
 902     process_dbg_cmd(dis_cmd_buf);
 903
 904     return ret;
 905 }
 906
 907
 908 static struct file_operations debug_fops = {
 909         .read  = debug_read,
 910     .write = debug_write,
 911         .open  = debug_open,
 912 };
 913
 914 #ifdef MTKFB_DEBUG_FS_CAPTURE_LAYER_CONTENT_SUPPORT
 915
 916 static ssize_t layer_debug_open(struct inode *inode, struct file *file)
 917 {
 918     MTKFB_LAYER_DBG_OPTIONS *dbgopt;
 919     ///record the private data
 920     file->private_data = inode->i_private;
 921     dbgopt = (MTKFB_LAYER_DBG_OPTIONS *)file->private_data;
 922
 923     dbgopt->working_size = DISP_GetScreenWidth()*DISP_GetScreenHeight()*2 + 32;
 924     dbgopt->working_buf = (UINT32)vmalloc(dbgopt->working_size);
 925     if(dbgopt->working_buf == 0)
 926         DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "Vmalloc to get temp buffer failed\n");
 927
 928     return 0;
 929 }
 930
 931
 932 static ssize_t layer_debug_read(struct file *file,
 933                           char __user *ubuf, size_t count, loff_t *ppos)
 934 {
 935         return 0;
 936 }
 937
 938
 939 static ssize_t layer_debug_write(struct file *file,
 940                            const char __user *ubuf, size_t count, loff_t *ppos)
 941 {
 942     MTKFB_LAYER_DBG_OPTIONS *dbgopt = (MTKFB_LAYER_DBG_OPTIONS *)file->private_data;
 943
 944     DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "mtkfb_layer%d write is not implemented yet \n", dbgopt->layer_index);
 945
 946     return count;
 947 }
 948
 949 static int layer_debug_release(struct inode *inode, struct file *file)
 950 {
 951     MTKFB_LAYER_DBG_OPTIONS *dbgopt;
 952     dbgopt = (MTKFB_LAYER_DBG_OPTIONS *)file->private_data;
 953
 954     if(dbgopt->working_buf != 0)
 955         vfree((void *)dbgopt->working_buf);
 956
 957     dbgopt->working_buf = 0;
 958
 959     return 0;
 960 }
 961
 962
 963 static struct file_operations layer_debug_fops = {
 964         .read  = layer_debug_read,
 965     .write = layer_debug_write,
 966         .open  = layer_debug_open,
 967     .release = layer_debug_release,
 968 };
 969
 970 #endif
 971
 972 void DBG_Init(void)
 973 {
 974     mtkfb_dbgfs = debugfs_create_file("mtkfb",
 975         S_IFREG|S_IRUGO, NULL, (void *)0, &debug_fops);
 976
 977     memset(&dbg_opt, sizeof(dbg_opt), 0);
 978         memset(&fps, sizeof(fps), 0);
 979     dbg_opt.log_fps_wnd_size = DEFAULT_LOG_FPS_WND_SIZE;
 980
 981 #ifdef MTKFB_DEBUG_FS_CAPTURE_LAYER_CONTENT_SUPPORT
 982     {
 983         unsigned int i;
 984         unsigned char a[13];
 985
 986         a[0] = 'm';
 987         a[1] = 't';
 988         a[2] = 'k';
 989         a[3] = 'f';
 990         a[4] = 'b';
 991         a[5] = '_';
 992         a[6] = 'l';
 993         a[7] = 'a';
 994         a[8] = 'y';
 995         a[9] = 'e';
 996         a[10] = 'r';
 997         a[11] = '0';
 998         a[12] = '\0';
 999
1000         for(i=0;i<DDP_OVL_LAYER_MUN;i++)
1001         {
1002             a[11] = '0' + i;
1003             mtkfb_layer_dbg_opt[i].layer_index = i;
1004             mtkfb_layer_dbgfs[i] = debugfs_create_file(a,
1005                 S_IFREG|S_IRUGO, NULL, (void *)&mtkfb_layer_dbg_opt[i], &layer_debug_fops);
1006         }
1007     }
1008 #endif
1009 }
1010
1011
1012 void DBG_Deinit(void)
1013 {
1014     debugfs_remove(mtkfb_dbgfs);
1015 #ifdef MTKFB_DEBUG_FS_CAPTURE_LAYER_CONTENT_SUPPORT
1016     {
1017         unsigned int i;
1018
1019         for(i=0;i<DDP_OVL_LAYER_MUN;i++)
1020             debugfs_remove(mtkfb_layer_dbgfs[i]);
1021     }
1022 #endif
1023 }
1024