drm_bridge.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */
 
#ifndef __DRM_BRIDGE_H__
#define __DRM_BRIDGE_H__
 
#include <linux/cleanup.h>
#include <linux/ctype.h>
#include <linux/list.h>
#include <linux/mutex.h>
 
#include <drm/drm_atomic.h>
#include <drm/drm_encoder.h>
#include <drm/drm_mode_object.h>
#include <drm/drm_modes.h>
 
struct cec_msg;
struct device_node;
 
struct drm_bridge;
struct drm_bridge_timings;
struct drm_connector;
struct drm_display_info;
struct drm_minor;
struct drm_panel;
struct edid;
struct hdmi_codec_daifmt;
struct hdmi_codec_params;
struct i2c_adapter;
 
enum drm_bridge_attach_flags {
    DRM_BRIDGE_ATTACH_NO_CONNECTOR = BIT(0),
};
 
struct drm_bridge_funcs {
    int (*attach)(struct drm_bridge *bridge, struct drm_encoder *encoder,
              enum drm_bridge_attach_flags flags);
 
    void (*destroy)(struct drm_bridge *bridge);
 
    void (*detach)(struct drm_bridge *bridge);
 
    enum drm_mode_status (*mode_valid)(struct drm_bridge *bridge,
                       const struct drm_display_info *info,
                       const struct drm_display_mode *mode);
 
    bool (*mode_fixup)(struct drm_bridge *bridge,
               const struct drm_display_mode *mode,
               struct drm_display_mode *adjusted_mode);
    void (*disable)(struct drm_bridge *bridge);
 
    void (*post_disable)(struct drm_bridge *bridge);
 
    void (*mode_set)(struct drm_bridge *bridge,
             const struct drm_display_mode *mode,
             const struct drm_display_mode *adjusted_mode);
    void (*pre_enable)(struct drm_bridge *bridge);
 
    void (*enable)(struct drm_bridge *bridge);
 
    void (*atomic_pre_enable)(struct drm_bridge *bridge,
                  struct drm_atomic_commit *state);
 
    void (*atomic_enable)(struct drm_bridge *bridge,
                  struct drm_atomic_commit *state);
    void (*atomic_disable)(struct drm_bridge *bridge,
                   struct drm_atomic_commit *state);
 
    void (*atomic_post_disable)(struct drm_bridge *bridge,
                    struct drm_atomic_commit *state);
 
    struct drm_bridge_state *(*atomic_duplicate_state)(struct drm_bridge *bridge);
 
    void (*atomic_destroy_state)(struct drm_bridge *bridge,
                     struct drm_bridge_state *state);
 
