/* Copyright (c) 2008-2012, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define TVENC_C #include "tvenc.h" #include "msm_fb.h" #include "mdp4.h" /* AXI rate in KHz */ #define MSM_SYSTEM_BUS_RATE 128000000 static int tvenc_probe(struct platform_device *pdev); static int tvenc_remove(struct platform_device *pdev); static int tvenc_off(struct platform_device *pdev); static int tvenc_on(struct platform_device *pdev); static struct platform_device *pdev_list[MSM_FB_MAX_DEV_LIST]; static int pdev_list_cnt; static struct clk *tvenc_clk; static struct clk *tvdac_clk; static struct clk *tvenc_pclk; static struct clk *mdp_tv_clk; #ifdef CONFIG_FB_MSM_MDP40 static struct clk *tv_src_clk; #endif #ifdef CONFIG_MSM_BUS_SCALING static uint32_t tvenc_bus_scale_handle; #endif static int tvenc_runtime_suspend(struct device *dev) { dev_dbg(dev, "pm_runtime: suspending...\n"); return 0; } static int tvenc_runtime_resume(struct device *dev) { dev_dbg(dev, "pm_runtime: resuming...\n"); return 0; } static struct dev_pm_ops tvenc_dev_pm_ops = { .runtime_suspend = tvenc_runtime_suspend, .runtime_resume = tvenc_runtime_resume, }; static struct platform_driver tvenc_driver = { .probe = tvenc_probe, .remove = tvenc_remove, .suspend = NULL, .resume = NULL, .shutdown = NULL, .driver = { .name = "tvenc", .pm = &tvenc_dev_pm_ops }, }; int tvenc_set_encoder_clock(boolean clock_on) { int ret = 0; if (clock_on) { #ifdef CONFIG_FB_MSM_MDP40 /* Consolidated clock used by both HDMI & TV encoder. Clock exists only in MDP4 and not in older versions */ ret = clk_set_rate(tv_src_clk, 27000000); if (ret) { pr_err("%s: tvsrc_clk set rate failed! %d\n", __func__, ret); goto tvsrc_err; } #endif ret = clk_prepare_enable(tvenc_clk); if (ret) { pr_err("%s: tvenc_clk enable failed! %d\n", __func__, ret); goto tvsrc_err; } if (!IS_ERR(tvenc_pclk)) { ret = clk_prepare_enable(tvenc_pclk); if (ret) { pr_err("%s: tvenc_pclk enable failed! %d\n", __func__, ret); goto tvencp_err; } } return ret; } else { if (!IS_ERR(tvenc_pclk)) clk_disable_unprepare(tvenc_pclk); clk_disable_unprepare(tvenc_clk); return ret; } tvencp_err: clk_disable_unprepare(tvenc_clk); tvsrc_err: return ret; } int tvenc_set_clock(boolean clock_on) { int ret = 0; if (clock_on) { if (tvenc_pdata->poll) { ret = tvenc_set_encoder_clock(CLOCK_ON); if (ret) { pr_err("%s: TVenc clock(s) enable failed! %d\n", __func__, ret); goto tvenc_err; } } ret = clk_prepare_enable(tvdac_clk); if (ret) { pr_err("%s: tvdac_clk enable failed! %d\n", __func__, ret); goto tvdac_err; } if (!IS_ERR(mdp_tv_clk)) { ret = clk_prepare_enable(mdp_tv_clk); if (ret) { pr_err("%s: mdp_tv_clk enable failed! %d\n", __func__, ret); goto mdptv_err; } } return ret; } else { if (!IS_ERR(mdp_tv_clk)) clk_disable_unprepare(mdp_tv_clk); clk_disable_unprepare(tvdac_clk); if (tvenc_pdata->poll) tvenc_set_encoder_clock(CLOCK_OFF); return ret; } mdptv_err: clk_disable_unprepare(tvdac_clk); tvdac_err: tvenc_set_encoder_clock(CLOCK_OFF); tvenc_err: return ret; } static int tvenc_off(struct platform_device *pdev) { int ret = 0; struct msm_fb_data_type *mfd; mfd = platform_get_drvdata(pdev); ret = panel_next_off(pdev); if (ret) pr_err("%s: tvout_off failed! %d\n", __func__, ret); tvenc_set_clock(CLOCK_OFF); if (tvenc_pdata && tvenc_pdata->pm_vid_en) ret = tvenc_pdata->pm_vid_en(0); #ifdef CONFIG_MSM_BUS_SCALING if (tvenc_bus_scale_handle > 0) msm_bus_scale_client_update_request(tvenc_bus_scale_handle, 0); #else if (mfd->ebi1_clk) clk_disable_unprepare(mfd->ebi1_clk); #endif if (ret) pr_err("%s: pm_vid_en(off) failed! %d\n", __func__, ret); mdp4_extn_disp = 0; return ret; } static int tvenc_on(struct platform_device *pdev) { int ret = 0; #ifndef CONFIG_MSM_BUS_SCALING struct msm_fb_data_type *mfd = platform_get_drvdata(pdev); #endif #ifdef CONFIG_MSM_BUS_SCALING if (tvenc_bus_scale_handle > 0) msm_bus_scale_client_update_request(tvenc_bus_scale_handle, 1); #else if (mfd->ebi1_clk) clk_prepare_enable(mfd->ebi1_clk); #endif mdp4_extn_disp = 1; if (tvenc_pdata && tvenc_pdata->pm_vid_en) ret = tvenc_pdata->pm_vid_en(1); if (ret) { pr_err("%s: pm_vid_en(on) failed! %d\n", __func__, ret); return ret; } ret = tvenc_set_clock(CLOCK_ON); if (ret) { pr_err("%s: tvenc_set_clock(CLOCK_ON) failed! %d\n", __func__, ret); tvenc_pdata->pm_vid_en(0); goto error; } ret = panel_next_on(pdev); if (ret) { pr_err("%s: tvout_on failed! %d\n", __func__, ret); tvenc_set_clock(CLOCK_OFF); tvenc_pdata->pm_vid_en(0); } error: return ret; } void tvenc_gen_test_pattern(struct msm_fb_data_type *mfd) { uint32 reg = 0, i; reg = readl(MSM_TV_ENC_CTL); reg |= TVENC_CTL_TEST_PATT_EN; for (i = 0; i < 3; i++) { TV_OUT(TV_ENC_CTL, 0); /* disable TV encoder */ switch (i) { /* * TV Encoder - Color Bar Test Pattern */ case 0: reg |= TVENC_CTL_TPG_CLRBAR; break; /* * TV Encoder - Red Frame Test Pattern */ case 1: reg |= TVENC_CTL_TPG_REDCLR; break; /* * TV Encoder - Modulated Ramp Test Pattern */ default: reg |= TVENC_CTL_TPG_MODRAMP; break; } TV_OUT(TV_ENC_CTL, reg); mdelay(5000); switch (i) { /* * TV Encoder - Color Bar Test Pattern */ case 0: reg &= ~TVENC_CTL_TPG_CLRBAR; break; /* * TV Encoder - Red Frame Test Pattern */ case 1: reg &= ~TVENC_CTL_TPG_REDCLR; break; /* * TV Encoder - Modulated Ramp Test Pattern */ default: reg &= ~TVENC_CTL_TPG_MODRAMP; break; } } } static int tvenc_resource_initialized; static int tvenc_probe(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct platform_device *mdp_dev = NULL; struct msm_fb_panel_data *pdata = NULL; int rc, ret; struct clk *ebi1_clk = NULL; if (pdev->id == 0) { tvenc_base = ioremap(pdev->resource[0].start, pdev->resource[0].end - pdev->resource[0].start + 1); if (!tvenc_base) { pr_err("tvenc_base ioremap failed!\n"); return -ENOMEM; } tvenc_clk = clk_get(&pdev->dev, "enc_clk"); tvdac_clk = clk_get(&pdev->dev, "dac_clk"); tvenc_pclk = clk_get(&pdev->dev, "iface_clk"); mdp_tv_clk = clk_get(&pdev->dev, "mdp_clk"); #ifndef CONFIG_MSM_BUS_SCALING ebi1_clk = clk_get(&pdev->dev, "mem_clk"); if (IS_ERR(ebi1_clk)) { rc = PTR_ERR(ebi1_clk); goto tvenc_probe_err; } clk_set_rate(ebi1_clk, MSM_SYSTEM_BUS_RATE); #endif #ifdef CONFIG_FB_MSM_MDP40 tv_src_clk = clk_get(&pdev->dev, "src_clk"); if (IS_ERR(tv_src_clk)) tv_src_clk = tvenc_clk; /* Fallback to slave */ #endif if (IS_ERR(tvenc_clk)) { pr_err("%s: error: can't get tvenc_clk!\n", __func__); return PTR_ERR(tvenc_clk); } if (IS_ERR(tvdac_clk)) { pr_err("%s: error: can't get tvdac_clk!\n", __func__); return PTR_ERR(tvdac_clk); } if (IS_ERR(tvenc_pclk)) { ret = PTR_ERR(tvenc_pclk); if (-ENOENT == ret) pr_info("%s: tvenc_pclk does not exist!\n", __func__); else { pr_err("%s: error: can't get tvenc_pclk!\n", __func__); return ret; } } if (IS_ERR(mdp_tv_clk)) { ret = PTR_ERR(mdp_tv_clk); if (-ENOENT == ret) pr_info("%s: mdp_tv_clk does not exist!\n", __func__); else { pr_err("%s: error: can't get mdp_tv_clk!\n", __func__); return ret; } } tvenc_pdata = pdev->dev.platform_data; tvenc_resource_initialized = 1; return 0; } if (!tvenc_resource_initialized) return -EPERM; mfd = platform_get_drvdata(pdev); mfd->ebi1_clk = ebi1_clk; if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (pdev_list_cnt >= MSM_FB_MAX_DEV_LIST) return -ENOMEM; if (tvenc_base == NULL) return -ENOMEM; mdp_dev = platform_device_alloc("mdp", pdev->id); if (!mdp_dev) return -ENOMEM; /* * link to the latest pdev */ mfd->pdev = mdp_dev; mfd->dest = DISPLAY_TV; /* * alloc panel device data */ if (platform_device_add_data (mdp_dev, pdev->dev.platform_data, sizeof(struct msm_fb_panel_data))) { pr_err("tvenc_probe: platform_device_add_data failed!\n"); platform_device_put(mdp_dev); return -ENOMEM; } /* * data chain */ pdata = mdp_dev->dev.platform_data; pdata->on = tvenc_on; pdata->off = tvenc_off; pdata->next = pdev; /* * get/set panel specific fb info */ mfd->panel_info = pdata->panel_info; #ifdef CONFIG_FB_MSM_MDP40 mfd->fb_imgType = MDP_RGB_565; /* base layer */ #else mfd->fb_imgType = MDP_YCRYCB_H2V1; #endif #ifdef CONFIG_MSM_BUS_SCALING if (!tvenc_bus_scale_handle && tvenc_pdata && tvenc_pdata->bus_scale_table) { tvenc_bus_scale_handle = msm_bus_scale_register_client( tvenc_pdata->bus_scale_table); if (!tvenc_bus_scale_handle) { printk(KERN_ERR "%s not able to get bus scale\n", __func__); } } #endif /* * set driver data */ platform_set_drvdata(mdp_dev, mfd); /* * register in mdp driver */ rc = platform_device_add(mdp_dev); if (rc) goto tvenc_probe_err; pm_runtime_set_active(&pdev->dev); pm_runtime_enable(&pdev->dev); pdev_list[pdev_list_cnt++] = pdev; return 0; tvenc_probe_err: #ifdef CONFIG_MSM_BUS_SCALING if (tvenc_pdata && tvenc_pdata->bus_scale_table && tvenc_bus_scale_handle > 0) { msm_bus_scale_unregister_client(tvenc_bus_scale_handle); tvenc_bus_scale_handle = 0; } #endif platform_device_put(mdp_dev); return rc; } static int tvenc_remove(struct platform_device *pdev) { struct msm_fb_data_type *mfd; mfd = platform_get_drvdata(pdev); #ifdef CONFIG_MSM_BUS_SCALING if (tvenc_pdata && tvenc_pdata->bus_scale_table && tvenc_bus_scale_handle > 0) { msm_bus_scale_unregister_client(tvenc_bus_scale_handle); tvenc_bus_scale_handle = 0; } #else clk_put(mfd->ebi1_clk); #endif pm_runtime_disable(&pdev->dev); return 0; } static int tvenc_register_driver(void) { return platform_driver_register(&tvenc_driver); } static int __init tvenc_driver_init(void) { return tvenc_register_driver(); } module_init(tvenc_driver_init);