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; }