void epd_write_epson_reg(unsigned short command, unsigned short addr, unsigned short data)
{
unsigned short value = 0;
u32 rd_reg=0; //Testing 0917
udelay(EPD_CMD_DELAY);
dd_printk("[w] %x,%x,%x\n", command, addr, data);
while(!value)
{
value = GET_HRDY_STATUS;
udelay(1);
rd_reg++;
if (rd_reg > 3000000)
break;
}
if (rd_reg > 3000000) // reinit EPD controller //Testing 0917
{
ep3_reinit();
//return;
}
ipu_adc_write_cmd(CMD,command);
//epd_write_command(command);
udelay(1);
__raw_writew(addr,bsaddr);
udelay(1);
__raw_writew(data,bsaddr);
udelay(1);
}
static int bs_wr_which(bool which, uint32_t data)
{
static int datacounter=0;
// display_port_t disp = BROADSHEET_DISPLAY_NUMBER;
cmddata_t type = (BS_CMD == which) ? CMD : DAT;
int result = EINKFB_FAILURE;
if (type == BS_CMD) {
datacounter = 0;
dd_printk("[C] %04x\n", data);
} else if (++datacounter <= 8) {
dd_printk("[D] %04x\n", data);
} else if (datacounter == 9) {
dd_printk("[D] ...\n");
}
if ( BS_READY() )
// result = ipu_adc_write_cmd(disp, type, data, 0, 0);
result = ipu_adc_write_cmd(type, data);
else
result = EINKFB_FAILURE;
return ( result );
}
/*!
* This function sets display region in the Epson panel
*
* @param disp display panel to config
* @param x1 x-coordinate of one vertex.
* @param x2 x-coordinate of second vertex.
* @param y1 y-coordinate of one vertex.
* @param y2 y-coordinate of second vertex.
*/
void set_panel_region(int disp, uint32_t x1, uint32_t x2,
uint32_t y1, uint32_t y2)
{
uint32_t param[8];
memset(param, 0, sizeof(uint32_t) * 8);
param[0] = x1;
param[2] = x2;
param[4] = y1;
param[6] = y2;
/* SD_CSET */
ipu_adc_write_cmd(disp, CMD, SD_CSET, param, 4);
/* SD_PSET */
ipu_adc_write_cmd(disp, CMD, SD_PSET, &(param[4]), 4);
}
/*!
* Function to initialize the panel. First it resets the panel and then
* initilizes panel.
*/
static void _init_panel(int disp)
{
uint32_t cmd_param;
uint32_t i;
gpio_lcd_active();
slcd_gpio_config();
/* DATCTL */
#ifdef CONFIG_FB_MXC_ASYNC_PANEL_IFC_16_BIT
/* 16-bit 565 mode */
cmd_param = 0x28;
#else
/* 8-bit 666 mode */
cmd_param = 0x08;
#endif
ipu_adc_write_cmd(disp, CMD, DATCTL, &cmd_param, 1);
/* Sleep OUT */
ipu_adc_write_cmd(disp, CMD, SLPOUT, 0, 0);
/* Set display to white
Setup page and column addresses */
set_panel_region(disp, MXCFB_SCREEN_LEFT_OFFSET,
MXCFB_SCREEN_WIDTH + MXCFB_SCREEN_LEFT_OFFSET - 1,
0, MXCFB_SCREEN_HEIGHT - 1);
/* Do RAM write cmd */
ipu_adc_write_cmd(disp, CMD, RAMWR, 0, 0);
#ifdef CONFIG_FB_MXC_ASYNC_PANEL_IFC_16_BIT
for (i = 0; i < (MXCFB_SCREEN_WIDTH * MXCFB_SCREEN_HEIGHT); i++)
#else
for (i = 0; i < (MXCFB_SCREEN_WIDTH * MXCFB_SCREEN_HEIGHT * 3); i++)
#endif
ipu_adc_write_cmd(disp, DAT, 0xFFFF, 0, 0);
/* Pause 80 ms */
mdelay(80);
/* Display ON */
ipu_adc_write_cmd(disp, CMD, DISON, 0, 0);
/* Pause 200 ms */
mdelay(200);
pr_debug("initialized panel\n");
}
// Scheduled loop for doing IO on framebuffer-sized buffers.
//
static int bs_io_buf(u32 data_size, u16 *data, bool which)
{
// display_port_t disp = BROADSHEET_DISPLAY_NUMBER;
int result = EINKFB_FAILURE;
dd_printk("[D] len=%i\n", data_size);
einkfb_debug_full("size = %d\n", data_size);
if ( BS_READY() )
{
int i = 0, j, length = (EINKFB_MEMCPY_MIN >> 1), num_loops = data_size/length,
remainder = data_size % length;
bool done = false;
if ( 0 != num_loops )
einkfb_debug("num_loops @ %d bytes = %d, remainder = %d\n",
(length << 1), num_loops, (remainder << 1));
result = EINKFB_SUCCESS;
// Read/write EINKFB_MEMCPY_MIN bytes (hence, divide by 2) at a time. While
// there are still bytes to read/write, yield the CPU.
//
do
{
if ( 0 >= num_loops )
length = remainder;
for ( j = 0; j < length; j++)
{
if ( BS_WR == which )
// ipu_adc_write_cmd(disp, DAT, (uint32_t)data[i + j], 0, 0);
ipu_adc_write_cmd(DAT, (uint32_t)data[i + j]);
else
// data[i + j] = (u16)(ipu_adc_read_data(disp) & 0x0000FFFF);
data[i + j] = (u16)(ipu_adc_read_data() & 0x0000FFFF);
}
i += length;
if ( i < data_size )
{
EINKFB_SCHEDULE();
num_loops--;
}
else
done = true;
}
while ( !done );
}
return ( result );
}
void epd_write_buffer(u32 data_size, u16 *data)
{
int i;
dd_printk("[b] size=%i\n", data_size);
for ( i = 0; i < data_size; i++)
{
ipu_adc_write_cmd(DAT, (uint32_t)data[i]);
}
}
static int bs_wr_which(bool which, uint32_t data)
{
display_port_t disp = BROADSHEET_DISPLAY_NUMBER;
cmddata_t type = (BS_CMD == which) ? CMD : DAT;
int result = EINKFB_FAILURE;
if ( BS_READY() )
result = ipu_adc_write_cmd(disp, type, data, 0, 0);
else
result = EINKFB_FAILURE;
return ( result );
}
/*!
* Suspends the framebuffer and blanks the screen. Power management support
*
* @param pdev pointer to device structure.
* @param state state of the device.
*
* @return success
*/
static int mxcfb_suspend(struct platform_device *pdev, pm_message_t state)
{
struct mxcfb_data *drv_data = platform_get_drvdata(pdev);
struct fb_info *fbi = drv_data->fbi;
struct mxcfb_info *mxc_fbi = fbi->par;
drv_data->suspended = true;
if (mxc_fbi->blank == FB_BLANK_UNBLANK)
mxcfb_set_refresh_mode(fbi, MXCFB_REFRESH_OFF, NULL);
/* Display OFF */
ipu_adc_write_cmd(mxc_fbi->disp_num, CMD, DISOFF, 0, 0);
return 0;
}
/*!
* Resumes the framebuffer and unblanks the screen. Power management support
*
* @param pdev pointer to device structure.
*
* @return success
*/
static int mxcfb_resume(struct platform_device *pdev)
{
struct mxcfb_data *drv_data = platform_get_drvdata(pdev);
struct fb_info *fbi = drv_data->fbi;
struct mxcfb_info *mxc_fbi = fbi->par;
/* Display ON */
ipu_adc_write_cmd(mxc_fbi->disp_num, CMD, DISON, 0, 0);
drv_data->suspended = false;
if (mxc_fbi->blank == FB_BLANK_UNBLANK)
mxcfb_set_refresh_mode(fbi, MXCFB_REFRESH_DEFAULT, NULL);
wake_up_interruptible(&drv_data->suspend_wq);
return 0;
}
static int mxc_ipu_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case IPU_INIT_CHANNEL:
{
ipu_channel_parm parm;
if (copy_from_user
(&parm, (ipu_channel_parm *) arg,
sizeof(ipu_channel_parm))) {
return -EFAULT;
}
if (!parm.flag) {
ret =
ipu_init_channel(parm.channel,
&parm.params);
} else {
ret = ipu_init_channel(parm.channel, NULL);
}
}
break;
case IPU_UNINIT_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_uninit_channel(ch);
}
break;
case IPU_INIT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm))) {
return -EFAULT;
}
ret =
ipu_init_channel_buffer(parm.channel, parm.type,
parm.pixel_fmt,
parm.width, parm.height,
parm.stride,
parm.rot_mode,
parm.phyaddr_0,
parm.phyaddr_1,
parm.u_offset,
parm.v_offset);
}
break;
case IPU_UPDATE_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm))) {
return -EFAULT;
}
if ((parm.phyaddr_0 != (dma_addr_t) NULL)
&& (parm.phyaddr_1 == (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_0);
} else if ((parm.phyaddr_0 == (dma_addr_t) NULL)
&& (parm.phyaddr_1 != (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_1);
} else {
ret = -1;
}
}
break;
case IPU_SELECT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm))) {
return -EFAULT;
}
ret =
ipu_select_buffer(parm.channel, parm.type,
parm.bufNum);
}
break;
case IPU_LINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link))) {
return -EFAULT;
}
ret = ipu_link_channels(link.src_ch, link.dest_ch);
}
break;
case IPU_UNLINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link))) {
return -EFAULT;
}
ret = ipu_unlink_channels(link.src_ch, link.dest_ch);
}
break;
case IPU_ENABLE_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_enable_channel(ch);
}
break;
case IPU_DISABLE_CHANNEL:
{
ipu_channel_info info;
if (copy_from_user
(&info, (ipu_channel_info *) arg,
sizeof(ipu_channel_info))) {
return -EFAULT;
}
ret = ipu_disable_channel(info.channel, info.stop);
}
break;
case IPU_ENABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_enable_irq(irq);
}
break;
case IPU_DISABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_disable_irq(irq);
}
break;
case IPU_CLEAR_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_clear_irq(irq);
}
break;
case IPU_FREE_IRQ:
{
ipu_irq_info info;
if (copy_from_user
(&info, (ipu_irq_info *) arg,
sizeof(ipu_irq_info))) {
return -EFAULT;
}
ipu_free_irq(info.irq, info.dev_id);
}
break;
case IPU_REQUEST_IRQ_STATUS:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ret = ipu_get_irq_status(irq);
}
break;
case IPU_SDC_INIT_PANEL:
{
ipu_sdc_panel_info sinfo;
if (copy_from_user
(&sinfo, (ipu_sdc_panel_info *) arg,
sizeof(ipu_sdc_panel_info))) {
return -EFAULT;
}
ret =
ipu_sdc_init_panel(sinfo.panel, sinfo.pixel_clk,
sinfo.width, sinfo.height,
sinfo.pixel_fmt,
sinfo.hStartWidth,
sinfo.hSyncWidth,
sinfo.hEndWidth,
sinfo.vStartWidth,
sinfo.vSyncWidth,
sinfo.vEndWidth, sinfo.signal);
}
break;
case IPU_SDC_SET_WIN_POS:
{
ipu_sdc_window_pos pos;
if (copy_from_user
(&pos, (ipu_sdc_window_pos *) arg,
sizeof(ipu_sdc_window_pos))) {
return -EFAULT;
}
ret =
ipu_sdc_set_window_pos(pos.channel, pos.x_pos,
pos.y_pos);
}
break;
case IPU_SDC_SET_GLOBAL_ALPHA:
{
ipu_sdc_global_alpha g;
if (copy_from_user
(&g, (ipu_sdc_global_alpha *) arg,
sizeof(ipu_sdc_global_alpha))) {
return -EFAULT;
}
ret = ipu_sdc_set_global_alpha(g.enable, g.alpha);
}
break;
case IPU_SDC_SET_COLOR_KEY:
{
ipu_sdc_color_key c;
if (copy_from_user
(&c, (ipu_sdc_color_key *) arg,
sizeof(ipu_sdc_color_key))) {
return -EFAULT;
}
ret =
ipu_sdc_set_color_key(c.channel, c.enable,
c.colorKey);
}
break;
case IPU_SDC_SET_BRIGHTNESS:
{
uint8_t b;
int __user *argp = (void __user *)arg;
if (get_user(b, argp))
return -EFAULT;
ret = ipu_sdc_set_brightness(b);
}
break;
case IPU_REGISTER_GENERIC_ISR:
{
ipu_event_info info;
if (copy_from_user
(&info, (ipu_event_info *) arg,
sizeof(ipu_event_info))) {
return -EFAULT;
}
ret =
ipu_request_irq(info.irq, mxc_ipu_generic_handler,
0, "video_sink", info.dev);
}
break;
case IPU_GET_EVENT:
/* User will have to allocate event_type structure and pass the pointer in arg */
{
event_type ev;
int r = -1;
r = get_events(&ev);
if (r == -1) {
wait_event_interruptible(waitq,
(pending_events != 0));
r = get_events(&ev);
}
ret = -1;
if (r == 0) {
if (!copy_to_user((event_type *) arg, &ev,
sizeof(event_type))) {
ret = 0;
}
}
}
break;
case IPU_ADC_WRITE_TEMPLATE:
{
ipu_adc_template temp;
if (copy_from_user
(&temp, (ipu_adc_template *) arg, sizeof(temp))) {
return -EFAULT;
}
ret =
ipu_adc_write_template(temp.disp, temp.pCmd,
temp.write);
}
break;
case IPU_ADC_UPDATE:
{
ipu_adc_update update;
if (copy_from_user
(&update, (ipu_adc_update *) arg, sizeof(update))) {
return -EFAULT;
}
ret =
ipu_adc_set_update_mode(update.channel, update.mode,
update.refresh_rate,
update.addr, update.size);
}
break;
case IPU_ADC_SNOOP:
{
ipu_adc_snoop snoop;
if (copy_from_user
(&snoop, (ipu_adc_snoop *) arg, sizeof(snoop))) {
return -EFAULT;
}
ret =
ipu_adc_get_snooping_status(snoop.statl,
snoop.stath);
}
break;
case IPU_ADC_CMD:
{
ipu_adc_cmd cmd;
if (copy_from_user
(&cmd, (ipu_adc_cmd *) arg, sizeof(cmd))) {
return -EFAULT;
}
ret =
ipu_adc_write_cmd(cmd.disp, cmd.type, cmd.cmd,
cmd.params, cmd.numParams);
}
break;
case IPU_ADC_INIT_PANEL:
{
ipu_adc_panel panel;
if (copy_from_user
(&panel, (ipu_adc_panel *) arg, sizeof(panel))) {
return -EFAULT;
}
ret =
ipu_adc_init_panel(panel.disp, panel.width,
panel.height, panel.pixel_fmt,
panel.stride, panel.signal,
panel.addr, panel.vsync_width,
panel.mode);
}
break;
case IPU_ADC_IFC_TIMING:
{
ipu_adc_ifc_timing t;
if (copy_from_user
(&t, (ipu_adc_ifc_timing *) arg, sizeof(t))) {
return -EFAULT;
}
ret =
ipu_adc_init_ifc_timing(t.disp, t.read,
t.cycle_time, t.up_time,
t.down_time,
t.read_latch_time,
t.pixel_clk);
}
break;
case IPU_CSI_INIT_INTERFACE:
{
ipu_csi_interface c;
if (copy_from_user
(&c, (ipu_csi_interface *) arg, sizeof(c)))
return -EFAULT;
ret =
ipu_csi_init_interface(c.width, c.height,
c.pixel_fmt, c.signal);
}
break;
case IPU_CSI_ENABLE_MCLK:
{
ipu_csi_mclk m;
if (copy_from_user(&m, (ipu_csi_mclk *) arg, sizeof(m)))
return -EFAULT;
ret = ipu_csi_enable_mclk(m.src, m.flag, m.wait);
}
break;
case IPU_CSI_READ_MCLK_FLAG:
{
ret = ipu_csi_read_mclk_flag();
}
break;
case IPU_CSI_FLASH_STROBE:
{
bool strobe;
int __user *argp = (void __user *)arg;
if (get_user(strobe, argp))
return -EFAULT;
ipu_csi_flash_strobe(strobe);
}
break;
case IPU_CSI_GET_WIN_SIZE:
{
ipu_csi_window_size w;
ipu_csi_get_window_size(&w.width, &w.height);
if (copy_to_user
((ipu_csi_window_size *) arg, &w, sizeof(w)))
return -EFAULT;
}
break;
case IPU_CSI_SET_WIN_SIZE:
{
ipu_csi_window_size w;
if (copy_from_user
(&w, (ipu_csi_window_size *) arg, sizeof(w)))
return -EFAULT;
ipu_csi_set_window_size(w.width, w.height);
}
break;
case IPU_CSI_SET_WINDOW:
{
ipu_csi_window p;
if (copy_from_user
(&p, (ipu_csi_window *) arg, sizeof(p)))
return -EFAULT;
ipu_csi_set_window_pos(p.left, p.top);
}
break;
case IPU_PF_SET_PAUSE_ROW:
{
uint32_t p;
int __user *argp = (void __user *)arg;
if (get_user(p, argp))
return -EFAULT;
ret = ipu_pf_set_pause_row(p);
}
break;
default:
break;
}
return ret;
}
void bs_wr_one(u16 data)
{
// ipu_adc_write_cmd((display_port_t)BROADSHEET_DISPLAY_NUMBER, DAT, (uint32_t)data, 0, 0);
ipu_adc_write_cmd(DAT, (uint32_t)data);
}
/*!
* Function to initialize the panel. First it resets the panel and then
* initilizes panel.
*/
static void _init_panel(int disp)
{
uint32_t cmd_param;
uint32_t i;
slcd_gpio_config();
// Reset
cmd_param = 0x01;
ipu_adc_write_cmd(disp, CMD, 0x03, &cmd_param, 1);
// Turn on oscillator
cmd_param = 0x01;
ipu_adc_write_cmd(disp, CMD, 0x3A, &cmd_param, 1);
cmd_param = 0x02;
ipu_adc_write_cmd(disp, CMD, 0x32, &cmd_param, 1);
cmd_param = 0x01;
ipu_adc_write_cmd(disp, CMD, 0x33, &cmd_param, 1);
cmd_param = 0x00;
ipu_adc_write_cmd(disp, CMD, 0x37, &cmd_param, 1);
cmd_param = 0x0FFF;
ipu_adc_write_cmd(disp, CMD, 0x77, &cmd_param, 1);
cmd_param = 0x01;
ipu_adc_write_cmd(disp, CMD, 0x72, &cmd_param, 1);
cmd_param = 0x1C3B;
ipu_adc_write_cmd(disp, CMD, 0x1C, &cmd_param, 1);
cmd_param = 0x21;
ipu_adc_write_cmd(disp, CMD, 0x52, &cmd_param, 1);
cmd_param = 0x11;
ipu_adc_write_cmd(disp, CMD, 0x53, &cmd_param, 1);
cmd_param = 0x79;
ipu_adc_write_cmd(disp, CMD, 0x24, &cmd_param, 1);
cmd_param = 0x79;
ipu_adc_write_cmd(disp, CMD, 0x25, &cmd_param, 1);
cmd_param = 0x10;
ipu_adc_write_cmd(disp, CMD, 0x26, &cmd_param, 1);
cmd_param = 0x10;
ipu_adc_write_cmd(disp, CMD, 0x27, &cmd_param, 1);
cmd_param = 0x28;
ipu_adc_write_cmd(disp, CMD, 0x61, &cmd_param, 1);
cmd_param = 0x1A;
ipu_adc_write_cmd(disp, CMD, 0x62, &cmd_param, 1);
cmd_param = 0x1E;
ipu_adc_write_cmd(disp, CMD, 0x63, &cmd_param, 1);
cmd_param = 0x21;
ipu_adc_write_cmd(disp, CMD, 0x64, &cmd_param, 1);
cmd_param = 0x1B;
ipu_adc_write_cmd(disp, CMD, 0x65, &cmd_param, 1);
cmd_param = 0x29;
ipu_adc_write_cmd(disp, CMD, 0x66, &cmd_param, 1);
cmd_param = 0x205;
ipu_adc_write_cmd(disp, CMD, 0x4D, &cmd_param, 1);
cmd_param = 0x01;
ipu_adc_write_cmd(disp, CMD, 0x4E, &cmd_param, 1);
cmd_param = 0x104;
ipu_adc_write_cmd(disp, CMD, 0x4F, &cmd_param, 1);
cmd_param = 0x2F;
ipu_adc_write_cmd(disp, CMD, 0x2E, &cmd_param, 1);
cmd_param = 0x0;
ipu_adc_write_cmd(disp, CMD, 0x29, &cmd_param, 1);
cmd_param = 0x0;
ipu_adc_write_cmd(disp, CMD, 0x2A, &cmd_param, 1);
cmd_param = 0xEF;
ipu_adc_write_cmd(disp, CMD, 0x2B, &cmd_param, 1);
cmd_param = 0x13F;
ipu_adc_write_cmd(disp, CMD, 0x2C, &cmd_param, 1);
/* Window area setting */
cmd_param = 0x0;
ipu_adc_write_cmd(disp, CMD, 0x08, &cmd_param, 1);
cmd_param = 0xEF;
ipu_adc_write_cmd(disp, CMD, 0x09, &cmd_param, 1);
cmd_param = 0x0;
ipu_adc_write_cmd(disp, CMD, 0x0A, &cmd_param, 1);
cmd_param = 0x13F;
ipu_adc_write_cmd(disp, CMD, 0x0B, &cmd_param, 1);
/* Window mode setting */
cmd_param = 0x00;
ipu_adc_write_cmd(disp, CMD, 0x05, &cmd_param, 1);
/* Ram address setting */
cmd_param = 0x0;
ipu_adc_write_cmd(disp, CMD, 0x06, &cmd_param, 1);
cmd_param = 0x0;
ipu_adc_write_cmd(disp, CMD, 0x07, &cmd_param, 1);
/* Initialize RAM */
ipu_adc_write_cmd(disp, CMD, 0x0E, 0, 0);
for (i = 0; i < (MXCFB_SCREEN_WIDTH * MXCFB_SCREEN_HEIGHT / 2); i++)
ipu_adc_write_cmd(disp, DAT, 0x3FFFF, 0, 0);
for (i = 0; i < (MXCFB_SCREEN_WIDTH * MXCFB_SCREEN_HEIGHT / 2); i++)
ipu_adc_write_cmd(disp, DAT, 0, 0, 0);
cmd_param = 0x1F6A;
ipu_adc_write_cmd(disp, CMD, 0x18, &cmd_param, 1);
cmd_param = 0x00A2;
ipu_adc_write_cmd(disp, CMD, 0x1A, &cmd_param, 1);
cmd_param = 0x0028;
ipu_adc_write_cmd(disp, CMD, 0x1B, &cmd_param, 1);
cmd_param = 0x1C3B;
ipu_adc_write_cmd(disp, CMD, 0x1C, &cmd_param, 1);
cmd_param = 0x0075;
ipu_adc_write_cmd(disp, CMD, 0x1D, &cmd_param, 1);
cmd_param = 0x003D;
ipu_adc_write_cmd(disp, CMD, 0x1F, &cmd_param, 1);
cmd_param = 0x0080;
ipu_adc_write_cmd(disp, CMD, 0x20, &cmd_param, 1);
/* DC/DC on */
cmd_param = 0x1F6B;
ipu_adc_write_cmd(disp, CMD, 0x18, &cmd_param, 1);
msleep(100);
/* VCOM on */
cmd_param = 0x0021;
ipu_adc_write_cmd(disp, CMD, 0x1E, &cmd_param, 1);
/* GOE1,GOE2 setting (Gate output enable) */
cmd_param = 0x0001;
ipu_adc_write_cmd(disp, CMD, 0x3B, &cmd_param, 1);
cmd_param = 0x00;
ipu_adc_write_cmd(disp, CMD, 0x2, &cmd_param, 1);
/* Display on */
cmd_param = 0x00;
ipu_adc_write_cmd(disp, CMD, 0x0, &cmd_param, 1);
msleep(10);
pr_debug("initialized panel\n");
}
