drm/msm/hdmi: Convert PHY files according to new design
authorArchit Taneja <architt@codeaurora.org>
Thu, 25 Feb 2016 05:52:41 +0000 (11:22 +0530)
committerRob Clark <robdclark@gmail.com>
Mon, 29 Feb 2016 14:48:31 +0000 (09:48 -0500)
Remove the old PHY ops managed by hdmi_platform_config and use them as ops
provided by the HDMI PHY driver.

Remove the old HDMI 8960 PLL code that used the top level HDMI TX mmio
base.

NOTE: With this commit, HDMI functionality will break until the HDMI
PHY/PLL register offsets in hdmi.xml.h aren't updated to be used as
separate domains.

Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>
drivers/gpu/drm/msm/hdmi/hdmi.c
drivers/gpu/drm/msm/hdmi/hdmi.h
drivers/gpu/drm/msm/hdmi/hdmi_bridge.c
drivers/gpu/drm/msm/hdmi/hdmi_phy_8960.c
drivers/gpu/drm/msm/hdmi/hdmi_phy_8x60.c
drivers/gpu/drm/msm/hdmi/hdmi_phy_8x74.c

index 043a70c17f987b0f96b7dc710937b374591ca06b..d1401d92f6c3985734912ee1e7b46dac0125369f 100644 (file)
@@ -67,8 +67,6 @@ static irqreturn_t hdmi_irq(int irq, void *dev_id)
 
 static void hdmi_destroy(struct hdmi *hdmi)
 {
-       struct hdmi_phy *phy = hdmi->phy;
-
        /*
         * at this point, hpd has been disabled,
         * after flush workq, it's safe to deinit hdcp
@@ -78,8 +76,6 @@ static void hdmi_destroy(struct hdmi *hdmi)
                destroy_workqueue(hdmi->workq);
        }
        hdmi_hdcp_destroy(hdmi);
-       if (phy)
-               phy->funcs->destroy(phy);
 
        if (hdmi->phy_dev) {
                put_device(hdmi->phy_dev);
@@ -142,18 +138,6 @@ static struct hdmi *hdmi_init(struct platform_device *pdev)
        hdmi->config = config;
        spin_lock_init(&hdmi->reg_lock);
 
-       /* not sure about which phy maps to which msm.. probably I miss some */
-       if (config->phy_init) {
-               hdmi->phy = config->phy_init(hdmi);
-
-               if (IS_ERR(hdmi->phy)) {
-                       ret = PTR_ERR(hdmi->phy);
-                       dev_err(&pdev->dev, "failed to load phy: %d\n", ret);
-                       hdmi->phy = NULL;
-                       goto fail;
-               }
-       }
-
        hdmi->mmio = msm_ioremap(pdev, config->mmio_name, "HDMI");
        if (IS_ERR(hdmi->mmio)) {
                ret = PTR_ERR(hdmi->mmio);
@@ -371,15 +355,12 @@ fail:
 static const char *pwr_reg_names_none[] = {};
 static const char *hpd_reg_names_none[] = {};
 
-static struct hdmi_platform_config hdmi_tx_8660_config = {
-               .phy_init = hdmi_phy_8x60_init,
-};
+static struct hdmi_platform_config hdmi_tx_8660_config;
 
 static const char *hpd_reg_names_8960[] = {"core-vdda", "hdmi-mux"};
 static const char *hpd_clk_names_8960[] = {"core_clk", "master_iface_clk", "slave_iface_clk"};
 
 static struct hdmi_platform_config hdmi_tx_8960_config = {
-               .phy_init = hdmi_phy_8960_init,
                HDMI_CFG(hpd_reg, 8960),
                HDMI_CFG(hpd_clk, 8960),
 };
@@ -391,7 +372,6 @@ static const char *hpd_clk_names_8x74[] = {"iface_clk", "core_clk", "mdp_core_cl
 static unsigned long hpd_clk_freq_8x74[] = {0, 19200000, 0};
 
 static struct hdmi_platform_config hdmi_tx_8974_config = {
-               .phy_init = hdmi_phy_8x74_init,
                HDMI_CFG(pwr_reg, 8x74),
                HDMI_CFG(hpd_reg, 8x74),
                HDMI_CFG(pwr_clk, 8x74),
@@ -402,7 +382,6 @@ static struct hdmi_platform_config hdmi_tx_8974_config = {
 static const char *hpd_reg_names_8084[] = {"hpd-gdsc", "hpd-5v", "hpd-5v-en"};
 
 static struct hdmi_platform_config hdmi_tx_8084_config = {
-               .phy_init = hdmi_phy_8x74_init,
                HDMI_CFG(pwr_reg, 8x74),
                HDMI_CFG(hpd_reg, 8084),
                HDMI_CFG(pwr_clk, 8x74),
@@ -411,7 +390,6 @@ static struct hdmi_platform_config hdmi_tx_8084_config = {
 };
 
 static struct hdmi_platform_config hdmi_tx_8994_config = {
-               .phy_init = NULL, /* nothing to do for this HDMI PHY 20nm */
                HDMI_CFG(pwr_reg, 8x74),
                HDMI_CFG(hpd_reg, none),
                HDMI_CFG(pwr_clk, 8x74),
@@ -420,7 +398,6 @@ static struct hdmi_platform_config hdmi_tx_8994_config = {
 };
 
 static struct hdmi_platform_config hdmi_tx_8996_config = {
-               .phy_init = NULL,
                HDMI_CFG(pwr_reg, none),
                HDMI_CFG(hpd_reg, none),
                HDMI_CFG(pwr_clk, 8x74),
index f8122cf099b11b91908691a21b235e4c672f71d8..1f498b017b9310304171f13b77f1b56cf84b8a63 100644 (file)
@@ -98,7 +98,6 @@ struct hdmi {
 
 /* platform config data (ie. from DT, or pdata) */
 struct hdmi_platform_config {
-       struct hdmi_phy *(*phy_init)(struct hdmi *hdmi);
        const char *mmio_name;
        const char *qfprom_mmio_name;
 
@@ -143,11 +142,6 @@ static inline u32 hdmi_qfprom_read(struct hdmi *hdmi, u32 reg)
 /*
  * hdmi phy:
  */
-struct hdmi_phy_funcs {
-       void (*destroy)(struct hdmi_phy *phy);
-       void (*powerup)(struct hdmi_phy *phy, unsigned long int pixclock);
-       void (*powerdown)(struct hdmi_phy *phy);
-};
 
 enum hdmi_phy_type {
        MSM_HDMI_PHY_8x60,
@@ -179,10 +173,6 @@ struct hdmi_phy {
        struct clk **clks;
 };
 
-struct hdmi_phy *hdmi_phy_8960_init(struct hdmi *hdmi);
-struct hdmi_phy *hdmi_phy_8x60_init(struct hdmi *hdmi);
-struct hdmi_phy *hdmi_phy_8x74_init(struct hdmi *hdmi);
-
 static inline void hdmi_phy_write(struct hdmi_phy *phy, u32 reg, u32 data)
 {
        msm_writel(data, phy->mmio + reg);
index 92b69ae8caf9c41c9c6cb80249ed726faafde5f8..310d92d06229c64a9dfa256c5208a245eaecc13b 100644 (file)
@@ -95,13 +95,13 @@ static void hdmi_bridge_pre_enable(struct drm_bridge *bridge)
        DBG("power up");
 
        if (!hdmi->power_on) {
+               hdmi_phy_resource_enable(phy);
                power_on(bridge);
                hdmi->power_on = true;
                hdmi_audio_update(hdmi);
        }
 
-       if (phy)
-               phy->funcs->powerup(phy, hdmi->pixclock);
+       hdmi_phy_powerup(phy, hdmi->pixclock);
 
        hdmi_set_mode(hdmi, true);
 
@@ -129,13 +129,13 @@ static void hdmi_bridge_post_disable(struct drm_bridge *bridge)
        DBG("power down");
        hdmi_set_mode(hdmi, false);
 
-       if (phy)
-               phy->funcs->powerdown(phy);
+       hdmi_phy_powerdown(phy);
 
        if (hdmi->power_on) {
                power_off(bridge);
                hdmi->power_on = false;
                hdmi_audio_update(hdmi);
+               hdmi_phy_resource_disable(phy);
        }
 }
 
index cbdd70085d12ee06f3e2fb847ec89dbab52dd630..46d449e84d713bd1e08e47df1635ea7bd2999d6b 100644 (file)
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifdef CONFIG_COMMON_CLK
-#include <linux/clk.h>
-#include <linux/clk-provider.h>
-#endif
-
 #include "hdmi.h"
 
-struct hdmi_phy_8960 {
-       struct hdmi_phy base;
-       struct hdmi *hdmi;
-#ifdef CONFIG_COMMON_CLK
-       struct clk_hw pll_hw;
-       struct clk *pll;
-       unsigned long pixclk;
-#endif
-};
-#define to_hdmi_phy_8960(x) container_of(x, struct hdmi_phy_8960, base)
-
-#ifdef CONFIG_COMMON_CLK
-#define clk_to_phy(x) container_of(x, struct hdmi_phy_8960, pll_hw)
-
-/*
- * HDMI PLL:
- *
- * To get the parent clock setup properly, we need to plug in hdmi pll
- * configuration into common-clock-framework.
- */
-
-struct pll_rate {
-       unsigned long rate;
-       struct {
-               uint32_t val;
-               uint32_t reg;
-       } conf[32];
-};
-
-/* NOTE: keep sorted highest freq to lowest: */
-static const struct pll_rate freqtbl[] = {
-       { 154000000, {
-               { 0x08, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x20, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0xf9, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x03, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x0d, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x4d, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x5e, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0x42, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0, 0 } }
-       },
-       /* 1080p60/1080p50 case */
-       { 148500000, {
-               { 0x02, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x02, REG_HDMI_8960_PHY_PLL_CHRG_PUMP_CFG },
-               { 0x01, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0x33, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x2c, REG_HDMI_8960_PHY_PLL_IDAC_ADJ_CFG  },
-               { 0x06, REG_HDMI_8960_PHY_PLL_I_VI_KVCO_CFG },
-               { 0x0a, REG_HDMI_8960_PHY_PLL_PWRDN_B       },
-               { 0x76, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x01, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x4c, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0xc0, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0x9a, REG_HDMI_8960_PHY_PLL_SSC_CFG0      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG1      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG2      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG3      },
-               { 0x10, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG0  },
-               { 0x1a, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG1  },
-               { 0x0d, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2  },
-               { 0xe6, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x33, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG6   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG7   },
-               { 0, 0 } }
-       },
-       { 108000000, {
-               { 0x08, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x21, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0xf9, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x1c, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x49, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x49, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0, 0 } }
-       },
-       /* 720p60/720p50/1080i60/1080i50/1080p24/1080p30/1080p25 */
-       { 74250000, {
-               { 0x0a, REG_HDMI_8960_PHY_PLL_PWRDN_B       },
-               { 0x12, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x01, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0x33, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x76, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0xe6, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0, 0 } }
-       },
-       { 74176000, {
-               { 0x18, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x20, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0xf9, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0xe5, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x0c, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x4c, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x7d, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0xbc, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0, 0 } }
-       },
-       { 65000000, {
-               { 0x18, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x20, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0xf9, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x8a, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x0b, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x4b, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x7b, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0x09, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0, 0 } }
-       },
-       /* 480p60/480i60 */
-       { 27030000, {
-               { 0x0a, REG_HDMI_8960_PHY_PLL_PWRDN_B       },
-               { 0x38, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x02, REG_HDMI_8960_PHY_PLL_CHRG_PUMP_CFG },
-               { 0x20, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0xff, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x4e, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0xd7, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0x03, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0x2a, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x03, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x33, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG6   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG7   },
-               { 0, 0 } }
-       },
-       /* 576p50/576i50 */
-       { 27000000, {
-               { 0x32, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x02, REG_HDMI_8960_PHY_PLL_CHRG_PUMP_CFG },
-               { 0x01, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0x33, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x2c, REG_HDMI_8960_PHY_PLL_IDAC_ADJ_CFG  },
-               { 0x06, REG_HDMI_8960_PHY_PLL_I_VI_KVCO_CFG },
-               { 0x0a, REG_HDMI_8960_PHY_PLL_PWRDN_B       },
-               { 0x7b, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x01, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x4c, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0xc0, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0x9a, REG_HDMI_8960_PHY_PLL_SSC_CFG0      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG1      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG2      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG3      },
-               { 0x10, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG0  },
-               { 0x1a, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG1  },
-               { 0x0d, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2  },
-               { 0x2a, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x03, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x33, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG6   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG7   },
-               { 0, 0 } }
-       },
-       /* 640x480p60 */
-       { 25200000, {
-               { 0x32, REG_HDMI_8960_PHY_PLL_REFCLK_CFG    },
-               { 0x02, REG_HDMI_8960_PHY_PLL_CHRG_PUMP_CFG },
-               { 0x01, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG0 },
-               { 0x33, REG_HDMI_8960_PHY_PLL_LOOP_FLT_CFG1 },
-               { 0x2c, REG_HDMI_8960_PHY_PLL_IDAC_ADJ_CFG  },
-               { 0x06, REG_HDMI_8960_PHY_PLL_I_VI_KVCO_CFG },
-               { 0x0a, REG_HDMI_8960_PHY_PLL_PWRDN_B       },
-               { 0x77, REG_HDMI_8960_PHY_PLL_SDM_CFG0      },
-               { 0x4c, REG_HDMI_8960_PHY_PLL_SDM_CFG1      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG2      },
-               { 0xc0, REG_HDMI_8960_PHY_PLL_SDM_CFG3      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SDM_CFG4      },
-               { 0x9a, REG_HDMI_8960_PHY_PLL_SSC_CFG0      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG1      },
-               { 0x00, REG_HDMI_8960_PHY_PLL_SSC_CFG2      },
-               { 0x20, REG_HDMI_8960_PHY_PLL_SSC_CFG3      },
-               { 0x10, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG0  },
-               { 0x1a, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG1  },
-               { 0x0d, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2  },
-               { 0xf4, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG0   },
-               { 0x02, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG1   },
-               { 0x3b, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG2   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG3   },
-               { 0x86, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG4   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG5   },
-               { 0x33, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG6   },
-               { 0x00, REG_HDMI_8960_PHY_PLL_VCOCAL_CFG7   },
-               { 0, 0 } }
-       },
-};
-
-static int hdmi_pll_enable(struct clk_hw *hw)
-{
-       struct hdmi_phy_8960 *phy_8960 = clk_to_phy(hw);
-       struct hdmi *hdmi = phy_8960->hdmi;
-       int timeout_count, pll_lock_retry = 10;
-       unsigned int val;
-
-       DBG("");
-
-       /* Assert PLL S/W reset */
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2, 0x8d);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG0, 0x10);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG1, 0x1a);
-
-       /* Wait for a short time before de-asserting
-        * to allow the hardware to complete its job.
-        * This much of delay should be fine for hardware
-        * to assert and de-assert.
-        */
-       udelay(10);
-
-       /* De-assert PLL S/W reset */
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2, 0x0d);
-
-       val = hdmi_read(hdmi, REG_HDMI_8960_PHY_REG12);
-       val |= HDMI_8960_PHY_REG12_SW_RESET;
-       /* Assert PHY S/W reset */
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG12, val);
-       val &= ~HDMI_8960_PHY_REG12_SW_RESET;
-       /* Wait for a short time before de-asserting
-          to allow the hardware to complete its job.
-          This much of delay should be fine for hardware
-          to assert and de-assert. */
-       udelay(10);
-       /* De-assert PHY S/W reset */
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG12, val);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG2,  0x3f);
-
-       val = hdmi_read(hdmi, REG_HDMI_8960_PHY_REG12);
-       val |= HDMI_8960_PHY_REG12_PWRDN_B;
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG12, val);
-       /* Wait 10 us for enabling global power for PHY */
-       mb();
-       udelay(10);
-
-       val = hdmi_read(hdmi, REG_HDMI_8960_PHY_PLL_PWRDN_B);
-       val |= HDMI_8960_PHY_PLL_PWRDN_B_PLL_PWRDN_B;
-       val &= ~HDMI_8960_PHY_PLL_PWRDN_B_PD_PLL;
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_PWRDN_B, val);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG2, 0x80);
-
-       timeout_count = 1000;
-       while (--pll_lock_retry > 0) {
-
-               /* are we there yet? */
-               val = hdmi_read(hdmi, REG_HDMI_8960_PHY_PLL_STATUS0);
-               if (val & HDMI_8960_PHY_PLL_STATUS0_PLL_LOCK)
-                       break;
-
-               udelay(1);
-
-               if (--timeout_count > 0)
-                       continue;
-
-               /*
-                * PLL has still not locked.
-                * Do a software reset and try again
-                * Assert PLL S/W reset first
-                */
-               hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2, 0x8d);
-               udelay(10);
-               hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_LOCKDET_CFG2, 0x0d);
-
-               /*
-                * Wait for a short duration for the PLL calibration
-                * before checking if the PLL gets locked
-                */
-               udelay(350);
-
-               timeout_count = 1000;
-       }
-
-       return 0;
-}
-
-static void hdmi_pll_disable(struct clk_hw *hw)
-{
-       struct hdmi_phy_8960 *phy_8960 = clk_to_phy(hw);
-       struct hdmi *hdmi = phy_8960->hdmi;
-       unsigned int val;
-
-       DBG("");
-
-       val = hdmi_read(hdmi, REG_HDMI_8960_PHY_REG12);
-       val &= ~HDMI_8960_PHY_REG12_PWRDN_B;
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG12, val);
-
-       val = hdmi_read(hdmi, REG_HDMI_8960_PHY_PLL_PWRDN_B);
-       val |= HDMI_8960_PHY_REG12_SW_RESET;
-       val &= ~HDMI_8960_PHY_REG12_PWRDN_B;
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_PLL_PWRDN_B, val);
-       /* Make sure HDMI PHY/PLL are powered down */
-       mb();
-}
-
-static const struct pll_rate *find_rate(unsigned long rate)
-{
-       int i;
-       for (i = 1; i < ARRAY_SIZE(freqtbl); i++)
-               if (rate > freqtbl[i].rate)
-                       return &freqtbl[i-1];
-       return &freqtbl[i-1];
-}
-
-static unsigned long hdmi_pll_recalc_rate(struct clk_hw *hw,
-                               unsigned long parent_rate)
-{
-       struct hdmi_phy_8960 *phy_8960 = clk_to_phy(hw);
-       return phy_8960->pixclk;
-}
-
-static long hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate,
-               unsigned long *parent_rate)
-{
-       const struct pll_rate *pll_rate = find_rate(rate);
-       return pll_rate->rate;
-}
-
-static int hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate,
-               unsigned long parent_rate)
-{
-       struct hdmi_phy_8960 *phy_8960 = clk_to_phy(hw);
-       struct hdmi *hdmi = phy_8960->hdmi;
-       const struct pll_rate *pll_rate = find_rate(rate);
-       int i;
-
-       DBG("rate=%lu", rate);
-
-       for (i = 0; pll_rate->conf[i].reg; i++)
-               hdmi_write(hdmi, pll_rate->conf[i].reg, pll_rate->conf[i].val);
-
-       phy_8960->pixclk = rate;
-
-       return 0;
-}
-
-
-static const struct clk_ops hdmi_pll_ops = {
-       .enable = hdmi_pll_enable,
-       .disable = hdmi_pll_disable,
-       .recalc_rate = hdmi_pll_recalc_rate,
-       .round_rate = hdmi_pll_round_rate,
-       .set_rate = hdmi_pll_set_rate,
-};
-
-static const char *hdmi_pll_parents[] = {
-       "pxo",
-};
-
-static struct clk_init_data pll_init = {
-       .name = "hdmi_pll",
-       .ops = &hdmi_pll_ops,
-       .parent_names = hdmi_pll_parents,
-       .num_parents = ARRAY_SIZE(hdmi_pll_parents),
-};
-#endif
-
-/*
- * HDMI Phy:
- */
-
-static void hdmi_phy_8960_destroy(struct hdmi_phy *phy)
-{
-       struct hdmi_phy_8960 *phy_8960 = to_hdmi_phy_8960(phy);
-       kfree(phy_8960);
-}
-
 static void hdmi_phy_8960_powerup(struct hdmi_phy *phy,
-               unsigned long int pixclock)
+                                 unsigned long int pixclock)
 {
-       struct hdmi_phy_8960 *phy_8960 = to_hdmi_phy_8960(phy);
-       struct hdmi *hdmi = phy_8960->hdmi;
-
        DBG("pixclock: %lu", pixclock);
 
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG2, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG0, 0x1b);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG1, 0xf2);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG4, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG5, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG6, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG7, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG8, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG9, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG10, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG11, 0x00);
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG3, 0x20);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG2, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG0, 0x1b);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG1, 0xf2);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG4, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG5, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG6, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG7, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG8, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG9, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG10, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG11, 0x00);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG3, 0x20);
 }
 
 static void hdmi_phy_8960_powerdown(struct hdmi_phy *phy)
 {
-       struct hdmi_phy_8960 *phy_8960 = to_hdmi_phy_8960(phy);
-       struct hdmi *hdmi = phy_8960->hdmi;
-
        DBG("");
 
-       hdmi_write(hdmi, REG_HDMI_8960_PHY_REG2, 0x7f);
+       hdmi_phy_write(phy, REG_HDMI_8960_PHY_REG2, 0x7f);
 }
 
