static uint32 mipi_himax_manufacture_id(void)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 *lp;
int i;
char *cp;
tp = &himax_tx_buf;
rp = &himax_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &himax_manufacture_id_cmd;
mipi_dsi_cmds_rx(tp, rp, cmd, 3);
cp = (char *)rp->data;
PR_DISP_DEBUG("rx-data: ");
for (i = 0; i < rp->len; i++, cp++)
PR_DISP_DEBUG("%x ", *cp);
PR_DISP_DEBUG("\n");
lp = (uint32 *)rp->data;
PR_DISP_DEBUG("%s: manu_id=%x", __func__, *lp);
return *lp;
}
/**
* Read a bridge register
*
* @param mfd
*
* @return register data value
*/
static u32 mipi_d2l_read_reg(struct msm_fb_data_type *mfd, u16 reg)
{
u32 data;
int len = 4;
struct dsi_cmd_desc cmd_read_reg = {
DTYPE_GEN_READ2, 1, 0, 1, 0, /* cmd 0x24 */
sizeof(reg), (char *) ®};
mipi_dsi_buf_init(&d2l_tx_buf);
mipi_dsi_buf_init(&d2l_rx_buf);
mutex_lock(&mfd->dma->ov_mutex);
len = mipi_dsi_cmds_rx(mfd, &d2l_tx_buf, &d2l_rx_buf,
&cmd_read_reg, len);
mutex_unlock(&mfd->dma->ov_mutex);
data = *(u32 *)d2l_rx_buf.data;
if (len != 4)
pr_err("%s: invalid rlen=%d, expecting 4.\n", __func__, len);
pr_debug("%s: reg=0x%x.data=0x%08x.\n", __func__, reg, data);
return data;
}
static uint32 mipi_samsung_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 id_size;
char id[3];
mutex_lock(&dsi_tx_mutex);
id_size = 3;
tp = &msd.samsung_tx_buf;
rp = &msd.samsung_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id1_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, id_size);
id[0] = *rp->data;
id[1] = *(rp->data + 1);
id[2] = *(rp->data + 2);
mutex_unlock(&dsi_tx_mutex);
pr_info("%s id0: 0x%x, id1: 0x%x, id2: 0x%x", __func__,
id[0], id[1], id[2]);
return id[0] << 16 | id[1] << 8 | id[2] ;
}
static uint32 mipi_orise_manufacture_id(void)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 *lp;
tp = &orise_tx_buf;
rp = &orise_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &orise_manufacture_id_cmd;
mipi_dsi_cmds_rx(tp, rp, cmd, 3);
{
int i;
char *cp;
cp = (char *)rp->data;
printk("rx-data: ");
for (i = 0; i < rp->len; i++, cp++)
printk("%x ", *cp);
printk("\n");
}
lp = (uint32 *)rp->data;
printk("%s: manu_id=%x", __func__, *lp);
return *lp;
}
static int mipi_nt35565_ic_on_disp_on(struct msm_fb_data_type *mfd)
{
struct mipi_dsi_data *dsi_data;
struct dsi_controller *pctrl;
dsi_data = platform_get_drvdata(mfd->panel_pdev);
if (!dsi_data)
return -ENODEV;
pctrl = dsi_data->panel->pctrl;
if (!dsi_data->panel_detecting) {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
if (dsi_data->eco_mode_on && pctrl->display_on_eco_cmds) {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf,
pctrl->display_on_eco_cmds,
pctrl->display_on_eco_cmds_size);
dev_info(&mfd->panel_pdev->dev, "ECO MODE ON\n");
} else {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf,
pctrl->display_on_cmds,
pctrl->display_on_cmds_size);
dev_info(&mfd->panel_pdev->dev, "ECO MODE OFF\n");
}
}
return 0;
}
/*
* mipi_dsi_cmds_tx:
* ov_mutex need to be acquired before call this function.
*/
int mipi_dsi_cmds_tx(struct msm_fb_data_type *mfd,
struct dsi_buf *tp, struct dsi_cmd_desc *cmds, int cnt)
{
struct dsi_cmd_desc *cm;
uint32 dsi_ctrl, ctrl;
int i, video_mode;
int length_tx;
int ret;
/* turn on cmd mode
* for video mode, do not send cmds more than
* one pixel line, since it only transmit it
* during BLLP.
*/
dsi_ctrl = MIPI_INP(MIPI_DSI_BASE + 0x0000);
video_mode = dsi_ctrl & 0x02; /* VIDEO_MODE_EN */
if (video_mode) {
ctrl = dsi_ctrl | 0x04; /* CMD_MODE_EN */
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, ctrl);
} else { /* cmd mode */
/*
* during boot up, cmd mode is configured
* even it is video mode panel.
*/
/* make sure mdp dma is not txing pixel data */
if (mfd->panel_info.type == MIPI_CMD_PANEL)
mdp4_dsi_cmd_dma_busy_wait(mfd);
}
mipi_dsi_enable_irq();
cm = cmds;
mipi_dsi_buf_init(tp);
for (i = 0; i < cnt; i++) {
mipi_dsi_buf_init(tp);
mipi_dsi_cmd_dma_add(tp, cm);
length_tx = mipi_dsi_cmd_dma_tx(tp);
if( length_tx < 0 ) // if failed
{
pr_err(" mipi_dsi_cmd_dma_tx FAILED, %d/%d(%x %x %x %x)\n",
i, cnt, cm->payload[0], cm->payload[1], cm->payload[2], cm->payload[3]);
break;
}
if (cm->wait)
msleep(cm->wait);
cm++;
}
ret = i;
mipi_dsi_disable_irq();
if (video_mode)
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, dsi_ctrl); /* restore */
return ret;
}
static uint32 mipi_samsung_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
tp = &panel_tx_buf;
rp = &panel_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id_cmd;
return 0;
}
static int mipi_get_manufacture_icid(struct msm_fb_data_type *mfd)
{
uint32 icid = 0;
int i ;
struct mipi_manufacture_ic mipi_manufacture_icid[3] = {
{hx8363_setpassword_cmd,ARRAY_SIZE(hx8363_setpassword_cmd),&hx8363_icid_rd_cmd,3,1},
{nt3511_setpassword_cmd,ARRAY_SIZE(nt3511_setpassword_cmd),&nt3511_icid_rd_cmd,3,0},
{hx8369_setpassword_cmd,ARRAY_SIZE(hx8369_setpassword_cmd),&hx8369_icid_rd_cmd,3,1},
};
for(i = 0; i < ARRAY_SIZE(mipi_manufacture_icid) ; i++)
{ lcd_panle_reset();
mipi_dsi_buf_init(&lead_tx_buf);
mipi_dsi_buf_init(&lead_rx_buf);
mipi_set_tx_power_mode(1);
mipi_dsi_cmds_tx(mfd, &lead_tx_buf, mipi_manufacture_icid[i].readid_tx,mipi_manufacture_icid[i].readid_len_tx);
mipi_dsi_cmd_bta_sw_trigger();
if(!mipi_manufacture_icid[i].mode)
mipi_set_tx_power_mode(0);
mipi_dsi_cmds_rx(mfd,&lead_tx_buf, &lead_rx_buf, mipi_manufacture_icid[i].readid_rx,mipi_manufacture_icid[i].readid_len_rx);
if(mipi_manufacture_icid[i].mode)
mipi_set_tx_power_mode(0);
icid = *(uint32 *)(lead_rx_buf.data);
printk("debug read icid is %x\n",icid & 0xffffff);
switch(icid & 0xffffff){
case 0x1055:
return NOVATEK_35510;
case 0x6383ff:
return HIMAX_8363;
case 0x6983ff:
return HIMAX_8369;
default:
break;
}
}
return 0;
}
int mipi_smd_oled_hd_register_write_cmd( struct msm_fb_data_type *mfd,
struct msmfb_register_write *data )
{
char send_data[255];
struct dsi_cmd_desc param;
mipi_dsi_buf_init(&smd_oled_hd_tx_buf);
memcpy(send_data, (char*)(&data->data[0]), data->len);
param.dtype = (int)data->di;
param.last = 1;
param.vc = 0;
param.ack = 0;
param.wait = 0;
param.dlen = (int)data->len;
param.payload = send_data;
mipi_dsi_cmds_tx(&smd_oled_hd_tx_buf, ¶m, 1);
return 0;
}
void mipi_dsi_set_tear_off(struct msm_fb_data_type *mfd)
{
mutex_lock(&mfd->dma->ov_mutex);
mipi_dsi_buf_init(&dsi_tx_buf);
mipi_dsi_cmds_tx(mfd, &dsi_tx_buf, &dsi_tear_off_cmd, 1);
mutex_unlock(&mfd->dma->ov_mutex);
}
static int mipi_r63306_disp_off(struct msm_fb_data_type *mfd)
{
int ret = 0;
struct mipi_dsi_data *dsi_data;
dsi_data = platform_get_drvdata(mfd->panel_pdev);
if (!dsi_data || !dsi_data->lcd_power)
return -ENODEV;
if (!dsi_data->panel_detecting) {
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(&dsi_data->tx_buf,
dsi_data->panel->pctrl->display_off_cmds,
dsi_data->panel->pctrl->display_off_cmds_size);
#ifdef CONFIG_FB_MSM_RECOVER_PANEL
mipi_set_tx_power_mode(1);
#endif
ret = dsi_data->lcd_power(FALSE);
} else {
dsi_data->panel_detecting = false;
ret = 0;
}
return ret;
}
static int mipi_orise_rd(struct msm_fb_data_type *mfd, char addr)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
int *lp;
addr_buf[0] = addr;
tp = &orise_tx_buf;
rp = &orise_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &cmd_mipi_addr_buf;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 4);
lp = (uint32 *)rp->data;
pr_info("mipi_orise_rd addr=%x, data=%x\n", addr, *lp);
return *lp;
}
static int mipi_orise_manufacture_id(struct msm_fb_data_type *mfd)
{
char retDA = 0;
struct dsi_buf *tp = &orise_tx_buf;
struct dsi_buf *rp = &orise_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
mipi_dsi_cmds_rx(mfd, tp, rp, &orise_ReadDA, 1);
retDA = *((char *) rp->data);
printk(KERN_ALERT "[DISPLAY] Panel ID <0x%02x>\n", retDA);
return retDA;
}
void mipi_dsi_set_tear_off(void)
{
mutex_lock(&dsi_mutex);
mipi_dsi_buf_init(&dsi_tx_buf);
mipi_dsi_cmds_tx(&dsi_tx_buf, &dsi_tear_off_cmd, 1);
mutex_unlock(&dsi_mutex);
}
static uint32 mipi_get_commic_panleid(struct msm_fb_data_type *mfd,struct dsi_cmd_desc *para,uint32 len,int mode)
{
uint32 panelid = 0;
mipi_dsi_buf_init(&lead_tx_buf);
mipi_dsi_buf_init(&lead_rx_buf);
mipi_dsi_cmd_bta_sw_trigger();
if(mode)
mipi_set_tx_power_mode(1);
else
mipi_set_tx_power_mode(0);
mipi_dsi_cmds_rx(mfd,&lead_tx_buf, &lead_rx_buf, para,len);
if(mode)
mipi_set_tx_power_mode(0);
panelid = *(uint32 *)(lead_rx_buf.data);
printk("debug read panelid is %x\n",panelid & 0xffffffff);
return panelid & 0xff;
}
static int mipi_r63306_disp_on(struct msm_fb_data_type *mfd)
{
int ret = 0;
struct mipi_dsi_data *dsi_data;
struct dsi_controller *pctrl;
dsi_data = platform_get_drvdata(mfd->panel_pdev);
if (!dsi_data || !dsi_data->lcd_power) {
ret = -ENODEV;
goto disp_on_fail;
}
pctrl = dsi_data->panel->pctrl;
if (!dsi_data->panel_detecting) {
ret = dsi_data->lcd_power(TRUE);
if (ret)
goto disp_on_fail;
mipi_dsi_op_mode_config(DSI_CMD_MODE);
if (pctrl->display_init_cmds) {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf,
pctrl->display_init_cmds,
pctrl->display_init_cmds_size);
}
if (dsi_data->eco_mode_on && pctrl->display_on_eco_cmds) {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf,
pctrl->display_on_eco_cmds,
pctrl->display_on_eco_cmds_size);
dev_info(&mfd->panel_pdev->dev, "ECO MODE ON\n");
} else {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(mfd, &dsi_data->tx_buf,
pctrl->display_on_cmds,
pctrl->display_on_cmds_size);
dev_info(&mfd->panel_pdev->dev, "ECO MODE OFF\n");
}
}
disp_on_fail:
return ret;
}
/*
* mipi_dsi_cmds_tx:
* ov_mutex need to be acquired before call this function.
*/
int mipi_dsi_cmds_tx(struct msm_fb_data_type *mfd,
struct dsi_buf *tp, struct dsi_cmd_desc *cmds, int cnt)
{
struct dsi_cmd_desc *cm;
uint32 dsi_ctrl, ctrl;
int i, video_mode;
/* turn on cmd mode
* for video mode, do not send cmds more than
* one pixel line, since it only transmit it
* during BLLP.
*/
dsi_ctrl = MIPI_INP(MIPI_DSI_BASE + 0x0000);
video_mode = dsi_ctrl & 0x02; /* VIDEO_MODE_EN */
if (video_mode) {
ctrl = dsi_ctrl | 0x04; /* CMD_MODE_EN */
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, ctrl);
} else { /* cmd mode */
/*
* during boot up, cmd mode is configured
* even it is video mode panel.
*/
/* make sure mdp dma is not txing pixel data */
#ifndef CONFIG_FB_MSM_MIPI_DSI_MAGNA
if (mfd->panel_info.type == MIPI_CMD_PANEL)
mdp4_dsi_cmd_dma_busy_wait(mfd);
#endif
}
cm = cmds;
mipi_dsi_buf_init(tp);
for (i = 0; i < cnt; i++) {
mipi_dsi_buf_init(tp);
mipi_dsi_cmd_dma_add(tp, cm);
mipi_dsi_cmd_dma_tx(tp);
if (cm->wait)
msleep(cm->wait);
cm++;
}
if (video_mode)
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, dsi_ctrl); /* restore */
return cnt;
}
static uint32 protou_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 *lp;
tp = &protou_panel_tx_buf;
rp = &protou_panel_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &lg_manufacture_id_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 3);
lp = (uint32 *)rp->data;
PR_DISP_INFO("%s: manufacture_id=%x\n", __func__, *lp);
return *lp;
}
static void read_error_register(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT)
char *cmd_lp;
#else
struct dsi_cmd_desc *cmd;
#endif
wake_lock(&idle_wake_lock);
#if CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT
mutex_lock(&mipi_lp_mutex);
#endif
mutex_lock(&mfd->dma->ov_mutex);
mipi_dsi_mdp_busy_wait();
tp = &msd.samsung_tx_buf;
rp = &msd.samsung_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT)
cmd_lp = &error_id2_cmd;
mipi_dsi_cmds_rx_lp(mfd, tp, rp, cmd_lp, 1);
error_buf[0] = *rp->data;
mipi_dsi_cmds_rx_lp(mfd, tp, rp, cmd_lp, 1);
pr_debug("############ error buf E5 = %x\n", error_buf[0]);
#else
cmd = &error_id2_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
error_buf[0] = *rp->data;
pr_debug("############ error buf E5 %x\n", error_buf[0]);
#endif
mutex_unlock(&mfd->dma->ov_mutex);
#if CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT
mutex_unlock(&mipi_lp_mutex);
#endif
wake_unlock(&idle_wake_lock);
}
static int panel_id_reg_check(struct msm_fb_data_type *mfd, struct dsi_buf *ptx,
struct dsi_buf *prx, const struct panel_id* panel)
{
int i;
mutex_lock(&mfd->dma->ov_mutex);
mipi_dsi_buf_init(prx);
mipi_dsi_buf_init(ptx);
mipi_dsi_cmds_rx(mfd, ptx, prx, panel->pctrl->read_id_cmds,
panel->id_num);
mutex_unlock(&mfd->dma->ov_mutex);
for (i = 0; i < panel->id_num; i++) {
if ((i >= prx->len) ||
((prx->data[i] != panel->id[i]) &&
(panel->id[i] != 0xff)))
return -ENODEV;
}
return 0;
}
static uint32 mipi_samsung_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
/* uint32 *lp; */
tp = &ville_panel_tx_buf;
rp = &ville_panel_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id_cmd;
/*
//- mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 3);
//- lp = (uint32 *)rp->data;
//- PR_DISP_INFO("%s: manufacture_id=%x\n", __func__, *lp);
//- return *lp;
*/
return 0;
}
int mipi_dsi_cmds_tx(struct dsi_buf *tp, struct dsi_cmd_desc *cmds, int cnt)
{
struct dsi_cmd_desc *cm;
uint32 dsi_ctrl, ctrl;
int i, video_mode;
dsi_mutex_lock();
dsi_busy_check();
/* turn on cmd mode
* for video mode, do not send cmds more than
* one pixel line, since it only transmit it
* during BLLP.
*/
dsi_ctrl = MIPI_INP(MIPI_DSI_BASE + 0x0000);
video_mode = dsi_ctrl & 0x02; /* VIDEO_MODE_EN */
if (video_mode) {
ctrl = dsi_ctrl | 0x04; /* CMD_MODE_EN */
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, ctrl);
}
mipi_dsi_enable_irq();
cm = cmds;
mipi_dsi_buf_init(tp);
for (i = 0; i < cnt; i++) {
mipi_dsi_buf_init(tp);
mipi_dsi_cmd_dma_add(tp, cm);
mipi_dsi_cmd_dma_tx(tp);
if (cm->wait)
hr_msleep(cm->wait);
cm++;
}
mipi_dsi_disable_irq();
if (video_mode)
MIPI_OUTP(MIPI_DSI_BASE + 0x0000, dsi_ctrl); /* restore */
dsi_mutex_unlock();
return cnt;
}
static int mipi_smd_oled_hd_on( struct platform_device *pdev )
{
struct msm_fb_data_type *mfd;
mipi_smd_oled_hd_state_t curr_state;
printk(KERN_INFO "[In]%s. stat:%d \n", __func__, mipi_smd_oled_hd_state);
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
mipi_dsi_buf_init(&smd_oled_hd_tx_buf);
curr_state = mipi_smd_oled_hd_state;
switch (curr_state)
{
case MIPI_SMD_OLED_HD_STATE_OFF :
mipi_smd_oled_hd_initialize_setup(mfd);
mipi_smd_oled_hd_set_display_on(mfd);
mipi_smd_oled_hd_state_transition(curr_state, MIPI_SMD_OLED_HD_STATE_NORMAL_MODE);
break;
case MIPI_SMD_OLED_HD_STATE_READY :
printk(KERN_INFO "%s. Driver Status Error. %d.\n", __func__, curr_state);
break;
case MIPI_SMD_OLED_HD_STATE_STANDBY :
printk(KERN_INFO "%s. Driver Status Error. %d.\n", __func__, curr_state);
break;
case MIPI_SMD_OLED_HD_STATE_NORMAL_MODE :
break;
default :
printk(KERN_ERR "Invalid Status !! %d\n", __LINE__);
break;
}
printk(KERN_INFO "[Out]%s. stat:%d \n", __func__, mipi_smd_oled_hd_state);
return 0;
}
int mipi_smd_oled_hd_read_dev_reg( struct msm_fb_data_type *mfd, struct msmfb_register_read *data)
{
const int one_read_size = 4;
const int loop_limit = 16;
int read_pos = 0;
int readed_size = 0;
int data_cnt = 0;
int i,j;
read_target_reg[0] = (char)data->w_data[0];
packet_size[0] = (char)data->len;
mipi_dsi_cmds_tx(&smd_oled_hd_tx_buf, &(mipi_smd_oled_hd_packet_size_cmd), 1);
for (j = 0; j < loop_limit; j++)
{
read_position[1] = read_pos;
if ( mipi_dsi_cmds_tx(&smd_oled_hd_tx_buf, &(mipi_smd_oled_hd_read_pos_cmd), 1) < 1 )
{
printk(KERN_ERR "%s. mipi_dsi_cmds_tx FAILED.\n", __func__);
return -1;
}
mipi_dsi_op_mode_config(DSI_CMD_MODE);
mipi_dsi_sw_reset();
mipi_dsi_buf_init(&smd_oled_hd_rx_buf);
readed_size = mipi_dsi_cmds_rx(mfd, &smd_oled_hd_tx_buf, &smd_oled_hd_rx_buf, &mipi_smd_oled_hd_read_reg_cmd, one_read_size);
for (i = 0; i < readed_size; i++, data_cnt++)
{
if( data_cnt < data->len )
data->r_data[data_cnt] = smd_oled_hd_rx_buf.data[i];
}
mipi_dsi_sw_reset();
mipi_dsi_op_mode_config(DSI_VIDEO_MODE);
read_pos += readed_size;
if( read_pos > data->len )
break;
}
return 0;
}
int mipi_mot_panel_off(struct msm_fb_data_type *mfd)
{
struct dsi_buf *tp = mot_panel->mot_tx_buf;
mdp4_dsi_cmd_dma_busy_wait(mfd);
mipi_dsi_mdp_busy_wait(mfd);
mipi_dsi_buf_init(tp);
mipi_dsi_cmds_tx(mfd, tp, &mot_display_off_cmd, 1);
return 0;
}
static uint32 mipi_samsung_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 id, id1;
tp = &msd.samsung_tx_buf;
rp = &msd.samsung_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
/*read Id1 two time since fist time id read is always returning 0*/
cmd = &samsung_manufacture_id1_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
id1 = *((uint8 *)rp->data);
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id1_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
id = *((uint8 *)rp->data) | id1;
pr_info("%s: manufacture_id1=%x\n", __func__, *rp->data);
id <<= 8;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id2_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
pr_info("%s: manufacture_id2=%x\n", __func__, *rp->data);
id |= *((uint8 *)rp->data);
id <<= 8;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id3_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
pr_info("%s: manufacture_id3=%x\n", __func__, *rp->data);
id |= *((uint8 *)rp->data);
pr_info("%s: manufacture_id=%x\n", __func__, id);
#ifdef FACTORY_TEST
if (id == 0x00) {
pr_info("Lcd is not connected\n");
is_lcd_connected = 0;
}
#endif
return id;
}
static uint32 mipi_samsung_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 id = 0;
tp = &msd.samsung_tx_buf;
rp = &msd.samsung_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
if (system_rev == 0) {
pr_err("[LCD] %s, temp return! for rev00\n", __func__);
return 0;
}
cmd = &samsung_manufacture_id1_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
pr_info("%s: manufacture_id1=%x\n", __func__, *rp->data);
id = *rp->data & 0xFF;
id <<= 8;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id2_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
pr_info("%s: manufacture_id2=%x\n", __func__, *rp->data);
id |= *rp->data & 0xFF;
id <<= 8;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id3_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
pr_info("%s: manufacture_id3=%x\n", __func__, *rp->data);
id |= *rp->data & 0xFF;
id <<= 8;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
cmd = &samsung_manufacture_id4_cmd;
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
pr_info("%s: manufacture_id4=%x\n", __func__, *rp->data);
id |= *rp->data & 0xFF;
pr_info("%s: manufacture_id=%x\n", __func__, id);
return id;
}
static int32 get_panel_info(struct msm_fb_data_type *mfd,
struct mipi_mot_panel *mot_panel,
struct dsi_cmd_desc *cmd)
{
struct dsi_buf *rp, *tp;
uint32 *lp;
int ret;
tp = mot_panel->mot_tx_buf;
rp = mot_panel->mot_rx_buf;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
ret = mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 1);
if (!ret)
ret = -1;
else {
lp = (uint32 *)rp->data;
ret = (int)*lp;
}
return ret;
}
int mipi_dsi_eco_mode_switch(struct msm_fb_data_type *mfd)
{
int ret = 0;
struct mipi_dsi_data *dsi_data;
struct dsi_controller *pctrl;
dsi_data = platform_get_drvdata(mfd->panel_pdev);
if (!dsi_data || !dsi_data->lcd_power) {
ret = -ENODEV;
goto eco_mode_switch_fail;
}
pctrl = dsi_data->panel->pctrl;
mipi_set_tx_power_mode(0);
if (dsi_data->eco_mode_on && pctrl->eco_mode_gamma_cmds) {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(&dsi_data->tx_buf,
pctrl->eco_mode_gamma_cmds,
pctrl->eco_mode_gamma_cmds_size);
dev_info(&mfd->panel_pdev->dev, "ECO MODE ON\n");
} else if (pctrl->normal_gamma_cmds) {
mipi_dsi_buf_init(&dsi_data->tx_buf);
mipi_dsi_cmds_tx(&dsi_data->tx_buf,
pctrl->normal_gamma_cmds,
pctrl->normal_gamma_cmds_size);
dev_info(&mfd->panel_pdev->dev, "ECO MODE OFF\n");
}
mipi_set_tx_power_mode(1);
return ret;
eco_mode_switch_fail:
return ret;
}
uint32 nt35590_read_manufacture_id(struct msm_fb_data_type *mfd)
{
struct dsi_buf *rp, *tp;
struct dsi_cmd_desc *cmd;
uint32 *lp;
uint32 id=0xff;
printk("==========%s:line%d===========\n",__func__,__LINE__);
tp = &z5mini_tx_buf;
rp = &z5mini_rx_buf;
cmd = nt35590_manufacture_id_cmd;
mipi_dsi_buf_init(rp);
mipi_dsi_buf_init(tp);
mipi_dsi_cmd_bta_sw_trigger(); /* clean up ack_err_status */
mipi_dsi_cmds_rx(mfd, tp, rp, cmd, 2);
lp = (uint32 *)rp->data;
// id=(((*lp)&0xff00)>>8);
id=(*lp);
pr_info("%s: manufacture_id=0x%x,id=0x%x\n", __func__, (*lp)&0xffff ,id);
return id;
}
