/* * * Function Name: DSI_Atomic_Update * * Description: * */ Int32 DSI_Atomic_Update( DISPDRV_HANDLE_T drvH, void *buff, DISPDRV_WIN_t *p_win) { DispDrv_PANEL_t *pPanel = (DispDrv_PANEL_t *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; DSI_INFO("+\n"); if (pPanel->pwrState == STATE_PWR_OFF) { DSI_ERR("Skip Due To Power State\n"); return -1; } if (p_win == NULL) p_win = &pPanel->win_dim; CSL_DSI_Force_Stop(pPanel->dsiCmVcHandle); CSL_DSI_Lock(pPanel->dsiCmVcHandle); csl_dma_lock(); DSI_WinSet(drvH, TRUE, p_win); req.buff = buff; req.lineLenP = p_win->w; req.lineCount = p_win->h; req.buffBpp = pPanel->disp_info->Bpp; req.timeOut_ms = pPanel->disp_info->vmode ? MAX_SCHEDULE_TIMEOUT : 100; req.xStrideB = 0; req.cslLcdCbRec.cslH = pPanel->clientH; req.cslLcdCbRec.dispDrvApiCbRev = DISP_DRV_CB_API_REV_1_0; req.cslLcdCbRec.dispDrvApiCb = NULL; req.cslLcdCbRec.dispDrvApiCbP1 = NULL; req.cslLcdCb = NULL; DSI_INFO("buf=%08x, linelenp = %lu, linecnt =%lu\n", (u32)req.buff, req.lineLenP, req.lineCount); if (pPanel->disp_info->vmode) res = CSL_DSI_UpdateVmVc(pPanel->dsiCmVcHandle, &req); else res = CSL_DSI_UpdateCmVc(pPanel->dsiCmVcHandle, &req, pPanel->isTE); if (res != CSL_LCD_OK) { DSI_ERR("ERROR ret by CSL_DSI_UpdateCmVc\n"); res = -1; } DSI_INFO("-\n"); csl_dma_unlock(); CSL_DSI_Unlock(pPanel->dsiCmVcHandle); return res; }
//***************************************************************************** // // Function Name: _Update // // Description: DMA/OS Update using INT frame buffer // //***************************************************************************** Int32 DISPDRV_Update ( DISPDRV_HANDLE_T drvH, int fb_idx, DISPDRV_WIN_t* p_win, DISPDRV_CB_T apiCb ) { DISPDRV_PANEL_T *pPanel = (DISPDRV_PANEL_T *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; // LCD_DBG ( LCD_DBG_ID, "[DISPDRV] +%s\r\n", __FUNCTION__ ); DISPDRV_CHECK_PTR_2_RET( drvH, &panel[0], &panel[1], __FUNCTION__ ); if ( pPanel->pwrState != DISP_PWR_SLEEP_OFF ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] +%s: Skip Due To Power State\r\n",__FUNCTION__ ); return ( -1 ); } if (0 == fb_idx) req.buff = pPanel->pFbA; else req.buff = (void *)((UInt32)pPanel->pFbA + Disp_Info.width * Disp_Info.height * 2); //@HW // req.buff = pPanel->pFbA; req.lineLenP = Disp_Info.width; req.lineCount = Disp_Info.height; req.buffBpp = 2; //4; //@HW req.timeOut_ms = 100; // SKC 1000 LCD_DBG ( LCD_DBG_ID, "buf=%08x, linelenp = %d, linecnt =%d\n", (u32)req.buff, (u32)req.lineLenP, (u32)req.lineCount); req.cslLcdCbRec.cslH = pPanel->clientH; req.cslLcdCbRec.dispDrvApiCbRev = DISP_DRV_CB_API_REV_1_0; req.cslLcdCbRec.dispDrvApiCb = (void*) apiCb; req.cslLcdCbRec.dispDrvApiCbP1 = NULL; if( apiCb != NULL ) req.cslLcdCb = DISPDRV_Cb; else req.cslLcdCb = NULL; //if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req, FALSE ) != CSL_LCD_OK ) if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req, pPanel->isTE ) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } // LCD_DBG ( LCD_DBG_ID, "[DISPDRV] -%s\r\n", __FUNCTION__ ); return ( res ); }
//***************************************************************************** // // Function Name: _Update // // Description: DMA/OS Update using INT frame buffer // //***************************************************************************** Int32 DISPDRV_Update(DISPDRV_HANDLE_T drvH, void *buff, DISPDRV_WIN_t *p_win, DISPDRV_CB_T apiCb) { DISPDRV_PANEL_T *pPanel = (DISPDRV_PANEL_T *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; // LCD_DBG ( LCD_DBG_ID, "[DISPDRV] +%s\r\n", __FUNCTION__ ); if (pPanel->pwrState == STATE_PWR_OFF) { LCD_DBG(LCD_DBG_ERR_ID, "[DISPDRV] +%s: Skip Due To Power State\r\n", __FUNCTION__); return (-1); } req.buff = buff; req.lineLenP = pPanel->disp_info->width; req.lineCount = pPanel->disp_info->height; req.buffBpp = pPanel->disp_info->Bpp; req.timeOut_ms = 100; LCD_DBG(LCD_DBG_ID, "buf=%08x, linelenp = %d, linecnt =%d\n", (u32)req.buff, (u32)req.lineLenP, (u32)req.lineCount); req.cslLcdCbRec.cslH = pPanel->clientH; req.cslLcdCbRec.dispDrvApiCbRev = DISP_DRV_CB_API_REV_1_0; req.cslLcdCbRec.dispDrvApiCb = (void *)apiCb; req.cslLcdCbRec.dispDrvApiCbP1 = NULL; if (apiCb != NULL) req.cslLcdCb = DISPDRV_Cb; else req.cslLcdCb = NULL; if((panelID== LCD_PANEL_ID_READ_ERROR)||(panelID==LCD_PANEL_ID_NOT_SET)) { // printk("[LCD] %s, There are no LCD module\n", __func__); if (req.cslLcdCb != NULL) DISPDRV_Cb(CSL_LCD_OK, &req.cslLcdCbRec); return 0; } //if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req, FALSE ) != CSL_LCD_OK ) if (CSL_DSI_UpdateCmVc(pPanel->dsiCmVcHandle, &req, pPanel->isTE) != CSL_LCD_OK) { LCD_DBG(LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__); res = -1; } // LCD_DBG ( LCD_DBG_ID, "[DISPDRV] -%s\r\n", __FUNCTION__ ); return (res); }
//***************************************************************************** // // Function Name: dsic_send_data // // Description: DMA/OS Update using INT frame buffer // //***************************************************************************** Int32 dsic_send_data ( DISPDRV_HANDLE_T drvH, int fb_idx, DISPDRV_CB_T apiCb, int img_width, int img_height ) { dsic_panel_t *pPanel = (dsic_panel_t *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; //LCD_DBG ( LCD_DBG_ID, "[DISPDRV] +%s\r\n", __FUNCTION__ ); if ( pPanel->pwrState != DISP_PWR_SLEEP_OFF ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] +%s: Skip Due To Power State\r\n", __FUNCTION__ ); return ( -1 ); } if (0 == fb_idx) req.buff = pPanel->pFbA; else req.buff = (void *)((UInt32)pPanel->pFbA + DSI_Display_Info.width * DSI_Display_Info.height * INPUT_BPP); req.lineLenP = img_width; req.lineCount = img_height; req.buffBpp = INPUT_BPP; req.timeOut_ms = 100; req.multiLLI = false; //printk(KERN_ERR "SSSSK buf=%08x, linelenp = %d, linecnt =%d\n", (u32)req.buff, req.lineLenP, req.lineCount); req.cslLcdCbRef = NULL; dispdrv_cb = apiCb; if( apiCb != NULL ) req.cslLcdCb = dsi_cb; else req.cslLcdCb = NULL; dsi_setwindow(drvH); if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req ) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } //LCD_DBG ( LCD_DBG_ID, "[DISPDRV] -%s\r\n", __FUNCTION__ ); return ( res ); }
//***************************************************************************** // // Function Name: DISPDRV__Update_ExtFb // // Description: DMA/OS Update using EXT frame buffer // //***************************************************************************** Int32 DISPDRV_Update_ExtFb ( DISPDRV_HANDLE_T drvH, void *pFb, DISPDRV_CB_API_1_1_T apiCb ) { DISPDRV_PANEL_T *pPanel = (DISPDRV_PANEL_T *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; LCD_DBG ( LCD_DBG_ID, "[DISPDRV] +%s\r\n", __FUNCTION__ ); DISPDRV_CHECK_PTR_2_RET( drvH, &panel[0], &panel[1], __FUNCTION__ ); if ( pPanel->pwrState != DISP_PWR_SLEEP_OFF ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] +%s: Skip Due To Power State\r\n", __FUNCTION__ ); return ( -1 ); } req.buff = pFb; req.lineLenP = Disp_Info.width; req.lineCount = Disp_Info.height; req.buffBpp = 2; //4; //@HW req.timeOut_ms = 100; // SKC 1000 req.cslLcdCbRec.cslH = pPanel->clientH; req.cslLcdCbRec.dispDrvApiCbRev = DISP_DRV_CB_API_REV_1_1; req.cslLcdCbRec.dispDrvApiCb = (void*) apiCb; req.cslLcdCbRec.dispDrvApiCbP1 = pFb; if( apiCb != NULL ) req.cslLcdCb = DISPDRV_Cb; else req.cslLcdCb = NULL; if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req, FALSE ) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } LCD_DBG ( LCD_DBG_ID, "[DISPDRV] -%s\n\r", __FUNCTION__ ); return ( res ); }
//***************************************************************************** // // Function Name: dsic_update // // Description: DMA/OS Update using INT frame buffer // Call this only when the full frame update is required. // //***************************************************************************** Int32 dsic_update ( DISPDRV_HANDLE_T drvH, int fb_idx, DISPDRV_CB_T apiCb ) { dsic_panel_t *pPanel = (dsic_panel_t *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; bool multiLLI_Set = true; OSDAL_Dma_Buffer_List *buffer_list=NULL, *temp_list=NULL; //LCD_DBG ( LCD_DBG_ID, "[DISPDRV] +%s\r\n", __FUNCTION__ ); if ( pPanel->pwrState != DISP_PWR_SLEEP_OFF ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] +%s: Skip Due To Power State\r\n", __FUNCTION__ ); return ( -1 ); } if(multiLLI_Set == true) { void* src_buff = NULL; int i=0; buffer_list = kzalloc((DSI_Display_Info.height) * sizeof(OSDAL_Dma_Buffer_List), GFP_KERNEL); if (!buffer_list) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] +%s: Could not allocate memory\r\n", __FUNCTION__ ); goto done; } if (0 == fb_idx) src_buff = pPanel->pFbA; else src_buff = (void *)((UInt32)pPanel->pFbA + DSI_Display_Info.width * DSI_Display_Info.height * INPUT_BPP); temp_list = buffer_list; for (i = 0; i < DSI_Display_Info.height; i++) { temp_list->buffers[0].srcAddr = (UInt32)src_buff + (i * DSI_Display_Info.width * INPUT_BPP); temp_list->buffers[0].destAddr = 0x084a0140; temp_list->buffers[0].length = DSI_Display_Info.width * INPUT_BPP; temp_list->buffers[0].bRepeat = 0; temp_list++; } temp_list--; /* Go back to the last list item to set interrupt = 1 */ temp_list->buffers[0].interrupt = 1; req.buff = (void *)buffer_list; req.multiLLI = true; } else if( multiLLI_Set == false) { if (0 == fb_idx) req.buff = pPanel->pFbA; else req.buff = (void *)((UInt32)pPanel->pFbA + DSI_Display_Info.width * DSI_Display_Info.height * INPUT_BPP); req.multiLLI = false; } req.lineLenP = DSI_Display_Info.width; req.lineCount = DSI_Display_Info.height; req.buffBpp = INPUT_BPP; req.timeOut_ms = 100; //printk(KERN_ERR "buf=%08x, linelenp = %d, linecnt =%d\n", (u32)req.buff, req.lineLenP, req.lineCount); req.cslLcdCbRef = NULL; dispdrv_cb = apiCb; if( apiCb != NULL ) req.cslLcdCb = dsi_cb; else req.cslLcdCb = NULL; pPanel->col_start = 0; pPanel->col_end = (DSI_Display_Info.width -1); pPanel->row_start = 0; pPanel->row_end = (DSI_Display_Info.height-1); dsi_setwindow(drvH); if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req ) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } fail: if(buffer_list) kfree(buffer_list); done: //LCD_DBG ( LCD_DBG_ID, "[DISPDRV] -%s\r\n", __FUNCTION__ ); return ( res ); }
//***************************************************************************** // // Function Name: dsic_dirty_rect_update // // Description: DMA/OS Update using INT frame buffer // //***************************************************************************** Int32 dsic_dirty_rect_update ( DISPDRV_HANDLE_T drvH, lcd_drv_rect_t * dirtyRect, DISPDRV_CB_T apiCb ) { dsic_panel_t *pPanel = (dsic_panel_t *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; Int32 i; Int32 err = -EINVAL; OSDAL_Dma_Buffer_List *buffer_list, *temp_list; //LCD_DBG ( LCD_DBG_ID, "[DISPDRV] +%s\r\n", __FUNCTION__ ); if ( pPanel->pwrState != DISP_PWR_SLEEP_OFF ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] +%s: Skip Due To Power State\r\n", __FUNCTION__ ); return ( -1 ); } if(!dirtyRect) { pr_info("dirtyRect pointer is NULL\n"); return -1; } if ((dirtyRect->top > dirtyRect->bottom) || ((dirtyRect->bottom - dirtyRect->top) >= DSI_Display_Info.height) || (dirtyRect->left > dirtyRect->right) || ((dirtyRect->right - dirtyRect->left) >= DSI_Display_Info.width)) { LCD_DBG("invalid dirty-rows params - ignoring\n"); LCD_DBG("top = %u, bottom = %u, left = %u, right = %u\n", dirtyRect->top, dirtyRect->bottom, dirtyRect->left, dirtyRect->right); return -1; } pPanel->win = *dirtyRect; pPanel->row_start = pPanel->win.top % DSI_Display_Info.height; pPanel->row_end = pPanel->win.bottom % DSI_Display_Info.height; pPanel->win.width = DSI_Display_Info.width; pPanel->win.height = DSI_Display_Info.height; /*If start address is aligned to odd boundary */ if (is_unaligned(pPanel)) { pPanel->col_start = pPanel->win.left; pPanel->col_end = pPanel->win.left; dsi_setwindow(drvH); dsi_update_column(pPanel, pPanel->win.left,NULL); pPanel->win.left += 1; } /*If length is odd multiple */ if (is_odd_stride(pPanel) || (is_odd_total(pPanel))) { pPanel->col_start = pPanel->win.right; pPanel->col_end = pPanel->win.right; dsi_setwindow(drvH); dsi_update_column(pPanel, pPanel->win.right,NULL); pPanel->win.right -= 1; } if (is_out_of_bounds(pPanel) || (is_tx_done_16(pPanel)) || (is_tx_done_32(pPanel))) { /* Dirty columns have been transferred. No further processing required.*/ goto done; } buffer_list = kzalloc((pPanel->win.bottom - pPanel->win.top + 1) * sizeof(OSDAL_Dma_Buffer_List), GFP_KERNEL); if (!buffer_list) { pr_info("Couldn't allocate memory for dma buffer list\n"); goto done; } temp_list = buffer_list; for (i = pPanel->win.top; i <= pPanel->win.bottom; i++) { temp_list->buffers[0].srcAddr = (UInt32)pPanel->pFbA + (i * DSI_Display_Info.width + pPanel->win.left) * INPUT_BPP; temp_list->buffers[0].destAddr = 0x084a0140; temp_list->buffers[0].length = (pPanel->win.right - pPanel->win.left +1) * INPUT_BPP; temp_list->buffers[0].bRepeat = 0; temp_list++; } temp_list--; /* Go back to the last list item to set interrupt = 1 */ temp_list->buffers[0].interrupt = 1; req.buff = (void *)buffer_list; req.buffBpp = INPUT_BPP; req.lineLenP = pPanel->win.right - pPanel->win.left + 1; req.lineCount = pPanel->win.bottom - pPanel->win.top + 1; req.timeOut_ms = 100; req.multiLLI = true; req.cslLcdCbRef = NULL; dispdrv_cb = apiCb; if( apiCb != NULL ) req.cslLcdCb = dsi_cb; else req.cslLcdCb = NULL; pPanel->col_start = pPanel->win.left; pPanel->col_end = pPanel->win.right; dsi_setwindow(drvH); if ( CSL_DSI_UpdateCmVc ( pPanel->dsiCmVcHandle, &req ) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } done: //LCD_DBG ( LCD_DBG_ID, "[DISPDRV] -%s\r\n", __FUNCTION__ ); kfree(buffer_list); return ( res ); }
/**************************************************************************** * * dsi_update_column * * Update one column of LCD in non-DMA mode within dirty region. * DMA mode is also implemented * * ***************************************************************************/ static int dsi_update_column( dsic_panel_t * dev, unsigned int column, DISPDRV_CB_T apiCb ) { int i, stride; uint32_t *source; Int32 res = 0; CSL_LCD_UPD_REQ_T req; uint32_t count; #ifdef LCD_COLUMN_UPDATE_CPU unsigned int data_buff[480]; #endif #ifdef LCD_COLUMN_UPDATE_DMA OSDAL_Dma_Buffer_List *buffer_list, *temp_list; #endif stride = DSI_Display_Info.width * INPUT_BPP; source = (u32)(phys_to_virt(dev->pFbA)) + stride * dev->win.top + column * INPUT_BPP; if (4 == INPUT_BPP) { count = (dev->win.bottom - dev->win.top + 1); count &= ~1; //Ignore one pixel in case count is odd #ifdef LCD_COLUMN_UPDATE_DMA buffer_list = kzalloc((dev->win.bottom - dev->win.top + 1) * sizeof(OSDAL_Dma_Buffer_List), GFP_KERNEL); if (!buffer_list) { pr_info("Couldn't allocate memory for dma buffer list\n"); goto done; } temp_list = buffer_list; for (i = 0; i < count; i++) { temp_list->buffers[0].srcAddr = source; temp_list->buffers[0].destAddr = 0x084a0140; temp_list->buffers[0].length = 1 * INPUT_BPP; temp_list->buffers[0].bRepeat = 0; temp_list++; source += stride; } temp_list--; /* Go back to the last list item to set interrupt = 1 */ temp_list->buffers[0].interrupt = 1; req.buff = (void *)buffer_list; req.lineLenP = 1; req.lineCount = count; req.buffBpp = INPUT_BPP; req.timeOut_ms = 100; req.multiLLI = true; req.cslLcdCbRef = NULL; dispdrv_cb = apiCb; if( apiCb != NULL ) req.cslLcdCb = dsi_cb; else req.cslLcdCb = NULL; if ( CSL_DSI_UpdateCmVc ( dev->dsiCmVcHandle, &req ) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } #endif #ifdef LCD_COLUMN_UPDATE_CPU for (i = 0; i < count; i++) { data_buff[i] = *source; source += stride; } req.lineLenP =1; req.lineCount =count; req.cslLcdCbRef = NULL; dispdrv_cb = apiCb; if( apiCb != NULL ) req.cslLcdCb = dsi_cb; else req.cslLcdCb =NULL; if( CSL_DSI_CPU_UpdateCmVc(dev->dsiCmVcHandle, &req,data_buff) != CSL_LCD_OK ) { LCD_DBG ( LCD_DBG_ERR_ID, "[DISPDRV] %s: ERROR ret by " "CSL_DSI_UpdateCmVc\n\r", __FUNCTION__ ); res = -1; } #endif } else { pr_info("bpp=%d is not supported\n", INPUT_BPP); } #ifdef LCD_COLUMN_UPDATE_DMA done : kfree(buffer_list); #endif return ( res ); }
/* * * Function Name: DSI_Update * * Description: * */ Int32 DSI_Update( DISPDRV_HANDLE_T drvH, void *buff, DISPDRV_WIN_t *p_win, DISPDRV_CB_T apiCb) { DispDrv_PANEL_t *pPanel = (DispDrv_PANEL_t *)drvH; CSL_LCD_UPD_REQ_T req; Int32 res = 0; uint32_t offset; DSI_INFO("+\n"); if (pPanel->pwrState == STATE_PWR_OFF) { DSI_ERR("Skip Due To Power State\n"); return -1; } if (p_win == NULL) p_win = &pPanel->win_dim; DSI_INFO("%d %d %d %d\n", p_win->l, p_win->r, p_win->t, p_win->b); DSI_WinSet(drvH, TRUE, p_win); offset = (uint32_t)buff; offset += (p_win->t * pPanel->disp_info->width + p_win->l) * pPanel->disp_info->Bpp; req.buff = (uint32_t *)offset; req.lineLenP = p_win->w; req.lineCount = p_win->h; req.xStrideB = pPanel->disp_info->width - p_win->w; req.buffBpp = pPanel->disp_info->Bpp; req.timeOut_ms = pPanel->disp_info->vmode ? MAX_SCHEDULE_TIMEOUT : 3000; req.cslLcdCbRec.cslH = pPanel->clientH; req.cslLcdCbRec.dispDrvApiCbRev = DISP_DRV_CB_API_REV_1_0; req.cslLcdCbRec.dispDrvApiCb = (void *) apiCb; req.cslLcdCbRec.dispDrvApiCbP1 = NULL; DSI_INFO("buf=%08x, linelenp = %lu, linecnt =%lu\n", (u32)req.buff, req.lineLenP, req.lineCount); if (apiCb != NULL) req.cslLcdCb = DSI_Cb; else req.cslLcdCb = NULL; if (pPanel->disp_info->vmode) res = CSL_DSI_UpdateVmVc(pPanel->dsiCmVcHandle, &req); else res = CSL_DSI_UpdateCmVc(pPanel->dsiCmVcHandle, &req, pPanel->isTE); if (res != CSL_LCD_OK) { DSI_ERR("ERROR ret by CSL_DSI_UpdateCmVc\n"); res = -1; DSI_Cb(res, &req.cslLcdCbRec); } DSI_INFO("-\n"); return res; }