-static const struct hdmi_phy_funcs hdmi_phy_8960_funcs = {
-               .destroy = hdmi_phy_8960_destroy,
-               .powerup = hdmi_phy_8960_powerup,
-               .powerdown = hdmi_phy_8960_powerdown,
-};
-
 static const char * const hdmi_phy_8960_reg_names[] = {
        "core-vdda",
 };
@@ -481,47 +60,3 @@ const struct hdmi_phy_cfg hdmi_phy_8960_cfg = {
        .clk_names = hdmi_phy_8960_clk_names,
        .num_clks = ARRAY_SIZE(hdmi_phy_8960_clk_names),
 };
-
-struct hdmi_phy *hdmi_phy_8960_init(struct hdmi *hdmi)
-{
-       struct hdmi_phy_8960 *phy_8960;
-       struct hdmi_phy *phy = NULL;
-       int ret;
-#ifdef CONFIG_COMMON_CLK
-       int i;
-
-       /* sanity check: */
-       for (i = 0; i < (ARRAY_SIZE(freqtbl) - 1); i++)
-               if (WARN_ON(freqtbl[i].rate < freqtbl[i+1].rate))
-                       return ERR_PTR(-EINVAL);
-#endif
-
-       phy_8960 = kzalloc(sizeof(*phy_8960), GFP_KERNEL);
-       if (!phy_8960) {
-               ret = -ENOMEM;
-               goto fail;
-       }
-
-       phy = &phy_8960->base;
-
-       phy->funcs = &hdmi_phy_8960_funcs;
-
-       phy_8960->hdmi = hdmi;
-
-#ifdef CONFIG_COMMON_CLK
-       phy_8960->pll_hw.init = &pll_init;
-       phy_8960->pll = devm_clk_register(&hdmi->pdev->dev, &phy_8960->pll_hw);
-       if (IS_ERR(phy_8960->pll)) {
-               ret = PTR_ERR(phy_8960->pll);
-               phy_8960->pll = NULL;
-               goto fail;
-       }
-#endif
-
-       return phy;
-
-fail:
-       if (phy)
-               hdmi_phy_8960_destroy(phy);
-       return ERR_PTR(ret);
-}
index d529164f938db8fdd0e24caf488be7159cb75846..38022b3af8c1a015b9806d9c5062e4951d63862a 100644 (file)
 
 #include "hdmi.h"
 