    u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge,
                       struct drm_bridge_state *bridge_state,
                       struct drm_crtc_state *crtc_state,
                       struct drm_connector_state *conn_state,
                       unsigned int *num_output_fmts);
 
    u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge,
                      struct drm_bridge_state *bridge_state,
                      struct drm_crtc_state *crtc_state,
                      struct drm_connector_state *conn_state,
                      u32 output_fmt,
                      unsigned int *num_input_fmts);
 
    int (*atomic_check)(struct drm_bridge *bridge,
                struct drm_bridge_state *bridge_state,
                struct drm_crtc_state *crtc_state,
                struct drm_connector_state *conn_state);
 
    struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge);
 
    enum drm_connector_status (*detect)(struct drm_bridge *bridge,
                        struct drm_connector *connector);
 
    int (*get_modes)(struct drm_bridge *bridge,
             struct drm_connector *connector);
 
    const struct drm_edid *(*edid_read)(struct drm_bridge *bridge,
                        struct drm_connector *connector);
 
    void (*hpd_notify)(struct drm_bridge *bridge,
               struct drm_connector *connector,
               enum drm_connector_status status);
 
    void (*hpd_enable)(struct drm_bridge *bridge);
 
    void (*hpd_disable)(struct drm_bridge *bridge);
 
    enum drm_mode_status
    (*hdmi_tmds_char_rate_valid)(const struct drm_bridge *bridge,
                     const struct drm_display_mode *mode,
                     unsigned long long tmds_rate);
 
    int (*hdmi_clear_avi_infoframe)(struct drm_bridge *bridge);
 
    int (*hdmi_write_avi_infoframe)(struct drm_bridge *bridge,
                    const u8 *buffer, size_t len);
 
    int (*hdmi_clear_hdmi_infoframe)(struct drm_bridge *bridge);
 
    int (*hdmi_write_hdmi_infoframe)(struct drm_bridge *bridge,
                        const u8 *buffer, size_t len);
 
    int (*hdmi_clear_hdr_drm_infoframe)(struct drm_bridge *bridge);
 
    int (*hdmi_write_hdr_drm_infoframe)(struct drm_bridge *bridge,
                    const u8 *buffer, size_t len);
 
    int (*hdmi_clear_spd_infoframe)(struct drm_bridge *bridge);
 
    int (*hdmi_write_spd_infoframe)(struct drm_bridge *bridge,
                    const u8 *buffer, size_t len);
 
    int (*hdmi_clear_audio_infoframe)(struct drm_bridge *bridge);
 
    int (*hdmi_write_audio_infoframe)(struct drm_bridge *bridge,
                      const u8 *buffer, size_t len);
 
    int (*hdmi_audio_startup)(struct drm_bridge *bridge,
                  struct drm_connector *connector);
 
    int (*hdmi_audio_prepare)(struct drm_bridge *bridge,
                  struct drm_connector *connector,
                  struct hdmi_codec_daifmt *fmt,
                  struct hdmi_codec_params *hparms);
 
    void (*hdmi_audio_shutdown)(struct drm_bridge *bridge,
                    struct drm_connector *connector);
 
    int (*hdmi_audio_mute_stream)(struct drm_bridge *bridge,
                      struct drm_connector *connector,
                      bool enable, int direction);
 
    int (*hdmi_cec_init)(struct drm_bridge *bridge,
                 struct drm_connector *connector);
 
    int (*hdmi_cec_enable)(struct drm_bridge *bridge, bool enable);
 
    int (*hdmi_cec_log_addr)(struct drm_bridge *bridge, u8 logical_addr);
 
    int (*hdmi_cec_transmit)(struct drm_bridge *bridge, u8 attempts,
                 u32 signal_free_time, struct cec_msg *msg);
 
    int (*dp_audio_startup)(struct drm_bridge *bridge,
                struct drm_connector *connector);
 
    int (*dp_audio_prepare)(struct drm_bridge *bridge,
                struct drm_connector *connector,
                struct hdmi_codec_daifmt *fmt,
                struct hdmi_codec_params *hparms);
 
    void (*dp_audio_shutdown)(struct drm_bridge *bridge,
                  struct drm_connector *connector);
 
    int (*dp_audio_mute_stream)(struct drm_bridge *bridge,
                    struct drm_connector *connector,
                    bool enable, int direction);
 
    void (*debugfs_init)(struct drm_bridge *bridge, struct dentry *root);
};
 
struct drm_bridge_timings {
    u32 input_bus_flags;
    u32 setup_time_ps;
    u32 hold_time_ps;
    bool dual_link;
};
 
enum drm_bridge_ops {
    DRM_BRIDGE_OP_DETECT = BIT(0),
    DRM_BRIDGE_OP_EDID = BIT(1),
    DRM_BRIDGE_OP_HPD = BIT(2),
    DRM_BRIDGE_OP_MODES = BIT(3),
    DRM_BRIDGE_OP_HDMI = BIT(4),
    DRM_BRIDGE_OP_HDMI_AUDIO = BIT(5),
    DRM_BRIDGE_OP_DP_AUDIO = BIT(6),
    DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER = BIT(7),
    DRM_BRIDGE_OP_HDMI_CEC_ADAPTER = BIT(8),
    DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME = BIT(9),
    DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME = BIT(10),
};
 
