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 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 ventana_panel_init(void)
{
int err;
struct resource *res;
printk("Disp: ventana_panel_init() in\n");
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);
/* CONFIG_HAS_EARLYSUSPEND has been defined. */
#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));
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;
if (!err)
err = nvhost_device_register(&ventana_disp1_device);
if (!err)
err = nvhost_device_register(&ventana_disp2_device);
printk("Disp: ventana_panel_init() out\n");
return err;
}
int __init star_panel_init(void)
{
int err;
struct resource *res;
gpio_request(star_bl_enb, "wled_en");
tegra_gpio_enable(star_bl_enb);
gpio_direction_output(star_bl_enb, 1);
gpio_request(star_lvds_shutdown, "lvds_en");
tegra_gpio_enable(star_lvds_shutdown);
gpio_direction_output(star_lvds_shutdown, 1);
gpio_request(star_panel_enb, "vdd_3v3_en");
tegra_gpio_enable(star_panel_enb);
gpio_direction_output(star_panel_enb, 1);
tegra_gpio_enable(star_hdmi_hpd);
gpio_request(star_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(star_hdmi_hpd);
#ifdef CONFIG_HAS_EARLYSUSPEND
star_panel_early_suspender.suspend = star_panel_early_suspend;
star_panel_early_suspender.resume = star_panel_late_resume;
star_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&star_panel_early_suspender);
#endif
star_carveouts[1].base = tegra_carveout_start;
star_carveouts[1].size = tegra_carveout_size;
err = platform_add_devices(star_gfx_devices,
ARRAY_SIZE(star_gfx_devices));
res = nvhost_get_resource_byname(&star_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
res = nvhost_get_resource_byname(&star_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(&star_disp1_device);
if (!err)
err = nvhost_device_register(&star_disp2_device);
if (!err)
platform_device_register(&star_backlight_device);
return err;
}
int __init p852_panel_init(void)
{
int err;
struct resource *res;
pr_info("%s\n", __func__);
p852_carveouts[1].base = tegra_carveout_start;
p852_carveouts[1].size = tegra_carveout_size;
err = platform_device_register(&p852_nvmap_device);
if (err)
return err;
#ifdef CONFIG_TEGRA_GRHOST
err = nvhost_device_register(&tegra_grhost_device);
if (err)
return err;
#endif
err = platform_add_devices(p852_gfx_devices,
ARRAY_SIZE(p852_gfx_devices));
res = nvhost_get_resource_byname(&p852_disp_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
if (!err)
err = nvhost_device_register(&p852_disp_device);
return err;
}
int nvhost_get_irq_byname(struct nvhost_device *dev, const char *name)
{
struct resource *r = nvhost_get_resource_byname(dev, IORESOURCE_IRQ,
name);
return r ? r->start : -ENXIO;
}
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 p1852_panel_init(void)
{
int err;
struct resource *res;
p1852_carveouts[1].base = tegra_carveout_start;
p1852_carveouts[1].size = tegra_carveout_size;
tegra_nvmap_device.dev.platform_data = &p1852_nvmap_data;
tegra_disp1_device.dev.platform_data = &p1852_disp1_pdata;
res = nvhost_get_resource_byname(&tegra_disp1_device,
IORESOURCE_MEM, "fbmem");
if (!res) {
pr_err("No memory resources\n");
return -ENODEV;
}
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
err = platform_add_devices(p1852_gfx_devices,
ARRAY_SIZE(p1852_gfx_devices));
if (!err)
err = nvhost_device_register(&tegra_disp1_device);
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 whistler_panel_init(void)
{
int err;
struct resource *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
whistler_carveouts[1].base = tegra_carveout_start;
whistler_carveouts[1].size = tegra_carveout_size;
err = platform_add_devices(whistler_gfx_devices,
ARRAY_SIZE(whistler_gfx_devices));
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;
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);
return err;
}
int __init n1_panel_init(void)
{
int err;
struct resource *res;
/* tegra_gpio_enable(n1_hdmi_enb);
gpio_request(n1_hdmi_enb, "hdmi_5v_en");
gpio_direction_output(n1_hdmi_enb, 1);
tegra_gpio_enable(n1_hdmi_hpd);
gpio_request(n1_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(n1_hdmi_hpd);
*/
n1_carveouts[1].base = tegra_carveout_start;
n1_carveouts[1].size = tegra_carveout_size;
#ifdef CONFIG_HAS_EARLYSUSPEND
n1_panel_early_suspender.suspend = n1_panel_early_suspend;
n1_panel_early_suspender.resume = n1_panel_late_resume;
n1_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&n1_panel_early_suspender);
#endif
err = platform_add_devices(n1_gfx_devices,
ARRAY_SIZE(n1_gfx_devices));
res = nvhost_get_resource_byname(&n1_disp1_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
/* res = nvhost_get_resource_byname(&n1_disp2_device,
IORESOURCE_MEM, "fbmem");
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
*/
spi_register_board_info(n1_spi_device2, ARRAY_SIZE(n1_spi_device2));
if (!err)
err = nvhost_device_register(&n1_disp1_device);
/* if (!err)
err = nvhost_device_register(&n1_disp2_device);
*/
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 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 ventana_panel_init(void)
{
int err;
struct resource *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));
//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;
//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);
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 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;
}
static int tegra_dc_probe(struct nvhost_device *ndev,
struct nvhost_device_id *id_table)
{
struct tegra_dc *dc;
struct tegra_dc_mode *mode;
struct clk *clk;
struct clk *emc_clk;
struct resource *res;
struct resource *base_res;
struct resource *fb_mem = NULL;
int ret = 0;
void __iomem *base;
int irq;
int i;
if (!ndev->dev.platform_data) {
dev_err(&ndev->dev, "no platform data\n");
return -ENOENT;
}
dc = kzalloc(sizeof(struct tegra_dc), GFP_KERNEL);
if (!dc) {
dev_err(&ndev->dev, "can't allocate memory for tegra_dc\n");
return -ENOMEM;
}
irq = nvhost_get_irq_byname(ndev, "irq");
if (irq <= 0) {
dev_err(&ndev->dev, "no irq\n");
ret = -ENOENT;
goto err_free;
}
res = nvhost_get_resource_byname(ndev, IORESOURCE_MEM, "regs");
if (!res) {
dev_err(&ndev->dev, "no mem resource\n");
ret = -ENOENT;
goto err_free;
}
base_res = request_mem_region(res->start, resource_size(res),
ndev->name);
if (!base_res) {
dev_err(&ndev->dev, "request_mem_region failed\n");
ret = -EBUSY;
goto err_free;
}
base = ioremap(res->start, resource_size(res));
if (!base) {
dev_err(&ndev->dev, "registers can't be mapped\n");
ret = -EBUSY;
goto err_release_resource_reg;
}
fb_mem = nvhost_get_resource_byname(ndev, IORESOURCE_MEM, "fbmem");
clk = clk_get(&ndev->dev, NULL);
if (IS_ERR_OR_NULL(clk)) {
dev_err(&ndev->dev, "can't get clock\n");
ret = -ENOENT;
goto err_iounmap_reg;
}
emc_clk = clk_get(&ndev->dev, "emc");
if (IS_ERR_OR_NULL(emc_clk)) {
dev_err(&ndev->dev, "can't get emc clock\n");
ret = -ENOENT;
goto err_put_clk;
}
dc->clk = clk;
dc->emc_clk = emc_clk;
dc->shift_clk_div = 1;
/* Initialize one shot work delay, it will be assigned by dsi
* according to refresh rate later. */
dc->one_shot_delay_ms = 40;
dc->base_res = base_res;
dc->base = base;
dc->irq = irq;
dc->ndev = ndev;
dc->pdata = ndev->dev.platform_data;
/*
* The emc is a shared clock, it will be set based on
* the requirements for each user on the bus.
*/
dc->emc_clk_rate = 0;
mutex_init(&dc->lock);
mutex_init(&dc->one_shot_lock);
init_completion(&dc->frame_end_complete);
init_waitqueue_head(&dc->wq);
init_waitqueue_head(&dc->timestamp_wq);
#ifdef CONFIG_ARCH_TEGRA_2x_SOC
INIT_WORK(&dc->reset_work, tegra_dc_reset_worker);
#endif
INIT_WORK(&dc->vblank_work, tegra_dc_vblank);
dc->vblank_ref_count = 0;
INIT_DELAYED_WORK(&dc->underflow_work, tegra_dc_underflow_worker);
INIT_DELAYED_WORK(&dc->one_shot_work, tegra_dc_one_shot_worker);
tegra_dc_init_lut_defaults(&dc->fb_lut);
dc->n_windows = DC_N_WINDOWS;
for (i = 0; i < dc->n_windows; i++) {
struct tegra_dc_win *win = &dc->windows[i];
win->idx = i;
win->dc = dc;
tegra_dc_init_csc_defaults(&win->csc);
tegra_dc_init_lut_defaults(&win->lut);
}
ret = tegra_dc_set(dc, ndev->id);
if (ret < 0) {
dev_err(&ndev->dev, "can't add dc\n");
goto err_free_irq;
}
nvhost_set_drvdata(ndev, dc);
#ifdef CONFIG_SWITCH
dc->modeset_switch.name = dev_name(&ndev->dev);
dc->modeset_switch.state = 0;
dc->modeset_switch.print_state = switch_modeset_print_mode;
switch_dev_register(&dc->modeset_switch);
#endif
tegra_dc_feature_register(dc);
if (dc->pdata->default_out)
tegra_dc_set_out(dc, dc->pdata->default_out);
else
dev_err(&ndev->dev, "No default output specified. Leaving output disabled.\n");
dc->vblank_syncpt = (dc->ndev->id == 0) ?
NVSYNCPT_VBLANK0 : NVSYNCPT_VBLANK1;
dc->ext = tegra_dc_ext_register(ndev, dc);
if (IS_ERR_OR_NULL(dc->ext)) {
dev_warn(&ndev->dev, "Failed to enable Tegra DC extensions.\n");
dc->ext = NULL;
}
/* interrupt handler must be registered before tegra_fb_register() */
if (request_irq(irq, tegra_dc_irq, 0,
dev_name(&ndev->dev), dc)) {
dev_err(&ndev->dev, "request_irq %d failed\n", irq);
ret = -EBUSY;
goto err_put_emc_clk;
}
disable_dc_irq(irq);
mutex_lock(&dc->lock);
if (dc->pdata->flags & TEGRA_DC_FLAG_ENABLED)
dc->enabled = _tegra_dc_enable(dc);
mutex_unlock(&dc->lock);
tegra_dc_create_debugfs(dc);
dev_info(&ndev->dev, "probed\n");
if (dc->pdata->fb) {
if (dc->enabled && dc->pdata->fb->bits_per_pixel == -1) {
unsigned long fmt;
tegra_dc_writel(dc,
WINDOW_A_SELECT << dc->pdata->fb->win,
DC_CMD_DISPLAY_WINDOW_HEADER);
fmt = tegra_dc_readl(dc, DC_WIN_COLOR_DEPTH);
dc->pdata->fb->bits_per_pixel =
tegra_dc_fmt_bpp(fmt);
}
mode = tegra_dc_get_override_mode(dc);
if (mode) {
dc->pdata->fb->xres = mode->h_active;
dc->pdata->fb->yres = mode->v_active;
}
dc->fb = tegra_fb_register(ndev, dc, dc->pdata->fb, fb_mem);
if (IS_ERR_OR_NULL(dc->fb))
dc->fb = NULL;
}
if (dc->out && dc->out->hotplug_init)
dc->out->hotplug_init();
if (dc->out_ops && dc->out_ops->detect)
dc->out_ops->detect(dc);
else
dc->connected = true;
tegra_dc_create_sysfs(&dc->ndev->dev);
return 0;
err_free_irq:
free_irq(irq, dc);
err_put_emc_clk:
clk_put(emc_clk);
err_put_clk:
clk_put(clk);
err_iounmap_reg:
iounmap(base);
if (fb_mem)
release_resource(fb_mem);
err_release_resource_reg:
release_resource(base_res);
err_free:
kfree(dc);
return ret;
}
static int tegra_dc_dsi_init(struct tegra_dc *dc)
{
struct tegra_dc_dsi_data *dsi;
struct resource *res;
struct resource *base_res;
void __iomem *base;
struct clk *dc_clk = NULL;
struct clk *dsi_clk = NULL;
int err;
err = 0;
dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
if (!dsi)
return -ENOMEM;
res = nvhost_get_resource_byname(dc->ndev, IORESOURCE_MEM,
"dsi_regs");
if (!res) {
dev_err(&dc->ndev->dev, "dsi: no mem resource\n");
err = -ENOENT;
goto err_free_dsi;
}
base_res = request_mem_region(res->start, resource_size(res),
dc->ndev->name);
if (!base_res) {
dev_err(&dc->ndev->dev, "dsi: request_mem_region failed\n");
err = -EBUSY;
goto err_free_dsi;
}
base = ioremap(res->start, resource_size(res));
if (!base) {
dev_err(&dc->ndev->dev, "dsi: registers can't be mapped\n");
err = -EBUSY;
goto err_release_regs;
}
dsi_clk = clk_get(&dc->ndev->dev, "dsi");
if (IS_ERR_OR_NULL(dsi_clk)) {
dev_err(&dc->ndev->dev, "dsi: can't get clock\n");
err = -EBUSY;
goto err_release_regs;
}
dc_clk = clk_get_sys(dev_name(&dc->ndev->dev), NULL);
if (IS_ERR_OR_NULL(dc_clk)) {
dev_err(&dc->ndev->dev, "dsi: dc clock %s unavailable\n",
dev_name(&dc->ndev->dev));
err = -EBUSY;
goto err_clk_put;
}
if (!dc->pdata->default_out->dsi) {
dev_err(&dc->ndev->dev, "dsi: dsi data not available\n");
goto err_dsi_data;
}
err = tegra_dc_dsi_cp_info(dsi, dc->pdata->default_out->dsi);
if (err < 0)
goto err_dsi_data;
mutex_init(&dsi->lock);
dsi->dc = dc;
dsi->base = base;
dsi->base_res = base_res;
dsi->dc_clk = dc_clk;
dsi->dsi_clk = dsi_clk;
tegra_dc_set_outdata(dc, dsi);
_tegra_dc_dsi_init(dc);
return 0;
err_dsi_data:
err_clk_put:
clk_put(dsi->dsi_clk);
err_release_regs:
release_resource(base_res);
err_free_dsi:
kfree(dsi);
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 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 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 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;
}
static int tegra_dc_probe(struct nvhost_device *ndev)
{
struct tegra_dc *dc;
struct clk *clk;
struct clk *emc_clk;
struct resource *res;
struct resource *base_res;
struct resource *fb_mem = NULL;
int ret = 0;
void __iomem *base;
int irq;
int i;
unsigned long emc_clk_rate;
if (!ndev->dev.platform_data) {
dev_err(&ndev->dev, "no platform data\n");
return -ENOENT;
}
dc = kzalloc(sizeof(struct tegra_dc), GFP_KERNEL);
if (!dc) {
dev_err(&ndev->dev, "can't allocate memory for tegra_dc\n");
return -ENOMEM;
}
irq = nvhost_get_irq_byname(ndev, "irq");
if (irq <= 0) {
dev_err(&ndev->dev, "no irq\n");
ret = -ENOENT;
goto err_free;
}
res = nvhost_get_resource_byname(ndev, IORESOURCE_MEM, "regs");
if (!res) {
dev_err(&ndev->dev, "no mem resource\n");
ret = -ENOENT;
goto err_free;
}
base_res = request_mem_region(res->start, resource_size(res), ndev->name);
if (!base_res) {
dev_err(&ndev->dev, "request_mem_region failed\n");
ret = -EBUSY;
goto err_free;
}
base = ioremap(res->start, resource_size(res));
if (!base) {
dev_err(&ndev->dev, "registers can't be mapped\n");
ret = -EBUSY;
goto err_release_resource_reg;
}
fb_mem = nvhost_get_resource_byname(ndev, IORESOURCE_MEM, "fbmem");
clk = clk_get(&ndev->dev, NULL);
if (IS_ERR_OR_NULL(clk)) {
dev_err(&ndev->dev, "can't get clock\n");
ret = -ENOENT;
goto err_iounmap_reg;
}
emc_clk = clk_get(&ndev->dev, "emc");
if (IS_ERR_OR_NULL(emc_clk)) {
dev_err(&ndev->dev, "can't get emc clock\n");
ret = -ENOENT;
goto err_put_clk;
}
dc->clk = clk;
dc->emc_clk = emc_clk;
dc->base_res = base_res;
dc->base = base;
dc->irq = irq;
dc->ndev = ndev;
dc->pdata = ndev->dev.platform_data;
/*
* The emc is a shared clock, it will be set based on
* the requirements for each user on the bus.
*/
emc_clk_rate = dc->pdata->emc_clk_rate;
clk_set_rate(emc_clk, emc_clk_rate ? emc_clk_rate : ULONG_MAX);
if (dc->pdata->flags & TEGRA_DC_FLAG_ENABLED)
dc->enabled = true;
mutex_init(&dc->lock);
init_waitqueue_head(&dc->wq);
INIT_WORK(&dc->reset_work, tegra_dc_reset_worker);
dc->n_windows = DC_N_WINDOWS;
for (i = 0; i < dc->n_windows; i++) {
dc->windows[i].idx = i;
dc->windows[i].dc = dc;
}
if (request_irq(irq, tegra_dc_irq, IRQF_DISABLED,
dev_name(&ndev->dev), dc)) {
dev_err(&ndev->dev, "request_irq %d failed\n", irq);
ret = -EBUSY;
goto err_put_emc_clk;
}
/* hack to ballence enable_irq calls in _tegra_dc_enable() */
disable_irq(dc->irq);
ret = tegra_dc_add(dc, ndev->id);
if (ret < 0) {
dev_err(&ndev->dev, "can't add dc\n");
goto err_free_irq;
}
nvhost_set_drvdata(ndev, dc);
if (dc->pdata->default_out)
tegra_dc_set_out(dc, dc->pdata->default_out);
else
dev_err(&ndev->dev, "No default output specified. Leaving output disabled.\n");
dc->vblank_syncpt = (dc->ndev->id == 0) ?
NVSYNCPT_VBLANK0 : NVSYNCPT_VBLANK1;
dc->ext = tegra_dc_ext_register(ndev, dc);
if (IS_ERR_OR_NULL(dc->ext)) {
dev_warn(&ndev->dev, "Failed to enable Tegra DC extensions.\n");
dc->ext = NULL;
}
if (dc->enabled)
_tegra_dc_enable(dc);
tegra_dc_dbg_add(dc);
dev_info(&ndev->dev, "probed\n");
if (dc->pdata->fb) {
if (dc->pdata->fb->bits_per_pixel == -1) {
unsigned long fmt;
tegra_dc_writel(dc,
WINDOW_A_SELECT << dc->pdata->fb->win,
DC_CMD_DISPLAY_WINDOW_HEADER);
fmt = tegra_dc_readl(dc, DC_WIN_COLOR_DEPTH);
dc->pdata->fb->bits_per_pixel =
tegra_dc_fmt_bpp(fmt);
}
dc->fb = tegra_fb_register(ndev, dc, dc->pdata->fb, fb_mem);
if (IS_ERR_OR_NULL(dc->fb))
dc->fb = NULL;
}
if (dc->out && dc->out->hotplug_init)
dc->out->hotplug_init();
if (dc->out_ops && dc->out_ops->detect)
dc->out_ops->detect(dc);
else
dc->connected = true;
return 0;
err_free_irq:
free_irq(irq, dc);
err_put_emc_clk:
clk_put(emc_clk);
err_put_clk:
clk_put(clk);
err_iounmap_reg:
iounmap(base);
if (fb_mem)
release_resource(fb_mem);
err_release_resource_reg:
release_resource(base_res);
err_free:
kfree(dc);
return ret;
}
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;
}
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;
}
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;
}
int __init grouper_panel_init(void)
{
int err;
struct resource __maybe_unused *res;
struct board_info board_info;
tegra_get_board_info(&board_info);
#if defined(CONFIG_TEGRA_NVMAP)
grouper_carveouts[1].base = tegra_carveout_start;
grouper_carveouts[1].size = tegra_carveout_size;
#endif
/*
gpio_request(grouper_lvds_avdd_en, "lvds_avdd_en");
gpio_direction_output(grouper_lvds_avdd_en, 1);
tegra_gpio_enable(grouper_lvds_avdd_en);
//gpio_request(grouper_lvds_stdby, "lvds_stdby");
//gpio_direction_output(grouper_lvds_stdby, 1);
//tegra_gpio_enable(grouper_lvds_stdby);
gpio_request(grouper_lvds_rst, "lvds_rst");
gpio_direction_output(grouper_lvds_rst, 1);
tegra_gpio_enable(grouper_lvds_rst);
if (board_info.fab == BOARD_FAB_A00) {
gpio_request(grouper_lvds_rs_a00, "lvds_rs");
gpio_direction_output(grouper_lvds_rs_a00, 0);
tegra_gpio_enable(grouper_lvds_rs_a00);
} else {
gpio_request(grouper_lvds_rs, "lvds_rs");
gpio_direction_output(grouper_lvds_rs, 0);
tegra_gpio_enable(grouper_lvds_rs);
}
gpio_request(grouper_lvds_lr, "lvds_lr");
gpio_direction_output(grouper_lvds_lr, 1);
tegra_gpio_enable(grouper_lvds_lr);
*/
/*
gpio_request(grouper_lvds_shutdown, "lvds_shutdown");
gpio_direction_output(grouper_lvds_shutdown, 1);
tegra_gpio_enable(grouper_lvds_shutdown);
*/
if( grouper_get_project_id() == GROUPER_PROJECT_BACH)
{
grouper_disp1_out.parent_clk = "pll_d_out0";
grouper_disp1_out.modes->pclk = 81750000;
grouper_disp1_out.modes->h_sync_width= 64;
grouper_disp1_out.modes->h_back_porch= 128;
grouper_disp1_out.modes->h_front_porch = 64;
printk("Bach: Set LCD pclk as %d Hz\n", grouper_disp1_out.modes->pclk);
gpio_request(TEGRA_GPIO_PV6, "gpio_v6");
tegra_gpio_enable(TEGRA_GPIO_PV6);
}
tegra_gpio_enable(grouper_hdmi_hpd);
gpio_request(grouper_hdmi_hpd, "hdmi_hpd");
gpio_direction_input(grouper_hdmi_hpd);
#ifdef CONFIG_HAS_EARLYSUSPEND
grouper_panel_early_suspender.suspend = grouper_panel_early_suspend;
grouper_panel_early_suspender.resume = grouper_panel_late_resume;
grouper_panel_early_suspender.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
register_early_suspend(&grouper_panel_early_suspender);
#endif
#ifdef CONFIG_TEGRA_GRHOST
err = nvhost_device_register(&tegra_grhost_device);
if (err)
return err;
#endif
err = platform_add_devices(grouper_gfx_devices,
ARRAY_SIZE(grouper_gfx_devices));
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = nvhost_get_resource_byname(&grouper_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(&grouper_disp1_device);
res = nvhost_get_resource_byname(&grouper_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(&grouper_disp2_device);
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err)
err = nvhost_device_register(&nvavp_device);
#endif
return err;
}