-struct hdmi_phy_8x60 {
-       struct hdmi_phy base;
-       struct hdmi *hdmi;
-};
-#define to_hdmi_phy_8x60(x) container_of(x, struct hdmi_phy_8x60, base)
-
-static void hdmi_phy_8x60_destroy(struct hdmi_phy *phy)
-{
-       struct hdmi_phy_8x60 *phy_8x60 = to_hdmi_phy_8x60(phy);
-       kfree(phy_8x60);
-}
-
 static void hdmi_phy_8x60_powerup(struct hdmi_phy *phy,
                unsigned long int pixclock)
 {
-       struct hdmi_phy_8x60 *phy_8x60 = to_hdmi_phy_8x60(phy);
-       struct hdmi *hdmi = phy_8x60->hdmi;
-
        /* De-serializer delay D/C for non-lbk mode: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG0,
-                       HDMI_8x60_PHY_REG0_DESER_DEL_CTRL(3));
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG0,
+                      HDMI_8x60_PHY_REG0_DESER_DEL_CTRL(3));
 
        if (pixclock == 27000000) {
                /* video_format == HDMI_VFRMT_720x480p60_16_9 */
-               hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG1,
-                               HDMI_8x60_PHY_REG1_DTEST_MUX_SEL(5) |
-                               HDMI_8x60_PHY_REG1_OUTVOL_SWING_CTRL(3));
+               hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG1,
+                              HDMI_8x60_PHY_REG1_DTEST_MUX_SEL(5) |
+                              HDMI_8x60_PHY_REG1_OUTVOL_SWING_CTRL(3));
        } else {
-               hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG1,
-                               HDMI_8x60_PHY_REG1_DTEST_MUX_SEL(5) |
-                               HDMI_8x60_PHY_REG1_OUTVOL_SWING_CTRL(4));
+               hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG1,
+                              HDMI_8x60_PHY_REG1_DTEST_MUX_SEL(5) |
+                              HDMI_8x60_PHY_REG1_OUTVOL_SWING_CTRL(4));
        }
 
        /* No matter what, start from the power down mode: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_PD_PWRGEN |
-                       HDMI_8x60_PHY_REG2_PD_PLL |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
-                       HDMI_8x60_PHY_REG2_PD_DESER);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_PD_PWRGEN |
+                      HDMI_8x60_PHY_REG2_PD_PLL |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
+                      HDMI_8x60_PHY_REG2_PD_DESER);
 
        /* Turn PowerGen on: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_PD_PLL |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
-                       HDMI_8x60_PHY_REG2_PD_DESER);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_PD_PLL |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
+                      HDMI_8x60_PHY_REG2_PD_DESER);
 
        /* Turn PLL power on: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
-                       HDMI_8x60_PHY_REG2_PD_DESER);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
+                      HDMI_8x60_PHY_REG2_PD_DESER);
 
        /* Write to HIGH after PLL power down de-assert: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG3,
-                       HDMI_8x60_PHY_REG3_PLL_ENABLE);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG3,
+                      HDMI_8x60_PHY_REG3_PLL_ENABLE);
 
        /* ASIC power on; PHY REG9 = 0 */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG9, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG9, 0);
 
        /* Enable PLL lock detect, PLL lock det will go high after lock
         * Enable the re-time logic
         */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG12,