struct drm_bridge {
    struct drm_private_obj base;
    struct drm_device *dev;
    struct drm_encoder *encoder;
    struct list_head chain_node;
    struct device_node *of_node;
    struct list_head list;
    const struct drm_bridge_timings *timings;
    const struct drm_bridge_funcs *funcs;
 
    void *container;
 
    struct kref refcount;
 
    bool unplugged;
 
    void *driver_private;
    enum drm_bridge_ops ops;
    int type;
    bool interlace_allowed;
    bool ycbcr_420_allowed;
    bool pre_enable_prev_first;
    bool support_hdcp;
    struct i2c_adapter *ddc;
 
    const char *vendor;
 
    const char *product;
 
    unsigned int supported_formats;
 
    unsigned int max_bpc;
 
    struct device *hdmi_cec_dev;
 
    struct device *hdmi_audio_dev;
 
    int hdmi_audio_max_i2s_playback_channels;
 
    u64 hdmi_audio_i2s_formats;
 
    unsigned int hdmi_audio_spdif_playback : 1;
 
    int hdmi_audio_dai_port;
 
    const char *hdmi_cec_adapter_name;
 
    u8 hdmi_cec_available_las;
 
    struct mutex hpd_mutex;
    void (*hpd_cb)(void *data, enum drm_connector_status status);
    void *hpd_data;
 
    struct drm_bridge *next_bridge;
};
 
static inline struct drm_bridge *
drm_priv_to_bridge(struct drm_private_obj *priv)
{
    return container_of(priv, struct drm_bridge, base);
}
 
bool drm_bridge_enter(struct drm_bridge *bridge, int *idx);
void drm_bridge_exit(int idx);
void drm_bridge_unplug(struct drm_bridge *bridge);
 
struct drm_bridge *drm_bridge_get(struct drm_bridge *bridge);
void drm_bridge_put(struct drm_bridge *bridge);
void drm_bridge_clear_and_put(struct drm_bridge **bridge_pp);
 
/* Cleanup action for use with __free() */
DEFINE_FREE(drm_bridge_put, struct drm_bridge *, if (_T) drm_bridge_put(_T))
 
void *__devm_drm_bridge_alloc(struct device *dev, size_t size, size_t offset,
                  const struct drm_bridge_funcs *funcs);
 
#define devm_drm_bridge_alloc(dev, type, member, funcs) \
    ((type *)__devm_drm_bridge_alloc(dev, sizeof(type), \
                     offsetof(type, member), funcs))
 
void drm_bridge_add(struct drm_bridge *bridge);
int devm_drm_bridge_add(struct device *dev, struct drm_bridge *bridge);
void drm_bridge_remove(struct drm_bridge *bridge);
int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge,
              struct drm_bridge *previous,
              enum drm_bridge_attach_flags flags);
 
#ifdef CONFIG_OF
struct drm_bridge *of_drm_find_and_get_bridge(struct device_node *np);
struct drm_bridge *of_drm_find_bridge(struct device_node *np);
struct drm_bridge *of_drm_get_bridge_by_endpoint(const struct device_node *np,
                         int port, int endpoint);
#else
static inline struct drm_bridge *of_drm_find_and_get_bridge(struct device_node *np)
{
    return NULL;
}
static inline struct drm_bridge *of_drm_find_bridge(struct device_node *np)
{
    return NULL;
}
static inline struct drm_bridge *of_drm_get_bridge_by_endpoint(const struct device_node *np,
                                   int port, int endpoint)
{
    return ERR_PTR(-ENODEV);
}
#endif
 
static inline bool drm_bridge_is_last(struct drm_bridge *bridge)
{
    return list_is_last(&bridge->chain_node, &bridge->encoder->bridge_chain);
}
 
