drivers/gpu/drm/bridge/panel.c

   1 /*
   2  * Copyright (C) 2016 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   3  * Copyright (C) 2017 Broadcom
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or (at your option) any later version.
   9  */
  10
  11 #include <drm/drmP.h>
  12 #include <drm/drm_panel.h>
  13 #include <drm/drm_atomic_helper.h>
  14 #include <drm/drm_connector.h>
  15 #include <drm/drm_crtc_helper.h>
  16 #include <drm/drm_encoder.h>
  17 #include <drm/drm_modeset_helper_vtables.h>
  18 #include <drm/drm_panel.h>
  19
  20 struct panel_bridge {
  21         struct drm_bridge bridge;
  22         struct drm_connector connector;
  23         struct drm_panel *panel;
  24         u32 connector_type;
  25 };
  26
  27 static inline struct panel_bridge *
  28 drm_bridge_to_panel_bridge(struct drm_bridge *bridge)
  29 {
  30         return container_of(bridge, struct panel_bridge, bridge);
  31 }
  32
  33 static inline struct panel_bridge *
  34 drm_connector_to_panel_bridge(struct drm_connector *connector)
  35 {
  36         return container_of(connector, struct panel_bridge, connector);
  37 }
  38
  39 static int panel_bridge_connector_get_modes(struct drm_connector *connector)
  40 {
  41         struct panel_bridge *panel_bridge =
  42                 drm_connector_to_panel_bridge(connector);
  43
  44         return drm_panel_get_modes(panel_bridge->panel);
  45 }
  46
  47 static const struct drm_connector_helper_funcs
  48 panel_bridge_connector_helper_funcs = {
  49         .get_modes = panel_bridge_connector_get_modes,
  50 };
  51
  52 static const struct drm_connector_funcs panel_bridge_connector_funcs = {
  53         .dpms = drm_atomic_helper_connector_dpms,
  54         .reset = drm_atomic_helper_connector_reset,
  55         .fill_modes = drm_helper_probe_single_connector_modes,
  56         .destroy = drm_connector_cleanup,
  57         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  58         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  59 };
  60
  61 static int panel_bridge_attach(struct drm_bridge *bridge)
  62 {
  63         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  64         struct drm_connector *connector = &panel_bridge->connector;
  65         int ret;
  66
  67         if (!bridge->encoder) {
  68                 DRM_ERROR("Missing encoder\n");
  69                 return -ENODEV;
  70         }
  71
  72         drm_connector_helper_add(connector,
  73                                  &panel_bridge_connector_helper_funcs);
  74
  75         ret = drm_connector_init(bridge->dev, connector,
  76                                  &panel_bridge_connector_funcs,
  77                                  panel_bridge->connector_type);
  78         if (ret) {
  79                 DRM_ERROR("Failed to initialize connector\n");
  80                 return ret;
  81         }
  82
  83         drm_mode_connector_attach_encoder(&panel_bridge->connector,
  84                                           bridge->encoder);
  85
  86         ret = drm_panel_attach(panel_bridge->panel, &panel_bridge->connector);
  87         if (ret < 0)
  88                 return ret;
  89
  90         return 0;
  91 }
  92
  93 static void panel_bridge_detach(struct drm_bridge *bridge)
  94 {
  95         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  96
  97         drm_panel_detach(panel_bridge->panel);
  98 }
  99
 100 static void panel_bridge_pre_enable(struct drm_bridge *bridge)
 101 {
 102         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 103
 104         drm_panel_prepare(panel_bridge->panel);
 105 }
 106
 107 static void panel_bridge_enable(struct drm_bridge *bridge)
 108 {
 109         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 110
 111         drm_panel_enable(panel_bridge->panel);
 112 }
 113
 114 static void panel_bridge_disable(struct drm_bridge *bridge)
 115 {
 116         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 117
 118         drm_panel_disable(panel_bridge->panel);
 119 }
 120
 121 static void panel_bridge_post_disable(struct drm_bridge *bridge)
 122 {
 123         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 124
 125         drm_panel_unprepare(panel_bridge->panel);
 126 }
 127
 128 static const struct drm_bridge_funcs panel_bridge_bridge_funcs = {
 129         .attach = panel_bridge_attach,
 130         .detach = panel_bridge_detach,
 131         .pre_enable = panel_bridge_pre_enable,
 132         .enable = panel_bridge_enable,
 133         .disable = panel_bridge_disable,
 134         .post_disable = panel_bridge_post_disable,
 135 };
 136
 137 /**
 138  * drm_panel_bridge_add - Creates a drm_bridge and drm_connector that
 139  * just calls the appropriate functions from drm_panel.
 140  *
 141  * @panel: The drm_panel being wrapped.  Must be non-NULL.
 142  * @connector_type: The DRM_MODE_CONNECTOR_* for the connector to be
 143  * created.
 144  *
 145  * For drivers converting from directly using drm_panel: The expected
 146  * usage pattern is that during either encoder module probe or DSI
 147  * host attach, a drm_panel will be looked up through
 148  * drm_of_find_panel_or_bridge().  drm_panel_bridge_add() is used to
 149  * wrap that panel in the new bridge, and the result can then be
 150  * passed to drm_bridge_attach().  The drm_panel_prepare() and related
 151  * functions can be dropped from the encoder driver (they're now
 152  * called by the KMS helpers before calling into the encoder), along
 153  * with connector creation.  When done with the bridge,
 154  * drm_bridge_detach() should be called as normal, then
 155  * drm_panel_bridge_remove() to free it.
 156  */
 157 struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel,
 158                                         u32 connector_type)
 159 {
 160         struct panel_bridge *panel_bridge;
 161         int ret;
 162
 163         if (!panel)
 164                 return ERR_PTR(-EINVAL);
 165
 166         panel_bridge = devm_kzalloc(panel->dev, sizeof(*panel_bridge),
 167                                     GFP_KERNEL);
 168         if (!panel_bridge)
 169                 return ERR_PTR(-ENOMEM);
 170
 171         panel_bridge->connector_type = connector_type;
 172         panel_bridge->panel = panel;
 173
 174         panel_bridge->bridge.funcs = &panel_bridge_bridge_funcs;
 175 #ifdef CONFIG_OF
 176         panel_bridge->bridge.of_node = panel->dev->of_node;
 177 #endif
 178
 179         ret = drm_bridge_add(&panel_bridge->bridge);
 180         if (ret)
 181                 return ERR_PTR(ret);
 182
 183         return &panel_bridge->bridge;
 184 }
 185 EXPORT_SYMBOL(drm_panel_bridge_add);
 186
 187 /**
 188  * drm_panel_bridge_remove - Unregisters and frees a drm_bridge
 189  * created by drm_panel_bridge_add().
 190  *
 191  * @bridge: The drm_bridge being freed.
 192  */
 193 void drm_panel_bridge_remove(struct drm_bridge *bridge)
 194 {
 195         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 196
 197         drm_bridge_remove(bridge);
 198         devm_kfree(panel_bridge->panel->dev, bridge);
 199 }
 200 EXPORT_SYMBOL(drm_panel_bridge_remove);