static int icp_hd_power(int on)
{
int rc = 0;
SKYCDBG("%s %s:%d power = %d\n", __FILE__, __func__, __LINE__,on);
if(on) {
//standby control
rc = gpio_tlmm_config(GPIO_CFG(SENSOR_STANDBY_8M, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
if (!rc) {
SKYCDBG("%s %s:%d\n", __FILE__, __func__, __LINE__);
gpio_set_value(SENSOR_STANDBY_8M,0);
}
rc = regulator_enable(s2b_1p2v_8m);
if (rc) {
SKYCERR("%s: Enable regulator s2b_1p2v failed\n", __func__);
goto fail;
}
msleep(1);
rc = regulator_enable(lvs3b_1p8v_8m);
if (rc) {
SKYCERR("%s: Enable regulator mvs0b_1p8v failed\n", __func__);
goto fail;
}
msleep(1);
rc = regulator_enable(mvs0b_1p8v);
if (rc) {
SKYCERR("%s: Enable regulator mvs0b_1p8v failed\n", __func__);
goto fail;
}
msleep(1);
rc = regulator_enable(l20a_2p8v_8m);
if (rc) {
SKYCERR("%s: Enable regulator l20a_2p8v failed\n", __func__);
goto fail;
}
msleep(1);
rc = regulator_enable(l14a_2p8v_8m);
if (rc) {
SKYCERR("%s: Enable regulator l14a_2p8v failed\n", __func__);
goto fail;
}
SKYCDBG("%s %s ON Success:%d\n", __FILE__, __func__, __LINE__);
}
else {
SKYCDBG("%s %s:%d power \n", __FILE__, __func__, __LINE__);
#if 0
if(1)//s2b_1p2v)
{
rc = regulator_disable(s2b_1p2v_8m);
if (rc){
SKYCERR("%s: Disable regulator s2b_1p2v failed\n", __func__);
goto fail;
}
regulator_put(s2b_1p2v_8m);
}
if(mvs0b_1p8v) {
rc = regulator_disable(mvs0b_1p8v);
if (rc){
SKYCERR("%s: Disable regulator mvs0b_1p8v failed\n", __func__);
goto fail;
}
}
#endif
SKYCDBG("%s %s:%d power \n", __FILE__, __func__, __LINE__);
if(1)//mvs0b_1p8v)
{
rc = regulator_disable(lvs3b_1p8v_8m);
if (rc){
SKYCERR("%s: Disable regulator lvs3b_1p8v failed\n", __func__);
goto fail;
}
}
SKYCDBG("%s %s:%d power \n", __FILE__, __func__, __LINE__);
if(1)//l20a_2p8v)
{
rc = regulator_disable(l20a_2p8v_8m);
if (rc){
SKYCERR("%s: Disable regulator l20a_2p8v failed\n", __func__);
goto fail;
}
regulator_put(l20a_2p8v_8m);
}
SKYCDBG("%s %s:%d power \n", __FILE__, __func__, __LINE__);
if(1)//l14a_2p8v)
{
rc = regulator_disable(l14a_2p8v_8m);
if (rc){
SKYCERR("%s: Disable regulator l14a_2p8v failed\n", __func__);
goto fail;
}
regulator_put(l14a_2p8v_8m);
}
SKYCDBG("%s %s OFF Success:%d\n", __FILE__, __func__, __LINE__);
}
return rc;
fail:
SKYCERR("%s %s Failed!:%d\n", __FILE__, __func__, __LINE__);
if(l20a_2p8v_8m){
regulator_put(l20a_2p8v_8m);
}
if(s2b_1p2v_8m){
regulator_put(s2b_1p2v_8m);
}
if(l14a_2p8v_8m){
regulator_put(l14a_2p8v_8m);
}
return rc;
}
void sku3_lcdc_lcd_camera_power_init(void)
{
int rc = 0;
u32 socinfo = socinfo_get_platform_type();
/* LDO_EXT2V8 */
if (gpio_request(SKU3_LCDC_LCD_CAMERA_LDO_2V8, "lcd_camera_ldo_2v8")) {
pr_err("failed to request gpio lcd_camera_ldo_2v8\n");
return;
}
rc = gpio_tlmm_config(GPIO_CFG(SKU3_LCDC_LCD_CAMERA_LDO_2V8, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("%s:unable to enable lcd_camera_ldo_2v8!\n", __func__);
goto fail_gpio2;
}
/* LDO_EVT1V8 */
if (socinfo == 0x0B) {
if (gpio_request(SKU3_LCDC_LCD_CAMERA_LDO_1V8,
"lcd_camera_ldo_1v8")) {
pr_err("failed to request gpio lcd_camera_ldo_1v8\n");
goto fail_gpio1;
}
rc = gpio_tlmm_config(GPIO_CFG(SKU3_LCDC_LCD_CAMERA_LDO_1V8, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("%s: unable to enable lcdc_camera_ldo_1v8!\n",
__func__);
goto fail_gpio1;
}
} else if (socinfo == 0x0F || machine_is_msm8625_qrd7()) {
if (gpio_request(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8,
"lcd_camera_ldo_1v8")) {
pr_err("failed to request gpio lcd_camera_ldo_1v8\n");
goto fail_gpio1;
}
rc = gpio_tlmm_config(GPIO_CFG(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8,
0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("%s: unable to enable lcdc_camera_ldo_1v8!\n",
__func__);
goto fail_gpio1;
}
}
rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_truly_lcdc),
regs_truly_lcdc);
if (rc)
pr_err("%s: could not get regulators: %d\n", __func__, rc);
rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_truly_lcdc),
regs_truly_lcdc);
if (rc)
pr_err("%s: could not set voltages: %d\n", __func__, rc);
return;
fail_gpio1:
if (socinfo == 0x0B)
gpio_free(SKU3_LCDC_LCD_CAMERA_LDO_1V8);
else if (socinfo == 0x0F || machine_is_msm8625_qrd7())
gpio_free(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8);
fail_gpio2:
gpio_free(SKU3_LCDC_LCD_CAMERA_LDO_2V8);
return;
}
static int mipi_dsi_panel_msm_power(int on)
{
/*++ Huize - 20120927 Modify for identifying what the code is used by customization ++*/
#ifdef DISPLAY_CUSTOMIZATION
int rc = 0;
if (unlikely(!dsi_gpio_initialized)) {
pr_emerg("%s\n", __func__);
#ifndef CONFIG_LEDS_CHIP_LM3533
rc = gpio_request(GPIO_BACKLIGHT_EN, "gpio_bl_en");
if (rc < 0) {
pr_err("failed to request gpio_bl_en\n");
return rc;
}
rc = gpio_tlmm_config(
GPIO_CFG(GPIO_BACKLIGHT_EN,0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
#endif
if (rc) {
pr_err("Failed to enable gpio_bl_en\n");
goto fail_gpio1;
}
rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_dsi), regs_dsi);
if (rc) {
pr_err("%s: could not get regulators: %d\n",
__func__, rc);
goto fail_gpio2;
}
rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_dsi), regs_dsi);
if (rc) {
pr_err("%s: could not set voltages: %d\n",
__func__, rc);
goto fail_vreg;
}
dsi_gpio_initialized = 1;
}
#else
int rc = 0;
uint32_t lcdc_reset_cfg;
/* I2C-controlled GPIO Expander -init of the GPIOs very late */
if (unlikely(!dsi_gpio_initialized)) {
pmapp_disp_backlight_init();
rc = gpio_request(GPIO_DISPLAY_PWR_EN, "gpio_disp_pwr");
if (rc < 0) {
pr_err("failed to request gpio_disp_pwr\n");
return rc;
}
if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf()
|| machine_is_msm8625_surf()) {
rc = gpio_direction_output(GPIO_DISPLAY_PWR_EN, 1);
if (rc < 0) {
pr_err("failed to enable display pwr\n");
goto fail_gpio1;
}
rc = gpio_request(GPIO_BACKLIGHT_EN, "gpio_bkl_en");
if (rc < 0) {
pr_err("failed to request gpio_bkl_en\n");
goto fail_gpio1;
}
rc = gpio_direction_output(GPIO_BACKLIGHT_EN, 1);
if (rc < 0) {
pr_err("failed to enable backlight\n");
goto fail_gpio2;
}
}
rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_dsi), regs_dsi);
if (rc) {
pr_err("%s: could not get regulators: %d\n",
__func__, rc);
goto fail_gpio2;
}
rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_dsi),
regs_dsi);
if (rc) {
pr_err("%s: could not set voltages: %d\n",
__func__, rc);
goto fail_vreg;
}
if (pmapp_disp_backlight_set_brightness(100))
pr_err("backlight set brightness failed\n");
dsi_gpio_initialized = 1;
}
if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf() ||
machine_is_msm8625_surf()) {
gpio_set_value_cansleep(GPIO_DISPLAY_PWR_EN, on);
gpio_set_value_cansleep(GPIO_BACKLIGHT_EN, on);
} else if (machine_is_msm7x27a_ffa() || machine_is_msm7625a_ffa()
|| machine_is_msm8625_ffa()) {
if (on) {
/* This line drives an active low pin on FFA */
rc = gpio_direction_output(GPIO_DISPLAY_PWR_EN, !on);
if (rc < 0)
pr_err("failed to set direction for "
"display pwr\n");
} else {
gpio_set_value_cansleep(GPIO_DISPLAY_PWR_EN, !on);
rc = gpio_direction_input(GPIO_DISPLAY_PWR_EN);
if (rc < 0)
pr_err("failed to set direction for "
"display pwr\n");
}
}
if (on) {
gpio_set_value_cansleep(GPIO_LCDC_BRDG_PD, 0);
if (machine_is_msm7x27a_surf() ||
machine_is_msm7625a_surf() ||
machine_is_msm8625_surf()) {
lcdc_reset_cfg = readl_relaxed(lcdc_reset_ptr);
rmb();
lcdc_reset_cfg &= ~1;
writel_relaxed(lcdc_reset_cfg, lcdc_reset_ptr);
msleep(20);
wmb();
lcdc_reset_cfg |= 1;
writel_relaxed(lcdc_reset_cfg, lcdc_reset_ptr);
} else {
gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 0);
msleep(20);
gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 1);
}
} else {
gpio_set_value_cansleep(GPIO_LCDC_BRDG_PD, 1);
}
#endif
/*-- Huize - 20120927 Modify for identifying what the code is used by customization --*/
rc = on ? regulator_bulk_enable(ARRAY_SIZE(regs_dsi), regs_dsi) :
regulator_bulk_disable(ARRAY_SIZE(regs_dsi), regs_dsi);
if (rc)
pr_err("%s: could not %sable regulators: %d\n",
__func__, on ? "en" : "dis", rc);
return rc;
fail_vreg:
regulator_bulk_free(ARRAY_SIZE(regs_dsi), regs_dsi);
fail_gpio2:
gpio_free(GPIO_BACKLIGHT_EN);
fail_gpio1:
//Jordan-20111230 , remove
// gpio_free(GPIO_DISPLAY_PWR_EN);
dsi_gpio_initialized = 0;
return rc;
}
static int mipi_dsi_on(struct platform_device *pdev)
{
int ret = 0;
u32 clk_rate;
struct msm_fb_data_type *mfd;
struct fb_info *fbi;
struct fb_var_screeninfo *var;
struct msm_panel_info *pinfo;
struct mipi_panel_info *mipi;
u32 hbp, hfp, vbp, vfp, hspw, vspw, width, height;
u32 ystride, bpp, data;
u32 dummy_xres, dummy_yres;
int target_type = 0;
u32 tmp;
pr_debug("%s+:\n", __func__);
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
pdev_for_esd = pdev;
#endif
mfd = platform_get_drvdata(pdev);
fbi = mfd->fbi;
var = &fbi->var;
pinfo = &mfd->panel_info;
esc_byte_ratio = pinfo->mipi.esc_byte_ratio;
if (mipi_dsi_pdata && mipi_dsi_pdata->power_common)
mipi_dsi_pdata->power_common();
#if defined(CONFIG_SUPPORT_SECOND_POWER)
if (mipi_dsi_pdata && mipi_dsi_pdata->panel_power_save)
mipi_dsi_pdata->panel_power_save(1);
#endif
if (system_rev == 6)
mdelay(500);
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_power_save)
mipi_dsi_pdata->dsi_power_save(1);
cont_splash_clk_ctrl(0);
mipi_dsi_prepare_clocks();
mipi_dsi_ahb_ctrl(1);
clk_rate = mfd->fbi->var.pixclock;
clk_rate = min(clk_rate, mfd->panel_info.clk_max);
mipi_dsi_phy_ctrl(1);
if (mdp_rev == MDP_REV_42 && mipi_dsi_pdata)
target_type = mipi_dsi_pdata->target_type;
mipi_dsi_phy_init(0, &(mfd->panel_info), target_type);
mipi_dsi_clk_enable();
MIPI_OUTP(MIPI_DSI_BASE + 0x114, 1);
MIPI_OUTP(MIPI_DSI_BASE + 0x114, 0);
hbp = var->left_margin;
hfp = var->right_margin;
vbp = var->upper_margin;
vfp = var->lower_margin;
hspw = var->hsync_len;
vspw = var->vsync_len;
width = mfd->panel_info.xres;
height = mfd->panel_info.yres;
mipi = &mfd->panel_info.mipi;
if (mfd->panel_info.type == MIPI_VIDEO_PANEL) {
dummy_xres = mfd->panel_info.lcdc.xres_pad;
dummy_yres = mfd->panel_info.lcdc.yres_pad;
if (mdp_rev >= MDP_REV_41) {
MIPI_OUTP(MIPI_DSI_BASE + 0x20,
((hspw + hbp + width + dummy_xres) << 16 |
(hspw + hbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x24,
((vspw + vbp + height + dummy_yres) << 16 |
(vspw + vbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x28,
(vspw + vbp + height + dummy_yres +
vfp - 1) << 16 | (hspw + hbp +
width + dummy_xres + hfp - 1));
} else {
/* DSI_LAN_SWAP_CTRL */
MIPI_OUTP(MIPI_DSI_BASE + 0x00ac, mipi->dlane_swap);
MIPI_OUTP(MIPI_DSI_BASE + 0x20,
((hbp + width + dummy_xres) << 16 | (hbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x24,
((vbp + height + dummy_yres) << 16 | (vbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x28,
(vbp + height + dummy_yres + vfp) << 16 |
(hbp + width + dummy_xres + hfp));
}
MIPI_OUTP(MIPI_DSI_BASE + 0x2c, (hspw << 16));
MIPI_OUTP(MIPI_DSI_BASE + 0x30, 0);
MIPI_OUTP(MIPI_DSI_BASE + 0x34, (vspw << 16));
} else { /* command mode */
if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB888)
bpp = 3;
else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB666)
bpp = 3;
else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB565)
bpp = 2;
else
bpp = 3; /* Default format set to RGB888 */
ystride = width * bpp + 1;
/* DSI_COMMAND_MODE_MDP_STREAM_CTRL */
data = (ystride << 16) | (mipi->vc << 8) | DTYPE_DCS_LWRITE;
MIPI_OUTP(MIPI_DSI_BASE + 0x5c, data);
MIPI_OUTP(MIPI_DSI_BASE + 0x54, data);
/* DSI_COMMAND_MODE_MDP_STREAM_TOTAL */
data = height << 16 | width;
MIPI_OUTP(MIPI_DSI_BASE + 0x60, data);
MIPI_OUTP(MIPI_DSI_BASE + 0x58, data);
}
mipi_dsi_host_init(mipi);
msleep(10);
/* LP11 */
tmp = MIPI_INP(MIPI_DSI_BASE + 0xA8);
tmp &= ~(1<<28);
MIPI_OUTP(MIPI_DSI_BASE + 0xA8, tmp);
wmb();
/* LP11 */
usleep(5000);
if (mipi_dsi_pdata && mipi_dsi_pdata->active_reset)
mipi_dsi_pdata->active_reset(1); /* high */
usleep(10000);
/* always high */
if (mipi->force_clk_lane_hs) {
tmp = MIPI_INP(MIPI_DSI_BASE + 0xA8);
tmp |= (1<<28);
MIPI_OUTP(MIPI_DSI_BASE + 0xA8, tmp);
wmb();
}
if (mdp_rev >= MDP_REV_41)
mutex_lock(&mfd->dma->ov_mutex);
else
down(&mfd->dma->mutex);
ret = panel_next_on(pdev);
mipi_dsi_op_mode_config(mipi->mode);
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
if (pinfo->lcd.vsync_enable) {
if (pinfo->lcd.hw_vsync_mode && vsync_gpio >= 0) {
if (mdp_rev >= MDP_REV_41) {
if (gpio_request(vsync_gpio,
"MDP_VSYNC") == 0)
gpio_direction_input(
vsync_gpio);
else
pr_err("%s: unable to \
request gpio=%d\n",
__func__, vsync_gpio);
} else if (mdp_rev == MDP_REV_303) {
if (!tlmm_settings && gpio_request(
vsync_gpio, "MDP_VSYNC") == 0) {
ret = gpio_tlmm_config(
GPIO_CFG(
vsync_gpio, 1,
GPIO_CFG_INPUT,
GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (ret) {
pr_err(
"%s: unable to config \
tlmm = %d\n",
__func__, vsync_gpio);
}
tlmm_settings = TRUE;
gpio_direction_input(
vsync_gpio);
} else {
if (!tlmm_settings) {
pr_err(
"%s: unable to request \
gpio=%d\n",
__func__, vsync_gpio);
}
}
}
static int mipi_dsi_on(struct platform_device *pdev)
{
int ret = 0;
u32 clk_rate;
struct msm_fb_data_type *mfd;
struct fb_info *fbi;
struct fb_var_screeninfo *var;
struct msm_panel_info *pinfo;
struct mipi_panel_info *mipi;
u32 hbp, hfp, vbp, vfp, hspw, vspw, width, height;
u32 ystride, bpp, data;
u32 dummy_xres, dummy_yres;
int target_type = 0;
pr_debug("%s+:\n", __func__);
mfd = platform_get_drvdata(pdev);
fbi = mfd->fbi;
var = &fbi->var;
pinfo = &mfd->panel_info;
esc_byte_ratio = pinfo->mipi.esc_byte_ratio;
printk(KERN_INFO"%s is started.. \n", __func__);
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_power_save)
mipi_dsi_pdata->dsi_power_save(1);
cont_splash_clk_ctrl(0);
mipi_dsi_prepare_clocks();
mipi_dsi_ahb_ctrl(1);
clk_rate = mfd->fbi->var.pixclock;
clk_rate = min(clk_rate, mfd->panel_info.clk_max);
mipi_dsi_phy_ctrl(1);
if (mdp_rev == MDP_REV_42 && mipi_dsi_pdata)
target_type = mipi_dsi_pdata->target_type;
mipi_dsi_phy_init(0, &(mfd->panel_info), target_type);
mipi_dsi_clk_enable();
MIPI_OUTP(MIPI_DSI_BASE + 0x114, 1);
MIPI_OUTP(MIPI_DSI_BASE + 0x114, 0);
hbp = var->left_margin;
hfp = var->right_margin;
vbp = var->upper_margin;
vfp = var->lower_margin;
hspw = var->hsync_len;
vspw = var->vsync_len;
width = mfd->panel_info.xres;
height = mfd->panel_info.yres;
mipi = &mfd->panel_info.mipi;
if (mfd->panel_info.type == MIPI_VIDEO_PANEL) {
dummy_xres = mfd->panel_info.lcdc.xres_pad;
dummy_yres = mfd->panel_info.lcdc.yres_pad;
if (mdp_rev >= MDP_REV_41) {
MIPI_OUTP(MIPI_DSI_BASE + 0x20,
((hspw + hbp + width + dummy_xres) << 16 |
(hspw + hbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x24,
((vspw + vbp + height + dummy_yres) << 16 |
(vspw + vbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x28,
(vspw + vbp + height + dummy_yres +
vfp - 1) << 16 | (hspw + hbp +
width + dummy_xres + hfp - 1));
} else {
/* DSI_LAN_SWAP_CTRL */
MIPI_OUTP(MIPI_DSI_BASE + 0x00ac, mipi->dlane_swap);
MIPI_OUTP(MIPI_DSI_BASE + 0x20,
((hbp + width + dummy_xres) << 16 | (hbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x24,
((vbp + height + dummy_yres) << 16 | (vbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x28,
(vbp + height + dummy_yres + vfp) << 16 |
(hbp + width + dummy_xres + hfp));
}
MIPI_OUTP(MIPI_DSI_BASE + 0x2c, (hspw << 16));
MIPI_OUTP(MIPI_DSI_BASE + 0x30, 0);
MIPI_OUTP(MIPI_DSI_BASE + 0x34, (vspw << 16));
} else { /* command mode */
if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB888)
bpp = 3;
else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB666)
bpp = 3;
else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB565)
bpp = 2;
else
bpp = 3; /* Default format set to RGB888 */
ystride = width * bpp + 1;
/* DSI_COMMAND_MODE_MDP_STREAM_CTRL */
data = (ystride << 16) | (mipi->vc << 8) | DTYPE_DCS_LWRITE;
MIPI_OUTP(MIPI_DSI_BASE + 0x5c, data);
MIPI_OUTP(MIPI_DSI_BASE + 0x54, data);
/* DSI_COMMAND_MODE_MDP_STREAM_TOTAL */
data = height << 16 | width;
MIPI_OUTP(MIPI_DSI_BASE + 0x60, data);
MIPI_OUTP(MIPI_DSI_BASE + 0x58, data);
}
mipi_dsi_host_init(mipi);
if (mipi->force_clk_lane_hs) {
u32 tmp;
tmp = MIPI_INP(MIPI_DSI_BASE + 0xA8);
tmp |= (1<<28);
MIPI_OUTP(MIPI_DSI_BASE + 0xA8, tmp);
wmb();
}
if (mdp_rev >= MDP_REV_41)
mutex_lock(&mfd->dma->ov_mutex);
else
down(&mfd->dma->mutex);
#if defined(CONFIG_MACH_LGE)
/* LGE_CHANGE
* in case of WXGA panel,
* video mode MUST NOT be set prior to power_on_cmd seq.
* 2012-09-01 [email protected]
*/
ret = panel_next_on(pdev);
if (ret < 0)
{
if (mdp_rev >= MDP_REV_41)
mutex_unlock(&mfd->dma->ov_mutex);
else
up(&mfd->dma->mutex);
return ret;
} else {
ret = 0;
}
#if defined(CONFIG_FB_MSM_MIPI_HITACHI_VIDEO_HD_PT) || defined(CONFIG_FB_MSM_MIPI_DSI_LGIT_FHD)
mipi_dsi_op_mode_config(mipi->mode);
#endif
#else
ret = panel_next_on(pdev);
mipi_dsi_op_mode_config(mipi->mode);
#endif
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
if (pinfo->lcd.vsync_enable) {
if (pinfo->lcd.hw_vsync_mode && vsync_gpio >= 0) {
if (mdp_rev >= MDP_REV_41) {
if (gpio_request(vsync_gpio,
"MDP_VSYNC") == 0)
gpio_direction_input(
vsync_gpio);
else
pr_err("%s: unable to \
request gpio=%d\n",
__func__, vsync_gpio);
} else if (mdp_rev == MDP_REV_303) {
if (!tlmm_settings && gpio_request(
vsync_gpio, "MDP_VSYNC") == 0) {
ret = gpio_tlmm_config(
GPIO_CFG(
vsync_gpio, 1,
GPIO_CFG_INPUT,
GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (ret) {
pr_err(
"%s: unable to config \
tlmm = %d\n",
__func__, vsync_gpio);
}
tlmm_settings = TRUE;
gpio_direction_input(
vsync_gpio);
} else {
if (!tlmm_settings) {
pr_err(
"%s: unable to request \
gpio=%d\n",
__func__, vsync_gpio);
}
}
}
static int mipi_dsi_panel_power(int on)
{
static struct regulator *reg_l2;
int rc;
PR_DISP_INFO("%s: power %s.\n", __func__, on ? "on" : "off");
if (!dsi_power_on) {
gpio_tlmm_config(GPIO_CFG(MSM_LCD_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, 0), GPIO_CFG_ENABLE);
gpio_tlmm_config(GPIO_CFG(MSM_LCD_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, 0), GPIO_CFG_ENABLE);
reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi_vdda");
if (IS_ERR(reg_l2)) {
pr_err("could not get 8038_l2, rc = %ld\n",
PTR_ERR(reg_l2));
return -ENODEV;
}
rc = regulator_set_voltage(reg_l2, 1200000, 1200000);
if (rc) {
pr_err("set_voltage l2 failed, rc=%d\n", rc);
return -EINVAL;
}
dsi_power_on = true;
if (first_inited) {
first_inited = false;
rc = regulator_set_optimum_mode(reg_l2, 100000);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_l2);
if (rc) {
pr_err("enable l2 failed, rc=%d\n", rc);
return -ENODEV;
}
return 0;
}
}
if (on) {
if (panel_type == PANEL_ID_K2_WL_AUO || panel_type == PANEL_ID_K2_WL_AUO_C2) {
rc = regulator_set_optimum_mode(reg_l2, 100000);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
gpio_set_value(MSM_V_LCMIO_1V8_EN, 1);
hr_msleep(1);
gpio_set_value(MSM_V_LCM_3V3_EN, 1);
rc = regulator_enable(reg_l2);
if (rc) {
pr_err("enable l2 failed, rc=%d\n", rc);
return -ENODEV;
}
hr_msleep(55);
gpio_set_value(MSM_LCD_RSTz, 1);
usleep(20);
gpio_set_value(MSM_LCD_RSTz, 0);
usleep(30);
gpio_set_value(MSM_LCD_RSTz, 1);
hr_msleep(120);
} else if (panel_type == PANEL_ID_K2_WL_JDI_NT) {
rc = regulator_set_optimum_mode(reg_l2, 100000);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
gpio_set_value(MSM_V_LCMIO_1V8_EN, 1);
hr_msleep(1);
gpio_set_value(MSM_V_LCM_3V3_EN, 1);
rc = regulator_enable(reg_l2);
if (rc) {
pr_err("enable l2 failed, rc=%d\n", rc);
return -ENODEV;
}
hr_msleep(50);
gpio_set_value(MSM_LCD_RSTz, 1);
hr_msleep(10);
gpio_set_value(MSM_LCD_RSTz, 0);
hr_msleep(10);
gpio_set_value(MSM_LCD_RSTz, 1);
hr_msleep(120);
}
} else {
if (panel_type == PANEL_ID_K2_WL_AUO || panel_type == PANEL_ID_K2_WL_AUO_C2) {
rc = regulator_disable(reg_l2);
if (rc) {
pr_err("disable reg_l2 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_set_optimum_mode(reg_l2, 100);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
gpio_set_value(MSM_LCD_RSTz, 0);
hr_msleep(1);
gpio_set_value(MSM_V_LCM_3V3_EN, 0);
hr_msleep(5);
gpio_set_value(MSM_V_LCMIO_1V8_EN, 0);
} else if (panel_type == PANEL_ID_K2_WL_JDI_NT) {
rc = regulator_disable(reg_l2);
if (rc) {
pr_err("disable reg_l2 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_set_optimum_mode(reg_l2, 100);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
hr_msleep(10);
gpio_set_value(MSM_LCD_RSTz, 0);
hr_msleep(10);
gpio_set_value(MSM_V_LCM_3V3_EN, 0);
hr_msleep(10);
gpio_set_value(MSM_V_LCMIO_1V8_EN, 0);
}
}
return 0;
}
/* Configure gpio for uart - based on gsbi id */
void gpio_config_uart_dm(uint8_t id)
{
if(board_platform_id() == MPQ8064)
{
switch (id) {
case GSBI_ID_5:
/* configure rx gpio */
gpio_tlmm_config(52, 2, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(51, 2, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
default:
ASSERT(0);
}
}
else if((board_platform_id() == APQ8064) ||
(board_platform_id() == APQ8064AA) ||
(board_platform_id() == APQ8064AB))
{
switch (id) {
case GSBI_ID_1:
/* configure rx gpio */
gpio_tlmm_config(19, 1, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(18, 1, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
case GSBI_ID_2:
/* configure rx gpio */
gpio_tlmm_config(22, 1, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(23, 1, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
case GSBI_ID_7:
/* configure rx gpio */
gpio_tlmm_config(83, 1, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(82, 2, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
default:
ASSERT(0);
}
}
else
{
switch (id) {
case GSBI_ID_3:
/* configure rx gpio */
gpio_tlmm_config(15, 1, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(14, 1, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
case GSBI_ID_5:
/* configure rx gpio */
gpio_tlmm_config(23, 1, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(22, 1, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
case GSBI_ID_8:
/* configure rx gpio */
gpio_tlmm_config(35, 1, GPIO_INPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
/* configure tx gpio */
gpio_tlmm_config(34, 1, GPIO_OUTPUT, GPIO_NO_PULL,
GPIO_8MA, GPIO_DISABLE);
break;
default:
ASSERT(0);
}
}
}
static int fm_radio_setup(struct marimba_fm_platform_data *pdata)
{
int rc = 0;
const char *id = "FMPW";
uint32_t irqcfg;
struct marimba config = { .mod_id = SLAVE_ID_BAHAMA};
u8 value;
/* Voting for 1.8V Regulator */
fm_regulator = vreg_get(NULL , "msme1");
if (IS_ERR(fm_regulator)) {
pr_err("%s: vreg get failed with : (%ld)\n",
__func__, PTR_ERR(fm_regulator));
return -EINVAL;
}
/* Set the voltage level to 1.8V */
rc = vreg_set_level(fm_regulator, 1800);
if (rc < 0) {
pr_err("%s: set regulator level failed with :(%d)\n",
__func__, rc);
goto fm_vreg_fail;
}
/* Enabling the 1.8V regulator */
rc = vreg_enable(fm_regulator);
if (rc) {
pr_err("%s: enable regulator failed with :(%d)\n",
__func__, rc);
goto fm_vreg_fail;
}
/* Voting for 19.2MHz clock */
rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1,
PMAPP_CLOCK_VOTE_ON);
if (rc < 0) {
pr_err("%s: clock vote failed with :(%d)\n",
__func__, rc);
goto fm_clock_vote_fail;
}
rc = bt_set_gpio(1);
if (rc) {
pr_err("%s: bt_set_gpio = %d", __func__, rc);
goto fm_gpio_config_fail;
}
/*re-write FM Slave Id, after reset*/
value = BAHAMA_SLAVE_ID_FM_ADDR;
rc = marimba_write_bit_mask(&config,
BAHAMA_SLAVE_ID_FM_REG, &value, 1, 0xFF);
if (rc < 0) {
pr_err("%s: FM Slave ID rewrite Failed = %d", __func__, rc);
goto fm_gpio_config_fail;
}
/* Configuring the FM GPIO */
irqcfg = GPIO_CFG(FM_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_2MA);
rc = gpio_tlmm_config(irqcfg, GPIO_CFG_ENABLE);
if (rc) {
pr_err("%s: gpio_tlmm_config(%#x)=%d\n",
__func__, irqcfg, rc);
goto fm_gpio_config_fail;
}
return 0;
fm_gpio_config_fail:
pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1,
PMAPP_CLOCK_VOTE_OFF);
bt_set_gpio(0);
fm_clock_vote_fail:
vreg_disable(fm_regulator);
fm_vreg_fail:
vreg_put(fm_regulator);
return rc;
};
static int mipi_dsi_power_tft_request(void)
{
int rc = 0;
#if defined(CONFIG_MACH_JACTIVE_ATT)
if (system_rev < 10){
gpio33 = PM8921_GPIO_PM_TO_SYS(LCD_22V_EN);
rc = gpio_request(gpio33, "led_dirver");
if (rc) {
pr_err("request gpio lcd_22v_en failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(gpio33, &gpio43_param);
if (rc) {
pr_err("gpio_config lcd_22v_en failed (3), rc=%d\n", rc);
return -EINVAL;
}
}
else{
pr_info("[lcd] request gpio lcd_22v_en\n");
rc = gpio_request(LCD_22V_EN, "lcd_22v_en");
if (rc) {
gpio_free(LCD_22V_EN);
rc = gpio_request(LCD_22V_EN, "lcd_22v_en");
if(rc){
pr_err("request gpio lcd_22v_en failed, rc=%d\n", rc);
return -ENODEV;
}
}
pr_info("[lcd] configure LCD_22V_EN\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
#if defined(CONFIG_FB_MSM_ENABLE_LCD_EN2)
if( system_rev >= 13 ) // rev0.5 + 8
{
pr_info("[lcd] request gpio lcd_22v_en_2\n");
rc = gpio_request(LCD_22V_EN_2, "lcd_22v_en_2");
if (rc) {
gpio_free(LCD_22V_EN_2);
rc = gpio_request(LCD_22V_EN_2, "lcd_22v_en_2");
if(rc){
pr_err("request gpio lcd_22v_en_2 failed, rc=%d\n", rc);
return -ENODEV;
}
}
pr_info("[lcd] configure LCD_22V_EN_2\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN_2, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
#endif
}
#else
pr_info("[lcd] request gpio lcd_22v_en\n");
rc = gpio_request(LCD_22V_EN, "lcd_22v_en");
if (rc) {
pr_err("request gpio lcd_22v_en failed, rc=%d\n", rc);
return -ENODEV;
}
pr_info("[lcd] configure LCD_22V_EN\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
#if defined(CONFIG_FB_MSM_ENABLE_LCD_EN2)
if( system_rev >= 16 ) // rev0.6 + 10
{
pr_info("[lcd] request gpio lcd_22v_en_2\n");
rc = gpio_request(LCD_22V_EN_2, "lcd_22v_en_2");
if (rc) {
pr_err("request gpio lcd_22v_en_2 failed, rc=%d\n", rc);
return -ENODEV;
}
pr_info("[lcd] configure LCD_22V_EN_2\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN_2, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
#endif
#endif
if (system_rev == 0) {
gpio43 = PM8921_GPIO_PM_TO_SYS(
PMIC_GPIO_LCD_RST);
rc = gpio_request(gpio43, "mlcd_rst");
if (rc) {
pr_err("request gpio mlcd_rst failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(gpio43, &gpio43_param);
if (rc) {
pr_err("gpio_config mlcd_rst failed (3), rc=%d\n", rc);
return -EINVAL;
}
}
#if defined(CONFIG_MACH_JACTIVE_ATT)
if (system_rev < 10)
gpio27 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_LED_DRIVER_REV00);
else
gpio27 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_LED_DRIVER_REV10);
#else
gpio27 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_LED_DRIVER);
#endif
rc = gpio_request(gpio27, "led_dirver");
if (rc) {
pr_err("request gpio led_dirver failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(gpio27, &gpio43_param);
if (rc) {
pr_err("gpio_config led_dirver failed (3), rc=%d\n", rc);
return -EINVAL;
}
gpio_direction_output(gpio27, 0);
return rc;
}
// Pantech Earjack Probe Function
static int __devinit pantech_earjack_probe(struct platform_device *pdev)
{
int rc = 0;
int err = 0;
struct input_dev *ipdev;
dbg_func_in();
irq_state = 0;
// Alloc Devices
earjack = kzalloc(sizeof(struct pantech_earjack), GFP_KERNEL);
if (!earjack)
return -ENOMEM;
earjack->sdev.name = "h2w";
earjack->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&earjack->sdev);
if (rc)
goto err_switch_dev_register;
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, earjack);
// Init Status Flags
earjack->ipdev = ipdev;
earjack->car_kit = 0;
earjack->type=EARJACK_STATE_OFF;
earjack->remotekey_pressed = 0;
earjack->remotekey_index = 0;
// Initialize Work Queue
INIT_DELAYED_WORK(&earjack_work,earjack_detect_func); // INIT WORK
INIT_DELAYED_WORK(&remotekey_work,remotekey_detect_func);
// Get Power Source
#if defined(CONFIG_MIC_BIAS_1_8V)
err = 0;
#else
hs_jack_l8 = regulator_get(NULL, "8058_l8");
regulator_set_voltage(hs_jack_l8,2700000,2700000);
dbg("regulator_enable hs_jack_l8 value => %d\n",err);
#endif
// Initialize Wakelocks
wake_lock_init(&earjack_wake_lock, WAKE_LOCK_SUSPEND, "earjack_wake_lock_init");
wake_lock_init(&remotekey_wake_lock, WAKE_LOCK_SUSPEND, "remotekey_wake_lock_init");
// Setup GPIO's
gpio_request(EARJACK_DET, "earjack_det");
gpio_request(REMOTEKEY_DET, "remotekey_det");
gpio_tlmm_config(GPIO_CFG(EARJACK_DET, 0, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
rc = request_irq(gpio_to_irq(EARJACK_DET), Earjack_Det_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "earjack_det-irq", earjack);
// Warning: REMOTEKEY_DET using default gpio config.
//gpio_tlmm_config(GPIO_CFG(REMOTEKEY_DET, 0, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
irq_set_irq_wake(gpio_to_irq(EARJACK_DET), 1);
irq_set_irq_wake(gpio_to_irq(REMOTEKEY_DET), 1);
// Init Input Device
//pz1946 merge for wired long key
#ifdef CONFIG_MACH_MSM8X60_PRESTO
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0;
ipdev->id.product = 0;
ipdev->id.version = 0;
#else
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
#endif
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(ipdev, EV_KEY, KEY_POWER);
input_set_capability(ipdev, EV_KEY, KEY_END);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, earjack);
rc = sysfs_create_group(&pdev->dev.kobj, &dev_attr_grp);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: sysfs_create_group rc=%d\n", rc);
goto err_earjack_init;
}
// Scehdule earjack_detect_func for initial detect
disable_irq_detect(); //disable_irq_nosync(gpio_to_irq(EARJACK_DET));
wake_lock(&earjack_wake_lock);
disable_irq_nosync(gpio_to_irq(REMOTEKEY_DET));
schedule_delayed_work(&earjack_work,10); // after 100ms
dbg_func_out();
return 0;
err_earjack_init:
err_reg_input_dev:
input_unregister_device(ipdev);
ipdev = NULL;
err_alloc_input_dev:
input_free_device(ipdev);
err_switch_dev_register:
kfree(earjack);
return 0;
}
////////////////////////////////
// Power ON
////////////////////////////////
static int cam12mp_sensor_poweron(void)
{
struct vreg *vreg_gp1, *vreg_gp6;
LOGI("+%s()\n", __func__);
vreg_gp6 = vreg_get(NULL, "gp6");
if (IS_ERR(vreg_gp6)) {
LOGE(" - vreg_get(gp6) failed (%ld) !\n", PTR_ERR(vreg_gp6));
return -1;
}
if (vreg_set_level(vreg_gp6, 1800)) {
LOGE(" - vreg gp6 set level failed !\n");
return -1;
}
vreg_gp1 = vreg_get(NULL, "gp1");
if (IS_ERR(vreg_gp1)) {
LOGE(" - vreg_get(gp1) failed (%ld)\n", PTR_ERR(vreg_gp1));
return -1;
}
if (vreg_set_level(vreg_gp1, 2700)) {
LOGE(" - vreg gp1 set level failed !\n");
return -1;
}
sub_pmic_reg_ctrl(SUB_PMIC_REG2, SUB_PMIC_LDO_ON);
mdelay(1);
if (vreg_enable(vreg_gp6)) {
LOGE(" - vreg gp6 enable failed !\n");
goto _sensor_poweron_fail_1;
}
mdelay(1);
sub_pmic_ldo_ctrl(SUB_PMIC_CAM12V, SUB_PMIC_LDO_ON);
mdelay(1);
gpio_set_value(CAM_18V, 1);
mdelay(1);
sub_pmic_ldo_ctrl(SUB_PMIC_CAM28V, SUB_PMIC_LDO_ON);
mdelay(1);
if (vreg_enable(vreg_gp1)) {
LOGE(" - vreg gp1 enable failed !\n");
goto _sensor_poweron_fail_2;
}
mdelay(1);
gpio_tlmm_config(GPIO_CFG(MCLK, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), GPIO_ENABLE);
msm_camio_clk_rate_set(9600000);
msm_camio_camif_pad_reg_reset();
gpio_set_value(H_STBY, 1);
gpio_set_value(R_STBY, 1);
mdelay(1);
gpio_set_value(RESET, 1);
mdelay(4);
return 0;
_sensor_poweron_fail_2:
sub_pmic_ldo_ctrl(SUB_PMIC_CAM28V, SUB_PMIC_LDO_OFF);
gpio_set_value(CAM_18V, 0);
sub_pmic_ldo_ctrl(SUB_PMIC_CAM12V, SUB_PMIC_LDO_OFF);
vreg_disable(vreg_gp6);
_sensor_poweron_fail_1:
sub_pmic_reg_ctrl(SUB_PMIC_REG2, SUB_PMIC_LDO_OFF);
LOGI("-%s (fail.)\n", __func__);
return -1;
}
void wacom_init_gpio(struct wacom_g5_platform_data *pdata)
{
int ret;
pr_err("epen: %s, %d \n",__func__, __LINE__ );
pr_err("epen: %d, %d, %d, %d, %d \n",pdata->gpio_reset_n,pdata->gpio_fwe1, pdata->gpio_pendct,pdata->gpio_irq,pdata->gpio_ldo_en );
// reset
ret = gpio_request(pdata->gpio_reset_n, "gpio_reset_n");
if(ret) {
printk(KERN_INFO "epen: %s: unable to gpio [%d], r:%d\n", __func__, pdata->gpio_reset_n, ret);
return;
}
gpio_direction_output(pdata->gpio_reset_n, 0);
// slp, fwe1
ret = gpio_request(pdata->gpio_fwe1, "gpio_fwe1");
if(ret) {
printk(KERN_INFO "epen: %s: unable to gpio [%d], r:%d\n", __func__, pdata->gpio_fwe1, ret);
return;
}
gpio_direction_output(pdata->gpio_fwe1, 0);
// pdct
ret = gpio_request(pdata->gpio_pendct, "gpio_pendct");
if(ret) {
printk(KERN_INFO "epen: %s: unable to gpio [%d], r:%d\n", __func__, pdata->gpio_pendct, ret);
return;
}
gpio_tlmm_config(GPIO_CFG(pdata->gpio_pendct, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
// irq
ret = gpio_request(pdata->gpio_irq, "gpio_irq");
if(ret) {
printk(KERN_INFO "epen: %s: unable to gpio [%d], r:%d\n", __func__, pdata->gpio_irq, ret);
return;
}
gpio_tlmm_config(GPIO_CFG(pdata->gpio_irq, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
// ldo en
ret = gpio_request(pdata->gpio_ldo_en, "gpio_ldo_en");
if(ret) {
printk(KERN_INFO "epen: %s: unable to gpio [%d], r:%d\n", __func__, pdata->gpio_ldo_en, ret);
return;
}
gpio_direction_output(pdata->gpio_ldo_en, 1);
gpio_tlmm_config(GPIO_CFG(GPIO_PEN_SDA_18V, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
gpio_tlmm_config(GPIO_CFG(GPIO_PEN_SCL_N_18V, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
// pen_insert
ret = gpio_request(pdata->gpio_pen_insert, "gpio_pen_insert");
if(ret) {
printk(KERN_INFO "epen: %s: unable to gpio [%d], r:%d\n", __func__, pdata->gpio_pen_insert, ret);
return;
}
if(g_gpio_insert_pen_pull){
gpio_tlmm_config(GPIO_CFG(pdata->gpio_pen_insert, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), 1);
}else{
gpio_tlmm_config(GPIO_CFG(pdata->gpio_pen_insert, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
}
}
void __init qrd7627a_add_io_devices(void)
{
int rc;
int i; //hanjue
/* touchscreen */
if (machine_is_msm7627a_qrd1()) {
i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID,
synaptic_i2c_clearpad3k,
ARRAY_SIZE(synaptic_i2c_clearpad3k));
} else if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() ||
machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a()) {
#if 1 //linxc 2012-12-21 +++
if (machine_is_msm8625_qrd5()) {
i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID,
himax_ts_i2c_info,
ARRAY_SIZE(himax_ts_i2c_info));
}
#else
/* Use configuration data for sku5 */
if (machine_is_msm8625_qrd5()) {
mxt_config_array[0].config = mxt_config_data_qrd5;
mxt_config_array[0].config_length =
ARRAY_SIZE(mxt_config_data_qrd5);
mxt_platform_data.panel_maxy = 875;
mxt_platform_data.need_calibration = true;
mxt_vkey_setup();
}
if (machine_is_msm7x27a_qrd5a()) {
mxt_config_array[0].config = mxt_config_data_qrd5a;
mxt_config_array[0].config_length =
ARRAY_SIZE(mxt_config_data_qrd5a);
mxt_platform_data.panel_maxy = 875;
mxt_vkey_setup();
}
rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_IRQ_GPIO, 0,
GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,
GPIO_CFG_8MA), GPIO_CFG_ENABLE);
if (rc) {
pr_err("%s: gpio_tlmm_config for %d failed\n",
__func__, MXT_TS_IRQ_GPIO);
}
rc = gpio_tlmm_config(GPIO_CFG(MXT_TS_RESET_GPIO, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN,
GPIO_CFG_8MA), GPIO_CFG_ENABLE);
if (rc) {
pr_err("%s: gpio_tlmm_config for %d failed\n",
__func__, MXT_TS_RESET_GPIO);
}
i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID,
mxt_device_info,
ARRAY_SIZE(mxt_device_info));
#endif //linxc 2012-12-21 ---
} else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7() || machine_is_msm8625q_skud() || machine_is_msm8625q_skue()) {
ft5x06_touchpad_setup();
}
/* headset */
platform_device_register(&hs_pdev);
/* vibrator */
#ifdef CONFIG_MSM_RPC_VIBRATOR
msm_init_pmic_vibrator();
#endif
//add by hanjue
/* change the keymap for qrd sku5 */
if(machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a()) {
kp_matrix_info_8625.keymap = keymap_8625_qrd5;
kp_matrix_info_8625.output_gpios = kp_row_gpios_8625_qrd5;
kp_matrix_info_8625.noutputs = ARRAY_SIZE(kp_row_gpios_8625_qrd5);
for (i = 0; i < kp_matrix_info_8625.noutputs; i++) {
rc = gpio_tlmm_config(GPIO_CFG(kp_matrix_info_8625.output_gpios[i], 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (rc) {
pr_err("%s: gpio_tlmm_config for %d failed\n",
__func__, kp_matrix_info_8625.output_gpios[i]);
}
}
for (i = 0; i < kp_matrix_info_8625.ninputs; i++) {
rc = gpio_tlmm_config(GPIO_CFG(kp_matrix_info_8625.input_gpios[i], 0,
GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,
GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (rc) {
pr_err("%s: gpio_tlmm_config for %d failed\n",
__func__, kp_matrix_info_8625.input_gpios[i]);
}
}
}
/* keypad */
if (machine_is_msm7627a_evb() ||
machine_is_msm8625_evb()||
machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a() ||
machine_is_msm8625_qrd7())
platform_device_register(&kp_pdev_8625);
else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7())
platform_device_register(&kp_pdev_qrd3);
else if (machine_is_msm8625q_skud())
platform_device_register(&kp_pdev_skud);
#if 0
/* keypad */
if (machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a())
kp_matrix_info_8625.keymap = keymap_8625_qrd5;
if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() ||
machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a())
platform_device_register(&kp_pdev_8625);
else if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7())
platform_device_register(&kp_pdev_qrd3);
else if (machine_is_msm8625q_skud())
platform_device_register(&kp_pdev_skud);
#endif
/*start by lf 2012.12.26 */
#if 0
/* leds */
if (machine_is_msm7627a_evb() || machine_is_msm8625_evb()
|| machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a()) {
platform_device_register(&pmic_mpp_leds_pdev);
platform_device_register(&tricolor_leds_pdev);
} else if (machine_is_msm8625q_skud()) {
platform_device_register(&pmic_mpp_leds_pdev_skud);
/* enable the skud flash and torch by gpio leds driver */
platform_device_register(&gpio_flash_skud);
}
#endif
/*end by lf 2012.12.26 */
#ifdef CONFIG_LEDS_TRICOLOR_FLAHSLIGHT
/*tricolor leds init*/
if (machine_is_msm7627a_evb() || machine_is_msm8625_evb()
|| machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a()) {
platform_device_register(&msm_device_tricolor_leds);
tricolor_leds_gpio_setup();
}
#endif
}
// struct sn3193_i2c_platform_data rgb_pdata = {
// .sdb_gpio = APQ_SLED_SDB_GPIO,
//};
static void SN3193_power(void)
{
/* if (on) {
if (get_pcb_version() <= PCB_VERSION_EVT) {
//evt---lvs5
lvs5 = regulator_get(NULL, "8921_lvs5");
if (IS_ERR(lvs5)){
pr_err("%s: VREG LVS5 get failed\n", __func__);
lvs5 = NULL;
goto lvs5_get_failed;
}
if (regulator_enable(lvs5)) {
pr_err("%s: VREG LVS5 enable failed\n", __func__);
goto lvs5_get_failed;
}
}
else {
//dvt---l21
ldo121 = regulator_get(NULL, "8921_l21");
if (IS_ERR(ldo121)){
pr_err("%s: VREG ldo121 get failed\n", __func__);
ldo121 = NULL;
goto ldo121_get_failed;
}
if (regulator_set_voltage(ldo121, 1800000, 1800000)) {
pr_err("%s: VREG ldo121 set voltage failed\n", __func__);
goto ldo121_get_failed;
}
if (regulator_enable(ldo121)) {
pr_err("%s: VREG ldo121 enable failed\n", __func__);
goto ldo121_get_failed;
}
}
}else if (!on) {
if (get_pcb_version() <= PCB_VERSION_EVT) { //evt
if (lvs5){
regulator_disable(lvs5);
regulator_put(lvs5);
}
}else { //dvt
if (ldo121) {
regulator_disable(ldo121);
regulator_put(ldo121);
}
}
}
return 0 ;
ldo121_get_failed:
regulator_disable(ldo121);
lvs5_get_failed:
regulator_put(lvs5);
return -1 ;
*/
int ret = 0 ;
//irq
//Delete by Jianfeng.Qiu, 2014-09-12, not use
#if 0
ret = gpio_tlmm_config(SN3193_SDB, GPIO_CFG_ENABLE);
if (ret) {
printk(KERN_ERR "%s:yuyi,gpio_tlmm_config(%#x)=%d\n",
__func__, SN3193_SDB, ret);
}
#endif
gpio_set_value(SN3193_sled_dev_sate->ena_gpio, 1);
ret = gpio_get_value(SN3193_sled_dev_sate->ena_gpio);
printk("the gpio_get_value is %d\n", ret);
printk("yuyi,sn3193 power end\n");
printk(KERN_ERR "%s:yuyi for SN3193_SDB gpio---\n", __func__);
}
int seport_platform_register_button_gpio_callback(int (*func)(int, void *arg),
void *data)
{
int retval, mean_rid, mean_ain, irq;
/* TODO: Make sure that we handle errors in a later state! */
gpio_set_value(seport_conf->rid_ping_enable_pin, 0);
msleep(10);
retval = gpio_tlmm_config(GPIO_CFG(seport_conf->button_detect_pin,
0, GPIO_INPUT, GPIO_NO_PULL,
GPIO_2MA),
GPIO_ENABLE);
if (retval) {
printk(KERN_CRIT "Failed to configure GPIO pin. Aborting\n");
gpio_set_value(seport_conf->rid_ping_enable_pin, 0);
return retval;
}
/* Delay a bit to make sure GPIOs are in the correct mode. */
msleep(10);
mean_rid = seport_platform_read_mean_rid_val(3);
/* Enabling DCout to see if we have different AIN value than RID.
* This is used to filter out inserted accessories with pressed
* buttons. */
(void)seport_set_dcout(1);
msleep(10);
mean_ain = seport_platform_read_mean_rid_val(3);
/*
* Here we try to detect if we have a valid AIN accessory. This will
* not handle if RID == AIN which can be the case in very special
* circumstances even though the accessory is a valid AIN event. This
* can happen if a button is pressed when the accessory is inserted and
* we have no way to filter that specific case.
* The +-4 steps should be a good range to handle different RID values.
*/
if (abs(mean_ain - mean_rid) > 4) {
irq = gpio_to_irq(seport_conf->button_detect_pin);
if (0 <= irq) {
retval = request_irq(irq,
func, IRQF_TRIGGER_FALLING,
"seport_buttondetect",
data);
if (retval) {
printk(KERN_CRIT "Failed to register" \
" interrupt handler for button" \
" detection\n");
return retval;
}
} else {
printk(KERN_CRIT "%s - Irq for requested GPIO (%d) " \
"does not exist. Button detection will not " \
"work\n", __func__,
seport_conf->button_detect_pin);
return -ENXIO;
}
/*
* Setting interrupt enabled here, will in worst case generate
* a "unmatched irq_wake" print in the kernel log when
* shutting down the system, but at least some detection will
* work.
*/
seport_button_detect_interrupt_enabled = 1;
retval = enable_irq_wake(irq);
if (retval)
printk(KERN_CRIT "Failed to enable wakup on IRQ " \
"request\n");
return retval;
} else {
printk(KERN_INFO "Accessory was not detected as an AIN " \
"accessory or a special button was pressed while " \
"inserting accessory\n");
/* Ignoring return values here. Can't do much about
them if they fail. */
gpio_set_value(seport_conf->rid_ping_enable_pin, 1);
(void)gpio_tlmm_config(GPIO_CFG(seport_conf->button_detect_pin,
0, GPIO_OUTPUT, GPIO_PULL_DOWN,
GPIO_2MA),
GPIO_ENABLE);
}
return -3; /* ERROR_NO_AIN_ACCESSORY; */
}
void __init verdi_lte_audio_init(void)
{
mutex_init(&bt_sco_lock);
mutex_init(&mic_lock);
#ifdef CONFIG_MSM8X60_AUDIO_LTE
pr_aud_info("%s\n", __func__);
htc_8x60_register_analog_ops(&ops);
htc_8x60_register_icodec_ops(&iops);
htc_8x60_register_ecodec_ops(&eops);
acoustic_register_ops(&acoustic);
htc_8x60_register_aic3254_ops(&aops);
#endif
aic3254_register_ctl_ops(&cops);
/* PMIC GPIO Init (See board-verdi-lte.c) */
mutex_init(&audio_2v85_usage_lock);
audio_2v85_usage_counter = 0;
verdi_lte_audio_2v85_set_voltage(1);
/* Reset AIC3254 */
gpio_tlmm_config(msm_aic3254_reset_gpio[0], GPIO_CFG_ENABLE);
/* this PIN is only defined in XA board */
if (system_rev == 0) {
gpio_set_value(VERDI_LTE_AUD_LDO_SEL, 0);
mdelay(1);
config_gpio_table(msm_snddev_gpio_on, \
ARRAY_SIZE(msm_snddev_gpio_on));
gpio_set_value(VERDI_LTE_AUD_RX_MCLK1, 0);
gpio_set_value(VERDI_LTE_AUD_QTR_TX_MCLK1, 0);
gpio_set_value(VERDI_LTE_AUD_QTR_TX_I2S_SD2, 0);
} else {
config_gpio_table(msm_snddev_gpio_off, \
ARRAY_SIZE(msm_snddev_gpio_off));
gpio_set_value(VERDI_LTE_AUD_RX_MCLK1, 0);
gpio_set_value(VERDI_LTE_AUD_QTR_TX_MCLK1, 0);
gpio_set_value(VERDI_LTE_AUD_QTR_TX_I2S_SD2, 0);
}
config_gpio_table(verdi_lte_a1028_gpio, \
ARRAY_SIZE(verdi_lte_a1028_gpio));
gpio_set_value(VERDI_LTE_AUD_A1028_RESET, 0);
gpio_set_value(VERDI_LTE_AUD_A1028_WAKEUP, 0);
gpio_set_value(VERDI_LTE_AUD_A1028_INT, 0);
config_gpio_table(verdi_lte_i2s_rx2_gpio, \
ARRAY_SIZE(verdi_lte_i2s_rx2_gpio));
gpio_set_value(VERDI_LTE_AUD_RX_CLK2, 0);
gpio_set_value(VERDI_LTE_AUD_RX_WS2, 0);
gpio_set_value(VERDI_LTE_AUD_RX_SD2, 0);
gpio_set_value(VERDI_LTE_AUD_RX_MCLK2, 0);
gpio_tlmm_config(msm_qtr_reset_gpio[0], GPIO_CFG_ENABLE);
gpio_set_value(VERDI_LTE_AUD_QTR_RESET, 1);
/* BT AUX PCM PIN init */
config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
gpio_set_value(VERDI_LTE_GPIO_BT_PCM_OUT, 0);
gpio_set_value(VERDI_LTE_GPIO_BT_PCM_SYNC, 0);
gpio_set_value(VERDI_LTE_GPIO_BT_PCM_CLK, 0);
audio_first_boot_counter = 0;
}
int es705_gpio_init(struct es705_priv *es705)
{
int rc = 0;
#ifdef CONFIG_SND_SOC_ES704_TEMP
static int gpio_initialized = 0;
if (gpio_initialized)
return rc;
#endif
if (es705->pdata->reset_gpio != -1) {
rc = gpio_request(es705->pdata->reset_gpio, "es705_reset");
if (rc < 0) {
dev_err(es705->dev, "%s(): es705_reset request failed",
__func__);
goto reset_gpio_request_error;
}
rc = gpio_direction_output(es705->pdata->reset_gpio, 0);
if (rc < 0) {
dev_err(es705->dev, "%s(): es705_reset direction failed",
__func__);
goto reset_gpio_direction_error;
}
} else {
dev_warn(es705->dev, "%s(): es705_reset undefined\n",
__func__);
}
if (es705->pdata->wakeup_gpio != -1) {
rc = gpio_request(es705->pdata->wakeup_gpio, "es705_wakeup");
if (rc < 0) {
dev_err(es705->dev, "%s(): es705_wakeup request failed",
__func__);
goto wakeup_gpio_request_error;
}
rc = gpio_direction_output(es705->pdata->wakeup_gpio, 0);
if (rc < 0) {
dev_err(es705->dev, "%s(): es705_wakeup direction failed",
__func__);
goto wakeup_gpio_direction_error;
}
} else {
dev_warn(es705->dev, "%s(): wakeup_gpio undefined\n",
__func__);
}
/* under H/W rev 0.5 */
if (es705->pdata->uart_gpio != -1) {
rc = gpio_request(es705->pdata->uart_gpio, "es705_uart");
if (rc < 0) {
dev_err(es705->dev, "%s(): es705_uart request failed",
__func__);
goto uart_gpio_request_error;
}
rc = gpio_direction_output(es705->pdata->uart_gpio, 0);
if (rc < 0) {
dev_err(es705->dev, "%s(): es705_uart direction failed",
__func__);
goto uart_gpio_direction_error;
}
} else {
dev_warn(es705->dev, "%s(): es705_uart undefined\n",
__func__);
}
if (es705->pdata->gpiob_gpio) {
rc = request_threaded_irq(es705->pdata->irq_base,
NULL,
es705_irq_event, IRQF_TRIGGER_RISING,
"es705-irq-event", es705);
if (rc) {
dev_err(es705->dev, "%s(): event request_irq() failed\n",
__func__);
goto event_irq_request_error;
}
rc = irq_set_irq_wake(es705->pdata->irq_base, 1);
if (rc < 0) {
dev_err(es705->dev, "%s(): set event irq wake failed\n",
__func__);
disable_irq(es705->pdata->irq_base);
free_irq(es705->pdata->irq_base, es705);
goto event_irq_wake_error;
}
}
#if defined(CONFIG_MACH_K3GDUOS_CTC)
gpio_tlmm_config(GPIO_CFG(es705->pdata->uart_tx_gpio, 2, GPIO_CFG_OUTPUT,GPIO_CFG_NO_PULL, GPIO_CFG_8MA), 1);
gpio_tlmm_config(GPIO_CFG(es705->pdata->uart_rx_gpio, 2, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_8MA), 1);
#endif /* CONFIG_MACH_K3GDUOS_CTC */
#ifdef CONFIG_SND_SOC_ES704_TEMP
gpio_initialized = 1;
#endif
return rc;
uart_gpio_direction_error:
gpio_free(es705->pdata->uart_gpio);
uart_gpio_request_error:
wakeup_gpio_direction_error:
gpio_free(es705->pdata->wakeup_gpio);
wakeup_gpio_request_error:
reset_gpio_direction_error:
gpio_free(es705->pdata->reset_gpio);
reset_gpio_request_error:
event_irq_wake_error:
event_irq_request_error:
return rc;
}
static int mipi_dsi_on(struct platform_device *pdev)
{
int ret = 0;
u32 clk_rate;
struct msm_fb_data_type *mfd;
struct fb_info *fbi;
struct fb_var_screeninfo *var;
struct msm_panel_info *pinfo;
struct mipi_panel_info *mipi;
u32 hbp, hfp, vbp, vfp, hspw, vspw, width, height;
u32 ystride, bpp, data;
u32 dummy_xres, dummy_yres;
int target_type = 0;
mfd = platform_get_drvdata(pdev);
fbi = mfd->fbi;
var = &fbi->var;
pinfo = &mfd->panel_info;
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_power_save)
mipi_dsi_pdata->dsi_power_save(1);
#if defined(CONFIG_FB_MSM_MIPI_PANEL_POWERON_LP11)
/*
* Fix for floating state of VDD line in toshiba chip
* */
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_client_power_save)
mipi_dsi_pdata->dsi_client_power_save(1);
#endif /* CONFIG_FB_MSM_MIPI_PANEL_POWERON_LP11 */
cont_splash_clk_ctrl();
local_bh_disable();
mipi_dsi_ahb_ctrl(1);
local_bh_enable();
clk_rate = mfd->fbi->var.pixclock;
clk_rate = min(clk_rate, mfd->panel_info.clk_max);
MIPI_OUTP(MIPI_DSI_BASE + 0x114, 1);
MIPI_OUTP(MIPI_DSI_BASE + 0x114, 0);
hbp = var->left_margin;
hfp = var->right_margin;
vbp = var->upper_margin;
vfp = var->lower_margin;
hspw = var->hsync_len;
vspw = var->vsync_len;
width = mfd->panel_info.xres;
height = mfd->panel_info.yres;
mipi_dsi_phy_ctrl(1);
if (mdp_rev == MDP_REV_42 && mipi_dsi_pdata)
target_type = mipi_dsi_pdata->target_type;
mipi_dsi_phy_init(0, &(mfd->panel_info), target_type);
local_bh_disable();
mipi_dsi_clk_enable();
local_bh_enable();
mipi = &mfd->panel_info.mipi;
if (mfd->panel_info.type == MIPI_VIDEO_PANEL) {
dummy_xres = mfd->panel_info.mipi.xres_pad;
dummy_yres = mfd->panel_info.mipi.yres_pad;
if (mdp_rev >= MDP_REV_41) {
MIPI_OUTP(MIPI_DSI_BASE + 0x20,
((hspw + hbp + width + dummy_xres) << 16 |
(hspw + hbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x24,
((vspw + vbp + height + dummy_yres) << 16 |
(vspw + vbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x28,
(vspw + vbp + height + dummy_yres +
vfp - 1) << 16 | (hspw + hbp +
width + dummy_xres + hfp - 1));
} else {
/* DSI_LAN_SWAP_CTRL */
MIPI_OUTP(MIPI_DSI_BASE + 0x00ac, mipi->dlane_swap);
MIPI_OUTP(MIPI_DSI_BASE + 0x20,
((hbp + width + dummy_xres) << 16 | (hbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x24,
((vbp + height + dummy_yres) << 16 | (vbp)));
MIPI_OUTP(MIPI_DSI_BASE + 0x28,
(vbp + height + dummy_yres + vfp) << 16 |
(hbp + width + dummy_xres + hfp));
}
MIPI_OUTP(MIPI_DSI_BASE + 0x2c, (hspw << 16));
MIPI_OUTP(MIPI_DSI_BASE + 0x30, 0);
MIPI_OUTP(MIPI_DSI_BASE + 0x34, (vspw << 16));
} else { /* command mode */
if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB888)
bpp = 3;
else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB666)
bpp = 3;
else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB565)
bpp = 2;
else
bpp = 3; /* Default format set to RGB888 */
ystride = width * bpp + 1;
/* DSI_COMMAND_MODE_MDP_STREAM_CTRL */
data = (ystride << 16) | (mipi->vc << 8) | DTYPE_DCS_LWRITE;
MIPI_OUTP(MIPI_DSI_BASE + 0x5c, data);
MIPI_OUTP(MIPI_DSI_BASE + 0x54, data);
/* DSI_COMMAND_MODE_MDP_STREAM_TOTAL */
data = height << 16 | width;
MIPI_OUTP(MIPI_DSI_BASE + 0x60, data);
MIPI_OUTP(MIPI_DSI_BASE + 0x58, data);
}
mipi_dsi_host_init(mipi);
#if defined(CONFIG_FB_MSM_MIPI_PANEL_POWERON_LP11)
/*
* For TC358764 D2L IC, one of the requirement for power on
* is to maintain an LP11 state in data and clock lanes during
* power enabling and reset assertion. This change is to
* achieve that.
* */
if (mipi_dsi_pdata && mipi_dsi_pdata->dsi_client_power_save) {
u32 tmp_reg0c, tmp_rega8;
mipi_dsi_pdata->dsi_client_reset();
udelay(200);
/* backup register values */
tmp_reg0c = MIPI_INP(MIPI_DSI_BASE + 0x000c);
tmp_rega8 = MIPI_INP(MIPI_DSI_BASE + 0xA8);
/* Clear HS mode assertion and related flags */
MIPI_OUTP(MIPI_DSI_BASE + 0x0c, 0x8000);
MIPI_OUTP(MIPI_DSI_BASE + 0xA8, 0x0);
wmb();
mdelay(5);
/* restore previous values */
MIPI_OUTP(MIPI_DSI_BASE + 0x0c, tmp_reg0c);
MIPI_OUTP(MIPI_DSI_BASE + 0xa8, tmp_rega8);
wmb();
}
#endif /* CONFIG_FB_MSM_MIPI_PANEL_POWERON_LP11 */
if (mipi->force_clk_lane_hs) {
u32 tmp;
tmp = MIPI_INP(MIPI_DSI_BASE + 0xA8);
tmp |= (1<<28);
MIPI_OUTP(MIPI_DSI_BASE + 0xA8, tmp);
wmb();
}
if (mdp_rev >= MDP_REV_41)
mutex_lock(&mfd->dma->ov_mutex);
else
down(&mfd->dma->mutex);
ret = panel_next_on(pdev);
mipi_dsi_op_mode_config(mipi->mode);
if (mfd->panel_info.type == MIPI_CMD_PANEL) {
if (pinfo->lcd.vsync_enable) {
if (pinfo->lcd.hw_vsync_mode && vsync_gpio >= 0) {
if (mdp_rev >= MDP_REV_41) {
if (gpio_request(vsync_gpio,
"MDP_VSYNC") == 0)
gpio_direction_input(
vsync_gpio);
else
pr_err("%s: unable to request gpio=%d\n",
__func__, vsync_gpio);
} else if (mdp_rev == MDP_REV_303) {
if (!tlmm_settings && gpio_request(
vsync_gpio, "MDP_VSYNC") == 0) {
ret = gpio_tlmm_config(
GPIO_CFG(
vsync_gpio, 1,
GPIO_CFG_INPUT,
GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (ret) {
pr_err("%s: unable to config tlmm = %d\n",
__func__, vsync_gpio);
}
tlmm_settings = TRUE;
gpio_direction_input(
vsync_gpio);
} else {
if (!tlmm_settings) {
pr_err("%s: unable to request gpio=%d\n",
__func__, vsync_gpio);
}
}
}
}
mipi_dsi_set_tear_on(mfd);
}
}
#ifdef CONFIG_MSM_BUS_SCALING
mdp_bus_scale_update_request(2);
#endif
mdp4_overlay_dsi_state_set(ST_DSI_RESUME);
if (mdp_rev >= MDP_REV_41)
mutex_unlock(&mfd->dma->ov_mutex);
else
up(&mfd->dma->mutex);
pr_debug("%s-:\n", __func__);
return ret;
}
void mdp_config_vsync(struct msm_fb_data_type *mfd)
{
/* vsync on primary lcd only for now */
if ((mfd->dest != DISPLAY_LCD) || (mfd->panel_info.pdest != DISPLAY_1)
|| (!vsync_mode)) {
goto err_handle;
}
if (mfd->panel_info.lcd.vsync_enable) {
mfd->total_porch_lines = mfd->panel_info.lcd.v_back_porch +
mfd->panel_info.lcd.v_front_porch +
mfd->panel_info.lcd.v_pulse_width;
mfd->total_lcd_lines =
mfd->panel_info.yres + mfd->total_porch_lines;
mfd->lcd_ref_usec_time =
100000000 / mfd->panel_info.lcd.refx100;
mfd->vsync_handler_pending = FALSE;
mfd->last_vsync_timetick.tv.sec = 0;
mfd->last_vsync_timetick.tv.nsec = 0;
#ifdef MDP_HW_VSYNC
if (mdp_vsync_clk == NULL)
mdp_vsync_clk = clk_get(NULL, "mdp_vsync_clk");
if (IS_ERR(mdp_vsync_clk)) {
printk(KERN_ERR "error: can't get mdp_vsync_clk!\n");
mfd->use_mdp_vsync = 0;
} else
mfd->use_mdp_vsync = 1;
if (mfd->use_mdp_vsync) {
uint32 vsync_cnt_cfg, vsync_cnt_cfg_dem;
uint32 mdp_vsync_clk_speed_hz;
mdp_vsync_clk_speed_hz = clk_get_rate(mdp_vsync_clk);
if (mdp_vsync_clk_speed_hz == 0) {
mfd->use_mdp_vsync = 0;
} else {
/*
* Do this calculation in 2 steps for
* rounding uint32 properly.
*/
vsync_cnt_cfg_dem =
(mfd->panel_info.lcd.refx100 *
mfd->total_lcd_lines) / 100;
vsync_cnt_cfg =
(mdp_vsync_clk_speed_hz) /
vsync_cnt_cfg_dem;
/* MDP cmd block enable */
mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON,
FALSE);
mdp_hw_vsync_clk_enable(mfd);
mdp_set_sync_cfg_0(mfd, vsync_cnt_cfg);
/*
* load the last line + 1 to be in the
* safety zone
*/
vsync_load_cnt = mfd->panel_info.yres;
/* line counter init value at the next pulse */
MDP_OUTP(MDP_BASE + MDP_PRIM_VSYNC_INIT_VAL,
vsync_load_cnt);
/*
* external vsync source pulse width and
* polarity flip
*/
MDP_OUTP(MDP_BASE + MDP_PRIM_VSYNC_OUT_CTRL,
BIT(30) | BIT(0));
/* threshold */
MDP_OUTP(MDP_BASE + 0x200,
(vsync_above_th << 16) |
(vsync_start_th));
mdp_hw_vsync_clk_disable(mfd);
/* MDP cmd block disable */
mdp_pipe_ctrl(MDP_CMD_BLOCK,
MDP_BLOCK_POWER_OFF, FALSE);
}
}
#else
mfd->use_mdp_vsync = 0;
hrtimer_init(&mfd->dma_hrtimer, CLOCK_MONOTONIC,
HRTIMER_MODE_REL);
mfd->dma_hrtimer.function = mdp_dma2_vsync_hrtimer_handler;
mfd->vsync_width_boundary = vmalloc(mfd->panel_info.xres * 4);
#endif
mfd->channel_irq = 0;
if (mfd->panel_info.lcd.hw_vsync_mode) {
u32 vsync_gpio = mfd->vsync_gpio;
u32 ret;
if (vsync_gpio == -1) {
MSM_FB_INFO("vsync_gpio not defined!\n");
goto err_handle;
}
ret = gpio_tlmm_config(GPIO_CFG
(vsync_gpio,
(mfd->use_mdp_vsync) ? 1 : 0,
GPIO_CFG_INPUT,
GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (ret)
goto err_handle;
if (!mfd->use_mdp_vsync) {
mfd->channel_irq = MSM_GPIO_TO_INT(vsync_gpio);
if (request_irq
(mfd->channel_irq,
&mdp_hw_vsync_handler_proxy,
IRQF_TRIGGER_FALLING, "VSYNC_GPIO",
(void *)mfd)) {
MSM_FB_INFO
("irq=%d failed! vsync_gpio=%d\n",
mfd->channel_irq,
vsync_gpio);
goto err_handle;
}
}
}
mdp_set_vsync((unsigned long)mfd);
}
return;
err_handle:
if (mfd->vsync_width_boundary)
vfree(mfd->vsync_width_boundary);
mfd->panel_info.lcd.vsync_enable = FALSE;
printk(KERN_ERR "%s: failed!\n", __func__);
}
void gpio_set_diag_gpio_table(unsigned long *dwMFG_gpio_table)
{
int i = 0;
unsigned cfg;
PSUSPEND_PIN_CONFIG pSuspendPinConfig = 0;
pSuspendPinConfig = (PSUSPEND_PIN_CONFIG)(dwMFG_gpio_table);
#if defined(CONFIG_ARCH_MSM7X00A)
for (i = 0; i <= 121; i++)
#elif defined(CONFIG_ARCH_MSM7225)
for (i = 0; i < 132; i++)
#elif defined(CONFIG_ARCH_MSM7227)
for (i = 0; i < 132; i++)
#elif defined(CONFIG_ARCH_QSD8X50)
for (i = 0; i <= 164; i++)
#elif defined(CONFIG_ARCH_MSM7X30)
for (i = 0; i <= 181; i++)
#elif defined(CONFIG_ARCH_MSM8X60)
for (i = 0; i < 173; i++)
#elif defined(CONFIG_ARCH_MSM8960)
for (i = 0; i < 151; i++)
#endif
{
unsigned char tempGpio = pSuspendPinConfig->arGpio[i];
if (tempGpio & 0x1) {
/* configure by the settings from DIAG */
unsigned long dwGpioKind, dwGpioConfig, dwOutputLevel;
if (tempGpio & 0x2) { /* GPIO INPUT PIN */
dwGpioKind = GPIO_INPUT;
dwOutputLevel = 0;
} else { /* GPIO_OUTPUT_PIN */
dwGpioKind = GPIO_OUTPUT;
if (tempGpio & 0x4)
dwOutputLevel = 1;
else
dwOutputLevel = 0;
}
/* config GpioPullStatus */
if ((tempGpio & 0x10) && (tempGpio & 0x08))
dwGpioConfig = GPIO_PULL_UP;
else if (tempGpio & 0x08)
dwGpioConfig = GPIO_PULL_DOWN;
else if (tempGpio & 0x10)
dwGpioConfig = GPIO_KEEPER;
else
dwGpioConfig = GPIO_NO_PULL;
#if defined(CONFIG_ARCH_MSM8X60) || defined(CONFIG_ARCH_MSM8960)
cfg = GPIO_CFG(i, 0, dwGpioKind, dwGpioConfig, GPIO_2MA);
gpio_tlmm_config(cfg, GPIO_CFG_ENABLE);
#else
cfg = PCOM_GPIO_CFG(i, 0, dwGpioKind, dwGpioConfig, GPIO_2MA);
msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &cfg, 0);
#endif
if (dwGpioKind == GPIO_OUTPUT)
gpio_direction_output(i, dwOutputLevel);
} else {
/* DIAG does not want to config this GPIO */
continue;
}
}
}
static void kingdom_setup_input_gpio(void)
{
gpio_tlmm_config(inputs_gpio_table[0], GPIO_CFG_ENABLE);
}
static int max77804k_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct max77804k_dev *max77804k;
struct max77804k_platform_data *pdata;
u8 reg_data;
int ret = 0;
dev_info(&i2c->dev, "%s\n", __func__);
max77804k = kzalloc(sizeof(struct max77804k_dev), GFP_KERNEL);
if (max77804k == NULL)
return -ENOMEM;
if (i2c->dev.of_node) {
pdata = devm_kzalloc(&i2c->dev,
sizeof(struct max77804k_platform_data),
GFP_KERNEL);
if (!pdata) {
dev_err(&i2c->dev, "Failed to allocate memory \n");
ret = -ENOMEM;
goto err;
}
ret = of_max77804k_dt(&i2c->dev, pdata);
if (ret < 0){
dev_err(&i2c->dev, "Failed to get device of_node \n");
ret = -ENOMEM;
goto err;
}
/*Filling the platform data*/
pdata->muic_data = &max77804k_muic;
#ifdef CONFIG_REGULATOR_MAX77804K
pdata->num_regulators = MAX77804K_REG_MAX;
pdata->regulators = max77804k_regulators;
#endif
#ifdef CONFIG_LEDS_MAX77804K
pdata->led_data = &max77804k_led_pdata;
#endif
/*pdata update to other modules*/
i2c->dev.platform_data = pdata;
} else
pdata = i2c->dev.platform_data;
i2c_set_clientdata(i2c, max77804k);
max77804k->dev = &i2c->dev;
max77804k->i2c = i2c;
max77804k->irq = i2c->irq;
if (pdata) {
max77804k->irq_base = pdata->irq_base;
max77804k->irq_gpio = pdata->irq_gpio;
max77804k->wakeup = pdata->wakeup;
gpio_tlmm_config(GPIO_CFG(max77804k->irq_gpio, 0, GPIO_CFG_INPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
} else {
ret = -EINVAL;
goto err;
}
mutex_init(&max77804k->iolock);
if (max77804k_read_reg(i2c, MAX77804K_PMIC_REG_PMIC_ID2, ®_data) < 0) {
dev_err(max77804k->dev,
"device not found on this channel (this is not an error)\n");
ret = -ENODEV;
goto err;
} else {
/* print rev */
max77804k->pmic_rev = (reg_data & 0x7);
max77804k->pmic_ver = ((reg_data & 0xF8) >> 0x3);
pr_info("%s: device found: rev.0x%x, ver.0x%x\n", __func__,
max77804k->pmic_rev, max77804k->pmic_ver);
}
max77804k_update_reg(i2c, MAX77804K_CHG_REG_SAFEOUT_CTRL, 0x00, 0x30);
max77804k->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC);
i2c_set_clientdata(max77804k->muic, max77804k);
max77804k->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC);
i2c_set_clientdata(max77804k->haptic, max77804k);
ret = max77804k_irq_init(max77804k);
if (ret < 0)
goto err_irq_init;
ret = mfd_add_devices(max77804k->dev, -1, max77804k_devs,
ARRAY_SIZE(max77804k_devs), NULL, 0);
if (ret < 0)
goto err_mfd;
device_init_wakeup(max77804k->dev, pdata->wakeup);
/* Set continuous mode */
max77804k_update_reg(max77804k->muic, MAX77804K_MUIC_REG_CTRL4,
ADC_ALWAYS, CTRL4_ADCMODE_MASK);
return ret;
err_mfd:
mfd_remove_devices(max77804k->dev);
max77804k_irq_exit(max77804k);
err_irq_init:
i2c_unregister_device(max77804k->muic);
i2c_unregister_device(max77804k->haptic);
err:
kfree(max77804k);
return ret;
}
/* get module value */
int get_tp_id(void)
{
int id0 = 0;
int id1 = 0;
int high_read = 0;
int low_read = 0;
int ret = 0;
ret = gpio_request(TP_ID0, "TP_ID0");
if(ret < 0)
{
printk(KERN_ERR"TP_ID0 gpio[%d] request failed\n", TP_ID0);
return -1;
}
ret = gpio_request(TP_ID1, "TP_ID1");
if(ret < 0)
{
printk(KERN_ERR"TP_ID1 gpio[%d] request failed\n", TP_ID1);
return -1;
}
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
gpio_set_value(TP_ID0,0);
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
low_read = gpio_get_value(TP_ID0);
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
gpio_set_value(TP_ID0,1);
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
high_read = gpio_get_value(TP_ID0);
if (low_read != high_read)
{
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
id0 = BIT(1);
}
else
{
id0 = low_read;
if (id0)
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
else
gpio_tlmm_config(GPIO_CFG(TP_ID0, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
gpio_set_value(TP_ID1,0);
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
low_read = gpio_get_value(TP_ID1);
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
gpio_set_value(TP_ID1,1);
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
high_read = gpio_get_value(TP_ID1);
if (low_read != high_read)
{
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
id1 = BIT(1);
}
else
{
id1 = low_read;
if (id1)
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
else
gpio_tlmm_config(GPIO_CFG(TP_ID1, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
gpio_free(TP_ID0);
gpio_free(TP_ID1);
return id1 << 2 | id0;
}
static int __devinit jogball_probe(struct platform_device *pdev)
{
struct jogball_platform_data *pdata = pdev->dev.platform_data;
struct jogball_drvdata *ddata;
struct jogball_button *button;
int i;
int error = -1;
#ifdef CONFIG_HUAWEI_FEATURE_U8220_PP1
int iHwversion = -1;
#endif
gpio_tlmm_config(GPIO_CFG(pdata->gpio_ctl, 0, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_2MA), GPIO_ENABLE);
for (i = 0; i < pdata->nbuttons; i++) {
button = &pdata->buttons[i];
gpio_tlmm_config(GPIO_CFG(button->gpio, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE);
}
ddata = kzalloc(sizeof(struct jogball_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL);
if (!ddata) {
error = -ENOMEM;
printk("\n kzalloc error \n");
goto err_alloc;
}
ddata->input = input_allocate_device();
if (!(ddata->input)) {
error = -ENOMEM;
printk("\n input_allocate_device error \n");
goto err_inputalloc;
}
set_bit(EV_KEY, ddata->input->evbit);
platform_set_drvdata(pdev, ddata);
ddata->input->name = pdev->name;
error = gpio_request(pdata->gpio_ctl, "jogball_ctl");
if (error<0) {
printk("jogball_ctl: failed to request GPIO for jogball_ctl %d,"
" error %d\n", pdata->gpio_ctl, error);
goto err_gpio_req;
}
error = gpio_direction_output(pdata->gpio_ctl,GPIO_LOW_VALUE);
if (error<0) {
pr_err("jogball_clt: gpio_configure failed for "
"output %d\n", pdata->gpio_ctl);
goto err_gpio_dir;
}
for (i = 0; i < pdata->nbuttons; i++) {
button = &pdata->buttons[i];
//unsigned int type = button->type ?: EV_KEY;
error = gpio_request(button->gpio, "jogball");
if (error < 0) {
printk("jogball: failed to request GPIO %d,"
" error %d\n", button->gpio, error);
while (--i >= 0) {
gpio_free(pdata->buttons[i].gpio);
}
goto err_gpio_dir;
}
error = gpio_direction_input(button->gpio);
if (error < 0) {
printk("jogball: failed to configure input"
" direction for GPIO %d, error %d\n",
button->gpio, error);
while (--i >= 0) {
gpio_free(pdata->buttons[i].gpio);
}
/*we release one more*/
gpio_free(button->gpio);
goto err_gpio_dir;
}
//input_set_capability(ddata->input, type, button->code);
}
#ifdef CONFIG_HUAWEI_FEATURE_U8220_PP1
/*decide HW version for deal jogball */
iHwversion = bio_get_hw_sub_ver();
if(HW_VER_T1 == iHwversion)
{/*T1,T2*/
g_iJogballReport = 0;
}
else if (HW_VER_PP1 == iHwversion)
{/*PP1*/
g_iJogballReport = JOGBALL_REPNUM;
}
else
{
g_iJogballReport = JOGBALL_REPNUM;
}
#endif
g_iJogballReport = JOGBALL_REPNUM;
input_set_capability(ddata->input, EV_KEY, BTN_MOUSE);
input_set_capability(ddata->input, EV_REL, REL_X);
input_set_capability(ddata->input, EV_REL, REL_Y);
INIT_WORK(&ddata->jogball_work, jogball_do_work);
error = jogball_up_isr_start(pdev);
if(error < 0)
{
goto err_gpiodir_req;
}
error = jogball_down_isr_start(pdev);
if(error < 0)
{
goto err_gpiodir_req;
}
error = jogball_left_isr_start(pdev);
if(error < 0)
{
goto err_gpiodir_req;
}
error = jogball_right_isr_start(pdev);
if(error < 0)
{
goto err_gpiodir_req;
}
error = input_register_device(ddata->input);
if (error) {
printk("jogball: Unable to register input device, " "error: %d\n", error);
goto err_gpiodir_req;
}
return 0;
//error:
err_gpiodir_req:
for(i = 0; i < pdata->nbuttons; i++) {
gpio_free(pdata->buttons[i].gpio);
}
err_gpio_dir:
//gpio_free(JOGBALL_CTL);
gpio_free(pdata->gpio_ctl);
err_gpio_req:
platform_set_drvdata(pdev, NULL);
input_free_device(ddata->input);
err_inputalloc:
kfree(ddata);
err_alloc:
return error;
}
static void sdcc_gpio_init(void)
{
#ifdef CONFIG_MMC_MSM_CARD_HW_DETECTION
int rc = 0;
if (gpio_request(sd_detect_gpio, "sdc1_status_pin_irq"))
pr_err("failed to request gpio sdc1_status_irq\n");
rc = gpio_tlmm_config(GPIO_CFG(sd_detect_gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,
GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (rc)
printk(KERN_ERR "%s: Failed to configure GPIO %d\n",
__func__, rc);
/* if (gpio_request(GPIO_MMC_COVER_DETECT, "sdc1_status_socket_irq")) */
/* pr_err("failed to request gpio sdc1_status_irq\n"); */
/* rc = gpio_tlmm_config(GPIO_CFG(GPIO_MMC_COVER_DETECT, 0, GPIO_INPUT, GPIO_PULL_UP, */
/* GPIO_2MA), GPIO_ENABLE); */
/* if (rc) */
/* printk(KERN_ERR "%s: Failed to configure GPIO %d\n", */
/* __func__, rc); */
#endif
/* SDC1 GPIOs */
#ifdef CONFIG_MMC_MSM_SDC1_SUPPORT
#ifdef CONFIG_MMC_MSM_CARD_HW_DETECTION
if (gpio_request(GPIO_SD_DATA_3, "sdc1_data_3"))
pr_err("failed to request gpio sdc1_data_3\n");
if (gpio_request(GPIO_SD_DATA_2, "sdc1_data_2"))
pr_err("failed to request gpio sdc1_data_2\n");
if (gpio_request(GPIO_SD_DATA_1, "sdc1_data_1"))
pr_err("failed to request gpio sdc1_data_1\n");
if (gpio_request(GPIO_SD_DATA_0, "sdc1_data_0"))
pr_err("failed to request gpio sdc1_data_0\n");
if (gpio_request(GPIO_SD_CMD, "sdc1_cmd"))
pr_err("failed to request gpio sdc1_cmd\n");
if (gpio_request(GPIO_SD_CLK, "sdc1_clk"))
pr_err("failed to request gpio sdc1_clk\n");
#else
if (gpio_request(51, "sdc1_data_3"))
pr_err("failed to request gpio sdc1_data_3\n");
if (gpio_request(52, "sdc1_data_2"))
pr_err("failed to request gpio sdc1_data_2\n");
if (gpio_request(53, "sdc1_data_1"))
pr_err("failed to request gpio sdc1_data_1\n");
if (gpio_request(54, "sdc1_data_0"))
pr_err("failed to request gpio sdc1_data_0\n");
if (gpio_request(55, "sdc1_cmd"))
pr_err("failed to request gpio sdc1_cmd\n");
if (gpio_request(56, "sdc1_clk"))
pr_err("failed to request gpio sdc1_clk\n");
#endif
#endif
/* SDC2 GPIOs */
#ifdef CONFIG_MMC_MSM_SDC2_SUPPORT
if (gpio_request(62, "sdc2_clk"))
pr_err("failed to request gpio sdc2_clk\n");
if (gpio_request(63, "sdc2_cmd"))
pr_err("failed to request gpio sdc2_cmd\n");
if (gpio_request(64, "sdc2_data_3"))
pr_err("failed to request gpio sdc2_data_3\n");
if (gpio_request(65, "sdc2_data_2"))
pr_err("failed to request gpio sdc2_data_2\n");
if (gpio_request(66, "sdc2_data_1"))
pr_err("failed to request gpio sdc2_data_1\n");
if (gpio_request(67, "sdc2_data_0"))
pr_err("failed to request gpio sdc2_data_0\n");
#endif
/* SDC3 GPIOs */
#ifdef CONFIG_MMC_MSM_SDC3_SUPPORT
if (gpio_request(88, "sdc3_clk"))
pr_err("failed to request gpio sdc3_clk\n");
if (gpio_request(89, "sdc3_cmd"))
pr_err("failed to request gpio sdc3_cmd\n");
if (gpio_request(90, "sdc3_data_3"))
pr_err("failed to request gpio sdc3_data_3\n");
if (gpio_request(91, "sdc3_data_2"))
pr_err("failed to request gpio sdc3_data_2\n");
if (gpio_request(92, "sdc3_data_1"))
pr_err("failed to request gpio sdc3_data_1\n");
if (gpio_request(93, "sdc3_data_0"))
pr_err("failed to request gpio sdc3_data_0\n");
#endif
/* SDC4 GPIOs */
#ifdef CONFIG_MMC_MSM_SDC4_SUPPORT
if (gpio_request(19, "sdc4_data_3"))
pr_err("failed to request gpio sdc4_data_3\n");
if (gpio_request(20, "sdc4_data_2"))
pr_err("failed to request gpio sdc4_data_2\n");
if (gpio_request(21, "sdc4_data_1"))
pr_err("failed to request gpio sdc4_data_1\n");
if (gpio_request(107, "sdc4_cmd"))
pr_err("failed to request gpio sdc4_cmd\n");
if (gpio_request(108, "sdc4_data_0"))
pr_err("failed to request gpio sdc4_data_0\n");
if (gpio_request(109, "sdc4_clk"))
pr_err("failed to request gpio sdc4_clk\n");
#endif
}
static int
qcom_ehci_attach(device_t self)
{
ehci_softc_t *sc;
struct qcom_ehci_softc *esc;
bus_space_handle_t bsh;
int err;
uint32_t val;
esc = device_get_softc(self);
sc = &esc->base;
sc->sc_bus.parent = self;
sc->sc_bus.devices = sc->sc_devices;
sc->sc_bus.devices_max = EHCI_MAX_DEVICES;
/* get all DMA memory */
if (usb_bus_mem_alloc_all(&sc->sc_bus,
USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) {
return (ENOMEM);
}
sc->sc_bus.usbrev = USB_REV_2_0;
if (bus_alloc_resources(self, qcom_ehci_spec, esc->res)) {
device_printf(self, "could not allocate resources\n");
return (ENXIO);
}
/* EHCI registers */
sc->sc_io_tag = rman_get_bustag(esc->res[0]);
bsh = rman_get_bushandle(esc->res[0]);
sc->sc_io_size = rman_get_size(esc->res[0]);
/* GPIO */
esc->gpio_bst = rman_get_bustag(esc->res[1]);
esc->gpio_bsh = rman_get_bushandle(esc->res[1]);
if (bus_space_subregion(sc->sc_io_tag, bsh, 0x100,
sc->sc_io_size, &sc->sc_io_hdl) != 0)
panic("%s: unable to subregion USB host registers",
device_get_name(self));
sc->sc_bus.bdev = device_add_child(self, "usbus", -1);
if (!sc->sc_bus.bdev) {
device_printf(self, "Could not add USB device\n");
goto error;
}
device_set_ivars(sc->sc_bus.bdev, &sc->sc_bus);
device_set_desc(sc->sc_bus.bdev, EHCI_HC_DEVSTR);
sprintf(sc->sc_vendor, "Qualcomm");
err = bus_setup_intr(self, esc->res[2], INTR_TYPE_BIO | INTR_MPSAFE,
NULL, (driver_intr_t *)ehci_interrupt, sc, &sc->sc_intr_hdl);
if (err) {
device_printf(self, "Could not setup irq, %d\n", err);
sc->sc_intr_hdl = NULL;
goto error;
}
sc->sc_flags |= EHCI_SCFLG_DONTRESET;
/* Configure GPIO for output */
gpio_tlmm_config(esc, 77, 0, QGPIO_OUTPUT, QGPIO_NO_PULL, QGPIO_8MA, QGPIO_ENABLE);
/* Output High */
gpio_set(esc, 77, 2);
/* ehci phy reset */
val = READ_4(sc, USB_PORTSC) & ~PORTSC_PTS_MASK;
WRITE_4(sc, USB_PORTSC, val | PORTSC_PTS_ULPI);
WRITE_4(sc, USB_USBCMD, USBCMD_RESET);
/* reset */
WRITE_4(sc, USB_USBCMD, 0x00080000);
/* select ULPI phy */
WRITE_4(sc, USB_PORTSC, 0x80000000);
/* burst of unspecified len */
WRITE_4(sc, USB_AHB_BURST, 0);
/* HPROT mode */
WRITE_4(sc, USB_AHB_MODE, 0x08);
/* disable BAM */
WRITE_4(sc, USB_GENCONFIG, (1 << 13));
// READ_4(sc, USB_DCCPARAMS);
/* Disable streaming mode and select host mode */
WRITE_4(sc, USB_USBMODE, 0x13);
/* go to RUN mode (D+ pullup enable) */
WRITE_4(sc, USB_USBCMD, 0x00080000);
// breakpoint();
err = ehci_init(sc);
if (!err)
err = device_probe_and_attach(sc->sc_bus.bdev);
if (err) {
device_printf(self, "USB init failed err=%d\n", err);
goto error;
}
return (0);
error:
qcom_ehci_detach(self);
return (ENXIO);
}
/* FIH-SW-MM-VH-DISPLAY-JB00*[ */
static int msm_fb_dsi_client_msm_reset(int hold)
{
int rc = 0;
static int dsi_reset_initialized = 0;
printk(KERN_INFO "[DISPLAY]%s: E, hold <%d>\n", __func__, hold);
if (dsi_reset_initialized == 0) {
rc = gpio_request(GPIO_LCM_RESET, "gpio_disp_pwr");
if (rc < 0) {
pr_err("[DISPLAY] %s: Failed to request lcm_reset, rc <%d>\n", __func__, rc);
//return rc;
}
rc = gpio_tlmm_config(GPIO_CFG(GPIO_LCM_RESET, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (unlikely(fih_get_product_phase() < Phase_SP2)) {
printk(KERN_ALERT "[DISPLAY]%s: <%d> < SP2\n", __func__, fih_get_product_phase());
rc = gpio_request(GPIO_LCM_BKL_EN, "lcm_bkl_en");
if (rc < 0) {
pr_err("[DISPLAY] %s: Failed to request lcm_bkl_en\n", __func__);
//goto gpio_error;
}
rc = gpio_tlmm_config(GPIO_CFG(GPIO_LCM_BKL_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("[DISPLAY] %s: Failed lcm_bkl_en enable\n", __func__);
//goto gpio_error2;
}
}
dsi_reset_initialized = 1;
}
if (hold) {
gpio_direction_output(GPIO_LCM_RESET, 0);
} else {
rc |= gpio_direction_output(GPIO_LCM_RESET, 1);
msleep(5);
rc |= gpio_direction_output(GPIO_LCM_RESET, 0);
msleep(5);
rc |= gpio_direction_output(GPIO_LCM_RESET, 1);
}
msleep(150);
#if 0
if (!rc) {
if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf()
|| machine_is_msm8625_surf()) {
lcdc_reset_ptr = ioremap_nocache(LCDC_RESET_PHYS,
sizeof(uint32_t));
printk(KERN_ERR "[DISPLAY]%s: surf\n", __func__);
if (!lcdc_reset_ptr)
return 0;
}
printk(KERN_ERR "[DISPLAY]%s: X, rc <%d>\n", __func__, rc);
return rc;
} else {
//goto gpio_error;
}
#endif
#if 0
gpio_error2:
pr_err("Failed GPIO bridge pd\n");
gpio_free(GPIO_LCDC_BRDG_PD);
gpio_error:
pr_err("Failed GPIO bridge reset\n");
gpio_free(GPIO_LCDC_BRDG_RESET_N);
#endif
printk(KERN_INFO "[DISPLAY]%s: X, rc <%d>\n", __func__, rc);
return rc;
}
int pic16f_fw_update(bool pull96)
{
unsigned char zero_buf[1] = {0};
unsigned char addr_buf[2] = {0x02,0x00};
unsigned char temp_buf[1];
int i,rc=0;
unsigned int addr = 0x200;
int download_again = 0;
pr_err("%s pic16F_update_fw,erase data ing.......\n",__func__);
//pull up GPIO96 to power on MCU1503
if(pull96){
gpio_set_value(96,1);
rc = gpio_tlmm_config(GPIO_CFG(96, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
if(rc < 0){
pr_err("%s pull up GPIO96 fail\n",__func__);
return rc;
}
msleep(300);
}
update_fw:
//erase address 0x200-0x7FF
for(i = 0;i < ERASE_COUNT;i++){
//first:set address
rc = i2c_smbus_write_i2c_block_data(pic16F_client,0x01,2,&addr_buf[0]);
if(rc < 0){
pr_err("%s pic16F_update_fw,i2c_write 0x01 error\n",__func__);
goto update_fw_err;
}
//erase data:0x10 words once
i2c_smbus_write_i2c_block_data(pic16F_client,0x04,1,&zero_buf[0]);
msleep(1);
i2c_smbus_read_i2c_block_data(pic16F_client,0x04,1,&temp_buf[0]);
//printk("lfc read 0x04,temp_buf[0]:0x%x\n",temp_buf[0]);
addr = addr + 0x10;
addr_buf[0] = addr >> 8;
addr_buf[1] = addr & 0xFF;
//printk("lfc addr_buf[0]:0x%x,addr_buf[1]:0x%x\n",addr_buf[0],addr_buf[1]);
}
msleep(10);
pic16f_fw_write(Pic16F_firmware_data,0,sizeof(Pic16F_firmware_data) - 34);
//fw check begin:read data from pic1503/1508,and compare it with Pic16F_firmware_data[]
rc = pic16f_fw_check();
if(rc == FW_CHECK_FAIL){
download_again++;
if(download_again > 3){
goto update_fw_err;
}
pr_err("%s fw check fail,download fw again\n",__func__);
goto update_fw;
}
//fw check end
//write 0x7F0~0x7FF(0x7FF = 0x3455)
rc = pic16f_fw_write(Pic16F_firmware_data,sizeof(Pic16F_firmware_data) - 34,34);
if(rc < 0){
goto update_fw_err;
}
//write 0x7F0~0x7FF end
msleep(2);
//jump to app code begin
i2c_smbus_write_i2c_block_data(pic16F_client,0x06,1,&zero_buf[0]);
i2c_smbus_read_i2c_block_data(pic16F_client,0x06,1,&temp_buf[0]);
//jump to app code end
pic_have_updated = 1;
//pull down GPIO96 to power off MCU1503/1508
if(pull96) {
gpio_set_value(96,0);
rc = gpio_tlmm_config(GPIO_CFG(96, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
if(rc < 0){
pr_err("%s pull down GPIO96 fail\n",__func__);
}
}
pr_err("%s pic16F update_fw success\n",__func__);
return 0;
update_fw_err:
if(pull96){
gpio_set_value(96,0);
rc = gpio_tlmm_config(GPIO_CFG(96, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
if(rc < 0){
pr_err("%s pull down GPIO96 fail\n",__func__);
}
}
pr_err("%s pic16F update_fw fail\n",__func__);
return 1;
}
static int mipi_dsi_panel_qrd3_power(int on)
{
int rc = 0;
if (!qrd3_dsi_gpio_initialized) {
pmapp_disp_backlight_init();
rc = gpio_request(GPIO_QRD3_LCD_BACKLIGHT_EN,
"qrd3_gpio_bkl_en");
if (rc < 0)
return rc;
qrd3_dsi_gpio_initialized = 1;
if (mdp_pdata.cont_splash_enabled) {
rc = gpio_tlmm_config(GPIO_CFG(
GPIO_QRD3_LCD_BACKLIGHT_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("failed QRD3 GPIO_BACKLIGHT_EN tlmm config\n");
return rc;
}
rc = gpio_direction_output(GPIO_QRD3_LCD_BACKLIGHT_EN,
1);
if (rc < 0) {
pr_err("failed to enable backlight\n");
gpio_free(GPIO_QRD3_LCD_BACKLIGHT_EN);
return rc;
}
/*Configure LCD Bridge reset*/
rc = gpio_tlmm_config(qrd3_mipi_dsi_gpio[0],
GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("Failed to enable LCD Bridge reset enable\n");
return rc;
}
rc = gpio_direction_output(GPIO_QRD3_LCD_BRDG_RESET_N,
1);
if (rc < 0) {
pr_err("Failed GPIO bridge Reset\n");
gpio_free(GPIO_QRD3_LCD_BRDG_RESET_N);
return rc;
}
return 0;
}
}
if (on) {
rc = gpio_tlmm_config(GPIO_CFG(GPIO_QRD3_LCD_BACKLIGHT_EN, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("failed QRD3 GPIO_BACKLIGHT_EN tlmm config\n");
return rc;
}
rc = gpio_direction_output(GPIO_QRD3_LCD_BACKLIGHT_EN, 1);
if (rc < 0) {
pr_err("failed to enable backlight\n");
gpio_free(GPIO_QRD3_LCD_BACKLIGHT_EN);
return rc;
}
/*Toggle Backlight GPIO*/
gpio_set_value_cansleep(GPIO_QRD3_LCD_BACKLIGHT_EN, 1);
udelay(100);
gpio_set_value_cansleep(GPIO_QRD3_LCD_BACKLIGHT_EN, 0);
udelay(430);
gpio_set_value_cansleep(GPIO_QRD3_LCD_BACKLIGHT_EN, 1);
/* 1 wire mode starts from this low to high transition */
udelay(50);
/*Enable EXT_2.85 and 1.8 regulators*/
rc = regulator_enable(gpio_reg_2p85v);
if (rc < 0)
pr_err("%s: reg enable failed\n", __func__);
rc = regulator_enable(gpio_reg_1p8v);
if (rc < 0)
pr_err("%s: reg enable failed\n", __func__);
/*Configure LCD Bridge reset*/
rc = gpio_tlmm_config(qrd3_mipi_dsi_gpio[0], GPIO_CFG_ENABLE);
if (rc < 0) {
pr_err("Failed to enable LCD Bridge reset enable\n");
return rc;
}
rc = gpio_direction_output(GPIO_QRD3_LCD_BRDG_RESET_N, 1);
if (rc < 0) {
pr_err("Failed GPIO bridge Reset\n");
gpio_free(GPIO_QRD3_LCD_BRDG_RESET_N);
return rc;
}
/*Toggle Bridge Reset GPIO*/
msleep(20);
gpio_set_value_cansleep(GPIO_QRD3_LCD_BRDG_RESET_N, 0);
msleep(20);
gpio_set_value_cansleep(GPIO_QRD3_LCD_BRDG_RESET_N, 1);
msleep(20);
} else {
gpio_tlmm_config(GPIO_CFG(GPIO_QRD3_LCD_BACKLIGHT_EN, 0,
GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_DISABLE);
gpio_tlmm_config(GPIO_CFG(GPIO_QRD3_LCD_BRDG_RESET_N, 0,
GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),
GPIO_CFG_DISABLE);
rc = regulator_disable(gpio_reg_2p85v);
if (rc < 0)
pr_err("%s: reg disable failed\n", __func__);
rc = regulator_disable(gpio_reg_1p8v);
if (rc < 0)
pr_err("%s: reg disable failed\n", __func__);
}
return rc;
}
static int rt9396_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *i2c_dev_id)
{
struct lge_backlight_platform_data *pdata;
struct rt9396_driver_data *drvdata;
struct backlight_device *bd;
int err;
rt9396_powerstate = NORMAL_STATE;
dprintk("start, client addr=0x%x\n", i2c_dev->addr);
pdata = i2c_dev->dev.platform_data;
if(!pdata)
return -EINVAL;
drvdata = kzalloc(sizeof(struct rt9396_driver_data), GFP_KERNEL);
if (!drvdata) {
dev_err(&i2c_dev->dev, "failed to allocate memory\n");
return -ENOMEM;
}
if (pdata && pdata->platform_init)
pdata->platform_init();
drvdata->client = i2c_dev;
drvdata->gpio = pdata->gpio;
drvdata->max_intensity = LCD_LED_MAX;
if (pdata->max_current > 0)
drvdata->max_intensity = pdata->max_current;
drvdata->intensity = LCD_LED_MIN;
drvdata->mode = NORMAL_MODE;
drvdata->state = UNINIT_STATE;
drvdata->version = pdata->version;
if(rt9396_setup_version(drvdata) != 0) {
eprintk("Error while requesting gpio %d\n", drvdata->gpio);
kfree(drvdata);
return -ENODEV;
}
//[V3][junghoon79.kim][2012.9.10] #if 0 -> #if 1
#if 1 //not use enable pin in rt9396
if (drvdata->gpio && gpio_request(drvdata->gpio, "rt9396_en") != 0) {
eprintk("Error while requesting gpio %d\n", drvdata->gpio);
kfree(drvdata);
return -ENODEV;
}
gpio_tlmm_config(GPIO_CFG(drvdata->gpio, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
#endif
//[V3][junghoon79.kim][2012.9.10]- end
bd = backlight_device_register("rt9396-bl", &i2c_dev->dev, NULL, &rt9396_ops, NULL);
if (bd == NULL) {
eprintk("entering rt9396 probe function error \n");
//if (gpio_is_valid(drvdata->gpio))
// gpio_free(drvdata->gpio);
kfree(drvdata);
return -1;
}
bd->props.power = FB_BLANK_UNBLANK;
bd->props.brightness = drvdata->intensity;
bd->props.max_brightness = drvdata->max_intensity;
drvdata->bd = bd;
#ifdef CONFIG_BACKLIGHT_LEDS_CLASS
if (led_classdev_register(&i2c_dev->dev, &rt9396_led_dev) == 0) {
eprintk("Registering led class dev successfully.\n");
drvdata->led = &rt9396_led_dev;
err = device_create_file(drvdata->led->dev, &dev_attr_alc);
err = device_create_file(drvdata->led->dev, &dev_attr_reg);
err = device_create_file(drvdata->led->dev, &dev_attr_drvstat);
err = device_create_file(drvdata->led->dev, &dev_attr_chargerlogo);
}
/*2012-09-26 junghoon-kim([email protected]) porting from bu61800 driver [START]*/
#ifdef USE_BUTTON_BACKLIGHT
/* [email protected] */
if (led_classdev_register(&i2c_dev->dev, &rt9396_keyled_dev) == 0) {
eprintk("Registering led class dev successfully.\n");
drvdata->led = &rt9396_keyled_dev;
}
/* [email protected] */
#endif
/*2012-09-26 junghoon-kim([email protected]) porting from bu61800 driver [END]*/
#endif
i2c_set_clientdata(i2c_dev, drvdata);
i2c_set_adapdata(i2c_dev->adapter, i2c_dev);
rt9396_device_init(drvdata);
rt9396_send_intensity(drvdata, RT9396BL_DEFAULT_BRIGHTNESS);
#ifdef CONFIG_HAS_EARLYSUSPEND
drvdata->early_suspend.suspend = rt9396_early_suspend;
drvdata->early_suspend.resume = rt9396_late_resume;
drvdata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40;
register_early_suspend(&drvdata->early_suspend);
#endif
rt9396_ref = drvdata;
eprintk("done\n");
return 0;
}