static inline struct drm_bridge_state *
drm_bridge_get_current_state(struct drm_bridge *bridge)
{
    if (!bridge)
        return NULL;
 
    /*
     * Only atomic bridges will have bridge->base initialized by
     * drm_atomic_private_obj_init(), so we need to make sure we're
     * working with one before we try to use the lock.
     */
    if (!bridge->funcs || !bridge->funcs->atomic_reset)
        return NULL;
 
    drm_modeset_lock_assert_held(&bridge->base.lock);
 
    if (!bridge->base.state)
        return NULL;
 
    return drm_priv_to_bridge_state(bridge->base.state);
}
 
static inline struct drm_bridge *
drm_bridge_get_next_bridge(struct drm_bridge *bridge)
{
    if (list_is_last(&bridge->chain_node, &bridge->encoder->bridge_chain))
        return NULL;
 
    return drm_bridge_get(list_next_entry(bridge, chain_node));
}
 
static inline struct drm_bridge *
drm_bridge_get_prev_bridge(struct drm_bridge *bridge)
{
    if (list_is_first(&bridge->chain_node, &bridge->encoder->bridge_chain))
        return NULL;
 
    return drm_bridge_get(list_prev_entry(bridge, chain_node));
}
 
static inline struct drm_bridge *
drm_bridge_chain_get_first_bridge(struct drm_encoder *encoder)
{
    return drm_bridge_get(list_first_entry_or_null(&encoder->bridge_chain,
                               struct drm_bridge, chain_node));
}
 
static inline struct drm_bridge *
drm_bridge_chain_get_last_bridge(struct drm_encoder *encoder)
{
    return drm_bridge_get(list_last_entry_or_null(&encoder->bridge_chain,
                              struct drm_bridge, chain_node));
}
 
/* Internal to drm_for_each_bridge_in_chain*() */
static inline struct drm_bridge *__drm_for_each_bridge_in_chain_next(struct drm_bridge *bridge)
{
    struct drm_bridge *next = drm_bridge_get_next_bridge(bridge);
 
    if (!next)
        mutex_unlock(&bridge->encoder->bridge_chain_mutex);
 
    drm_bridge_put(bridge);
 
    return next;
}
 
/* Internal to drm_for_each_bridge_in_chain*() */
DEFINE_FREE(__drm_for_each_bridge_in_chain_cleanup, struct drm_bridge *,
    if (_T) { mutex_unlock(&_T->encoder->bridge_chain_mutex); drm_bridge_put(_T); })
 
/* Internal to drm_for_each_bridge_in_chain_scoped() */
static inline struct drm_bridge *
__drm_for_each_bridge_in_chain_scoped_start(struct drm_encoder *encoder)
{
    mutex_lock(&encoder->bridge_chain_mutex);
 
    struct drm_bridge *bridge = drm_bridge_chain_get_first_bridge(encoder);
 
    if (!bridge)
        mutex_unlock(&encoder->bridge_chain_mutex);
 
    return bridge;
}
 
#define drm_for_each_bridge_in_chain_scoped(encoder, bridge)                \
    for (struct drm_bridge *bridge __free(__drm_for_each_bridge_in_chain_cleanup) = \
        __drm_for_each_bridge_in_chain_scoped_start((encoder));         \
         bridge;                                    \
         bridge = __drm_for_each_bridge_in_chain_next(bridge))          \
 
/* Internal to drm_for_each_bridge_in_chain_from() */
static inline struct drm_bridge *
__drm_for_each_bridge_in_chain_from_start(struct drm_bridge *bridge)
{
    drm_bridge_get(bridge);
    mutex_lock(&bridge->encoder->bridge_chain_mutex);
 
    return bridge;
}
 
#define drm_for_each_bridge_in_chain_from(first_bridge, bridge)             \
    for (struct drm_bridge *bridge __free(__drm_for_each_bridge_in_chain_cleanup) = \
        __drm_for_each_bridge_in_chain_from_start(first_bridge);        \
         bridge;                                    \
         bridge = __drm_for_each_bridge_in_chain_next(bridge))          \
 