-                       HDMI_8x60_PHY_REG12_RETIMING_EN |
-                       HDMI_8x60_PHY_REG12_PLL_LOCK_DETECT_EN);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG12,
+                      HDMI_8x60_PHY_REG12_RETIMING_EN |
+                      HDMI_8x60_PHY_REG12_PLL_LOCK_DETECT_EN);
 
        /* Drivers are on: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_PD_DESER);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_PD_DESER);
 
        /* If the RX detector is needed: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_RCV_SENSE_EN |
-                       HDMI_8x60_PHY_REG2_PD_DESER);
-
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG4, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG5, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG6, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG7, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG8, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG9, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG10, 0);
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG11, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_RCV_SENSE_EN |
+                      HDMI_8x60_PHY_REG2_PD_DESER);
+
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG4, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG5, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG6, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG7, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG8, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG9, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG10, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG11, 0);
 
        /* If we want to use lock enable based on counting: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG12,
-                       HDMI_8x60_PHY_REG12_RETIMING_EN |
-                       HDMI_8x60_PHY_REG12_PLL_LOCK_DETECT_EN |
-                       HDMI_8x60_PHY_REG12_FORCE_LOCK);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG12,
+                      HDMI_8x60_PHY_REG12_RETIMING_EN |
+                      HDMI_8x60_PHY_REG12_PLL_LOCK_DETECT_EN |
+                      HDMI_8x60_PHY_REG12_FORCE_LOCK);
 }
 
 static void hdmi_phy_8x60_powerdown(struct hdmi_phy *phy)
 {
-       struct hdmi_phy_8x60 *phy_8x60 = to_hdmi_phy_8x60(phy);
-       struct hdmi *hdmi = phy_8x60->hdmi;
-
        /* Assert RESET PHY from controller */
