Commit | Line | Data |
---|---|---|
aead40ea TR |
1 | /* |
2 | * Copyright (C) 2013, NVIDIA Corporation. All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sub license, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice (including the | |
12 | * next paragraph) shall be included in all copies or substantial portions | |
13 | * of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL | |
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |
21 | * DEALINGS IN THE SOFTWARE. | |
22 | */ | |
23 | ||
152dbdea | 24 | #include <linux/backlight.h> |
aead40ea TR |
25 | #include <linux/err.h> |
26 | #include <linux/module.h> | |
27 | ||
28 | #include <drm/drm_crtc.h> | |
29 | #include <drm/drm_panel.h> | |
152dbdea | 30 | #include <drm/drm_print.h> |
aead40ea TR |
31 | |
32 | static DEFINE_MUTEX(panel_lock); | |
33 | static LIST_HEAD(panel_list); | |
34 | ||
83127f67 TR |
35 | /** |
36 | * DOC: drm panel | |
37 | * | |
38 | * The DRM panel helpers allow drivers to register panel objects with a | |
39 | * central registry and provide functions to retrieve those panels in display | |
40 | * drivers. | |
0aa5eb3a DV |
41 | * |
42 | * For easy integration into drivers using the &drm_bridge infrastructure please | |
43 | * take look at drm_panel_bridge_add() and devm_drm_panel_bridge_add(). | |
83127f67 TR |
44 | */ |
45 | ||
46 | /** | |
47 | * drm_panel_init - initialize a panel | |
48 | * @panel: DRM panel | |
6dbe0c4b LP |
49 | * @dev: parent device of the panel |
50 | * @funcs: panel operations | |
9a2654c0 LP |
51 | * @connector_type: the connector type (DRM_MODE_CONNECTOR_*) corresponding to |
52 | * the panel interface | |
83127f67 | 53 | * |
6dbe0c4b LP |
54 | * Initialize the panel structure for subsequent registration with |
55 | * drm_panel_add(). | |
83127f67 | 56 | */ |
6dbe0c4b | 57 | void drm_panel_init(struct drm_panel *panel, struct device *dev, |
9a2654c0 | 58 | const struct drm_panel_funcs *funcs, int connector_type) |
aead40ea TR |
59 | { |
60 | INIT_LIST_HEAD(&panel->list); | |
6dbe0c4b LP |
61 | panel->dev = dev; |
62 | panel->funcs = funcs; | |
9a2654c0 | 63 | panel->connector_type = connector_type; |
aead40ea TR |
64 | } |
65 | EXPORT_SYMBOL(drm_panel_init); | |
66 | ||
83127f67 TR |
67 | /** |
68 | * drm_panel_add - add a panel to the global registry | |
69 | * @panel: panel to add | |
70 | * | |
71 | * Add a panel to the global registry so that it can be looked up by display | |
72 | * drivers. | |
83127f67 | 73 | */ |
c3ee8c65 | 74 | void drm_panel_add(struct drm_panel *panel) |
aead40ea TR |
75 | { |
76 | mutex_lock(&panel_lock); | |
77 | list_add_tail(&panel->list, &panel_list); | |
78 | mutex_unlock(&panel_lock); | |
aead40ea TR |
79 | } |
80 | EXPORT_SYMBOL(drm_panel_add); | |
81 | ||
83127f67 TR |
82 | /** |
83 | * drm_panel_remove - remove a panel from the global registry | |
84 | * @panel: DRM panel | |
85 | * | |
86 | * Removes a panel from the global registry. | |
87 | */ | |
aead40ea TR |
88 | void drm_panel_remove(struct drm_panel *panel) |
89 | { | |
90 | mutex_lock(&panel_lock); | |
91 | list_del_init(&panel->list); | |
92 | mutex_unlock(&panel_lock); | |
93 | } | |
94 | EXPORT_SYMBOL(drm_panel_remove); | |
95 | ||
7a833d30 SR |
96 | /** |
97 | * drm_panel_prepare - power on a panel | |
98 | * @panel: DRM panel | |
99 | * | |
100 | * Calling this function will enable power and deassert any reset signals to | |
101 | * the panel. After this has completed it is possible to communicate with any | |
102 | * integrated circuitry via a command bus. | |
103 | * | |
104 | * Return: 0 on success or a negative error code on failure. | |
105 | */ | |
106 | int drm_panel_prepare(struct drm_panel *panel) | |
107 | { | |
5dce87a9 SR |
108 | if (!panel) |
109 | return -EINVAL; | |
110 | ||
111 | if (panel->funcs && panel->funcs->prepare) | |
7a833d30 SR |
112 | return panel->funcs->prepare(panel); |
113 | ||
5dce87a9 | 114 | return 0; |
7a833d30 SR |
115 | } |
116 | EXPORT_SYMBOL(drm_panel_prepare); | |
117 | ||
118 | /** | |
119 | * drm_panel_unprepare - power off a panel | |
120 | * @panel: DRM panel | |
121 | * | |
122 | * Calling this function will completely power off a panel (assert the panel's | |
123 | * reset, turn off power supplies, ...). After this function has completed, it | |
124 | * is usually no longer possible to communicate with the panel until another | |
125 | * call to drm_panel_prepare(). | |
126 | * | |
127 | * Return: 0 on success or a negative error code on failure. | |
128 | */ | |
129 | int drm_panel_unprepare(struct drm_panel *panel) | |
130 | { | |
5dce87a9 SR |
131 | if (!panel) |
132 | return -EINVAL; | |
133 | ||
134 | if (panel->funcs && panel->funcs->unprepare) | |
7a833d30 SR |
135 | return panel->funcs->unprepare(panel); |
136 | ||
5dce87a9 | 137 | return 0; |
7a833d30 SR |
138 | } |
139 | EXPORT_SYMBOL(drm_panel_unprepare); | |
140 | ||
141 | /** | |
142 | * drm_panel_enable - enable a panel | |
143 | * @panel: DRM panel | |
144 | * | |
145 | * Calling this function will cause the panel display drivers to be turned on | |
146 | * and the backlight to be enabled. Content will be visible on screen after | |
147 | * this call completes. | |
148 | * | |
149 | * Return: 0 on success or a negative error code on failure. | |
150 | */ | |
151 | int drm_panel_enable(struct drm_panel *panel) | |
152 | { | |
152dbdea SR |
153 | int ret; |
154 | ||
5dce87a9 SR |
155 | if (!panel) |
156 | return -EINVAL; | |
157 | ||
152dbdea SR |
158 | if (panel->funcs && panel->funcs->enable) { |
159 | ret = panel->funcs->enable(panel); | |
160 | if (ret < 0) | |
161 | return ret; | |
162 | } | |
163 | ||
164 | ret = backlight_enable(panel->backlight); | |
165 | if (ret < 0) | |
166 | DRM_DEV_INFO(panel->dev, "failed to enable backlight: %d\n", | |
167 | ret); | |
7a833d30 | 168 | |
5dce87a9 | 169 | return 0; |
7a833d30 SR |
170 | } |
171 | EXPORT_SYMBOL(drm_panel_enable); | |
172 | ||
173 | /** | |
174 | * drm_panel_disable - disable a panel | |
175 | * @panel: DRM panel | |
176 | * | |
177 | * This will typically turn off the panel's backlight or disable the display | |
178 | * drivers. For smart panels it should still be possible to communicate with | |
179 | * the integrated circuitry via any command bus after this call. | |
180 | * | |
181 | * Return: 0 on success or a negative error code on failure. | |
182 | */ | |
183 | int drm_panel_disable(struct drm_panel *panel) | |
184 | { | |
152dbdea SR |
185 | int ret; |
186 | ||
5dce87a9 SR |
187 | if (!panel) |
188 | return -EINVAL; | |
189 | ||
152dbdea SR |
190 | ret = backlight_disable(panel->backlight); |
191 | if (ret < 0) | |
192 | DRM_DEV_INFO(panel->dev, "failed to disable backlight: %d\n", | |
193 | ret); | |
194 | ||
5dce87a9 | 195 | if (panel->funcs && panel->funcs->disable) |
7a833d30 SR |
196 | return panel->funcs->disable(panel); |
197 | ||
5dce87a9 | 198 | return 0; |
7a833d30 SR |
199 | } |
200 | EXPORT_SYMBOL(drm_panel_disable); | |
201 | ||
202 | /** | |
203 | * drm_panel_get_modes - probe the available display modes of a panel | |
204 | * @panel: DRM panel | |
06c4a9c2 | 205 | * @connector: DRM connector |
7a833d30 SR |
206 | * |
207 | * The modes probed from the panel are automatically added to the connector | |
208 | * that the panel is attached to. | |
209 | * | |
210 | * Return: The number of modes available from the panel on success or a | |
211 | * negative error code on failure. | |
212 | */ | |
06c4a9c2 SR |
213 | int drm_panel_get_modes(struct drm_panel *panel, |
214 | struct drm_connector *connector) | |
7a833d30 | 215 | { |
5dce87a9 SR |
216 | if (!panel) |
217 | return -EINVAL; | |
218 | ||
219 | if (panel->funcs && panel->funcs->get_modes) | |
06c4a9c2 | 220 | return panel->funcs->get_modes(panel, connector); |
7a833d30 | 221 | |
5dce87a9 | 222 | return -EOPNOTSUPP; |
7a833d30 SR |
223 | } |
224 | EXPORT_SYMBOL(drm_panel_get_modes); | |
225 | ||
aead40ea | 226 | #ifdef CONFIG_OF |
83127f67 TR |
227 | /** |
228 | * of_drm_find_panel - look up a panel using a device tree node | |
229 | * @np: device tree node of the panel | |
230 | * | |
231 | * Searches the set of registered panels for one that matches the given device | |
232 | * tree node. If a matching panel is found, return a pointer to it. | |
233 | * | |
234 | * Return: A pointer to the panel registered for the specified device tree | |
5fa8e4a2 | 235 | * node or an ERR_PTR() if no panel matching the device tree node can be found. |
3eb3cd04 | 236 | * |
c59eb3cf | 237 | * Possible error codes returned by this function: |
3eb3cd04 | 238 | * |
c59eb3cf BB |
239 | * - EPROBE_DEFER: the panel device has not been probed yet, and the caller |
240 | * should retry later | |
241 | * - ENODEV: the device is not available (status != "okay" or "ok") | |
83127f67 | 242 | */ |
327bc443 | 243 | struct drm_panel *of_drm_find_panel(const struct device_node *np) |
aead40ea TR |
244 | { |
245 | struct drm_panel *panel; | |
246 | ||
c59eb3cf BB |
247 | if (!of_device_is_available(np)) |
248 | return ERR_PTR(-ENODEV); | |
249 | ||
aead40ea TR |
250 | mutex_lock(&panel_lock); |
251 | ||
252 | list_for_each_entry(panel, &panel_list, list) { | |
253 | if (panel->dev->of_node == np) { | |
254 | mutex_unlock(&panel_lock); | |
255 | return panel; | |
256 | } | |
257 | } | |
258 | ||
259 | mutex_unlock(&panel_lock); | |
5fa8e4a2 | 260 | return ERR_PTR(-EPROBE_DEFER); |
aead40ea TR |
261 | } |
262 | EXPORT_SYMBOL(of_drm_find_panel); | |
263 | #endif | |
264 | ||
4a34a9dc | 265 | #if IS_REACHABLE(CONFIG_BACKLIGHT_CLASS_DEVICE) |
152dbdea SR |
266 | /** |
267 | * drm_panel_of_backlight - use backlight device node for backlight | |
268 | * @panel: DRM panel | |
269 | * | |
270 | * Use this function to enable backlight handling if your panel | |
271 | * uses device tree and has a backlight phandle. | |
272 | * | |
273 | * When the panel is enabled backlight will be enabled after a | |
274 | * successful call to &drm_panel_funcs.enable() | |
275 | * | |
276 | * When the panel is disabled backlight will be disabled before the | |
277 | * call to &drm_panel_funcs.disable(). | |
278 | * | |
279 | * A typical implementation for a panel driver supporting device tree | |
280 | * will call this function at probe time. Backlight will then be handled | |
281 | * transparently without requiring any intervention from the driver. | |
282 | * drm_panel_of_backlight() must be called after the call to drm_panel_init(). | |
283 | * | |
284 | * Return: 0 on success or a negative error code on failure. | |
285 | */ | |
286 | int drm_panel_of_backlight(struct drm_panel *panel) | |
287 | { | |
288 | struct backlight_device *backlight; | |
289 | ||
290 | if (!panel || !panel->dev) | |
291 | return -EINVAL; | |
292 | ||
293 | backlight = devm_of_find_backlight(panel->dev); | |
294 | ||
295 | if (IS_ERR(backlight)) | |
296 | return PTR_ERR(backlight); | |
297 | ||
298 | panel->backlight = backlight; | |
299 | return 0; | |
300 | } | |
301 | EXPORT_SYMBOL(drm_panel_of_backlight); | |
302 | #endif | |
303 | ||
aead40ea TR |
304 | MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>"); |
305 | MODULE_DESCRIPTION("DRM panel infrastructure"); | |
306 | MODULE_LICENSE("GPL and additional rights"); |