drivers/gpu/drm/msm/hdmi/hdmi.h

   1 /*
   2  * Copyright (C) 2013 Red Hat
   3  * Author: Rob Clark <robdclark@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef __HDMI_CONNECTOR_H__
  19 #define __HDMI_CONNECTOR_H__
  20
  21 #include <linux/i2c.h>
  22 #include <linux/clk.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/regulator/consumer.h>
  25 #include <linux/hdmi.h>
  26
  27 #include "msm_drv.h"
  28 #include "hdmi.xml.h"
  29
  30
  31 struct hdmi_phy;
  32 struct hdmi_platform_config;
  33
  34 struct hdmi_audio {
  35         bool enabled;
  36         struct hdmi_audio_infoframe infoframe;
  37         int rate;
  38 };
  39
  40 struct hdmi_hdcp_ctrl;
  41
  42 struct hdmi {
  43         struct drm_device *dev;
  44         struct platform_device *pdev;
  45
  46         const struct hdmi_platform_config *config;
  47
  48         /* audio state: */
  49         struct hdmi_audio audio;
  50
  51         /* video state: */
  52         bool power_on;
  53         unsigned long int pixclock;
  54
  55         void __iomem *mmio;
  56         void __iomem *qfprom_mmio;
  57         phys_addr_t mmio_phy_addr;
  58
  59         struct regulator **hpd_regs;
  60         struct regulator **pwr_regs;
  61         struct clk **hpd_clks;
  62         struct clk **pwr_clks;
  63
  64         struct hdmi_phy *phy;
  65         struct i2c_adapter *i2c;
  66         struct drm_connector *connector;
  67         struct drm_bridge *bridge;
  68
  69         /* the encoder we are hooked to (outside of hdmi block) */
  70         struct drm_encoder *encoder;
  71
  72         bool hdmi_mode;               /* are we in hdmi mode? */
  73
  74         int irq;
  75         struct workqueue_struct *workq;
  76
  77         struct hdmi_hdcp_ctrl *hdcp_ctrl;
  78
  79         /*
  80         * spinlock to protect registers shared by different execution
  81         * REG_HDMI_CTRL
  82         * REG_HDMI_DDC_ARBITRATION
  83         * REG_HDMI_HDCP_INT_CTRL
  84         * REG_HDMI_HPD_CTRL
  85         */
  86         spinlock_t reg_lock;
  87 };
  88
  89 /* platform config data (ie. from DT, or pdata) */
  90 struct hdmi_platform_config {
  91         struct hdmi_phy *(*phy_init)(struct hdmi *hdmi);
  92         const char *mmio_name;
  93         const char *qfprom_mmio_name;
  94
  95         /* regulators that need to be on for hpd: */
  96         const char **hpd_reg_names;
  97         int hpd_reg_cnt;
  98
  99         /* regulators that need to be on for screen pwr: */
 100         const char **pwr_reg_names;
 101         int pwr_reg_cnt;
 102
 103         /* clks that need to be on for hpd: */
 104         const char **hpd_clk_names;
 105         const long unsigned *hpd_freq;
 106         int hpd_clk_cnt;
 107
 108         /* clks that need to be on for screen pwr (ie pixel clk): */
 109         const char **pwr_clk_names;
 110         int pwr_clk_cnt;
 111
 112         /* gpio's: */
 113         int ddc_clk_gpio, ddc_data_gpio, hpd_gpio, mux_en_gpio, mux_sel_gpio;
 114         int mux_lpm_gpio;
 115 };
 116
 117 void hdmi_set_mode(struct hdmi *hdmi, bool power_on);
 118
 119 static inline void hdmi_write(struct hdmi *hdmi, u32 reg, u32 data)
 120 {
 121         msm_writel(data, hdmi->mmio + reg);
 122 }
 123
 124 static inline u32 hdmi_read(struct hdmi *hdmi, u32 reg)
 125 {
 126         return msm_readl(hdmi->mmio + reg);
 127 }
 128
 129 static inline u32 hdmi_qfprom_read(struct hdmi *hdmi, u32 reg)
 130 {
 131         return msm_readl(hdmi->qfprom_mmio + reg);
 132 }
 133
 134 /*
 135  * The phy appears to be different, for example between 8960 and 8x60,
 136  * so split the phy related functions out and load the correct one at
 137  * runtime:
 138  */
 139
 140 struct hdmi_phy_funcs {
 141         void (*destroy)(struct hdmi_phy *phy);
 142         void (*powerup)(struct hdmi_phy *phy, unsigned long int pixclock);
 143         void (*powerdown)(struct hdmi_phy *phy);
 144 };
 145
 146 struct hdmi_phy {
 147         const struct hdmi_phy_funcs *funcs;
 148 };
 149
 150 struct hdmi_phy *hdmi_phy_8960_init(struct hdmi *hdmi);
 151 struct hdmi_phy *hdmi_phy_8x60_init(struct hdmi *hdmi);
 152 struct hdmi_phy *hdmi_phy_8x74_init(struct hdmi *hdmi);
 153
 154 /*
 155  * audio:
 156  */
 157
 158 int hdmi_audio_update(struct hdmi *hdmi);
 159 int hdmi_audio_info_setup(struct hdmi *hdmi, bool enabled,
 160         uint32_t num_of_channels, uint32_t channel_allocation,
 161         uint32_t level_shift, bool down_mix);
 162 void hdmi_audio_set_sample_rate(struct hdmi *hdmi, int rate);
 163
 164
 165 /*
 166  * hdmi bridge:
 167  */
 168
 169 struct drm_bridge *hdmi_bridge_init(struct hdmi *hdmi);
 170 void hdmi_bridge_destroy(struct drm_bridge *bridge);
 171
 172 /*
 173  * hdmi connector:
 174  */
 175
 176 void hdmi_connector_irq(struct drm_connector *connector);
 177 struct drm_connector *hdmi_connector_init(struct hdmi *hdmi);
 178
 179 /*
 180  * i2c adapter for ddc:
 181  */
 182
 183 void hdmi_i2c_irq(struct i2c_adapter *i2c);
 184 void hdmi_i2c_destroy(struct i2c_adapter *i2c);
 185 struct i2c_adapter *hdmi_i2c_init(struct hdmi *hdmi);
 186
 187 /*
 188  * hdcp
 189  */
 190 struct hdmi_hdcp_ctrl *hdmi_hdcp_init(struct hdmi *hdmi);
 191 void hdmi_hdcp_destroy(struct hdmi *hdmi);
 192 void hdmi_hdcp_on(struct hdmi_hdcp_ctrl *hdcp_ctrl);
 193 void hdmi_hdcp_off(struct hdmi_hdcp_ctrl *hdcp_ctrl);
 194 void hdmi_hdcp_irq(struct hdmi_hdcp_ctrl *hdcp_ctrl);
 195
 196 #endif /* __HDMI_CONNECTOR_H__ */