-       hdmi_write(hdmi, REG_HDMI_PHY_CTRL,
-                       HDMI_PHY_CTRL_SW_RESET);
+       hdmi_phy_write(phy, REG_HDMI_PHY_CTRL,
+                      HDMI_PHY_CTRL_SW_RESET);
        udelay(10);
        /* De-assert RESET PHY from controller */
-       hdmi_write(hdmi, REG_HDMI_PHY_CTRL, 0);
+       hdmi_phy_write(phy, REG_HDMI_PHY_CTRL, 0);
        /* Turn off Driver */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
-                       HDMI_8x60_PHY_REG2_PD_DESER);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
+                      HDMI_8x60_PHY_REG2_PD_DESER);
        udelay(10);
        /* Disable PLL */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG3, 0);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG3, 0);
        /* Power down PHY, but keep RX-sense: */
-       hdmi_write(hdmi, REG_HDMI_8x60_PHY_REG2,
-                       HDMI_8x60_PHY_REG2_RCV_SENSE_EN |
-                       HDMI_8x60_PHY_REG2_PD_PWRGEN |
-                       HDMI_8x60_PHY_REG2_PD_PLL |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
-                       HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
-                       HDMI_8x60_PHY_REG2_PD_DESER);
+       hdmi_phy_write(phy, REG_HDMI_8x60_PHY_REG2,
+                      HDMI_8x60_PHY_REG2_RCV_SENSE_EN |
+                      HDMI_8x60_PHY_REG2_PD_PWRGEN |
+                      HDMI_8x60_PHY_REG2_PD_PLL |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_4 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_3 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_2 |
+                      HDMI_8x60_PHY_REG2_PD_DRIVE_1 |
+                      HDMI_8x60_PHY_REG2_PD_DESER);
 }
 
