static int oled_panel_blank(struct msm_lcdc_panel_ops *op)
{
printk(KERN_DEBUG "%s\n", __func__);
atomic_set(&gate, 0);
if (!panel_type) {
/* start display off sequence */
lcm_spi_write(0x4, 0x3);
hr_msleep(100);
lcm_spi_write(0x4, 0x1);
hr_msleep(60);
lcm_spi_write(0x4, 0x0);
hr_msleep(100);
lcm_spi_write(0x20, 0x0);
} else {
/* config LCDC pin mux to gpio function */
config_legend_display_off_gpios();
gpio_set_value(LEGEND_LCD_VSYNC, 0);
gpio_set_value(LEGEND_LCD_HSYNC, 0);
gpio_set_value(LEGEND_LCD_DE, 0);
gpio_set_value(LEGEND_GPIO_EL_EN, 0);
gpio_set_value(LEGEND_GPIO_EL_ADJ, 0);
gpio_set_value(LEGEND_GPIO_LCD_RST_N, 0);
hr_msleep(10);
lcm_spi_write(0x28, 0x00);
lcm_spi_write(0x10, 0x00);
hr_msleep(120);
}
microp_spi_vote_enable(SPI_LCM, 0);
return 0;
}
static int hs_1wire_init(void)
{
char all_zero = 0;
char send_data = 0xF5;
HS_LOG("[1-wire]hs_1wire_init");
fp = openFile(hi->pdata.onewire_tty_dev,O_RDWR|O_SYNC|O_NONBLOCK,0660);
HS_LOG("Open %s", hi->pdata.onewire_tty_dev);
if (fp != NULL) {
if (!fp->private_data) {
HS_LOG("No private data");
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
} else {
HS_LOG("%s, openFile is NULL pointer\n", __func__);
return -1;
}
setup_hs_tty(fp);
HS_LOG("Setup HS tty");
if (hi->pdata.tx_level_shift_en) {
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 0);
HS_LOG("[HS]set tx_level_shift_en to 0");
}
if (hi->pdata.uart_sw) {
gpio_set_value_cansleep(hi->pdata.uart_sw, 1);
HS_LOG("[HS]Set uart sw = 1");
}
hi->aid = 0;
hr_msleep(20);
writeFile(fp,&all_zero,1);
hr_msleep(5);
writeFile(fp,&send_data,1);
HS_LOG("Send 0x00 0xF5");
usleep(300);
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
HS_LOG("[HS]Disable level shift");
hr_msleep(22);
if (hs_read_aid() == 0) {
HS_LOG("[1-wire]Valid AID received, enter 1-wire mode");
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
closeFile(fp);
return 0;
} else {
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
}
static void golfu_panel_power(int on)
{
PR_DISP_INFO("%s: power %s.\n", __func__, on ? "on" : "off");
if (on) {
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 1);
hr_msleep(1);
gpio_set_value(GOLFU_GPIO_LCM_1v8_EN, 1);
hr_msleep(5);
gpio_set_value(GOLFU_GPIO_LCM_2v85_EN, 1);
hr_msleep(1);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 1);
hr_msleep(1);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 0);
udelay(50);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 1);
udelay(50);
} else {
gpio_set_value(GOLFU_GPIO_LCM_2v85_EN, 0);
gpio_set_value(GOLFU_GPIO_LCM_1v8_EN, 0);
hr_msleep(300);
gpio_set_value(GOLFU_GPIO_LCD_RST_N, 0);
}
}
static int hs_1wire_init(void)
{
char all_zero = 0;
char send_data = 0xF5;
HS_LOG("[1-wire]hs_1wire_init");
fp = openFile(hi->pdata.onewire_tty_dev,O_CREAT|O_RDWR|O_NONBLOCK,0666);
HS_LOG("Open %s", hi->pdata.onewire_tty_dev);
if (!fp->private_data) {
HS_LOG("No private data");
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
setup_hs_tty(fp);
HS_LOG("Setup HS tty");
if (hi->pdata.tx_level_shift_en) {
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 0); /*Level shift low enable*/
HS_LOG("[HS]set tx_level_shift_en to 0");
}
if (hi->pdata.uart_sw) {
gpio_set_value_cansleep(hi->pdata.uart_sw, 1); /* 1: UART I/O to Audio Jack, 0: UART I/O to others */
HS_LOG("[HS]Set uart sw = 1");
}
hi->aid = 0;
hr_msleep(20);
writeFile(fp,&all_zero,1);
hr_msleep(5);
writeFile(fp,&send_data,1);
// if (hi->pdata.remote_press) {
// while(gpio_get_value(hi->pdata.remote_press) == 1) {
// HS_LOG("[HS]Polling remote_press low");
// }
// }
HS_LOG("Send 0x00 0x35");
usleep(300);
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
HS_LOG("[HS]Disable level shift");
hr_msleep(22);
if (hs_read_aid() == 0) {
HS_LOG("[1-wire]Valid AID received, enter 1-wire mode");
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
closeFile(fp);
return 0;
} else {
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
}
static void flyer_panel_power(bool on_off)
{
int gpio_lcm_en, gpio_lvds_on;
if (panel_type != PANEL_ID_FLR_SMD_XB) {
gpio_lcm_en = FLYER_LCM_3V3_EN_XC;
gpio_lvds_on = FLYER_LVDS_ON_XC;
} else {
gpio_lcm_en = FLYER_LCM_3V3_EN;
gpio_lvds_on = FLYER_LVDS_ON;
}
if (!!on_off) {
LCMDBG("%s(%d):\n", __func__, on_off);
vreg_enable(vreg_lcm_1v8);
gpio_set_value(gpio_lcm_en, 1);
if(panel_type == PANEL_ID_FLR_LG_XC || panel_type == PANEL_ID_FLR_LG_WS2)
hr_msleep(50);
else
hr_msleep(90);
gpio_set_value(gpio_lvds_on, 1);
} else {
gpio_set_value(gpio_lcm_en, 0);
if(panel_type == PANEL_ID_FLR_LG_XC || panel_type == PANEL_ID_FLR_LG_WS2)
hr_msleep(50);
else
hr_msleep(60);
gpio_set_value(gpio_lvds_on, 0);
vreg_disable(vreg_lcm_1v8);
}
}
int mdp_dsi_video_off(struct platform_device *pdev)
{
int ret = 0;
int retry_cnt = 0;
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)platform_get_drvdata(pdev);
PR_DISP_INFO("%s\n", __func__);
if (panel_type == PANEL_ID_PROTOU_LG || panel_type == PANEL_ID_PROTODCG_LG) {
if(!mfd) {
PR_DISP_ERR("mdp_dsi_video_off: mfd is NULL\n");
return -ENODEV;
}
do {
memset(mfd->fbi->screen_base, 0x00, mfd->fbi->fix.smem_len);
hr_msleep(80);
#ifdef CONFIG_MACH_DUMMY
ret = protodcg_lcd_off2(pdev);
#elif defined CONFIG_MACH_PROTOU
ret = protou_lcd_off2(pdev);
#else
#endif
if (ret < 0) {
panel_next_off(pdev);
hr_msleep(2);
panel_next_on(pdev);
hr_msleep(5);
retry_cnt++;
} else {
ret = 0;
break;
}
} while (retry_cnt < 10);
PR_DISP_INFO("%s : mipi_lg_lcd_off retry_cnt = %d\n", __func__, retry_cnt);
hr_msleep(20);
}
mdp_histogram_ctrl_all(FALSE);
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE);
MDP_OUTP(MDP_BASE + DSI_VIDEO_BASE, 0);
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
mdp_pipe_ctrl(MDP_DMA2_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
ret = panel_next_off(pdev);
atomic_set(&vsync_cntrl.suspend, 1);
atomic_set(&vsync_cntrl.vsync_resume, 0);
complete_all(&vsync_cntrl.vsync_wait);
msleep(20);
return ret;
}
int panel_power_on(void)
{
int rc;
/* turn on L19 for OJ. Note: must before L12 */
rc = vreg_enable(vreg_ldo19);
if (rc) {
pr_err("%s: LDO19 vreg enable failed (%d)\n",
__func__, rc);
return -1;
}
hr_msleep(5);
rc = vreg_enable(vreg_ldo12);
if (rc) {
pr_err("%s: LDO12 vreg enable failed (%d)\n",
__func__, rc);
return -1;
}
hr_msleep(5);
rc = vreg_enable(vreg_ldo20);
if (rc) {
pr_err("%s: LDO20 vreg enable failed (%d)\n",
__func__, rc);
return -1;
}
hr_msleep(5);
if (is_samsung_panel())
{
hr_msleep(5);
gpio_set_value(VISION_LCD_RSTz, 1);
hr_msleep(25);
gpio_set_value(VISION_LCD_RSTz, 0);
hr_msleep(10);
gpio_set_value(VISION_LCD_RSTz, 1);
hr_msleep(20);
/* XA, XB board has HW panel issue, need to set EL_EN pin */
if(system_rev <= 1)
gpio_set_value(VISION_EL_EN, 1);
}
else
{
hr_msleep(10);
gpio_set_value(VISION_LCD_RSTz, 1);
hr_msleep(10);
gpio_set_value(VISION_LCD_RSTz, 0);
udelay(500);
gpio_set_value(VISION_LCD_RSTz, 1);
hr_msleep(10);
}
return 0;
}
/* MM-VH-DISPLAY-NICKI17*[ */
static int msm_fb_dsi_client_reset(int hold)
{
int retVal = 0;
static int isGPIOInit = 0;
/* MM-VH-DISPLAY-NICKI18* */
pr_info("[DISPLAY] +%s(%d)\n", __func__, hold);
/* GPIO INIT */
if(isGPIOInit == 0){
retVal = gpio_request(DISP_RST_GPIO, "disp_rst_n");
if (retVal) {
pr_err("[DISPLAY] %s: Failed to request lcm_reset, error=%d\n", __func__, retVal);
retVal = -ENODEV;
goto error;
}
retVal = gpio_tlmm_config(GPIO_CFG(DISP_RST_GPIO , 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
isGPIOInit = 1;
}
if (hold) {
retVal = gpio_direction_output(DISP_RST_GPIO , 0);
} else {
#ifdef CONFIG_FIH_HR_MSLEEP
hr_msleep(2);
retVal = gpio_direction_output(DISP_RST_GPIO , 1);
hr_msleep(2);
retVal |= gpio_direction_output(DISP_RST_GPIO , 0);
hr_msleep(2);
retVal |= gpio_direction_output(DISP_RST_GPIO , 1);
#else
msleep(2);
retVal = gpio_direction_output(DISP_RST_GPIO , 1);
msleep(2);
retVal |= gpio_direction_output(DISP_RST_GPIO , 0);
msleep(2);
retVal |= gpio_direction_output(DISP_RST_GPIO , 1);
#endif
}
error:
if (retVal != 0) {
pr_err("[DISPLAY] %s: Failed LCD reset enable\n", __func__);
}
return retVal;
}
static int hs_1wire_init(void)
{
char all_zero = 0;
char send_data = 0x35;
HS_LOG("[1-wire]hs_1wire_init");
fp = openFile(hi->pdata.onewire_tty_dev,O_CREAT|O_RDWR|O_SYNC,0666);
HS_LOG("Open %s", hi->pdata.onewire_tty_dev);
if (!(fp->private_data)) {
HS_LOG("No private data");
return -1;
}
setup_hs_tty(fp);
HS_LOG("Setup HS tty");
if (hi->pdata.tx_level_shift_en) {
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 0);
HS_LOG("[HS]set tx_level_shift_en to 0");
}
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 1);
hi->aid = 0;
hr_msleep(20);
writeFile(fp,&all_zero,1);
hr_msleep(5);
writeFile(fp,&send_data,1);
if (hi->pdata.remote_press) {
while(gpio_get_value(hi->pdata.remote_press) == 1) {
HS_LOG("[HS]Polling remote_press low");
}
}
hr_msleep(1);
if (hi->pdata.tx_level_shift_en)
gpio_set_value(hi->pdata.tx_level_shift_en, 1);
HS_LOG("[HS]Disable level shift");
hr_msleep(22);
if (hs_read_aid() == 0) {
HS_LOG("[1-wire]Valid AID received, enter 1-wire mode");
return 0;
} else {
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
if (hi->pdata.uart_sw)
gpio_set_value_cansleep(hi->pdata.uart_sw, 0);
hi->aid = 0;
closeFile(fp);
return -1;
}
}
static int
chacha_mddi_init(struct msm_mddi_bridge_platform_data *bridge_data,
struct msm_mddi_client_data *client_data)
{
int i = 0, array_size;
struct mddi_cmd *renesas_init_cmd;
B(KERN_DEBUG "%s\n", __func__);
if (panel_type == 1) {
renesas_init_cmd = renesas_toppan_init_cmd_table;
array_size = ARRAY_SIZE(renesas_toppan_init_cmd_table);
} else {
renesas_init_cmd = renesas_init_cmd_table;
array_size = ARRAY_SIZE(renesas_init_cmd_table);
}
for (i = 0; i < array_size; i++) {
client_data->remote_write_vals(client_data,
renesas_init_cmd[i].vals,
renesas_init_cmd[i].cmd,
renesas_init_cmd[i].len);
if (renesas_init_cmd[i].delay)
hr_msleep(renesas_init_cmd[i].delay);
}
B(KERN_DEBUG "%s end\n", __func__);
return 0;
}
static int hs_1wire_read_key(void)
{
char key_code[10];
int read_count, retry, i;
if (hs_1wire_open()!=0)
return -1;
for (retry = 0; retry < 3; retry++) {
read_count = readFile(fp, key_code, 10);
HS_LOG("[1wire]key read_count = %d", read_count);
if (read_count > 0) {
for (i = 0; i < read_count; i++) {
HS_LOG("[1wire]key_code[%d] = 0x%x", i, key_code[i]);
if (key_code[i] == hi->pdata.one_wire_remote[0])
return 1;
else if (key_code[i] == hi->pdata.one_wire_remote[2])
return 2;
else if (key_code[i] == hi->pdata.one_wire_remote[4])
return 3;
else if (key_code[i] == hi->pdata.one_wire_remote[1])
return 0;
else
HS_LOG("Non key data, dropped");
}
}
hr_msleep(50);
}
return -1;
}
static int express_smd_panel_blank(struct msm_lcdc_panel_ops *ops)
{
express_adjust_backlight(0);
atomic_set(&lcm_init_done, 0);
hr_msleep(250);
return 0;
}
static int express_smd_panel_unblank(struct msm_lcdc_panel_ops *ops)
{
hr_msleep(250);
atomic_set(&lcm_init_done, 1);
express_adjust_backlight(last_val);
return 0;
}
static int mecha_sharp_panel_unblank(struct msm_lcdc_panel_ops *ops)
{
struct spi_msg set_brightness = {
.cmd = 0x51,
.len = 1,
.data = (unsigned char *)&last_val,
};
LCMDBG("\n");
if (color_enhancement == 0) {
mecha_mdp_color_enhancement(mdp_pdata.mdp_dev);
color_enhancement = 1;
}
mutex_lock(&panel_lock);
qspi_send_9bit(&set_brightness);
lcm_sharp_write_seq(sharp_turn_on_backlight,
ARRAY_SIZE(sharp_turn_on_backlight));
mutex_unlock(&panel_lock);
return 0;
}
static int mecha_sharp_panel_blank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
lcm_sharp_write_seq(sharp_blank_seq, ARRAY_SIZE(sharp_blank_seq));
hr_msleep(100);
mutex_unlock(&panel_lock);
return 0;
}
static int sonywvga_panel_blank(struct msm_lcdc_panel_ops *panel_data)
{
uint8_t data[4] = {0, 0, 0, 0};
LCMDBG("%s\n", __func__);
mutex_lock(&panel_lock);
blank_msg.cmd = 0x28;
qspi_send_9bit(&blank_msg);
blank_msg.cmd = 0x10;
qspi_send_9bit(&blank_msg);
hr_msleep(40);
g_unblank_stage = 0;
mutex_unlock(&panel_lock);
sonywvga_panel_power(0);
if (!is_sony_spi()) {
data[0] = 5;
data[1] = 0;
data[3] = 1;
microp_i2c_write(0x25, data, 4);
}
return 0;
}
static void
mddi_novatec_power(struct msm_mddi_client_data *client_data, int on)
{
int rc;
unsigned config;
if (on) {
if(axi_clk)
clk_set_rate(axi_clk, 192000000);
config = PCOM_GPIO_CFG(GLACIER_MDDI_TE, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(GLACIER_LCD_ID2, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(GLACIER_LCD_ID1, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(GLACIER_LCD_ID0, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
/* OJ_2V85*/
vreg_enable(OJ_2V85);
vreg_enable(V_LCMIO_2V8);
vreg_enable(V_LCMIO_1V8);
gpio_set_value(GLACIER_LCD_RSTz, 1);
hr_msleep(13);
gpio_set_value(GLACIER_LCD_RSTz, 0);
hr_msleep(13);
gpio_set_value(GLACIER_LCD_RSTz, 1);
hr_msleep(13);
} else {
gpio_set_value(GLACIER_LCD_RSTz, 0);
vreg_disable(V_LCMIO_2V8);
vreg_disable(V_LCMIO_1V8);
/* OJ_2V85*/
vreg_disable(OJ_2V85);
config = PCOM_GPIO_CFG(GLACIER_MDDI_TE, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(GLACIER_LCD_ID2, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(GLACIER_LCD_ID1, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(GLACIER_LCD_ID0, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
}
}
static void hs_1wire_deinit(void)
{
char all_zero = 0xaa;
if (fp) {
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 0);
hr_msleep(20);
writeFile(fp, &all_zero, 1);
HS_LOG("Write 0xaa to unblock");
hr_msleep(10);
HS_LOG("close file");
closeFile(fp);
fp = NULL;
if (hi->pdata.tx_level_shift_en)
gpio_set_value_cansleep(hi->pdata.tx_level_shift_en, 1);
}
}
bool Tri_state_dongle_GPIO0(void)
{
bool result = true;
#if 1
#define INTR_CBUS1_DESIRED_MASK (BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6)
#define UNMASK_CBUS1_INTERRUPTS I2C_WriteByte(CBUS_SLAVE_ADDR, 0x09, INTR_CBUS1_DESIRED_MASK)
#define MASK_CBUS1_INTERRUPTS I2C_WriteByte(CBUS_SLAVE_ADDR, 0x09, 0x00)
#define INTR_CBUS2_DESIRED_MASK (BIT_2 | BIT_3 | BIT_4)
#define UNMASK_CBUS2_INTERRUPTS I2C_WriteByte(CBUS_SLAVE_ADDR, 0x1F, INTR_CBUS2_DESIRED_MASK)
#define MASK_CBUS2_INTERRUPTS I2C_WriteByte(CBUS_SLAVE_ADDR, 0x1F, 0x00)
int timeout = 100;
MASK_CBUS1_INTERRUPTS;
MASK_CBUS2_INTERRUPTS;
//don't activate this function before problem solved
return result;
while(mscCmdInProgress && --timeout) {
hr_msleep(1);
}
printk("%s: timeout = %d\n", __func__, timeout);
if(!timeout) {
result = false;
goto l_end;
}
#endif
I2C_WriteByte(CBUS_SLAVE_ADDR,0x13, 0x33); // enable backdoor access
I2C_WriteByte(CBUS_SLAVE_ADDR,0x14, 0x80);
I2C_WriteByte(CBUS_SLAVE_ADDR,0x12, 0x08);
// Set GPIO0=Input
I2C_WriteByte(CBUS_SLAVE_ADDR, 0xc0, 0xff); // main page ; FE for Cbus page
I2C_WriteByte(CBUS_SLAVE_ADDR, 0xc1, 0x7F); // offset
I2C_WriteByte(CBUS_SLAVE_ADDR, 0xc2, 0xFF); // data set GPIO=input
I2C_WriteByte(CBUS_SLAVE_ADDR, 0x20, 0x02); // burst length-1
I2C_WriteByte(CBUS_SLAVE_ADDR, 0x13, 0x48); // offset in scratch pad
I2C_WriteByte(CBUS_SLAVE_ADDR, 0x12, 0x10); // trig this command
I2C_WriteByte(CBUS_SLAVE_ADDR,0x13, 0x33); // disable backdoor access
I2C_WriteByte(CBUS_SLAVE_ADDR,0x14, 0x00);
I2C_WriteByte(CBUS_SLAVE_ADDR,0x12, 0x08);
#if 1
l_end:
UNMASK_CBUS2_INTERRUPTS;
UNMASK_CBUS1_INTERRUPTS;
#endif
return result;
}
static void
mddi_novatec_power(struct msm_mddi_client_data *client_data, int on)
{
if (on) {
if(axi_clk)
clk_set_rate(axi_clk, 192000000);
vreg_enable(V_LCM_2V85);
hr_msleep(3);
vreg_disable(V_LCM_2V85);
hr_msleep(50);
vreg_enable(V_LCM_2V85);
vreg_enable(V_LCMIO_1V8);
hr_msleep(2);
gpio_set_value(SPEEDY_LCD_RSTz, 1);
hr_msleep(1);
gpio_set_value(SPEEDY_LCD_RSTz, 0);
hr_msleep(1);
gpio_set_value(SPEEDY_LCD_RSTz, 1);
hr_msleep(60);
} else {
gpio_set_value(SPEEDY_LCD_RSTz, 0);
hr_msleep(10);
vreg_disable(V_LCMIO_1V8);
vreg_disable(V_LCM_2V85);
}
}
static void mecha_auo_panel_power(bool on_off)
{
if (!!on_off) {
LCMDBG("%s(%d):\n", __func__, on_off);
gpio_set_value(MECHA_LCD_RSTz, 1);
udelay(500);
gpio_set_value(MECHA_LCD_RSTz, 0);
udelay(500);
gpio_set_value(MECHA_LCD_RSTz, 1);
hr_msleep(20);
panel_gpio_switch(on_off);
} else {
LCMDBG("%s(%d):\n", __func__, on_off);
gpio_set_value(MECHA_LCD_RSTz, 1);
hr_msleep(70);
panel_gpio_switch(on_off);
}
}
/* Access function pointed by ctl_ops to call control operations */
static int aic3008_config(CODEC_SPI_CMD *cmds, int size)
{
int i, retry, ret;
unsigned char data;
if(!aic3008_power_ctl->isPowerOn)
{
AUD_INFO("aic3008_config: AIC3008 is power off now");
return -EINVAL;
}
if (!codec_spi_dev) {
AUD_ERR("no spi device\n");
return -EFAULT;
}
if (cmds == NULL) {
AUD_ERR("invalid spi parameters\n");
return -EINVAL;
}
/* large dsp image use bulk mode to transfer */
if (size < 1000) {
for (i = 0; i < size; i++) {
switch (cmds[i].act) {
case 'w':
codec_spi_write(cmds[i].reg, cmds[i].data, true);
break;
case 'r':
for (retry = AIC3008_MAX_RETRY; retry > 0; retry--) {
ret = codec_spi_read(cmds[i].reg, &data, true);
if (ret < 0) {
AUD_ERR("read fail %d, retry\n", ret);
hr_msleep(1);
} else if (data == cmds[i].data) {
AUD_DBG("data == cmds\n");
break;
}
}
if (retry <= 0)
AUD_DBG("3008 power down procedure,"
" flag 0x%02X=0x%02X(0x%02X)\n",
cmds[i].reg, ret, cmds[i].data);
break;
case 'd':
msleep(cmds[i].data);
break;
default:
break;
}
}
} else {
/* use bulk to transfer large data */
spi_write_table_parsepage(cmds, size);
AUD_DBG("Here is bulk mode\n");
}
return 0;
}
static void
mddi_novatec_power(struct msm_mddi_client_data *client_data, int on)
{
int rc;
unsigned config;
B(KERN_DEBUG "%s(%d)\n", __func__, __LINE__);
if (on) {
if(axi_clk)
clk_set_rate(axi_clk, 192000000);
config = PCOM_GPIO_CFG(KINGDOM_MDDI_TE, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(KINGDOM_LCD_ID1, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(KINGDOM_LCD_ID0, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
if(skuid == 0x2) // incell
gpio_set_value(105, 0);
else // not incell
gpio_set_value(V_LCM_3V_EN, 0);
hr_msleep(1);
if(skuid == 0x2)
gpio_set_value(105, 1);
else
gpio_set_value(V_LCM_3V_EN, 1);
hr_msleep(1);
vreg_enable(V_LCMIO_1V8);
hr_msleep(6);
gpio_set_value(KINGDOM_LCD_RSTz, 1);
hr_msleep(1);
gpio_set_value(KINGDOM_LCD_RSTz, 0);
hr_msleep(1);
gpio_set_value(KINGDOM_LCD_RSTz, 1);
hr_msleep(6);
} else {
gpio_set_value(KINGDOM_LCD_RSTz, 0);
hr_msleep(120);
vreg_disable(V_LCMIO_1V8);
hr_msleep(1);
if(skuid == 0x2) // incell
gpio_set_value(105, 0);
else // not incell
gpio_set_value(V_LCM_3V_EN, 0);
config = PCOM_GPIO_CFG(KINGDOM_MDDI_TE, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(KINGDOM_LCD_ID1, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
config = PCOM_GPIO_CFG(KINGDOM_LCD_ID0, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA);
rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);
}
}
static int express_smd_panel_shutdown(struct msm_lcdc_panel_ops *ops)
{
express_adjust_backlight(0);
hr_msleep(250);
mutex_lock(&panel_lock);
express_panel_power(0);
atomic_set(&lcm_init_done, 0);
mutex_unlock(&panel_lock);
return 0;
}
static void spade_auo_panel_power(bool on_off)
{
if (!!on_off) {
LCMDBG("(%d):\n", on_off);
gpio_set_value(SPADE_LCD_RSTz, 1);
udelay(500);
gpio_set_value(SPADE_LCD_RSTz, 0);
udelay(500);
gpio_set_value(SPADE_LCD_RSTz, 1);
hr_msleep(20);
config_gpio_table( display_on_gpio_table,
ARRAY_SIZE(display_on_gpio_table));
} else {
LCMDBG("%s(%d):\n", __func__, on_off);
gpio_set_value(SPADE_LCD_RSTz, 1);
hr_msleep(70);
config_gpio_table( display_off_gpio_table,
ARRAY_SIZE(display_off_gpio_table));
}
}
static int lcm_write_tb(struct lcm_cmd cmd_table[], unsigned size)
{
int i;
for (i = 0; i < size; i++) {
lcm_write_cmd(cmd_table[i].reg, cmd_table[i].val);
if (cmd_table[i].delay)
hr_msleep(cmd_table[i].delay);
}
return 0;
}
static int amoled_panel_blank(struct msm_lcdc_panel_ops *panel_data)
{
LCMDBG("%s\n", __func__);
mutex_lock(&panel_lock);
qspi_send_9bit(&blank_cmd);
hr_msleep(120);
mutex_unlock(&panel_lock);
amoled_panel_power(0);
led_trigger_event(amoled_lcd_backlight, LED_OFF);
return 0;
}
static int oled_panel_uninit(struct msm_lcdc_panel_ops *ops)
{
unsigned id, off = 1;
printk(KERN_DEBUG "%s: enter.\n", __func__);
atomic_set(&gate, 0);
if (!panel_type) {
/* start power off sequence */
/*Reset pull low*/
gpio_set_value(LEGEND_GPIO_LCD_RST_N, 0);
hr_msleep(100);
/* config LCDC pin mux to gpio function */
config_legend_display_off_gpios();
gpio_set_value(LEGEND_LCD_B2,0);
mdelay(15);
/* turn off VCI */
id = PM_VREG_PDOWN_RFRX2_ID;
msm_proc_comm(PCOM_VREG_PULLDOWN, &off, &id);
vreg_disable(vreg_lcm_2v8);
/* turn off VDD3 */
id = PM_VREG_PDOWN_AUX_ID;
msm_proc_comm(PCOM_VREG_PULLDOWN, &off, &id);
vreg_disable(vreg_lcm_1v8);
mdelay(10);
} else {
id = PM_VREG_PDOWN_RFRX2_ID;
msm_proc_comm(PCOM_VREG_PULLDOWN, &off, &id);
vreg_disable(vreg_lcm_2v8);
hr_msleep(20);
id = PM_VREG_PDOWN_AUX_ID;
msm_proc_comm(PCOM_VREG_PULLDOWN, &off, &id);
vreg_disable(vreg_lcm_1v8);
hr_msleep(20);
}
microp_spi_vote_enable(SPI_LCM, 0);
return 0;
}
static int
chacha_AUO_panel_unblank(struct msm_mddi_bridge_platform_data *bridge_data,
struct msm_mddi_client_data *client_data)
{
B(KERN_DEBUG "%s: enter.\n", __func__);
hr_msleep(50);
atomic_set(&lcm_init_done, 1);
chacha_backlight_switch(client_data, LED_FULL);
return 0;
}
static int cp5_wl_lcd_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct mipi_panel_info *mipi;
struct msm_panel_info *pinfo;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
pinfo = &mfd->panel_info;
mipi = &mfd->panel_info.mipi;
if (mfd->init_mipi_lcd == 0) {
PR_DISP_INFO("Display On - 1st time\n");
mfd->init_mipi_lcd = 1;
} else
PR_DISP_INFO("Display On \n");
/* Pull reset pin for JDI panel */
if (panel_type == PANEL_ID_CP5_JDI_NOVATEK) {
hr_msleep(2);
gpio_set_value(MSM_LCD_RSTz, 1);
hr_msleep(1);
gpio_set_value(MSM_LCD_RSTz, 0);
hr_msleep(1);
gpio_set_value(MSM_LCD_RSTz, 1);
hr_msleep(20);
}
mipi_dsi_cmds_tx(&cp5_wl_panel_tx_buf, init_on_cmds, init_on_cmds_count);
atomic_set(&lcd_power_state, 1);
PR_DISP_DEBUG("Init done\n");
return 0;
}
static int
speedy_panel_unblank(struct msm_mddi_bridge_platform_data *bridge_data,
struct msm_mddi_client_data *client_data)
{
B(KERN_DEBUG "%s\n", __func__);
client_data->auto_hibernate(client_data, 0);
hr_msleep(50);
client_data->remote_write(client_data, 0x24, 0x5300);
client_data->remote_write(client_data, 0x0A, 0x22C0);
speedy_backlight_switch(LED_FULL);
client_data->auto_hibernate(client_data, 1);
return 0;
}
