/*
*
* 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;
}