-static const struct hdmi_phy_funcs hdmi_phy_8x60_funcs = {
-               .destroy = hdmi_phy_8x60_destroy,
-               .powerup = hdmi_phy_8x60_powerup,
-               .powerdown = hdmi_phy_8x60_powerdown,
-};
-
 const struct hdmi_phy_cfg hdmi_phy_8x60_cfg = {
        .type = MSM_HDMI_PHY_8x60,
        .powerup = hdmi_phy_8x60_powerup,
        .powerdown = hdmi_phy_8x60_powerdown,
 };
-
-struct hdmi_phy *hdmi_phy_8x60_init(struct hdmi *hdmi)
-{
-       struct hdmi_phy_8x60 *phy_8x60;
-       struct hdmi_phy *phy = NULL;
-       int ret;
-
-       phy_8x60 = kzalloc(sizeof(*phy_8x60), GFP_KERNEL);
-       if (!phy_8x60) {
-               ret = -ENOMEM;
-               goto fail;
-       }
-
-       phy = &phy_8x60->base;
-
-       phy->funcs = &hdmi_phy_8x60_funcs;
-
-       phy_8x60->hdmi = hdmi;
-
-       return phy;
-
-fail:
-       if (phy)
-               hdmi_phy_8x60_destroy(phy);
-       return ERR_PTR(ret);
-}
index 5e42d92f3699b15e9c6065075a08f7b9ca7f7297..145e38eb17e253abab52de413cc61aee4a086338 100644 (file)
 
 #include "hdmi.h"
 