enum drm_mode_status
drm_bridge_chain_mode_valid(struct drm_bridge *bridge,
                const struct drm_display_info *info,
                const struct drm_display_mode *mode);
void drm_bridge_chain_mode_set(struct drm_bridge *bridge,
                   const struct drm_display_mode *mode,
                   const struct drm_display_mode *adjusted_mode);
 
int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,
                  struct drm_crtc_state *crtc_state,
                  struct drm_connector_state *conn_state);
void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,
                     struct drm_atomic_commit *state);
void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,
                      struct drm_atomic_commit *state);
void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,
                    struct drm_atomic_commit *state);
void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,
                    struct drm_atomic_commit *state);
 
u32 *
drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
                    struct drm_bridge_state *bridge_state,
                    struct drm_crtc_state *crtc_state,
                    struct drm_connector_state *conn_state,
                    u32 output_fmt,
                    unsigned int *num_input_fmts);
 
enum drm_connector_status
drm_bridge_detect(struct drm_bridge *bridge, struct drm_connector *connector);
int drm_bridge_get_modes(struct drm_bridge *bridge,
             struct drm_connector *connector);
const struct drm_edid *drm_bridge_edid_read(struct drm_bridge *bridge,
                        struct drm_connector *connector);
void drm_bridge_hpd_enable(struct drm_bridge *bridge,
               void (*cb)(void *data,
                      enum drm_connector_status status),
               void *data);
void drm_bridge_hpd_disable(struct drm_bridge *bridge);
void drm_bridge_hpd_notify(struct drm_bridge *bridge,
               enum drm_connector_status status);
 
#ifdef CONFIG_DRM_PANEL_BRIDGE
bool drm_bridge_is_panel(const struct drm_bridge *bridge);
struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel);
struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel,
                          u32 connector_type);
void drm_panel_bridge_remove(struct drm_bridge *bridge);
int drm_panel_bridge_set_orientation(struct drm_connector *connector,
                     struct drm_bridge *bridge);
struct drm_bridge *devm_drm_panel_bridge_add(struct device *dev,
                         struct drm_panel *panel);
struct drm_bridge *devm_drm_panel_bridge_add_typed(struct device *dev,
                           struct drm_panel *panel,
                           u32 connector_type);
struct drm_bridge *drmm_panel_bridge_add(struct drm_device *drm,
                         struct drm_panel *panel);
struct drm_connector *drm_panel_bridge_connector(struct drm_bridge *bridge);
#else
static inline bool drm_bridge_is_panel(const struct drm_bridge *bridge)
{
    return false;
}
 
static inline int drm_panel_bridge_set_orientation(struct drm_connector *connector,
                           struct drm_bridge *bridge)
{
    return -EINVAL;
}
#endif
 
#if defined(CONFIG_OF) && defined(CONFIG_DRM_PANEL_BRIDGE)
struct drm_bridge *devm_drm_of_get_bridge(struct device *dev, struct device_node *node,
                      u32 port, u32 endpoint);
struct drm_bridge *drmm_of_get_bridge(struct drm_device *drm, struct device_node *node,
                      u32 port, u32 endpoint);
#else
static inline struct drm_bridge *devm_drm_of_get_bridge(struct device *dev,
                            struct device_node *node,
                            u32 port,
                            u32 endpoint)
{
    return ERR_PTR(-ENODEV);
}
 
static inline struct drm_bridge *drmm_of_get_bridge(struct drm_device *drm,
                             struct device_node *node,
                             u32 port,
                             u32 endpoint)
{
    return ERR_PTR(-ENODEV);
}
#endif
 
void devm_drm_put_bridge(struct device *dev, struct drm_bridge *bridge);
 
void drm_bridge_debugfs_params(struct dentry *root);
void drm_bridge_debugfs_encoder_params(struct dentry *root, struct drm_encoder *encoder);
 
#endif