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

diff --git a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.c b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.c
index 6214b38ec2fcc7036b8f4084383c781b34a5fc6e..f53046b634a21eeb29df124bb8b4bd8f0956723c 100755 (executable)
--- a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.c
+++ b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.c
@@ -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:

diff --git a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.h b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.h
index 7fcd7f6da6f9fd088d46956f4d092fd4822d0301..c2a807abfe98f4c38286693d75dfed1c8164bff7 100755 (executable)
--- a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.h
+++ b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi.h
@@ -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__ */

diff --git a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.c b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.c
index 55eb1ad9dcb1aa3761ad9dba297efc18a36a1883..1a86faa7b806c87d27b7a8851ba0df3ef1cccc27 100755 (executable)
--- a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.c
+++ b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.c
@@ -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();
 

diff --git a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.h b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.h
index ac3af6d8ea73d93896dc9ac1349787d24f635316..4d907792355caf58e9774e5c452384078b574359 100755 (executable)
--- a/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.h
+++ b/drivers/video/rockchip/hdmi/chips/rk616/rk616_hdmi_hw.h
@@ -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) 
-
-#define HDMIWrReg(addr, val)           do{ \
-                                               u32 temp = val; \
-                                               g_rk616_hdmi->write_dev(g_rk616_hdmi,(RK616_HDMI_BASE + ((addr)<<2)),&temp); \
-                                       }while(0)
-
-                                       
-#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;
-       
+static inline void hdmi_readl(u16 offset, u32 *val)
+{
+        struct rk616_hdmi *rk616_hdmi;
+        rk616_hdmi = container_of(hdmi, struct rk616_hdmi, g_hdmi);
+
+        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);
+}
+
 extern int rk616_hdmi_initial(void);
+extern void rk616_hdmi_work(void);
+
 
 #endif