-struct hdmi_phy_8x74 {
-       struct hdmi_phy base;
-       void __iomem *mmio;
-};
-#define to_hdmi_phy_8x74(x) container_of(x, struct hdmi_phy_8x74, base)
-
-
-static void phy_write(struct hdmi_phy_8x74 *phy, u32 reg, u32 data)
-{
-       msm_writel(data, phy->mmio + reg);
-}
-
-//static u32 phy_read(struct hdmi_phy_8x74 *phy, u32 reg)
-//{
-//     return msm_readl(phy->mmio + reg);
-//}
-
-static void hdmi_phy_8x74_destroy(struct hdmi_phy *phy)
-{
-       struct hdmi_phy_8x74 *phy_8x74 = to_hdmi_phy_8x74(phy);
-       kfree(phy_8x74);
-}
-
 static void hdmi_phy_8x74_powerup(struct hdmi_phy *phy,
                unsigned long int pixclock)
 {
-       struct hdmi_phy_8x74 *phy_8x74 = to_hdmi_phy_8x74(phy);
-
-       phy_write(phy_8x74, REG_HDMI_8x74_ANA_CFG0,   0x1b);
-       phy_write(phy_8x74, REG_HDMI_8x74_ANA_CFG1,   0xf2);
-       phy_write(phy_8x74, REG_HDMI_8x74_BIST_CFG0,  0x0);
-       phy_write(phy_8x74, REG_HDMI_8x74_BIST_PATN0, 0x0);
-       phy_write(phy_8x74, REG_HDMI_8x74_BIST_PATN1, 0x0);
-       phy_write(phy_8x74, REG_HDMI_8x74_BIST_PATN2, 0x0);
-       phy_write(phy_8x74, REG_HDMI_8x74_BIST_PATN3, 0x0);
-       phy_write(phy_8x74, REG_HDMI_8x74_PD_CTRL1,   0x20);
+       hdmi_phy_write(phy, REG_HDMI_8x74_ANA_CFG0,   0x1b);
+       hdmi_phy_write(phy, REG_HDMI_8x74_ANA_CFG1,   0xf2);
+       hdmi_phy_write(phy, REG_HDMI_8x74_BIST_CFG0,  0x0);
+       hdmi_phy_write(phy, REG_HDMI_8x74_BIST_PATN0, 0x0);
+       hdmi_phy_write(phy, REG_HDMI_8x74_BIST_PATN1, 0x0);
+       hdmi_phy_write(phy, REG_HDMI_8x74_BIST_PATN2, 0x0);
+       hdmi_phy_write(phy, REG_HDMI_8x74_BIST_PATN3, 0x0);
+       hdmi_phy_write(phy, REG_HDMI_8x74_PD_CTRL1,   0x20);
 }
 
 static void hdmi_phy_8x74_powerdown(struct hdmi_phy *phy)
 {
-       struct hdmi_phy_8x74 *phy_8x74 = to_hdmi_phy_8x74(phy);
-       phy_write(phy_8x74, REG_HDMI_8x74_PD_CTRL0, 0x7f);
+       hdmi_phy_write(phy, REG_HDMI_8x74_PD_CTRL0, 0x7f);
 }
 
