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_encoder.h>
  16 #include <drm/drm_modeset_helper_vtables.h>
  17 #include <drm/drm_probe_helper.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         .reset = drm_atomic_helper_connector_reset,
  54         .fill_modes = drm_helper_probe_single_connector_modes,
  55         .destroy = drm_connector_cleanup,
  56         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  57         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  58 };
  59
  60 static int panel_bridge_attach(struct drm_bridge *bridge)
  61 {
  62         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  63         struct drm_connector *connector = &panel_bridge->connector;
  64         int ret;
  65
  66         if (!bridge->encoder) {
  67                 DRM_ERROR("Missing encoder\n");
  68                 return -ENODEV;
  69         }
  70
  71         drm_connector_helper_add(connector,
  72                                  &panel_bridge_connector_helper_funcs);
  73
  74         ret = drm_connector_init(bridge->dev, connector,
  75                                  &panel_bridge_connector_funcs,
  76                                  panel_bridge->connector_type);
  77         if (ret) {
  78                 DRM_ERROR("Failed to initialize connector\n");
  79                 return ret;
  80         }
  81
  82         drm_connector_attach_encoder(&panel_bridge->connector,
  83                                           bridge->encoder);
  84
  85         ret = drm_panel_attach(panel_bridge->panel, &panel_bridge->connector);
  86         if (ret < 0)
  87                 return ret;
  88
  89         return 0;
  90 }
  91
  92 static void panel_bridge_detach(struct drm_bridge *bridge)
  93 {
  94         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
  95
  96         drm_panel_detach(panel_bridge->panel);
  97 }
  98
  99 static void panel_bridge_pre_enable(struct drm_bridge *bridge)
 100 {
 101         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 102
 103         drm_panel_prepare(panel_bridge->panel);
 104 }
 105
 106 static void panel_bridge_enable(struct drm_bridge *bridge)
 107 {
 108         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 109
 110         drm_panel_enable(panel_bridge->panel);
 111 }
 112
 113 static void panel_bridge_disable(struct drm_bridge *bridge)
 114 {
 115         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 116
 117         drm_panel_disable(panel_bridge->panel);
 118 }
 119
 120 static void panel_bridge_post_disable(struct drm_bridge *bridge)
 121 {
 122         struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
 123
 124         drm_panel_unprepare(panel_bridge->panel);
 125 }
 126
 127 static const struct drm_bridge_funcs panel_bridge_bridge_funcs = {
 128         .attach = panel_bridge_attach,
 129         .detach = panel_bridge_detach,
 130         .pre_enable = panel_bridge_pre_enable,
 131         .enable = panel_bridge_enable,
 132         .disable = panel_bridge_disable,
 133         .post_disable = panel_bridge_post_disable,
 134 };
 135
 136 /**
 137  * drm_panel_bridge_add - Creates a &drm_bridge and &drm_connector that
 138  * just calls the appropriate functions from &drm_panel.
 139  *
 140  * @panel: The drm_panel being wrapped.  Must be non-NULL.
 141  * @connector_type: The DRM_MODE_CONNECTOR_* for the connector to be
 142  * created.
 143  *
 144  * For drivers converting from directly using drm_panel: The expected
 145  * usage pattern is that during either encoder module probe or DSI
 146  * host attach, a drm_panel will be looked up through
 147  * drm_of_find_panel_or_bridge().  drm_panel_bridge_add() is used to
 148  * wrap that panel in the new bridge, and the result can then be
 149  * passed to drm_bridge_attach().  The drm_panel_prepare() and related
 150  * functions can be dropped from the encoder driver (they're now
 151  * called by the KMS helpers before calling into the encoder), along
 152  * with connector creation.  When done with the bridge (after
 153  * drm_mode_config_cleanup() if the bridge has already been attached), then
 154  * drm_panel_bridge_remove() to free it.
 155  *
 156  * See devm_drm_panel_bridge_add() for an automatically manged version of this
 157  * function.
 158  */
 159 struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel,
 160                                         u32 connector_type)
 161 {
 162         struct panel_bridge *panel_bridge;
 163
 164         if (!panel)
 165                 return ERR_PTR(-EINVAL);
 166
 167         panel_bridge = devm_kzalloc(panel->dev, sizeof(*panel_bridge),
 168                                     GFP_KERNEL);
 169         if (!panel_bridge)
 170                 return ERR_PTR(-ENOMEM);
 171
 172         panel_bridge->connector_type = connector_type;
 173         panel_bridge->panel = panel;
 174
 175         panel_bridge->bridge.funcs = &panel_bridge_bridge_funcs;
 176 #ifdef CONFIG_OF
 177         panel_bridge->bridge.of_node = panel->dev->of_node;
 178 #endif
 179
 180         drm_bridge_add(&panel_bridge->bridge);
 181
 182         return &panel_bridge->bridge;
 183 }
 184 EXPORT_SYMBOL(drm_panel_bridge_add);
 185
 186 /**
 187  * drm_panel_bridge_remove - Unregisters and frees a drm_bridge
 188  * created by drm_panel_bridge_add().
 189  *
 190  * @bridge: The drm_bridge being freed.
 191  */
 192 void drm_panel_bridge_remove(struct drm_bridge *bridge)
 193 {
 194         struct panel_bridge *panel_bridge;
 195
 196         if (!bridge)
 197                 return;
 198
 199         if (bridge->funcs != &panel_bridge_bridge_funcs)
 200                 return;
 201
 202         panel_bridge = drm_bridge_to_panel_bridge(bridge);
 203
 204         drm_bridge_remove(bridge);
 205         devm_kfree(panel_bridge->panel->dev, bridge);
 206 }
 207 EXPORT_SYMBOL(drm_panel_bridge_remove);
 208
 209 static void devm_drm_panel_bridge_release(struct device *dev, void *res)
 210 {
 211         struct drm_bridge **bridge = res;
 212
 213         drm_panel_bridge_remove(*bridge);
 214 }
 215
 216 /**
 217  * devm_drm_panel_bridge_add - Creates a managed &drm_bridge and &drm_connector
 218  * that just calls the appropriate functions from &drm_panel.
 219  * @dev: device to tie the bridge lifetime to
 220  * @panel: The drm_panel being wrapped.  Must be non-NULL.
 221  * @connector_type: The DRM_MODE_CONNECTOR_* for the connector to be
 222  * created.
 223  *
 224  * This is the managed version of drm_panel_bridge_add() which automatically
 225  * calls drm_panel_bridge_remove() when @dev is unbound.
 226  */
 227 struct drm_bridge *devm_drm_panel_bridge_add(struct device *dev,
 228                                              struct drm_panel *panel,
 229                                              u32 connector_type)
 230 {
 231         struct drm_bridge **ptr, *bridge;
 232
 233         ptr = devres_alloc(devm_drm_panel_bridge_release, sizeof(*ptr),
 234                            GFP_KERNEL);
 235         if (!ptr)
 236                 return ERR_PTR(-ENOMEM);
 237
 238         bridge = drm_panel_bridge_add(panel, connector_type);
 239         if (!IS_ERR(bridge)) {
 240                 *ptr = bridge;
 241                 devres_add(dev, ptr);
 242         } else {
 243                 devres_free(ptr);
 244         }
 245
 246         return bridge;
 247 }
 248 EXPORT_SYMBOL(devm_drm_panel_bridge_add);