static int sdc16x25_8_cmd_power_on( struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int ret; u8 cmd; PSB_DEBUG_ENTRY("\n"); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } /* display on */ cmd = set_display_on; ret = mdfld_dsi_send_mcs_short_lp(sender, cmd, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (ret) goto err_out; return 0; err_out: DRM_ERROR("failed to send command %#x\n", cmd); return ret; }
static int mdfld_auo_dsi_cmd_set_brightness(struct mdfld_dsi_config *dsi_config, int level) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); u8 backlight_value; u8 param[4]; int err = 0; PSB_DEBUG_ENTRY("level = %d\n", level); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } backlight_value = ((level * 0xff) / 100) & 0xff; param[0] = backlight_value; param[1] = 0x00; param[2] = 0x00; err = mdfld_dsi_send_dcs(sender, write_display_brightness, param, 3, CMD_DATA_SRC_SYSTEM_MEM, MDFLD_DSI_SEND_PACKAGE); if (err) DRM_ERROR("DCS 0x%x sent failed\n", exit_sleep_mode); return 0; }
int mdfld_dsi_sharp25x16_ic_init(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); struct drm_device *dev = dsi_config->dev; int err = 0; int i; PSB_DEBUG_ENTRY("\n"); if (!sender) { DRM_ERROR("Cannot get sender\n"); return -EINVAL; } for (i = 0; i < 7; i++) { err = mdfld_dsi_send_gen_long_hs(sender, sharp_mode_set_data[i], 3, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Mode data\n", __func__, __LINE__); goto ic_init_err; } REG_WRITE(MIPIA_HS_GEN_CTRL_REG, 5); } return 0; ic_init_err: err = -EIO; return err; }
static int mdfld_dsi_h8c7_cmd_set_brightness(struct mdfld_dsi_config *dsi_config, int level) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int duty_val = 0; static bool b_cabc_initialized = false; if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } if (drm_psb_enable_cabc && !b_cabc_initialized) { h8c7_disable_cabc[1] = 0x2; mdfld_dsi_send_mcs_long_hs(sender, h8c7_disable_cabc, sizeof(h8c7_disable_cabc), 0); mdelay(5); mdfld_dsi_send_gen_long_hs(sender, h8c7_mcs_protect_off, 4, 0); mdfld_dsi_send_mcs_long_hs(sender, h8c7_set_cabc_gain, 10, 0); mdfld_dsi_send_gen_long_hs(sender, h8c7_mcs_protect_on, 4, 0); b_cabc_initialized = true; } duty_val = (255 * level) / 100; h8c7_set_brightness[1] = duty_val; mdfld_dsi_send_mcs_short_lp(sender, h8c7_set_brightness[0], h8c7_set_brightness[1], 1, 0); return 0; }
static int otm1284a_vid_power_off(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err; printk("[DISP] %s\n", __func__); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } cancel_delayed_work_sync(&orise1284a_panel_reset_delay_work); usleep_range(1000, 1500); /* Send power off command*/ err = mdfld_dsi_send_mcs_short_hs(sender, MIPI_DCS_SET_DISPLAY_OFF, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("Failed to Set Display Off\n"); return err; } err = mdfld_dsi_send_mcs_short_hs(sender, MIPI_DCS_ENTER_SLEEP_MODE, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("Failed to Enter Sleep Mode\n"); return err; } usleep_range(50000, 55000); return 0; }
static int sharp10x19_cmd_set_brightness( struct mdfld_dsi_config *dsi_config, int level) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); u8 duty_val = 0; struct drm_device *dev = dsi_config->dev; PSB_DEBUG_ENTRY("level = %d\n", level); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } duty_val = (0xFF * level) / 255; mdfld_dsi_send_mcs_short_hs(sender, write_display_brightness, duty_val, 1, MDFLD_DSI_SEND_PACKAGE); if (is_dual_panel(dev)) { sender->work_for_slave_panel = true; mdfld_dsi_send_mcs_short_hs(sender, write_display_brightness, duty_val, 1, MDFLD_DSI_SEND_PACKAGE); sender->work_for_slave_panel = false; } return 0; }
static int otm1901a_vid_drv_ic_init(struct mdfld_dsi_config *dsi_config){ struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int i; if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } printk("[DISP] %s\n", __func__); gpio_set_value_cansleep(panel_reset_gpio, 0); usleep_range(10000, 10100); gpio_set_value_cansleep(panel_reset_gpio, 1); usleep_range(10000, 10100); /* panel initial settings */ mdfld_dsi_send_mcs_short_lp(sender, 0x00, 0x00, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_gen_long_lp(sender, cm_FF_1, sizeof(cm_FF_1), MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_lp(sender, 0x00, 0x80, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_gen_long_lp(sender, cm_FF_2, sizeof(cm_FF_2), MDFLD_DSI_SEND_PACKAGE); for(i = 0; i < otm1901a_power_on_table_size; i++) send_mipi_cmd_orise(sender, &otm1901a_power_on_table[i]); mdfld_dsi_send_mcs_short_lp(sender, 0x11, 0, 0, MDFLD_DSI_SEND_PACKAGE); mdelay(200); mdfld_dsi_send_mcs_short_lp(sender, 0x29, 0, 0, MDFLD_DSI_SEND_PACKAGE); return 0; }
static int ls04x_drv_ic_init(struct mdfld_dsi_config *dsi_config) { int r = 0; u8 data[16]; struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); PSB_DEBUG_ENTRY("\n"); if (!sender) return -EINVAL; sender->status = MDFLD_DSI_PKG_SENDER_FREE; memset(data, 0, sizeof(data)); mdfld_dsi_send_gen_short_hs(sender, ls04x_mcap[0], ls04x_mcap[1], 2, MDFLD_DSI_SEND_PACKAGE); r = mdfld_dsi_read_gen_hs(sender, ls04x_device_code_read[0], 0, 1, data, 5); PSB_DEBUG_GENERAL("device code read: %d %02x %02x %02x %02x %02x\n", r, data[0], data[1], data[2], data[3], data[4]); if ((data[2] == 0x14) && (data[3] == 0x13)) r = ls04x_igzo_drv_ic_init(dsi_config); else if ((data[2] == 0x34) && (data[3] == 0x15)) r = ls04x_cgs_drv_ic_init(dsi_config); else if ((data[2] == 0x94) && (data[3] == 0x31)) r = ls04x_igzo_g8_drv_ic_init(dsi_config); else DRM_INFO("unknown device code: %02x %02x\n", data[2], data[3]); return r; }
static int ls04x_cgs_cmd_set_brightness(struct mdfld_dsi_config *dsi_config, int level) { if (drm_psb_enable_cabc) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); if (!sender) return -EINVAL; u8 brightness[3] = {0, }; brightness[0] = write_display_brightness; brightness[1] = 0; brightness[2] = (level * 255 / 100) & 0xff; mdfld_dsi_send_mcs_long_hs(sender, brightness, sizeof(brightness), MDFLD_DSI_SEND_PACKAGE); } else { u8 brightness[2]; PSB_DEBUG_ENTRY("%d\n", level); brightness[0] = 0x0a; brightness[1] = level * 255 / 100; i2c_master_send(i2c_client, brightness, sizeof(brightness)); brightness[0] = 0x0b; i2c_master_send(i2c_client, brightness, sizeof(brightness)); } return 0; }
static int ls04x_cgs_drv_ic_init(struct mdfld_dsi_config *dsi_config) { DRM_INFO("CGS panel detected!\n"); pwm_width = 8; return handle_dsi_init_commands(mdfld_dsi_get_pkg_sender(dsi_config), cgs_init_commands); }
static int samsungWQHD_cmd_power_off(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err; printk("[DISP] %s\n", __func__); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } usleep_range(1000, 1500); /* Send power off command*/ err = mdfld_dsi_send_mcs_short_hs(sender, 0x28, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("Failed to Set Display Off\n"); return err; } usleep_range(35000, 35500); err = mdfld_dsi_send_mcs_short_hs(sender, 0x10, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("Failed to Enter Sleep Mode\n"); return err; } usleep_range(150000, 150500); /* Turn off VBAT*/ gpio_set_value_cansleep(stb1_en_gpio, 0); gpio_set_value_cansleep(stb2_en_gpio, 0); return 0; }
static int ls04x_igzo_drv_ic_init(struct mdfld_dsi_config *dsi_config) { DRM_INFO("IGZO panel detected!\n"); pwm_width = 12; return handle_dsi_init_commands(mdfld_dsi_get_pkg_sender(dsi_config), igzo_init_commands); }
static int mdfld_dsi_sharp25x16_set_brightness(struct mdfld_dsi_config *dsi_config, int level) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); struct drm_device *dev = dsi_config->dev; u8 duty_val = 0; PSB_DEBUG_ENTRY("level = %d\n", level); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } duty_val = (0xFF * level) / 255; if (duty_val < 12) duty_val = 0; sharp_set_brightness[2] = duty_val; mdfld_dsi_send_gen_long_hs(sender, sharp_set_brightness, 3, MDFLD_DSI_SEND_PACKAGE); REG_WRITE(MIPIA_HS_GEN_CTRL_REG, 5); return 0; }
static int jdi25x16_cmd_set_brightness( struct mdfld_dsi_config *dsi_config, int level) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); u8 duty_val = 0; int i; PSB_DEBUG_ENTRY("level = %d\n", level); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } duty_val = (0xFF * level) / 255; for (i = 0; i < 2; i++) { if (i == 0) sender->work_for_slave_panel = false; else sender->work_for_slave_panel = true; /* * Set maximum brightness here. AOB needs to be modified * to get real brightness setting */ mdfld_dsi_send_mcs_short_hs(sender, write_display_brightness, 0x90, 1, MDFLD_DSI_SEND_PACKAGE); } sender->work_for_slave_panel = false; return 0; }
static void smd_qhd_amoled_cmd_get_mtp_set4(struct mdfld_dsi_config *dsi_config, u8 *elvss, u8 *white_pt_adj) { static bool is_cached; static u8 cached_elvss = 0x08; /* init to default value per spec */ static u8 cached_white_pt_adj = 0xff; struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int r = 0; u8 reg_data[2]; u8 ver; if (!is_cached) { r = mdfld_dsi_read_mcs_hs(sender, 0xd4, reg_data, 2); if (r != 2) { DRM_ERROR("Failed to read MTP_SET4, r = %d\n", r); } else { cached_elvss = reg_data[0] & 0x3f; if (mdfld_mot_cmn_get_panel_cntrl_ver(sender, &ver)) DRM_ERROR("Failed to get panel controller " "version\n"); else { if (ver >= 1) cached_white_pt_adj = (reg_data[1] & 0xf0) >> 4; printk(KERN_ALERT"Read MTP_SET4, elvss = 0x%02x," "white_pt = 0x%02x\n", cached_elvss, cached_white_pt_adj); is_cached = true; } } }
static int __dpi_enter_ulps_locked(struct mdfld_dsi_config *dsi_config, int offset) { struct mdfld_dsi_hw_registers *regs = &dsi_config->regs; struct mdfld_dsi_hw_context *ctx = &dsi_config->dsi_hw_context; struct drm_device *dev = dsi_config->dev; struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); if (!sender) { DRM_ERROR("pkg sender is NULL\n"); return -EINVAL; } ctx->device_ready = REG_READ(regs->device_ready_reg + offset); if (ctx->device_ready & DSI_POWER_STATE_ULPS_MASK) { DRM_ERROR("Broken ULPS states\n"); return -EINVAL; } /*wait for all FIFOs empty*/ mdfld_dsi_wait_for_fifos_empty(sender); /*inform DSI host is to be put on ULPS*/ ctx->device_ready |= DSI_POWER_STATE_ULPS_ENTER; REG_WRITE(regs->device_ready_reg + offset, ctx->device_ready); PSB_DEBUG_ENTRY("entered ULPS state\n"); return 0; }
static int samsungWQHD_cmd_drv_ic_init(struct mdfld_dsi_config *dsi_config){ struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int i; if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } printk("[DISP] %s\n", __func__); /* HW_RST control */ gpio_set_value_cansleep(panel_reset_gpio, 1); usleep_range(1000, 1500); gpio_set_value_cansleep(panel_reset_gpio, 0); usleep_range(1000, 1500); gpio_set_value_cansleep(panel_reset_gpio, 1); usleep_range(10000, 10500); /* HW_RST control */ /* panel initial settings */ mdfld_dsi_send_mcs_short_lp(sender, 0x11, 0, 0, MDFLD_DSI_SEND_PACKAGE); usleep_range(20000, 20100); for (i = 0; i < samsungWQHD_power_on_table_size; i++) send_mipi_cmd_mcs(sender, &samsungWQHD_power_on_table[i]); return 0; }
void mdfld_dsi_dpi_set_color_mode(struct mdfld_dsi_config *dsi_config , bool on) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err; u32 spk_pkg = (on == true) ? MDFLD_DSI_DPI_SPK_COLOR_MODE_ON : MDFLD_DSI_DPI_SPK_COLOR_MODE_OFF; PSB_DEBUG_ENTRY("Turn color mode %s pkg value= %d...\n", (on ? "on" : "off"), spk_pkg); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return ; } /*send turn on/off color mode packet*/ err = mdfld_dsi_send_dpi_spk_pkg_hs(sender, spk_pkg); if (err) { DRM_ERROR("Failed to send turn on packet\n"); return ; } PSB_DEBUG_ENTRY("Turn color mode %s successful.\n", (on ? "on" : "off")); return; }
static int gi_renesas_dbi_ic_init(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); if (!sender) { DRM_ERROR("Cannot get sender\n"); return -EINVAL; } PSB_DEBUG_ENTRY("\n"); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_mcs_protect_on, 2, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_mcs_mem_access, 5, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_mcs_panel_driving, 9, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_disp_timming, 6, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_src_timming, 5, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_polarity_setting, 2, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_gamma_a, 25, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_gamma_b, 25, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_gamma_c, 25, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_power_setting, 17, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_vcom_setting, 5, 0); mdfld_dsi_send_mcs_long_hs(sender, gi_er61529_set_pixel_format, 2, 0); mdfld_dsi_send_mcs_long_hs(sender, gi_er61529_set_column_address, 5, 0); mdfld_dsi_send_mcs_long_hs(sender, gi_er61529_set_page_address, 5, 0); mdfld_dsi_send_mcs_long_hs(sender, gi_er61529_set_address_mode, 2, 0); mdfld_dsi_send_mcs_long_hs(sender, gi_er61529_set_te_scanline, 3, 0); mdfld_dsi_send_mcs_long_hs(sender, gi_er61529_set_tear_on, 2, 0); mdfld_dsi_send_gen_long_hs(sender, gi_er61529_mcs_protect_off, 2, 0); return 0; }
static int orise1284a_vid_drv_ic_reset_workaround(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int i; sender->status = MDFLD_DSI_PKG_SENDER_FREE; mdfld_dsi_send_mcs_short_hs(sender, 0x11, 0, 0, MDFLD_DSI_SEND_PACKAGE); mdelay(5); mdfld_dsi_send_mcs_short_hs(sender, 0x29, 0, 0, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0x00, 0x80, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0xFF, 0x12, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0xFF, 0x84, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0x00, 0x90, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0xB6, 0xB6, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0x00, 0x92, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0xB3, 0x06, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0x00, 0x80, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0xFF, 0x00, 1, MDFLD_DSI_SEND_PACKAGE); mdfld_dsi_send_mcs_short_hs(sender, 0xFF, 0x00, 1, MDFLD_DSI_SEND_PACKAGE); if (sender->status == MDFLD_DSI_CONTROL_ABNORMAL) { printk("[DISP] %s MDFLD_DSI_CONTROL_ABNORMAL !!\n", __func__); return -EIO; } return 0; }
static int mdfld_dsi_pr2_set_brightness(struct mdfld_dsi_config *dsi_config, int level) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int duty_val = 0; PSB_DEBUG_ENTRY("level = %d\n", level); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } duty_val = (255 * level) / 100; mdfld_dsi_send_gen_long_hs(sender, pr2_mcs_protect_off, 2, 0); /*update duty value*/ pr2_backlight_control_2[2] = duty_val; if (drm_psb_enable_cabc) { if (level < 50) { pr2_backlight_control_1[1] = 0x00; pr2_backlight_control_1[2] = 0x0f; pr2_backlight_control_1[3] = 0x0f; } else if (level < 66) { /* Case 10% */ pr2_backlight_control_1[1] = 0x01; pr2_backlight_control_1[2] = 0x07; pr2_backlight_control_1[3] = 0x07; pr2_backlight_control_1[6] = 0xe4; pr2_backlight_control_1[7] = 0xe4; } else if (level < 82) { /* Case 20% */ pr2_backlight_control_1[1] = 0x01; pr2_backlight_control_1[2] = 0x0b; pr2_backlight_control_1[3] = 0x0b; pr2_backlight_control_1[6] = 0xd4; pr2_backlight_control_1[7] = 0xd4; } else { /* Case 30% */ pr2_backlight_control_1[1] = 0x01; pr2_backlight_control_1[2] = 0x0f; pr2_backlight_control_1[3] = 0x0f; pr2_backlight_control_1[6] = 0xc8; pr2_backlight_control_1[7] = 0xc8; } mdfld_dsi_send_gen_long_hs(sender, pr2_backlight_control_1, 24, 0); } mdfld_dsi_send_gen_long_hs(sender, pr2_backlight_control_2, 8, 0); mdfld_dsi_send_gen_long_hs(sender, pr2_mcs_protect_on, 4, 0); return 0; }
static int __mdfld_auo_dsi_power_off(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); u8 cmd = 0; int err = 0; PSB_DEBUG_ENTRY("Turn off video mode TMD panel...\n"); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } /*enter sleep mode*/ cmd = enter_sleep_mode; err = mdfld_dsi_send_dcs(sender, cmd, NULL, 0, CMD_DATA_SRC_SYSTEM_MEM, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("DCS 0x%x sent failed\n", cmd); return err; } msleep(120); /*set tear off*/ cmd = set_tear_off; err = mdfld_dsi_send_dcs(sender, cmd, NULL, 0, CMD_DATA_SRC_SYSTEM_MEM, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("DCS 0x%x sent failed\n", cmd); return err; } /*set display off*/ cmd = set_display_off; err = mdfld_dsi_send_dcs(sender, cmd, NULL, 0, CMD_DATA_SRC_SYSTEM_MEM, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("DCS 0x%x sent failed\n", cmd); return err; } return err; }
static int sharp25x16_cmd_drv_ic_init(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); struct drm_device *dev = dsi_config->dev; int err = 0; int i; PSB_DEBUG_ENTRY("\n"); if (!sender) { DRM_ERROR("Cannot get sender\n"); return -EINVAL; } for (i = 0; i < 5; i++) { err = mdfld_dsi_send_gen_long_lp(sender, sharp_mode_set_data[i], 3, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Mode data\n", __func__, __LINE__); goto ic_init_err; } REG_WRITE(MIPIA_LP_GEN_CTRL_REG, 5); } err = mdfld_dsi_send_mcs_long_lp(sender, sharp_clumn_addr_left, 5, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Clumn Address\n", __func__, __LINE__); goto ic_init_err; } REG_WRITE(MIPIA_LP_GEN_CTRL_REG, 5); err = mdfld_dsi_send_mcs_long_lp(sender, sharp_page_addr_left, 5, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Page Address\n", __func__, __LINE__); goto ic_init_err; } REG_WRITE(MIPIA_LP_GEN_CTRL_REG, 5); err = mdfld_dsi_send_mcs_short_lp(sender, set_tear_on, 0x00, 1, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Tear On\n", __func__, __LINE__); goto ic_init_err; } return 0; ic_init_err: err = -EIO; return err; }
static int mdfld_dsi_sharp10x19_drv_ic_init(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err = 0; if (!sender) { DRM_ERROR("Cannot get sender\n"); return -EINVAL; } PSB_DEBUG_ENTRY("\n"); err = mdfld_dsi_send_mcs_short_hs(sender, access_protect, 0x4, 1 , 0); if (err) { DRM_ERROR("%s: %d: Set access_protect off\n", __func__, __LINE__); goto ic_init_err; } err = mdfld_dsi_send_mcs_short_hs(sender, 0xd6, 0x01, 1 , 0); if (err) { DRM_ERROR("%s: %d: Remove NVM reload\n", __func__, __LINE__); goto ic_init_err; } err = mdfld_dsi_send_mcs_short_hs(sender, write_ctrl_display, 0xc, 1 , 0); if (err) { DRM_ERROR("%s: %d: Set backlight\n", __func__, __LINE__); goto ic_init_err; } err = mdfld_dsi_send_mcs_short_hs(sender, write_ctrl_cabc, dsi_config->cabc_mode, 1, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: write_ctrl_cabc\n", __func__, __LINE__); goto ic_init_err; } err = mdfld_dsi_send_mcs_short_hs(sender, set_pixel_format, 0x77, 1, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: set_pixel_format\n", __func__, __LINE__); goto ic_init_err; } return 0; ic_init_err: err = -EIO; return err; }
static int __dpi_enter_ulps_locked(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_hw_registers *regs = &dsi_config->regs; struct mdfld_dsi_hw_context *ctx = &dsi_config->dsi_hw_context; struct drm_device *dev = dsi_config->dev; struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int retry = 5; ulps_recovery: PSB_DEBUG_ENTRY("\n"); ctx->device_ready = REG_READ(regs->device_ready_reg); if (ctx->device_ready & DSI_POWER_STATE_ULPS_MASK) { DRM_ERROR("Broken ULPS states\n"); return -EINVAL; } if (!sender) { DRM_ERROR("Cannot get sender\n"); return -EINVAL; } /* check latch out, expected to be lp11 */ intel_dc_dsi_check_latch_out(dsi_config); /*wait for all FIFOs empty*/ mdfld_dsi_wait_for_fifos_empty(sender); /*inform DSI host is to be put on ULPS*/ ctx->device_ready |= (DSI_POWER_STATE_ULPS_ENTER | DSI_DEVICE_READY); REG_WRITE(regs->device_ready_reg, ctx->device_ready); mdelay(1); /* check latch out, expected to be lp00 */ intel_dc_dsi_check_latch_out(dsi_config); if (intel_dc_dsi_wait_for_lp00(dsi_config)) { DRM_ERROR("faild to wait for lp00 status\n"); DRM_ERROR("reg[0x%x] = 0x%x\n", regs->mipi_reg, REG_READ(regs->mipi_reg)); if (retry--) { DRM_INFO("%s: retry enter ulps (times=%d)\n", __func__, 5-retry); if (__dpi_exit_ulps_locked(dsi_config)) { DRM_ERROR("Failed to exit ULPS\n"); } goto ulps_recovery; } } /* set AFE hold value*/ REG_WRITE(regs->mipi_reg, REG_READ(regs->mipi_reg) & (~PASS_FROM_SPHY_TO_AFE)); DRM_INFO("%s: entered ULPS state\n", __func__); return 0; }
int mdfld_dsi_dsr_update_panel_fb(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_dsr *dsr; struct mdfld_dsi_pkg_sender *sender; int err = 0; if (!dsi_config) { DRM_ERROR("Invalid parameter\n"); return -EINVAL; } dsr = dsi_config->dsr; if (!IS_ANN(dev)) { /*if no dsr attached, return 0*/ if (!dsr) return 0; } PSB_DEBUG_ENTRY("\n"); if (dsi_config->type == MDFLD_DSI_ENCODER_DPI) return 0; mutex_lock(&dsi_config->context_lock); if (!dsi_config->dsi_hw_context.panel_on) { PSB_DEBUG_ENTRY( "if screen off, update fb is not allowed\n"); err = -EINVAL; goto update_fb_out; } /*no pending fb updates, go ahead to send out write_mem_start*/ PSB_DEBUG_ENTRY("send out write_mem_start\n"); sender = mdfld_dsi_get_pkg_sender(dsi_config); if (!sender) { DRM_ERROR("No sender\n"); err = -EINVAL; goto update_fb_out; } err = mdfld_dsi_send_dcs(sender, write_mem_start, NULL, 0, CMD_DATA_SRC_PIPE, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("Failed to send write_mem_start"); err = -EINVAL; goto update_fb_out; } /*clear free count*/ dsr->free_count = 0; update_fb_out: mutex_unlock(&dsi_config->context_lock); return err; }
static int ls04x_igzo_g8_drv_ic_init(struct mdfld_dsi_config *dsi_config) { DRM_INFO("IGZO G8 panel detected!\n"); pwm_width = 8; u8 data[16]; struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); mdfld_dsi_read_gen_hs(sender, ls04x_vcom_setting_igzo_g8[0], 0, 1, data, 11); if (DEFAULT_VCOM_SETTING == data[4]) return handle_dsi_init_commands( mdfld_dsi_get_pkg_sender(dsi_config), igzo_g8_init_commands); else return handle_dsi_init_commands( mdfld_dsi_get_pkg_sender(dsi_config), programed_igzo_g8_init_commands); }
static int mdfld_dsi_jdi_power_off(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err; PSB_DEBUG_ENTRY("\n"); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } /*send SHUT_DOWN packet */ err = mdfld_dsi_send_dpi_spk_pkg_hs(sender, MDFLD_DSI_DPI_SPK_SHUT_DOWN); if (err) { DRM_ERROR("Failed to send turn off packet\n"); goto power_off_err; } /* According HW DSI spec, need to wait for 100ms. */ msleep(100); /* Set Display off */ err = mdfld_dsi_send_mcs_short_hs(sender, set_display_off, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Display On\n", __func__, __LINE__); goto power_off_err; } /* Wait for 1 frame after set_display_on. */ msleep(20); /* Sleep In */ err = mdfld_dsi_send_mcs_short_hs(sender, enter_sleep_mode, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Exit Sleep Mode\n", __func__, __LINE__); goto power_off_err; } /* Wait for 3 frames after enter_sleep_mode. */ msleep(51); /* Can not poweroff VPROG2, because many other module related to * this power supply, such as PSH sensor. */ /*__vpro2_power_ctrl(false);*/ if (bias_en_gpio) gpio_set_value_cansleep(bias_en_gpio, 0); return 0; power_off_err: err = -EIO; return err; }
static int sharp25x16_cmd_power_on( struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err = 0; PSB_DEBUG_ENTRY("\n"); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } err = mdfld_dsi_send_mcs_short_hs(sender, set_address_mode, 0x0, 1, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Address Mode\n", __func__, __LINE__); goto power_err; } // usleep_range(20000, 20100); err = mdfld_dsi_send_mcs_short_hs(sender, set_pixel_format, 0x77, 1, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Pixel format\n", __func__, __LINE__); goto power_err; } /* Sleep Out */ err = mdfld_dsi_send_mcs_short_hs(sender, exit_sleep_mode, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Exit Sleep Mode\n", __func__, __LINE__); goto power_err; } msleep(20); /* Set Display on 0x29 */ err = mdfld_dsi_send_mcs_short_hs(sender, set_display_on, 0, 0, MDFLD_DSI_SEND_PACKAGE); if (err) { DRM_ERROR("%s: %d: Set Display On\n", __func__, __LINE__); goto power_err; } msleep(150); power_err: return err; }
static int mdfld_dsi_pr2_power_on(struct mdfld_dsi_config *dsi_config) { struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config); int err; PSB_DEBUG_ENTRY("\n"); if (!sender) { DRM_ERROR("Failed to get DSI packet sender\n"); return -EINVAL; } /*send TURN_ON packet*/ err = mdfld_dsi_send_dpi_spk_pkg_hs(sender, MDFLD_DSI_DPI_SPK_TURN_ON); if (err) { DRM_ERROR("Failed to send turn on packet\n"); return err; } /** * According HW DSI spec, here need wait for 100ms. This is * not necessary as the code is anyway sleeping 141 ms later * in this function */ mdfld_dsi_send_gen_long_hs(sender, pr2_mcs_protect_off, 2, 0); /*change power state*/ mdfld_dsi_send_mcs_long_hs(sender, pr2_exit_sleep_mode, 4, 0); /*120ms delay is needed between enter and exit sleep mode per spec*/ msleep(120); /*enable PWMON*/ pr2_backlight_control_2[1] |= 0x01; mdfld_dsi_send_mcs_long_hs(sender, pr2_backlight_control_2, 8, 0); /*set display on*/ mdfld_dsi_send_mcs_long_hs(sender, pr2_set_display_on, 4, 0); /* Per panel spec, 21ms delay is needed */ msleep(21); /*Enable BLON , CABC*/ if (drm_psb_enable_cabc) { pr2_backlight_control_1[1] |= 0x01; mdfld_dsi_send_gen_long_hs(sender, pr2_backlight_control_1, 24, 0); DRM_INFO("%s: enable pr2 cabc\n", __func__); } return 0; }