shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-09 12:17:12 +09:00
Code Issues Packages Projects Releases Wiki Activity

rk616 hdmi: remove some hdmi global variable and change operate reg func name

Browse Source
This commit is contained in:
xuhuicong
2013-07-03 23:34:44 +08:00
parent d9f1316d4f
commit 6d3fbffa37
4 changed files with 154 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.c
View File

@@ -17,6 +17,7 @@
#include <mach/io.h>
#include <mach/gpio.h>
#include <mach/iomux.h>
#include <linux/rk_fb.h>
#if defined(CONFIG_DEBUG_FS)
#include <linux/fs.h>
@@ -27,19 +28,10 @@
#include "rk616_hdmi.h"
#include "rk616_hdmi_hw.h"
struct hdmi *hdmi = NULL;
struct mfd_rk616 *g_rk616_hdmi = NULL;
struct work_struct g_rk616_irq_work_struct;
struct delayed_work g_rk616_delay_work;
// extern void hdmi_irq(void);
extern void rk616_hdmi_work(void);
extern void hdmi_work(struct work_struct *work);
extern struct rk_lcdc_device_driver * rk_get_lcdc_drv(char *name);
extern void hdmi_register_display_sysfs(struct hdmi *hdmi, struct device *parent);
extern void hdmi_unregister_display_sysfs(struct hdmi *hdmi);
struct hdmi *hdmi = NULL;
#if defined(CONFIG_DEBUG_FS)
static int rk616_hdmi_reg_show(struct seq_file *s, void *v)
@@ -53,8 +45,6 @@ static int rk616_hdmi_reg_show(struct seq_file *s, void *v)
return 0;
}
//seq_printf(s,"------>gpio = %d \n",gpio_get_value(rk616->pdata->hdmi_irq));
seq_printf(s, "\n>>>rk616_ctl reg");
for (i = 0; i < 16; i++) {
seq_printf(s, " %2x", i);
@@ -162,7 +152,11 @@ static void hdmi_early_suspend(struct early_suspend *h)
static void hdmi_early_resume(struct early_suspend *h)
{
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
hdmi_dbg(hdmi->dev, "hdmi exit early resume\n");
mutex_lock(&hdmi->enable_mutex);
hdmi->suspend = 0;
@@ -172,8 +166,9 @@ static void hdmi_early_resume(struct early_suspend *h)
// hdmi_irq();
rk616_hdmi_work();
}
if (g_rk616_hdmi->pdata->hdmi_irq == INVALID_GPIO)
queue_delayed_work(hdmi->workqueue, &g_rk616_delay_work, 100);
if (rk616_hdmi->rk616_drv->pdata->hdmi_irq == INVALID_GPIO)
queue_delayed_work(hdmi->workqueue, &rk616_hdmi->rk616_delay_work, 100);
queue_delayed_work(hdmi->workqueue, &hdmi->delay_work, msecs_to_jiffies(10));
mutex_unlock(&hdmi->enable_mutex);
@@ -182,14 +177,18 @@ static void hdmi_early_resume(struct early_suspend *h)
#endif
static void rk616_delay_work_func(struct work_struct *work)
{
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
if(hdmi->suspend == 0) {
if(hdmi->enable == 1) {
//hdmi_irq();
rk616_hdmi_work();
}
if (g_rk616_hdmi->pdata->hdmi_irq == INVALID_GPIO) {
queue_delayed_work(hdmi->workqueue, &g_rk616_delay_work, 100);
if (rk616_hdmi->rk616_drv->pdata->hdmi_irq == INVALID_GPIO) {
queue_delayed_work(hdmi->workqueue, &rk616_hdmi->rk616_delay_work, 100);
}
}
}
@@ -203,7 +202,6 @@ static void rk616_irq_work_func(struct work_struct *work)
enable_irq(hdmi->irq);
}
#if 1
static irqreturn_t rk616_hdmi_irq(int irq, void *dev_id)
{
@@ -219,6 +217,7 @@ static irqreturn_t rk616_hdmi_irq(int irq, void *dev_id)
static int __devinit rk616_hdmi_probe (struct platform_device *pdev)
{
int ret;
struct rk616_hdmi *rk616_hdmi;
struct mfd_rk616 *rk616 = dev_get_drvdata(pdev->dev.parent);
if(!rk616)
@@ -227,15 +226,15 @@ static int __devinit rk616_hdmi_probe (struct platform_device *pdev)
return -ENODEV;
}
g_rk616_hdmi = rk616;
hdmi = kmalloc(sizeof(struct hdmi), GFP_KERNEL);
if(!hdmi)
rk616_hdmi = devm_kzalloc(&pdev->dev, sizeof(*rk616_hdmi), GFP_KERNEL);
if(!rk616_hdmi)
{
dev_err(&pdev->dev, ">>rk616 hdmi kmalloc fail!");
dev_err(&pdev->dev, ">>rk616_hdmi kmalloc fail!");
return -ENOMEM;
}
memset(hdmi, 0, sizeof(struct hdmi));
hdmi = &rk616_hdmi->g_hdmi;
rk616_hdmi->rk616_drv = rk616;
hdmi->dev = &pdev->dev;
platform_set_drvdata(pdev, hdmi);
@@ -275,11 +274,12 @@ static int __devinit rk616_hdmi_probe (struct platform_device *pdev)
spin_lock_init(&hdmi->irq_lock);
mutex_init(&hdmi->enable_mutex);
INIT_DELAYED_WORK(&g_rk616_delay_work, rk616_delay_work_func);
INIT_DELAYED_WORK(&rk616_hdmi->rk616_delay_work, rk616_delay_work_func);
/* get the IRQ */
if(rk616->pdata->hdmi_irq != INVALID_GPIO)
{
INIT_WORK(&g_rk616_irq_work_struct, rk616_irq_work_func);
INIT_WORK(&rk616_hdmi->rk616_irq_work_struct, rk616_irq_work_func);
ret = gpio_request(rk616->pdata->hdmi_irq,"rk616_hdmi_irq");
if(ret < 0)
{
@@ -294,7 +294,7 @@ static int __devinit rk616_hdmi_probe (struct platform_device *pdev)
}
/* request the IRQ */
ret = request_irq(hdmi->irq, rk616_hdmi_irq, IRQF_TRIGGER_LOW, dev_name(&pdev->dev), &g_rk616_irq_work_struct);
ret = request_irq(hdmi->irq, rk616_hdmi_irq, IRQF_TRIGGER_LOW, dev_name(&pdev->dev), &rk616_hdmi->rk616_irq_work_struct);
if (ret)
{
dev_err(hdmi->dev, "hdmi request_irq failed (%d).\n", ret);
@@ -312,7 +312,7 @@ static int __devinit rk616_hdmi_probe (struct platform_device *pdev)
}
#endif
// rk616_delay_work_func(NULL);
queue_delayed_work(hdmi->workqueue, &g_rk616_delay_work, msecs_to_jiffies(0));
queue_delayed_work(hdmi->workqueue, &rk616_hdmi->rk616_delay_work, msecs_to_jiffies(0));
dev_info(hdmi->dev, "rk616 hdmi probe success.\n");
return 0;
err1:

9
drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.h
View File

@@ -25,4 +25,13 @@ extern int rk616_hdmi_register_hdcp_callbacks(void (*hdcp_cb)(void),
void (*hdcp_irq_cb)(int status),
int (*hdcp_power_on_cb)(void),
void (*hdcp_power_off_cb)(void));
struct rk616_hdmi {
struct hdmi g_hdmi;
struct early_suspend early_suspend;
struct delayed_work rk616_delay_work;
struct work_struct rk616_irq_work_struct;
struct mfd_rk616 *rk616_drv;
};
#endif /* __RK30_HDMI_H__ */

181
drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.c
View File

@@ -10,7 +10,10 @@
static int rk616_hdmi_set_vif(rk_screen * screen,bool connect)
{
rk616_set_vif(g_rk616_hdmi,screen,connect);
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
rk616_set_vif(rk616_hdmi->rk616_drv,screen,connect);
return 0;
}
@@ -35,16 +38,16 @@ static inline void delay100us(void)
static void rk616_hdmi_av_mute(bool enable)
{
HDMIWrReg(AV_MUTE, v_AUDIO_MUTE(enable) | v_VIDEO_MUTE(enable));
hdmi_writel(AV_MUTE, v_AUDIO_MUTE(enable) | v_VIDEO_MUTE(enable));
}
static void rk616_hdmi_sys_power_up(void)
{
HDMIMskReg(SYS_CTRL,m_POWER, v_PWR_ON);
hdmi_msk_reg(SYS_CTRL,m_POWER, v_PWR_ON);
}
static void rk616_hdmi_sys_power_down(void)
{
HDMIMskReg(SYS_CTRL,m_POWER, v_PWR_OFF);
hdmi_msk_reg(SYS_CTRL,m_POWER, v_PWR_OFF);
}
@@ -57,15 +60,15 @@ static void rk616_hdmi_set_pwr_mode(int mode)
case NORMAL:
hdmi_dbg(hdmi->dev,"%s change pwr_mode NORMALpwr_mode = %d, mode = %d\n",__FUNCTION__,hdmi->pwr_mode,mode);
rk616_hdmi_sys_power_down();
HDMIWrReg(PHY_DRIVER,0xaa);
HDMIWrReg(PHY_PRE_EMPHASIS,0x0f);
HDMIWrReg(PHY_SYS_CTL,0x2d);
HDMIWrReg(PHY_SYS_CTL,0x2c);
HDMIWrReg(PHY_SYS_CTL,0x28);
HDMIWrReg(PHY_SYS_CTL,0x20);
HDMIWrReg(PHY_CHG_PWR,0x0f);
HDMIWrReg(0xce, 0x00);
HDMIWrReg(0xce, 0x01);
hdmi_writel(PHY_DRIVER,0xaa);
hdmi_writel(PHY_PRE_EMPHASIS,0x0f);
hdmi_writel(PHY_SYS_CTL,0x2d);
hdmi_writel(PHY_SYS_CTL,0x2c);
hdmi_writel(PHY_SYS_CTL,0x28);
hdmi_writel(PHY_SYS_CTL,0x20);
hdmi_writel(PHY_CHG_PWR,0x0f);
hdmi_writel(0xce, 0x00);
hdmi_writel(0xce, 0x01);
rk616_hdmi_av_mute(1);
rk616_hdmi_sys_power_up();
break;
@@ -73,10 +76,10 @@ static void rk616_hdmi_set_pwr_mode(int mode)
hdmi_dbg(hdmi->dev,"%s change pwr_mode LOWER_PWR pwr_mode = %d, mode = %d\n",__FUNCTION__,hdmi->pwr_mode,mode);
rk616_hdmi_av_mute(0);
rk616_hdmi_sys_power_down();
HDMIWrReg(PHY_DRIVER,0x00);
HDMIWrReg(PHY_PRE_EMPHASIS,0x00);
HDMIWrReg(PHY_CHG_PWR,0x00);
HDMIWrReg(PHY_SYS_CTL,0x2f);
hdmi_writel(PHY_DRIVER,0x00);
hdmi_writel(PHY_PRE_EMPHASIS,0x00);
hdmi_writel(PHY_CHG_PWR,0x00);
hdmi_writel(PHY_SYS_CTL,0x2f);
break;
default:
hdmi_dbg(hdmi->dev,"unkown rk616 hdmi pwr mode %d\n",mode);
@@ -89,12 +92,12 @@ int rk616_hdmi_detect_hotplug(void)
{
int value = 0;
#if 0
HDMIRdReg(INTERRUPT_STATUS1,&value);
hdmi_readl(INTERRUPT_STATUS1,&value);
if(value){
HDMIWrReg(INTERRUPT_STATUS1, value);
hdmi_writel(INTERRUPT_STATUS1, value);
}
#endif
HDMIRdReg(HDMI_STATUS,&value);
hdmi_readl(HDMI_STATUS,&value);
hdmi_dbg(hdmi->dev, "[%s] value %02x\n", __FUNCTION__, value);
value &= m_HOTPLUG;
@@ -126,29 +129,29 @@ int rk616_hdmi_read_edid(int block, u8 * buf)
printk("EDID DATA (Segment = %d Block = %d Offset = %d):\n", (int) Segment, (int) block, (int) Offset);
//set edid fifo first addr
c = 0x00;
HDMIWrReg(0x4f,0);
hdmi_writel(0x4f,0);
//set edid word address 00/80
c = Offset;
HDMIWrReg(0x4e, c);
hdmi_writel(0x4e, c);
//set edid segment pointer
c = Segment;
HDMIWrReg(0x4d, c);
hdmi_writel(0x4d, c);
//enable edid interrupt
// c=0xc6;
// HDMIWrReg(0xc0, c);
// hdmi_writel(0xc0, c);
//wait edid interrupt
msleep(10);
//printk("Interrupt generated\n");
//c=0x00;
//ret = HDMIRdReg(0xc1, &c);
//ret = hdmi_readl(0xc1, &c);
//printk("Interrupt reg=%x \n",c);
//clear EDID interrupt reg
//c=0x04;
//HDMIWrReg(0xc1, c);
//hdmi_writel(0xc1, c);
for(i=0; i <EDID_BLOCK_SIZE;i++){
c = 0;
HDMIRdReg( 0x50, &c);
hdmi_readl( 0x50, &c);
buf[i] = c;
if(i%16==0)
printk("\n>>>%d:",i);
@@ -163,7 +166,7 @@ static void rk616_hdmi_config_avi(unsigned char vic, unsigned char output_color)
char info[SIZE_AVI_INFOFRAME];
memset(info, 0, SIZE_AVI_INFOFRAME);
HDMIWrReg(CONTROL_PACKET_BUF_INDEX, INFOFRAME_AVI);
hdmi_writel(CONTROL_PACKET_BUF_INDEX, INFOFRAME_AVI);
info[0] = 0x82;
info[1] = 0x02;
info[2] = 0x0D;
@@ -182,7 +185,7 @@ static void rk616_hdmi_config_avi(unsigned char vic, unsigned char output_color)
info[3] = 0x100 - info[3];
for(i = 0; i < SIZE_AVI_INFOFRAME; i++)
HDMIWrReg(CONTROL_PACKET_ADDR + i, info[i]);
hdmi_writel(CONTROL_PACKET_ADDR + i, info[i]);
}
@@ -223,9 +226,11 @@ static int rk616_hdmi_config_video(struct hdmi_video_para *vpara)
{
int value;
struct fb_videomode *mode;
struct rk616_hdmi *rk616_hdmi;
hdmi_dbg(hdmi->dev, "[%s]\n", __FUNCTION__);
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
if(vpara == NULL) {
hdmi_err(hdmi->dev, "[%s] input parameter error\n", __FUNCTION__);
return -1;
@@ -240,14 +245,14 @@ static int rk616_hdmi_config_video(struct hdmi_video_para *vpara)
if(hdmi->hdcp_power_off_cb)
hdmi->hdcp_power_off_cb();
// Diable video and audio output
HDMIWrReg(AV_MUTE, v_AUDIO_MUTE(1) | v_VIDEO_MUTE(1));
hdmi_writel(AV_MUTE, v_AUDIO_MUTE(1) | v_VIDEO_MUTE(1));
// Input video mode is SDR RGB24bit, Data enable signal from external
HDMIWrReg(VIDEO_CONTRL1, v_VIDEO_INPUT_FORMAT(VIDEO_INPUT_SDR_RGB444) | v_DE_EXTERNAL);
HDMIWrReg(VIDEO_CONTRL2, v_VIDEO_INPUT_BITS(VIDEO_INPUT_8BITS) | (vpara->output_color & 0xFF));
hdmi_writel(VIDEO_CONTRL1, v_VIDEO_INPUT_FORMAT(VIDEO_INPUT_SDR_RGB444) | v_DE_EXTERNAL);
hdmi_writel(VIDEO_CONTRL2, v_VIDEO_INPUT_BITS(VIDEO_INPUT_8BITS) | (vpara->output_color & 0xFF));
// Set HDMI Mode
HDMIWrReg(HDCP_CTRL, v_HDMI_DVI(vpara->output_mode));
hdmi_writel(HDCP_CTRL, v_HDMI_DVI(vpara->output_mode));
// Enable or disalbe color space convert
if(vpara->input_color != vpara->output_color) {
@@ -255,11 +260,11 @@ static int rk616_hdmi_config_video(struct hdmi_video_para *vpara)
}
else
value = v_SOF_DISABLE;
HDMIWrReg(VIDEO_CONTRL3, value);
hdmi_writel(VIDEO_CONTRL3, value);
// Set ext video
#if 1
HDMIWrReg(VIDEO_TIMING_CTL, 0);
hdmi_writel(VIDEO_TIMING_CTL, 0);
mode = (struct fb_videomode *)hdmi_vic_to_videomode(vpara->vic);
if(mode == NULL)
{
@@ -273,42 +278,42 @@ static int rk616_hdmi_config_video(struct hdmi_video_para *vpara)
value |= v_HSYNC_POLARITY(1);
if(mode->sync & FB_SYNC_VERT_HIGH_ACT)
value |= v_VSYNC_POLARITY(1);
HDMIWrReg(VIDEO_TIMING_CTL, value);
hdmi_writel(VIDEO_TIMING_CTL, value);
value = mode->left_margin + mode->xres + mode->right_margin + mode->hsync_len;
HDMIWrReg(VIDEO_EXT_HTOTAL_L, value & 0xFF);
HDMIWrReg(VIDEO_EXT_HTOTAL_H, (value >> 8) & 0xFF);
hdmi_writel(VIDEO_EXT_HTOTAL_L, value & 0xFF);
hdmi_writel(VIDEO_EXT_HTOTAL_H, (value >> 8) & 0xFF);
value = mode->left_margin + mode->right_margin + mode->hsync_len;
HDMIWrReg(VIDEO_EXT_HBLANK_L, value & 0xFF);
HDMIWrReg(VIDEO_EXT_HBLANK_H, (value >> 8) & 0xFF);
hdmi_writel(VIDEO_EXT_HBLANK_L, value & 0xFF);
hdmi_writel(VIDEO_EXT_HBLANK_H, (value >> 8) & 0xFF);
value = mode->left_margin + mode->hsync_len;
HDMIWrReg(VIDEO_EXT_HDELAY_L, value & 0xFF);
HDMIWrReg(VIDEO_EXT_HDELAY_H, (value >> 8) & 0xFF);
hdmi_writel(VIDEO_EXT_HDELAY_L, value & 0xFF);
hdmi_writel(VIDEO_EXT_HDELAY_H, (value >> 8) & 0xFF);
value = mode->hsync_len;
HDMIWrReg(VIDEO_EXT_HDURATION_L, value & 0xFF);
HDMIWrReg(VIDEO_EXT_HDURATION_H, (value >> 8) & 0xFF);
hdmi_writel(VIDEO_EXT_HDURATION_L, value & 0xFF);
hdmi_writel(VIDEO_EXT_HDURATION_H, (value >> 8) & 0xFF);
value = mode->upper_margin + mode->yres + mode->lower_margin + mode->vsync_len;
HDMIWrReg(VIDEO_EXT_VTOTAL_L, value & 0xFF);
HDMIWrReg(VIDEO_EXT_VTOTAL_H, (value >> 8) & 0xFF);
hdmi_writel(VIDEO_EXT_VTOTAL_L, value & 0xFF);
hdmi_writel(VIDEO_EXT_VTOTAL_H, (value >> 8) & 0xFF);
value = mode->upper_margin + mode->vsync_len + mode->lower_margin;
HDMIWrReg(VIDEO_EXT_VBLANK, value & 0xFF);
hdmi_writel(VIDEO_EXT_VBLANK, value & 0xFF);
if(vpara->vic == HDMI_720x480p_60Hz_4_3 || vpara->vic == HDMI_720x480p_60Hz_16_9)
value = 42;
else
value = mode->upper_margin + mode->vsync_len;
HDMIWrReg(VIDEO_EXT_VDELAY, value & 0xFF);
hdmi_writel(VIDEO_EXT_VDELAY, value & 0xFF);
value = mode->vsync_len;
HDMIWrReg(VIDEO_EXT_VDURATION, value & 0xFF);
hdmi_writel(VIDEO_EXT_VDURATION, value & 0xFF);
#endif
rk616_set_polarity(g_rk616_hdmi, vpara->vic);
rk616_set_polarity(rk616_hdmi->rk616_drv, vpara->vic);
if(vpara->output_mode == OUTPUT_HDMI) {
rk616_hdmi_config_avi(vpara->vic, vpara->output_color);
@@ -319,16 +324,16 @@ static int rk616_hdmi_config_video(struct hdmi_video_para *vpara)
}
#if 1
HDMIWrReg(0xed, 0x0f);
HDMIWrReg(0xe7, 0x96);
hdmi_writel(0xed, 0x0f);
hdmi_writel(0xe7, 0x96);
#else
if(hdmi->tmdsclk >= 148500000) {
HDMIWrReg(0xed, 0xc);
HDMIWrReg(0xe7, 0x78);
hdmi_writel(0xed, 0xc);
hdmi_writel(0xe7, 0x78);
}
else {
HDMIWrReg(0xed, 0x3);
HDMIWrReg(0xe7, 0x1e);
hdmi_writel(0xed, 0x3);
hdmi_writel(0xe7, 0x1e);
}
#endif
return 0;
@@ -351,9 +356,9 @@ static void rk616_hdmi_config_aai(void)
info[3] = 0x100 - info[3];
HDMIWrReg(CONTROL_PACKET_BUF_INDEX, INFOFRAME_AAI);
hdmi_writel(CONTROL_PACKET_BUF_INDEX, INFOFRAME_AAI);
for(i = 0; i < SIZE_AUDIO_INFOFRAME; i++)
HDMIWrReg(CONTROL_PACKET_ADDR + i, info[i]);
hdmi_writel(CONTROL_PACKET_ADDR + i, info[i]);
}
static int rk616_hdmi_config_audio(struct hdmi_audio *audio)
@@ -413,45 +418,45 @@ static int rk616_hdmi_config_audio(struct hdmi_audio *audio)
//set_audio source I2S
if(HDMI_CODEC_SOURCE_SELECT == INPUT_IIS){
HDMIWrReg(AUDIO_CTRL1, 0x00);
HDMIWrReg(AUDIO_SAMPLE_RATE, rate);
HDMIWrReg(AUDIO_I2S_MODE, v_I2S_MODE(I2S_STANDARD) | v_I2S_CHANNEL(channel) );
HDMIWrReg(AUDIO_I2S_MAP, 0x00);
HDMIWrReg(AUDIO_I2S_SWAPS_SPDIF, 0); // no swap
hdmi_writel(AUDIO_CTRL1, 0x00);
hdmi_writel(AUDIO_SAMPLE_RATE, rate);
hdmi_writel(AUDIO_I2S_MODE, v_I2S_MODE(I2S_STANDARD) | v_I2S_CHANNEL(channel) );
hdmi_writel(AUDIO_I2S_MAP, 0x00);
hdmi_writel(AUDIO_I2S_SWAPS_SPDIF, 0); // no swap
}else{
HDMIWrReg(AUDIO_CTRL1, 0x08);
HDMIWrReg(AUDIO_I2S_SWAPS_SPDIF, 0); // no swap
hdmi_writel(AUDIO_CTRL1, 0x08);
hdmi_writel(AUDIO_I2S_SWAPS_SPDIF, 0); // no swap
}
//Set N value
HDMIWrReg(AUDIO_N_H, (N >> 16) & 0x0F);
HDMIWrReg(AUDIO_N_M, (N >> 8) & 0xFF);
HDMIWrReg(AUDIO_N_L, N & 0xFF);
rk616_hdmi_config_aai();
return 0;
//Set N value
hdmi_writel(AUDIO_N_H, (N >> 16) & 0x0F);
hdmi_writel(AUDIO_N_M, (N >> 8) & 0xFF);
hdmi_writel(AUDIO_N_L, N & 0xFF);
rk616_hdmi_config_aai();
return 0;
}
void rk616_hdmi_control_output(int enable)
{
char mutestatus = 0;
int mutestatus = 0;
if(enable) {
if(hdmi->pwr_mode == LOWER_PWR)
rk616_hdmi_set_pwr_mode(NORMAL);
HDMIRdReg(AV_MUTE,&mutestatus);
hdmi_readl(AV_MUTE,&mutestatus);
if(mutestatus && (m_AUDIO_MUTE | m_VIDEO_BLACK)) {
HDMIWrReg(AV_MUTE, v_AUDIO_MUTE(0) | v_VIDEO_MUTE(0));
hdmi_writel(AV_MUTE, v_AUDIO_MUTE(0) | v_VIDEO_MUTE(0));
}
rk616_hdmi_sys_power_up();
rk616_hdmi_sys_power_down();
rk616_hdmi_sys_power_up();
HDMIWrReg(0xce, 0x00);
hdmi_writel(0xce, 0x00);
delay100us();
HDMIWrReg(0xce, 0x01);
hdmi_writel(0xce, 0x01);
}
else {
HDMIWrReg(AV_MUTE, v_AUDIO_MUTE(1) | v_VIDEO_MUTE(1));
hdmi_writel(AV_MUTE, v_AUDIO_MUTE(1) | v_VIDEO_MUTE(1));
}
}
@@ -470,9 +475,9 @@ void rk616_hdmi_work(void)
u32 interrupt = 0;
// int value = 0;
HDMIRdReg(INTERRUPT_STATUS1,&interrupt);
hdmi_readl(INTERRUPT_STATUS1,&interrupt);
if(interrupt){
HDMIWrReg(INTERRUPT_STATUS1, interrupt);
hdmi_writel(INTERRUPT_STATUS1, interrupt);
}
if(interrupt & m_HOTPLUG){
@@ -502,20 +507,22 @@ static void rk616_hdmi_reset(void)
u32 val = 0;
u32 msk = 0;
HDMIMskReg(SYS_CTRL,m_RST_DIGITAL,v_NOT_RST_DIGITAL);
hdmi_msk_reg(SYS_CTRL,m_RST_DIGITAL,v_NOT_RST_DIGITAL);
delay100us();
HDMIMskReg(SYS_CTRL,m_RST_ANALOG,v_NOT_RST_ANALOG);
hdmi_msk_reg(SYS_CTRL,m_RST_ANALOG,v_NOT_RST_ANALOG);
delay100us();
msk = m_REG_CLK_INV | m_REG_CLK_SOURCE | m_POWER | m_INT_POL;
val = v_REG_CLK_INV | v_REG_CLK_SOURCE_SYS | v_PWR_ON |v_INT_POL_HIGH;
HDMIMskReg(SYS_CTRL,msk,val);
HDMIWrReg(INTERRUPT_MASK1,m_INT_HOTPLUG);
hdmi_msk_reg(SYS_CTRL,msk,val);
hdmi_writel(INTERRUPT_MASK1,m_INT_HOTPLUG);
rk616_hdmi_set_pwr_mode(LOWER_PWR);
}
int rk616_hdmi_initial(void)
{
int rc = HDMI_ERROR_SUCESS;
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
hdmi->pwr_mode = NORMAL;
hdmi->remove = rk616_hdmi_removed ;
@@ -528,7 +535,7 @@ int rk616_hdmi_initial(void)
rk616_hdmi_reset();
rk616_hdmi_init_pol_set(g_rk616_hdmi,0);
rk616_hdmi_init_pol_set(rk616_hdmi->rk616_drv, 0);
if(hdmi->hdcp_power_on_cb)
rc = hdmi->hdcp_power_on_cb();

36
drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.h
View File

@@ -273,20 +273,32 @@ enum {
#define PHY_PRE_DIV_RATIO 0xed
#define v_PRE_DIV_RATIO(n) (n&1f)
#define HDMIRdReg(addr,val) g_rk616_hdmi->read_dev(g_rk616_hdmi,(RK616_HDMI_BASE + ((addr)<<2)),(u32 *)val)
static inline void hdmi_readl(u16 offset, u32 *val)
{
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
#define HDMIWrReg(addr, val) do{ \
u32 temp = val; \
g_rk616_hdmi->write_dev(g_rk616_hdmi,(RK616_HDMI_BASE + ((addr)<<2)),&temp); \
}while(0)
rk616_hdmi->rk616_drv->read_dev(rk616_hdmi->rk616_drv, (RK616_HDMI_BASE + ((offset)<<2)), val);
}
static inline void hdmi_writel(u16 offset, u32 val)
{
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
rk616_hdmi->rk616_drv->write_dev(rk616_hdmi->rk616_drv, (RK616_HDMI_BASE + ((offset)<<2)), &val);
}
static inline void hdmi_msk_reg(u16 offset, u32 msk, u32 val)
{
struct rk616_hdmi *rk616_hdmi;
rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
rk616_hdmi->rk616_drv->write_dev_bits(rk616_hdmi->rk616_drv, (RK616_HDMI_BASE + ((offset)<<2)), msk, &val);
}
#define HDMIMskReg(addr,Msk,val) do{ \
u32 temp = val; \
g_rk616_hdmi->write_dev_bits(g_rk616_hdmi, (RK616_HDMI_BASE + ((addr)<<2)), Msk, &temp); \
}while(0)
extern struct mfd_rk616 *g_rk616_hdmi;
extern int rk616_hdmi_initial(void);
extern void rk616_hdmi_work(void);
#endif