]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/gpu/drm/bridge/panel.c
Merge branch 'vmwgfx-fixes-5.1' of git://people.freedesktop.org/~thomash/linux into...
[mirror_ubuntu-focal-kernel.git] / 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);