Add necessary glue code to be able to use new HDMI codec framework from
the DRM bridge drivers. The drm_bridge implements a limited set of the
hdmi_codec_ops interface, with the functions accepting both
drm_connector and drm_bridge instead of just a generic void pointer.

This framework is integrated with the DRM HDMI Connector framework, but
can also be used for DisplayPort connectors.

Signed-off-by: Dmitry Baryshkov <dmitry.barysh...@linaro.org>
---
 drivers/gpu/drm/display/drm_bridge_connector.c | 95 +++++++++++++++++++++++++-
 include/drm/drm_bridge.h                       | 23 +++++++
 2 files changed, 116 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/display/drm_bridge_connector.c 
b/drivers/gpu/drm/display/drm_bridge_connector.c
index 
320c297008aaa8b6ef5b1f4c71928849b202e8ac..12ab9f14cc8a8672478ae2804c9a68d766d88ea5
 100644
--- a/drivers/gpu/drm/display/drm_bridge_connector.c
+++ b/drivers/gpu/drm/display/drm_bridge_connector.c
@@ -20,6 +20,8 @@
 #include <drm/drm_probe_helper.h>
 #include <drm/display/drm_hdmi_state_helper.h>
 
+#include <sound/hdmi-codec.h>
+
 /**
  * DOC: overview
  *
@@ -354,10 +356,80 @@ static int drm_bridge_connector_write_infoframe(struct 
drm_connector *connector,
        return bridge->funcs->hdmi_write_infoframe(bridge, type, buffer, len);
 }
 
+static int drm_bridge_connector_audio_startup(struct drm_connector *connector)
+{
+       struct drm_bridge_connector *bridge_connector =
+               to_drm_bridge_connector(connector);
+       struct drm_bridge *bridge;
+
+       bridge = bridge_connector->bridge_hdmi;
+       if (!bridge)
+               return -EINVAL;
+
+       if (bridge->funcs->hdmi_codec_audio_startup)
+               return bridge->funcs->hdmi_codec_audio_startup(connector, 
bridge);
+       else
+               return 0;
+}
+
+static int drm_bridge_connector_prepare(struct drm_connector *connector,
+                                       struct hdmi_codec_daifmt *fmt,
+                                       struct hdmi_codec_params *hparms)
+{
+       struct drm_bridge_connector *bridge_connector =
+               to_drm_bridge_connector(connector);
+       struct drm_bridge *bridge;
+
+       bridge = bridge_connector->bridge_hdmi;
+       if (!bridge)
+               return -EINVAL;
+
+       return bridge->funcs->hdmi_codec_prepare(connector, bridge, fmt, 
hparms);
+}
+
+static void drm_bridge_connector_audio_shutdown(struct drm_connector 
*connector)
+{
+       struct drm_bridge_connector *bridge_connector =
+               to_drm_bridge_connector(connector);
+       struct drm_bridge *bridge;
+
+       bridge = bridge_connector->bridge_hdmi;
+       if (!bridge)
+               return;
+
+       bridge->funcs->hdmi_codec_audio_shutdown(connector, bridge);
+}
+
+static int drm_bridge_connector_mute_stream(struct drm_connector *connector,
+                                           bool enable, int direction)
+{
+       struct drm_bridge_connector *bridge_connector =
+               to_drm_bridge_connector(connector);
+       struct drm_bridge *bridge;
+
+       bridge = bridge_connector->bridge_hdmi;
+       if (!bridge)
+               return -EINVAL;
+
+       if (bridge->funcs->hdmi_codec_mute_stream)
+               return bridge->funcs->hdmi_codec_mute_stream(connector, bridge,
+                                                            enable, direction);
+       else
+               return -ENOTSUPP;
+}
+
+static const struct drm_connector_hdmi_codec_funcs 
drm_bridge_connector_hdmi_codec_funcs = {
+       .audio_startup = drm_bridge_connector_audio_startup,
+       .prepare = drm_bridge_connector_prepare,
+       .audio_shutdown = drm_bridge_connector_audio_shutdown,
+       .mute_stream = drm_bridge_connector_mute_stream,
+};
+
 static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = 
{
        .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid,
        .clear_infoframe = drm_bridge_connector_clear_infoframe,
        .write_infoframe = drm_bridge_connector_write_infoframe,
+       .codec_funcs = &drm_bridge_connector_hdmi_codec_funcs,
 };
 
 /* 
-----------------------------------------------------------------------------
@@ -459,7 +531,25 @@ struct drm_connector *drm_bridge_connector_init(struct 
drm_device *drm,
        if (connector_type == DRM_MODE_CONNECTOR_Unknown)
                return ERR_PTR(-EINVAL);
 
-       if (bridge_connector->bridge_hdmi)
+       if (bridge_connector->bridge_hdmi) {
+               bridge = bridge_connector->bridge_hdmi;
+
+               if (bridge->hdmi_codec_i2s ||
+                   bridge->hdmi_codec_spdif) {
+                       if (!bridge->funcs->hdmi_codec_prepare ||
+                           !bridge->funcs->hdmi_codec_audio_shutdown)
+                               return ERR_PTR(-EINVAL);
+
+                       bridge_connector->bridge_hdmi = bridge;
+
+                       connector->hdmi_codec.dev = bridge->hdmi_codec_dev;
+                       connector->hdmi_codec.i2s = bridge->hdmi_codec_i2s;
+                       connector->hdmi_codec.spdif = bridge->hdmi_codec_spdif;
+                       connector->hdmi_codec.max_i2s_channels =
+                               bridge->hdmi_codec_max_i2s_channels;
+                       connector->hdmi_codec.sound_dai_port = 
bridge->hdmi_codec_dai_port;
+               }
+
                ret = drmm_connector_hdmi_init(drm, connector,
                                               
bridge_connector->bridge_hdmi->vendor,
                                               
bridge_connector->bridge_hdmi->product,
@@ -468,10 +558,11 @@ struct drm_connector *drm_bridge_connector_init(struct 
drm_device *drm,
                                               connector_type, ddc,
                                               supported_formats,
                                               max_bpc);
-       else
+       } else {
                ret = drmm_connector_init(drm, connector,
                                          &drm_bridge_connector_funcs,
                                          connector_type, ddc);
+       }
        if (ret)
                return ERR_PTR(ret);
 
diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h
index 
e8d735b7f6a480468c88287e2517b387ceec0f22..0ef9580ef6669f84327bdcb85a24fc83f76541bb
 100644
--- a/include/drm/drm_bridge.h
+++ b/include/drm/drm_bridge.h
@@ -41,6 +41,8 @@ struct drm_display_info;
 struct drm_minor;
 struct drm_panel;
 struct edid;
+struct hdmi_codec_daifmt;
+struct hdmi_codec_params;
 struct i2c_adapter;
 
 /**
@@ -676,6 +678,21 @@ struct drm_bridge_funcs {
                                    enum hdmi_infoframe_type type,
                                    const u8 *buffer, size_t len);
 
+       int (*hdmi_codec_audio_startup)(struct drm_connector *connector,
+                                       struct drm_bridge *bridge);
+
+       int (*hdmi_codec_prepare)(struct drm_connector *connector,
+                                 struct drm_bridge *bridge,
+                                 struct hdmi_codec_daifmt *fmt,
+                                 struct hdmi_codec_params *hparms);
+
+       void (*hdmi_codec_audio_shutdown)(struct drm_connector *connector,
+                                         struct drm_bridge *bridge);
+
+       int (*hdmi_codec_mute_stream)(struct drm_connector *connector,
+                                     struct drm_bridge *bridge,
+                                     bool enable, int direction);
+
        /**
         * @debugfs_init:
         *
@@ -859,6 +876,12 @@ struct drm_bridge {
         * @DRM_BRIDGE_OP_HDMI is set.
         */
        unsigned int max_bpc;
+
+       struct device *hdmi_codec_dev;
+       int hdmi_codec_max_i2s_channels;
+       unsigned int hdmi_codec_i2s : 1;
+       unsigned int hdmi_codec_spdif : 1;
+       int hdmi_codec_dai_port;
 };
 
 static inline struct drm_bridge *

-- 
2.39.5

Reply via email to