-static const struct hdmi_phy_funcs hdmi_phy_8x74_funcs = {
-               .destroy = hdmi_phy_8x74_destroy,
-               .powerup = hdmi_phy_8x74_powerup,
-               .powerdown = hdmi_phy_8x74_powerdown,
-};
-
 static const char * const hdmi_phy_8x74_reg_names[] = {
        "core-vdda",
        "vddio",
@@ -86,35 +54,3 @@ const struct hdmi_phy_cfg hdmi_phy_8x74_cfg = {
        .clk_names = hdmi_phy_8x74_clk_names,
        .num_clks = ARRAY_SIZE(hdmi_phy_8x74_clk_names),
 };
-
-struct hdmi_phy *hdmi_phy_8x74_init(struct hdmi *hdmi)
-{
-       struct hdmi_phy_8x74 *phy_8x74;
-       struct hdmi_phy *phy = NULL;
-       int ret;
-
-       phy_8x74 = kzalloc(sizeof(*phy_8x74), GFP_KERNEL);
-       if (!phy_8x74) {
-               ret = -ENOMEM;
-               goto fail;
-       }
-
-       phy = &phy_8x74->base;
-
-       phy->funcs = &hdmi_phy_8x74_funcs;
-
-       /* for 8x74, the phy mmio is mapped separately: */
-       phy_8x74->mmio = msm_ioremap(hdmi->pdev,
-                       "phy_physical", "HDMI_8x74");
-       if (IS_ERR(phy_8x74->mmio)) {
-               ret = PTR_ERR(phy_8x74->mmio);
-               goto fail;
-       }
-
-       return phy;
-
-fail:
-       if (phy)
-               hdmi_phy_8x74_destroy(phy);
-       return ERR_PTR(ret);
-}