int __init ventana_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
gpio_request(ventana_pnl_pwr_enb, "pnl_pwr_enb");
gpio_direction_output(ventana_pnl_pwr_enb, 1);
tegra_gpio_enable(ventana_pnl_pwr_enb);
gpio_request(ventana_lvds_shutdown, "lvds_shdn");
gpio_direction_output(ventana_lvds_shutdown, 1);
tegra_gpio_enable(ventana_lvds_shutdown);
tegra_gpio_enable(ventana_hdmi_enb);
gpio_request(ventana_hdmi_enb, "hdmi_5v_en");
gpio_direction_output(ventana_hdmi_enb, 1);
tegra_gpio_enable(ventana_hdmi_hpd);
gpio_request(ventana_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(ventana_hdmi_hpd);
#ifdef CONFIG_HAS_EARLYSUSPEND
ventana_panel_early_suspender.suspend = ventana_panel_early_suspend;
ventana_panel_early_suspender.resume = ventana_panel_late_resume;
ventana_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&ventana_panel_early_suspender);
#endif
ventana_carveouts[1].base = tegra_carveout_start;
ventana_carveouts[1].size = tegra_carveout_size;
err = platform_add_devices(ventana_gfx_devices,
ARRAY_SIZE(ventana_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&ventana_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
res = nvhost_get_resource_byname(&ventana_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&ventana_disp1_device);
if (!err)
err = nvhost_device_register(&ventana_disp2_device);
#endif
return err;
}
int __init aruba_panel_init(void)
{
int err;
struct resource *res;
aruba_carveouts[1].base = tegra_carveout_start;
aruba_carveouts[1].size = tegra_carveout_size;
err = platform_add_devices(aruba_gfx_devices,
ARRAY_SIZE(aruba_gfx_devices));
res = nvhost_get_resource_byname(&aruba_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
if (!err)
err = nvhost_device_register(&aruba_disp1_device);
return err;
}
int __init whistler_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
tegra_gpio_enable(whistler_hdmi_hpd);
gpio_request(whistler_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(whistler_hdmi_hpd);
#ifdef CONFIG_HAS_EARLYSUSPEND
whistler_panel_early_suspender.suspend = whistler_panel_early_suspend;
whistler_panel_early_suspender.resume = whistler_panel_late_resume;
whistler_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&whistler_panel_early_suspender);
#endif
#if defined(CONFIG_TEGRA_NVMAP)
whistler_carveouts[1].base = tegra_carveout_start;
whistler_carveouts[1].size = tegra_carveout_size;
#endif
/* #ifdef CONFIG_TEGRA_GRHOST
err = nvhost_device_register(&tegra_grhost_device);
if (err)
return err;
#endif */
#ifdef CONFIG_TEGRA_GRHOST
&tegra_grhost_device,
#endif
err = platform_add_devices(whistler_gfx_devices,
ARRAY_SIZE(whistler_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&whistler_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&whistler_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err)
err = nvhost_device_register(&whistler_disp1_device);
if (!err)
err = nvhost_device_register(&whistler_disp2_device);
#endif
return err;
}
int __init whistler_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
struct platform_device *phost1x;
gpio_request(whistler_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(whistler_hdmi_hpd);
#if defined(CONFIG_TEGRA_NVMAP)
whistler_carveouts[1].base = tegra_carveout_start;
whistler_carveouts[1].size = tegra_carveout_size;
#endif
err = platform_add_devices(whistler_gfx_devices,
ARRAY_SIZE(whistler_gfx_devices));
#ifdef CONFIG_TEGRA_GRHOST
phost1x = tegra2_register_host1x_devices();
if (!phost1x)
return -EINVAL;
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = platform_get_resource_byname(&whistler_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = platform_get_resource_byname(&whistler_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err) {
whistler_disp1_device.dev.parent = &phost1x->dev;
err = platform_device_register(&whistler_disp1_device);
}
if (!err) {
whistler_disp2_device.dev.parent = &phost1x->dev;
err = platform_device_register(&whistler_disp2_device);
}
#endif
return err;
}
int __init olympus_panel_init(void)
{
struct resource *res;
int err;
printk(KERN_INFO "pICS_%s: Starting...",__func__);
olympus_hdmi_init();
#ifdef CONFIG_HAS_EARLYSUSPEND
olympus_panel_early_suspender.suspend = olympus_panel_early_suspend;
olympus_panel_early_suspender.resume = olympus_panel_late_resume;
olympus_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&olympus_panel_early_suspender);
#endif
olympus_carveouts[1].base = tegra_carveout_start;
olympus_carveouts[1].size = tegra_carveout_size;
err = platform_add_devices(olympus_gfx_devices,
ARRAY_SIZE(olympus_gfx_devices));
res = nvhost_get_resource_byname(&olympus_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
res = nvhost_get_resource_byname(&olympus_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
if (!err)
err = nvhost_device_register(&olympus_disp1_device);
if (!err)
err = nvhost_device_register(&olympus_disp2_device);
printk(KERN_INFO "pICS_%s: Ending...",__func__);
return err;
}
int __init aruba_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
#if defined(CONFIG_TEGRA_NVMAP)
aruba_carveouts[1].base = tegra_carveout_start;
aruba_carveouts[1].size = tegra_carveout_size;
#endif
#ifdef CONFIG_TEGRA_GRHOST
err = nvhost_device_register(&tegra_grhost_device);
if (err)
return err;
#endif
err = platform_add_devices(aruba_gfx_devices,
ARRAY_SIZE(aruba_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&aruba_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&aruba_disp1_device);
#endif
return err;
}
int __init cardhu_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
tegra_get_board_info(&board_info);
tegra_get_display_board_info(&display_board_info);
#if defined(CONFIG_TEGRA_NVMAP)
cardhu_carveouts[1].base = tegra_carveout_start;
cardhu_carveouts[1].size = tegra_carveout_size;
#endif
#if defined(CONFIG_ION_TEGRA)
tegra_ion_data.heaps[0].base = tegra_carveout_start;
tegra_ion_data.heaps[0].size = tegra_carveout_size;
#endif
cardhu_panel_preinit();
if (is_dsi_panel()) {
if (is_panel_1506) {
/*
* HACK: To be Removed
*/
int i;
struct clk *c = tegra_get_clock_by_name("dsia");
for (i = 0; i < c->dvfs->num_freqs; i++)
c->dvfs->freqs[i] = 500000000;
}
goto skip_lvds;
}
#if defined(CONFIG_TEGRA_DC)
if (WARN_ON(board_info.board_id == BOARD_E1291 &&
((board_info.sku & SKU_TOUCHSCREEN_MECH_FIX) == 0))) {
/* use 55Hz panel timings to reduce noise on sensitive touch */
printk("Using cardhu_panel_modes_55hz\n");
cardhu_disp1_out.parent_clk = "pll_p";
cardhu_disp1_out.modes = cardhu_panel_modes_55hz;
cardhu_disp1_out.n_modes = ARRAY_SIZE(cardhu_panel_modes_55hz);
}
if (display_board_info.board_id == BOARD_DISPLAY_PM313) {
/* initialize the values */
#if defined(PM313_LVDS_PANEL_19X12)
cardhu_disp1_out.modes = panel_19X12_modes;
cardhu_disp1_out.n_modes = ARRAY_SIZE(panel_19X12_modes);
cardhu_disp1_out.parent_clk = "pll_d_out0";
#if (PM313_LVDS_PANEL_BPP == 1)
cardhu_disp1_out.depth = 18;
#else
cardhu_disp1_out.depth = 24;
#endif
cardhu_fb_data.xres = 1920;
cardhu_fb_data.yres = 1200;
cardhu_disp2_out.parent_clk = "pll_d2_out0";
cardhu_hdmi_fb_data.xres = 1920;
cardhu_hdmi_fb_data.yres = 1200;
#endif
/* lvds configuration */
err = gpio_request(pm313_R_FDE, "R_FDE");
err |= gpio_direction_output(pm313_R_FDE, 1);
err |= gpio_request(pm313_R_FB, "R_FB");
err |= gpio_direction_output(pm313_R_FB, 1);
err |= gpio_request(pm313_MODE0, "MODE0");
err |= gpio_direction_output(pm313_MODE0, 1);
err |= gpio_request(pm313_MODE1, "MODE1");
err |= gpio_direction_output(pm313_MODE1, 0);
err |= gpio_request(pm313_BPP, "BPP");
err |= gpio_direction_output(pm313_BPP, PM313_LVDS_PANEL_BPP);
err = gpio_request(pm313_lvds_shutdown, "lvds_shutdown");
/* free ride provided by bootloader */
err |= gpio_direction_output(pm313_lvds_shutdown, 1);
if (err)
printk(KERN_ERR "ERROR(s) in LVDS configuration\n");
} else if ((display_board_info.board_id == BOARD_DISPLAY_E1247 &&
board_info.board_id == BOARD_PM269) ||
(board_info.board_id == BOARD_E1257) ||
(board_info.board_id == BOARD_PM305) ||
(board_info.board_id == BOARD_PM311)) {
gpio_request(e1247_pm269_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(e1247_pm269_lvds_shutdown, 1);
} else {
gpio_request(cardhu_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(cardhu_lvds_shutdown, 1);
}
#endif
skip_lvds:
gpio_request(cardhu_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(cardhu_hdmi_hpd);
#if !(DC_CTRL_MODE & TEGRA_DC_OUT_ONE_SHOT_MODE)
tegra_gpio_enable(e1506_lcd_te);
gpio_request(e1506_lcd_te, "lcd_te");
gpio_direction_input(e1506_lcd_te);
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
cardhu_panel_early_suspender.suspend = cardhu_panel_early_suspend;
cardhu_panel_early_suspender.resume = cardhu_panel_late_resume;
cardhu_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&cardhu_panel_early_suspender);
#endif
#ifdef CONFIG_TEGRA_GRHOST
err = nvhost_device_register(&tegra_grhost_device);
if (err)
return err;
#endif
err = platform_add_devices(cardhu_gfx_devices,
ARRAY_SIZE(cardhu_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&cardhu_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&cardhu_disp1_device);
res = nvhost_get_resource_byname(&cardhu_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
/* Copy the bootloader fb to the fb2. */
tegra_move_framebuffer(tegra_fb2_start, tegra_bootloader_fb_start,
min(tegra_fb2_size, tegra_bootloader_fb_size));
if (!err)
err = nvhost_device_register(&cardhu_disp2_device);
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}
int __init dalmore_panel_init(void)
{
int err = 0;
struct resource __maybe_unused *res;
struct platform_device *phost1x;
sd_settings = dalmore_sd_settings;
dalmore_panel_select();
#ifdef CONFIG_TEGRA_NVMAP
dalmore_carveouts[1].base = tegra_carveout_start;
dalmore_carveouts[1].size = tegra_carveout_size;
dalmore_carveouts[2].base = tegra_vpr_start;
dalmore_carveouts[2].size = tegra_vpr_size;
err = platform_device_register(&dalmore_nvmap_device);
if (err) {
pr_err("nvmap device registration failed\n");
return err;
}
#endif
phost1x = dalmore_host1x_init();
if (!phost1x) {
pr_err("host1x devices registration failed\n");
return -EINVAL;
}
gpio_request(dalmore_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(dalmore_hdmi_hpd);
res = platform_get_resource_byname(&dalmore_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
/* Copy the bootloader fb to the fb. */
__tegra_move_framebuffer(&dalmore_nvmap_device,
tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
/*
* If the bootloader fb2 is valid, copy it to the fb2, or else
* clear fb2 to avoid garbage on dispaly2.
*/
if (tegra_bootloader_fb2_size)
tegra_move_framebuffer(tegra_fb2_start,
tegra_bootloader_fb2_start,
min(tegra_fb2_size, tegra_bootloader_fb2_size));
else
tegra_clear_framebuffer(tegra_fb2_start, tegra_fb2_size);
res = platform_get_resource_byname(&dalmore_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
dalmore_disp1_device.dev.parent = &phost1x->dev;
err = platform_device_register(&dalmore_disp1_device);
if (err) {
pr_err("disp1 device registration failed\n");
return err;
}
dalmore_disp2_device.dev.parent = &phost1x->dev;
err = platform_device_register(&dalmore_disp2_device);
if (err) {
pr_err("disp2 device registration failed\n");
return err;
}
#ifdef CONFIG_TEGRA_NVAVP
nvavp_device.dev.parent = &phost1x->dev;
err = platform_device_register(&nvavp_device);
if (err) {
pr_err("nvavp device registration failed\n");
return err;
}
#endif
return err;
}
int __init adam_gpu_register_devices(void)
{
struct resource *res;
int err;
#if defined(DYNAMIC_GPU_MEM)
/* Plug in framebuffer 1 memory area and size */
if (tegra_fb_start > 0 && tegra_fb_size > 0) {
res = nvhost_get_resource_byname(&adam_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
}
/* Plug in framebuffer 2 memory area and size */
if (tegra_fb2_start > 0 && tegra_fb2_size > 0) {
res = nvhost_get_resource_byname(&adam_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
}
/* Plug in carveout memory area and size */
if (tegra_carveout_start > 0 && tegra_carveout_size > 0) {
adam_carveouts[1].base = tegra_carveout_start;
adam_carveouts[1].size = tegra_carveout_size;
}
#endif
gpio_request(ADAM_EN_VDD_PANEL, "en_vdd_pnl");
gpio_direction_output(ADAM_EN_VDD_PANEL, 1);
gpio_request(ADAM_BL_VDD, "bl_vdd");
gpio_direction_output(ADAM_BL_VDD, 1);
// gpio_request(ADAM_HDMI_ENB, "hdmi_5v_en");
// gpio_direction_output(ADAM_HDMI_ENB, 1);
gpio_request(ADAM_LVDS_SHUTDOWN, "lvds_shdn");
gpio_direction_output(ADAM_LVDS_SHUTDOWN, 1);
#ifdef CONFIG_HAS_EARLYSUSPEND
adam_panel_early_suspender.suspend = adam_panel_early_suspend;
adam_panel_early_suspender.resume = adam_panel_late_resume;
adam_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&adam_panel_early_suspender);
#endif
err = platform_add_devices(adam_gfx_devices,
ARRAY_SIZE(adam_gfx_devices));
#if defined(DYNAMIC_GPU_MEM)
/* Move the bootloader framebuffer to our framebuffer */
if (tegra_bootloader_fb_start > 0 && tegra_fb_start > 0 &&
tegra_fb_size > 0 && tegra_bootloader_fb_size > 0) {
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
}
#endif
/* Register the framebuffers */
if (!err)
err = nvhost_device_register(&adam_disp1_device);
if (!err)
err = nvhost_device_register(&adam_disp2_device);
return err;
}
int __init ventana_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
gpio_request(ventana_pnl_pwr_enb, "pnl_pwr_enb");
/* Compal Earvin 20111103 begin */
if (isBatteryFail) {
ventana_backlight_data.dft_brightness = 0;
printk("ventana_panel_init - Disable panel power when battery fail\n");
}
/* Compal Earvin 20111103 end */
gpio_direction_output(ventana_pnl_pwr_enb, 1);
tegra_gpio_enable(ventana_pnl_pwr_enb);
gpio_request(ventana_lvds_shutdown, "lvds_shdn");
gpio_direction_output(ventana_lvds_shutdown, 1);
tegra_gpio_enable(ventana_lvds_shutdown);
/*tegra_gpio_enable(ventana_hdmi_enb);
gpio_request(ventana_hdmi_enb, "hdmi_5v_en");
gpio_direction_output(ventana_hdmi_enb, 1);*/
tegra_gpio_enable(ventana_hdmi_hpd);
gpio_request(ventana_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(ventana_hdmi_hpd);
#ifdef CONFIG_HAS_EARLYSUSPEND
ventana_panel_early_suspender.suspend = ventana_panel_early_suspend;
ventana_panel_early_suspender.resume = ventana_panel_late_resume;
ventana_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&ventana_panel_early_suspender);
#endif
ventana_carveouts[1].base = tegra_carveout_start;
ventana_carveouts[1].size = tegra_carveout_size;
err = platform_add_devices(ventana_gfx_devices,
ARRAY_SIZE(ventana_gfx_devices));
//cloud-0510start
if(lcd_type == 1)
{
printk("detect LCD panel: LG\n");
res = nvhost_get_resource_byname(&LG_disp1_device,
IORESOURCE_MEM, "fbmem");
}
else if(lcd_type == 2)
{
printk("detect LCD panel: SEC\n");
res = nvhost_get_resource_byname(&SEC_disp1_device,
IORESOURCE_MEM, "fbmem");
}
else if(lcd_type == 3)
{
printk("detect LCD panel: HYDIS\n");
res = nvhost_get_resource_byname(&HYDIS_disp1_device,
IORESOURCE_MEM, "fbmem");
}
else
{
printk("detect LCD panel: FAIL!\n");
res = nvhost_get_resource_byname(&ventana_disp1_device,
IORESOURCE_MEM, "fbmem");
}
//cloud-0510end
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
res = nvhost_get_resource_byname(&ventana_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
//cloud-0510start
if (!err)
{
if(lcd_type == 1)
err = nvhost_device_register(&LG_disp1_device);
else if(lcd_type == 2)
err = nvhost_device_register(&SEC_disp1_device);
else if(lcd_type == 3)
err = nvhost_device_register(&HYDIS_disp1_device);
else
err = nvhost_device_register(&ventana_disp1_device);
}
//cloud-0510end
if (!err)
err = nvhost_device_register(&ventana_disp2_device);
#endif
return err;
}
int __init cardhu_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
tegra_get_board_info(&board_info);
tegra_get_display_board_info(&display_board_info);
cardhu_carveouts[1].base = tegra_carveout_start;
cardhu_carveouts[1].size = tegra_carveout_size;
if (board_info.board_id == BOARD_E1291 &&
((board_info.sku & SKU_TOUCHSCREEN_MECH_FIX) == 0)) {
/* use 55Hz panel timings to reduce noise on sensitive touch */
printk("Using cardhu_panel_modes_55hz\n");
cardhu_disp1_out.modes = cardhu_panel_modes_55hz;
cardhu_disp1_out.n_modes = ARRAY_SIZE(cardhu_panel_modes_55hz);
}
#if defined(CONFIG_TEGRA_DC) && !defined(CONFIG_TEGRA_CARDHU_DSI)
if (display_board_info.board_id == BOARD_DISPLAY_PM313) {
/* initialize the values */
#if defined(PM313_LVDS_PANEL_19X12)
cardhu_disp1_out.modes = panel_19X12_modes;
cardhu_disp1_out.n_modes = ARRAY_SIZE(panel_19X12_modes);
cardhu_disp1_out.parent_clk = "pll_d_out0";
#if (PM313_LVDS_PANEL_BPP == 1)
cardhu_disp1_out.depth = 18;
#else
cardhu_disp1_out.depth = 24;
#endif
cardhu_fb_data.xres = 1920;
cardhu_fb_data.yres = 1200;
cardhu_disp2_out.parent_clk = "pll_d2_out0";
cardhu_hdmi_fb_data.xres = 1920;
cardhu_hdmi_fb_data.yres = 1200;
#endif
/* lvds configuration */
err = gpio_request(pm313_R_FDE, "R_FDE");
err |= gpio_direction_output(pm313_R_FDE, 1);
tegra_gpio_enable(pm313_R_FDE);
err |= gpio_request(pm313_R_FB, "R_FB");
err |= gpio_direction_output(pm313_R_FB, 1);
tegra_gpio_enable(pm313_R_FB);
err |= gpio_request(pm313_MODE0, "MODE0");
err |= gpio_direction_output(pm313_MODE0, 1);
tegra_gpio_enable(pm313_MODE0);
err |= gpio_request(pm313_MODE1, "MODE1");
err |= gpio_direction_output(pm313_MODE1, 0);
tegra_gpio_enable(pm313_MODE1);
err |= gpio_request(pm313_BPP, "BPP");
err |= gpio_direction_output(pm313_BPP, PM313_LVDS_PANEL_BPP);
tegra_gpio_enable(pm313_BPP);
err = gpio_request(pm313_lvds_shutdown, "lvds_shutdown");
/* free ride provided by bootloader */
err |= gpio_direction_output(pm313_lvds_shutdown, 1);
tegra_gpio_enable(pm313_lvds_shutdown);
if (err)
printk(KERN_ERR "ERROR(s) in LVDS configuration\n");
}
/* else if ((display_board_info.board_id == BOARD_DISPLAY_E1247 &&
board_info.board_id == BOARD_PM269) ||
(board_info.board_id == BOARD_E1257) ||
(board_info.board_id == BOARD_PM305) ||
(board_info.board_id == BOARD_PM311)) {
gpio_request(e1247_pm269_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(e1247_pm269_lvds_shutdown, 1);
tegra_gpio_enable(e1247_pm269_lvds_shutdown);
} else {
gpio_request(cardhu_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(cardhu_lvds_shutdown, 1);
tegra_gpio_enable(cardhu_lvds_shutdown);
}
*/
#endif
tegra_gpio_enable(cardhu_hdmi_enb);
gpio_request(cardhu_hdmi_enb, "hdmi_5v_en");
gpio_direction_output(cardhu_hdmi_enb, 1);
tegra_gpio_enable(cardhu_hdmi_hpd);
gpio_request(cardhu_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(cardhu_hdmi_hpd);
#ifdef CONFIG_HAS_EARLYSUSPEND
cardhu_panel_early_suspender.suspend = cardhu_panel_early_suspend;
cardhu_panel_early_suspender.resume = cardhu_panel_late_resume;
cardhu_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&cardhu_panel_early_suspender);
#endif
err = platform_add_devices(cardhu_gfx_devices,
ARRAY_SIZE(cardhu_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&cardhu_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&cardhu_disp1_device);
res = nvhost_get_resource_byname(&cardhu_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err)
err = nvhost_device_register(&cardhu_disp2_device);
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}
int __init acer_panel_init(void)
{
int err;
struct resource *res;
tegra_get_board_info(&board_info);
acer_carveouts[1].base = tegra_carveout_start;
acer_carveouts[1].size = tegra_carveout_size;
tegra_gpio_enable(LVDS_SHUTDOWN);
tegra_gpio_enable(LCD_VDD);
tegra_gpio_enable(LCD_CABC);
tegra_gpio_enable(BL_ENABLE);
#if defined(CONFIG_TEGRA_HDMI)
tegra_gpio_enable(HDMI_HPD);
#endif
gpio_request(LVDS_SHUTDOWN, "lvds_shutdown");
gpio_request(LCD_VDD, "lcd_vdd");
gpio_request(LCD_CABC, "lcd_cabc");
gpio_request(BL_ENABLE, "bl_enable");
#if defined(CONFIG_TEGRA_HDMI)
gpio_request(HDMI_HPD, "hdmi_hpd");
#endif
gpio_direction_output(LVDS_SHUTDOWN,1);
gpio_direction_output(LCD_VDD, 1);
gpio_direction_output(LCD_CABC,0);
gpio_direction_output(BL_ENABLE,1);
#if defined(CONFIG_TEGRA_HDMI)
tegra_gpio_enable(HDMI_5V);
err = gpio_request(HDMI_5V, "hdmi_5V_enable");
if (err) {
pr_err("[HDMI] request 5V_enable failed\n");
}
#if HDMI_5V_ALWAYS_ON
err = gpio_direction_output(HDMI_5V, 1);
#else
err = gpio_direction_output(HDMI_5V, 0);
#endif
if (err) {
pr_err("[HDMI] failed to set direction of hdmi_5V_enable\n");
}
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
acer_panel_early_suspender.suspend = acer_panel_early_suspend;
acer_panel_early_suspender.resume = acer_panel_late_resume;
acer_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&acer_panel_early_suspender);
#endif
err = platform_add_devices(acer_gfx_devices,
ARRAY_SIZE(acer_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if ((acer_board_type == BOARD_PICASSO_M) || (acer_board_type == BOARD_PICASSO_E2)) {
res = nvhost_get_resource_byname(&acer_pm_disp1_device,
IORESOURCE_MEM, "fbmem");
}else{
res = nvhost_get_resource_byname(&acer_p2_disp1_device,
IORESOURCE_MEM, "fbmem");
}
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if(!err){
if ((acer_board_type == BOARD_PICASSO_M) || (acer_board_type == BOARD_PICASSO_E2)) {
err = nvhost_device_register(&acer_pm_disp1_device);
}else{
err = nvhost_device_register(&acer_p2_disp1_device);
}
}
#if defined(CONFIG_TEGRA_HDMI)
res = nvhost_get_resource_byname(&acer_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err)
err = nvhost_device_register(&acer_disp2_device);
#endif
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}
int __init enterprise_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
struct board_info board_info;
tegra_get_board_info(&board_info);
BUILD_BUG_ON(ARRAY_SIZE(enterprise_bl_output_measured_a03) != 256);
BUILD_BUG_ON(ARRAY_SIZE(enterprise_bl_output_measured_a02) != 256);
bl_output = enterprise_bl_output_measured_a03;
#if defined(CONFIG_TEGRA_NVMAP)
enterprise_carveouts[1].base = tegra_carveout_start;
enterprise_carveouts[1].size = tegra_carveout_size;
#endif
gpio_direction_input(enterprise_hdmi_hpd);
enterprise_backlight_init();
#ifdef CONFIG_HAS_EARLYSUSPEND
enterprise_panel_early_suspender.suspend = enterprise_panel_early_suspend;
enterprise_panel_early_suspender.resume = enterprise_panel_late_resume;
enterprise_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&enterprise_panel_early_suspender);
#endif
#ifdef CONFIG_TEGRA_GRHOST
err = tegra3_register_host1x_devices();
if (err)
return err;
#endif
err = platform_add_devices(enterprise_gfx_devices,
ARRAY_SIZE(enterprise_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&enterprise_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&enterprise_disp1_device);
disp1_emc_min_clk = clk_get(&enterprise_disp1_device.dev, "emc_min");
if (IS_ERR(disp1_emc_min_clk)) {
dev_dbg(&enterprise_disp1_device.dev, "no peripheral clock\n");
clk_put(disp1_emc_min_clk);
}
res = nvhost_get_resource_byname(&enterprise_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err)
err = nvhost_device_register(&enterprise_disp2_device);
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
if (!err)
err = platform_add_devices(enterprise_bl_devices,
ARRAY_SIZE(enterprise_bl_devices));
return err;
}
int __init pluto_panel_init(void)
{
int err = 0;
struct resource __maybe_unused *res;
struct platform_device *phost1x;
sd_settings = pluto_sd_settings;
#ifdef CONFIG_BACKLIGHT_1_WIRE_MODE
tps61165_pin_init();
#endif
pluto_panel_select();
err = gpio_request(pluto_LCD_1V8_EN, "LCD_1V8EN");
if(err < 0){
pr_err("[shangzhi]panel LCD 1v8 enable gpio request failed\n");
}
gpio_direction_output(pluto_LCD_1V8_EN,1);
#ifdef CONFIG_TEGRA_NVMAP
pluto_carveouts[1].base = tegra_carveout_start;
pluto_carveouts[1].size = tegra_carveout_size;
pluto_carveouts[2].base = tegra_vpr_start;
pluto_carveouts[2].size = tegra_vpr_size;
err = platform_device_register(&pluto_nvmap_device);
if (err) {
pr_err("nvmap device registration failed\n");
return err;
}
#endif
gpio_request(pluto_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(pluto_hdmi_hpd);
phost1x = pluto_host1x_init();
if (!phost1x) {
pr_err("host1x devices registration failed\n");
return -EINVAL;
}
res = platform_get_resource_byname(&pluto_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
/* Copy the bootloader fb to the fb. */
__tegra_move_framebuffer(&pluto_nvmap_device,
tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
/*
* If the bootloader fb2 is valid, copy it to the fb2, or else
* clear fb2 to avoid garbage on dispaly2.
*/
if (tegra_bootloader_fb2_size)
tegra_move_framebuffer(tegra_fb2_start,
tegra_bootloader_fb2_start,
min(tegra_fb2_size, tegra_bootloader_fb2_size));
else
tegra_clear_framebuffer(tegra_fb2_start, tegra_fb2_size);
res = platform_get_resource_byname(&pluto_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
pluto_disp1_device.dev.parent = &phost1x->dev;
err = platform_device_register(&pluto_disp1_device);
if (err) {
pr_err("disp1 device registration failed\n");
return err;
}
pluto_disp2_device.dev.parent = &phost1x->dev;
#if 0
err = platform_device_register(&pluto_disp2_device);
if (err) {
pr_err("disp2 device registration failed\n");
return err;
}
#endif
#if CONFIG_ESD_READ_TE
gpio_request(TEGRA_GPIO_PR6, "TE-irq");
gpio_direction_input(TEGRA_GPIO_PR6);
if (request_irq(gpio_to_irq(TEGRA_GPIO_PR6), te_signal_irq_handler,
IRQF_TRIGGER_RISING, "TE-Signal", NULL) < 0)
{
printk("Failed to request TE IRQ!\n");
}
setup_timer(&te_watchdog_timer, te_watchdog_timeout, 0);
mod_timer(&te_watchdog_timer, jiffies + msecs_to_jiffies(30000));
#endif
#if defined(CONFIG_LEDS_PWM)
err = platform_device_register(&tegra_pwfm0_device);
if (err) {
pr_err("led pwm device registration failed");
return err;
}
#endif
#ifdef CONFIG_TEGRA_NVAVP
nvavp_device.dev.parent = &phost1x->dev;
err = platform_device_register(&nvavp_device);
if (err) {
pr_err("nvavp device registration failed\n");
return err;
}
#endif
return err;
}
int __init shuttle_gpu_register_devices(void)
{
struct resource *res;
int err;
/* Plug in carveout memory area and size */
if (tegra_carveout_start > 0 && tegra_carveout_size > 0) {
shuttle_carveouts[1].base = tegra_carveout_start;
shuttle_carveouts[1].size = tegra_carveout_size;
}
gpio_request(SHUTTLE_EN_VDD_PANEL, "en_vdd_pnl");
gpio_direction_output(SHUTTLE_EN_VDD_PANEL, 1);
gpio_request(SHUTTLE_BL_VDD, "bl_vdd");
gpio_direction_output(SHUTTLE_BL_VDD, 1);
gpio_request(SHUTTLE_HDMI_ENB, "hdmi_5v_en");
gpio_direction_output(SHUTTLE_HDMI_ENB, 1);
gpio_request(SHUTTLE_LVDS_SHUTDOWN, "lvds_shdn");
gpio_direction_output(SHUTTLE_LVDS_SHUTDOWN, 1);
#ifdef CONFIG_HAS_EARLYSUSPEND
shuttle_panel_early_suspender.suspend = shuttle_panel_early_suspend;
shuttle_panel_early_suspender.resume = shuttle_panel_late_resume;
shuttle_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&shuttle_panel_early_suspender);
#endif
#ifdef CONFIG_TEGRA_GRHOST
err = nvhost_device_register(&tegra_grhost_device);
if (err)
return err;
#endif
err = platform_add_devices(shuttle_gfx_devices,
ARRAY_SIZE(shuttle_gfx_devices));
/* Plug in framebuffer 1 memory area and size */
if (tegra_fb_start > 0 && tegra_fb_size > 0) {
res = nvhost_get_resource_byname(&shuttle_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
}
/* Plug in framebuffer 2 memory area and size */
if (tegra_fb2_start > 0 && tegra_fb2_size > 0) {
res = nvhost_get_resource_byname(&shuttle_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
}
/* Move the bootloader framebuffer to our framebuffer */
if (tegra_bootloader_fb_start > 0 && tegra_fb_start > 0 &&
tegra_fb_size > 0 && tegra_bootloader_fb_size > 0) {
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
}
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
/* Register the framebuffers */
if (!err)
err = nvhost_device_register(&shuttle_disp1_device);
if (!err)
err = nvhost_device_register(&shuttle_disp2_device);
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
/* Register the nvavp device */
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}
int __init cardhu_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
tegra_get_board_info(&board_info);
tegra_get_display_board_info(&display_board_info);
#if defined(CONFIG_TEGRA_NVMAP)
cardhu_carveouts[1].base = tegra_carveout_start;
cardhu_carveouts[1].size = tegra_carveout_size;
#endif
#if defined(CONFIG_ION_TEGRA)
tegra_ion_data.heaps[0].base = tegra_carveout_start;
tegra_ion_data.heaps[0].size = tegra_carveout_size;
#endif
cardhu_panel_preinit();
if (is_dsi_panel())
goto skip_lvds;
#if defined(CONFIG_TEGRA_DC)
if (WARN_ON(board_info.board_id == BOARD_E1291 &&
((board_info.sku & SKU_TOUCHSCREEN_MECH_FIX) == 0))) {
/* use 55Hz panel timings to reduce noise on sensitive touch */
printk("Using cardhu_panel_modes_55hz\n");
cardhu_disp1_out.parent_clk = "pll_p";
cardhu_disp1_out.modes = cardhu_panel_modes_55hz;
cardhu_disp1_out.n_modes = ARRAY_SIZE(cardhu_panel_modes_55hz);
}
if (display_board_info.board_id == BOARD_DISPLAY_PM313) {
/* initialize the values */
#if defined(PM313_LVDS_PANEL_19X12)
cardhu_disp1_out.modes = panel_19X12_modes;
cardhu_disp1_out.n_modes = ARRAY_SIZE(panel_19X12_modes);
cardhu_disp1_out.parent_clk = "pll_d_out0";
#if (PM313_LVDS_PANEL_BPP == 1)
cardhu_disp1_out.depth = 18;
#else
cardhu_disp1_out.depth = 24;
#endif
/* Set height and width in mm. */
cardhu_disp1_out.height = 127;
cardhu_disp1_out.width = 203;
cardhu_fb_data.xres = 1920;
cardhu_fb_data.yres = 1200;
cardhu_disp2_out.parent_clk = "pll_d2_out0";
cardhu_hdmi_fb_data.xres = 1920;
cardhu_hdmi_fb_data.yres = 1200;
#endif
/* lvds configuration */
err = gpio_request(pm313_R_FDE, "R_FDE");
err |= gpio_direction_output(pm313_R_FDE, 1);
err |= gpio_request(pm313_R_FB, "R_FB");
err |= gpio_direction_output(pm313_R_FB, 1);
err |= gpio_request(pm313_MODE0, "MODE0");
err |= gpio_direction_output(pm313_MODE0, 1);
err |= gpio_request(pm313_MODE1, "MODE1");
err |= gpio_direction_output(pm313_MODE1, 0);
err |= gpio_request(pm313_BPP, "BPP");
err |= gpio_direction_output(pm313_BPP, PM313_LVDS_PANEL_BPP);
err = gpio_request(pm313_lvds_shutdown, "lvds_shutdown");
/* free ride provided by bootloader */
err |= gpio_direction_output(pm313_lvds_shutdown, 1);
if (err)
printk(KERN_ERR "ERROR(s) in LVDS configuration\n");
}
/* else if ((display_board_info.board_id == BOARD_DISPLAY_E1247 &&
board_info.board_id == BOARD_PM269) ||
(board_info.board_id == BOARD_E1257) ||
(board_info.board_id == BOARD_PM305) ||
(board_info.board_id == BOARD_PM311)) {
gpio_request(e1247_pm269_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(e1247_pm269_lvds_shutdown, 1);
} else {
gpio_request(cardhu_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(cardhu_lvds_shutdown, 1);
}
*/
if ( tegra3_get_project_id() == TEGRA3_PROJECT_P1801 ){
printk("P1801 display setting, set HDMI as main display\n ");
cardhu_fb_data.xres = 1920;
cardhu_fb_data.yres = 1080;
cardhu_disp1_pdata.default_out = &cardhu_disp1_out_P1801;
cardhu_disp1_device.resource = cardhu_disp1_resources_P1801;
cardhu_disp1_device.num_resources = ARRAY_SIZE(cardhu_disp1_resources_P1801);
}
if (tegra3_get_project_id()==0x4 ){
printk("Check TF700T setting \n ");
cardhu_disp1_out.modes = panel_19X12_modes;
cardhu_disp1_out.n_modes = ARRAY_SIZE(panel_19X12_modes);
cardhu_disp1_out.parent_clk = "pll_d_out0";
cardhu_disp1_out.depth = 24;
cardhu_fb_data.xres = 1920;
cardhu_fb_data.yres = 1200;
cardhu_disp2_out.parent_clk = "pll_d2_out0";
cardhu_hdmi_fb_data.xres = 1920;
cardhu_hdmi_fb_data.yres = 1200;
gpio_request(TEGRA_GPIO_PU5, "LDO_EN");
gpio_request(TEGRA_GPIO_PBB3, "TF700T_1.2V");
gpio_request(TEGRA_GPIO_PC6, "TF700T_1.8V");
gpio_request(TEGRA_GPIO_PX0, "TF700T_I2C_Switch");
gpio_request(TEGRA_GPIO_PD2, "TF700T_OSC");
}
#endif
if (tegra3_get_project_id()==0x4 ){
tegra_gpio_enable(cardhu_hdmi_enb);
gpio_request(cardhu_hdmi_enb, "hdmi_5v_en");
gpio_direction_output(cardhu_hdmi_enb, 0);
} else {
tegra_gpio_enable(cardhu_hdmi_enb);
gpio_request(cardhu_hdmi_enb, "hdmi_5v_en");
gpio_direction_output(cardhu_hdmi_enb, 1);
}
skip_lvds:
gpio_request(cardhu_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(cardhu_hdmi_hpd);
#if !(DC_CTRL_MODE & TEGRA_DC_OUT_ONE_SHOT_MODE)
tegra_gpio_enable(e1506_lcd_te);
gpio_request(e1506_lcd_te, "lcd_te");
gpio_direction_input(e1506_lcd_te);
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
cardhu_panel_early_suspender.suspend = cardhu_panel_early_suspend;
cardhu_panel_early_suspender.resume = cardhu_panel_late_resume;
cardhu_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&cardhu_panel_early_suspender);
#endif
#ifdef CONFIG_TEGRA_GRHOST
err = tegra3_register_host1x_devices();
if (err)
return err;
#endif
err = platform_add_devices(cardhu_gfx_devices,
ARRAY_SIZE(cardhu_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&cardhu_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&cardhu_disp1_device);
if ( tegra3_get_project_id() != TEGRA3_PROJECT_P1801 ){
res = nvhost_get_resource_byname(&cardhu_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
/* Copy the bootloader fb to the fb2. */
tegra_move_framebuffer(tegra_fb2_start, tegra_bootloader_fb_start,
min(tegra_fb2_size, tegra_bootloader_fb_size));
if (!err)
err = nvhost_device_register(&cardhu_disp2_device);
}
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}
int __init enterprise_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
bl_output = enterprise_bl_output_measured;
if (WARN_ON(ARRAY_SIZE(enterprise_bl_output_measured) != 256))
pr_err("bl_output array does not have 256 elements\n");
enterprise_dsi.chip_id = tegra_get_chipid();
enterprise_dsi.chip_rev = tegra_get_revision();
enterprise_carveouts[1].base = tegra_carveout_start;
enterprise_carveouts[1].size = tegra_carveout_size;
tegra_gpio_enable(enterprise_hdmi_hpd);
gpio_request(enterprise_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(enterprise_hdmi_hpd);
tegra_gpio_enable(enterprise_lcd_2d_3d);
gpio_request(enterprise_lcd_2d_3d, "lcd_2d_3d");
gpio_direction_output(enterprise_lcd_2d_3d, 0);
enterprise_stereo_set_mode(enterprise_stereo.mode_2d_3d);
tegra_gpio_enable(enterprise_lcd_swp_pl);
gpio_request(enterprise_lcd_swp_pl, "lcd_swp_pl");
gpio_direction_output(enterprise_lcd_swp_pl, 0);
enterprise_stereo_set_orientation(enterprise_stereo.orientation);
#if !(DC_CTRL_MODE & TEGRA_DC_OUT_ONE_SHOT_MODE)
tegra_gpio_enable(enterprise_lcd_te);
gpio_request(enterprise_lcd_swp_pl, "lcd_te");
gpio_direction_input(enterprise_lcd_te);
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
enterprise_panel_early_suspender.suspend = enterprise_panel_early_suspend;
enterprise_panel_early_suspender.resume = enterprise_panel_late_resume;
enterprise_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&enterprise_panel_early_suspender);
#endif
err = platform_add_devices(enterprise_gfx_devices,
ARRAY_SIZE(enterprise_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&enterprise_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
#endif
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
if (!err)
err = nvhost_device_register(&enterprise_disp1_device);
res = nvhost_get_resource_byname(&enterprise_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err)
err = nvhost_device_register(&enterprise_disp2_device);
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
if (!err)
err = platform_add_devices(enterprise_bl_devices,
ARRAY_SIZE(enterprise_bl_devices));
return err;
}
static int avalon_panel_init(void)
{
int err;
struct resource *res;
mutex_init(&lcd_lock);
ast_carveouts[1].base = tegra_carveout_start;
ast_carveouts[1].size = tegra_carveout_size;
err = gpio_request(AST_LVDS_SHUTDOWN, "lvds_shutdown");
if (err < 0)
return err;
gpio_direction_output(AST_LVDS_SHUTDOWN, 1);
tegra_gpio_enable(AST_LVDS_SHUTDOWN);
/* hdmi software enable pin */
/* tegra_gpio_enable(AST_HDMI_ENB);*/
/* gpio_request(AST_HDMI_ENB, "ast_hdmi_enb");*/
/* gpio_direction_output(AST_HDMI_ENB, 1);*/
gpio_request(AST_HDMI_HPD, "hdmi_hpd");
gpio_direction_input(AST_HDMI_HPD);
tegra_gpio_enable(AST_HDMI_HPD);
#ifdef CONFIG_HAS_EARLYSUSPEND
ast_panel_early_suspender.suspend = ast_panel_early_suspend;
ast_panel_early_suspender.resume = ast_panel_late_resume;
ast_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&ast_panel_early_suspender);
#endif
err = platform_add_devices(ast_gfx_devices,
ARRAY_SIZE(ast_gfx_devices));
res = nvhost_get_resource_byname(&ast_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
/* Copy the bootloader fb to the fb. */
tegra_move_framebuffer(tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
if (!err)
err = nvhost_device_register(&ast_disp1_device);
res = nvhost_get_resource_byname(&ast_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
if (!err)
err = nvhost_device_register(&ast_disp2_device);
#if defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}
