1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2012 Texas Instruments |
4 | * Author: Rob Clark <robdclark@gmail.com> |
5 | */ |
6 | |
7 | #include <linux/backlight.h> |
8 | #include <linux/gpio/consumer.h> |
9 | #include <linux/pinctrl/consumer.h> |
10 | #include <linux/platform_device.h> |
11 | |
12 | #include <video/display_timing.h> |
13 | #include <video/of_display_timing.h> |
14 | #include <video/videomode.h> |
15 | |
16 | #include <drm/drm_atomic_state_helper.h> |
17 | #include <drm/drm_connector.h> |
18 | #include <drm/drm_modeset_helper_vtables.h> |
19 | #include <drm/drm_probe_helper.h> |
20 | #include <drm/drm_simple_kms_helper.h> |
21 | |
22 | #include "tilcdc_drv.h" |
23 | #include "tilcdc_panel.h" |
24 | |
25 | struct panel_module { |
26 | struct tilcdc_module base; |
27 | struct tilcdc_panel_info *info; |
28 | struct display_timings *timings; |
29 | struct backlight_device *backlight; |
30 | struct gpio_desc *enable_gpio; |
31 | }; |
32 | #define to_panel_module(x) container_of(x, struct panel_module, base) |
33 | |
34 | |
35 | /* |
36 | * Encoder: |
37 | */ |
38 | |
39 | struct panel_encoder { |
40 | struct drm_encoder base; |
41 | struct panel_module *mod; |
42 | }; |
43 | #define to_panel_encoder(x) container_of(x, struct panel_encoder, base) |
44 | |
45 | static void panel_encoder_dpms(struct drm_encoder *encoder, int mode) |
46 | { |
47 | struct panel_encoder *panel_encoder = to_panel_encoder(encoder); |
48 | struct backlight_device *backlight = panel_encoder->mod->backlight; |
49 | struct gpio_desc *gpio = panel_encoder->mod->enable_gpio; |
50 | |
51 | if (backlight) { |
52 | backlight->props.power = mode == DRM_MODE_DPMS_ON ? |
53 | FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; |
54 | backlight_update_status(bd: backlight); |
55 | } |
56 | |
57 | if (gpio) |
58 | gpiod_set_value_cansleep(desc: gpio, |
59 | value: mode == DRM_MODE_DPMS_ON ? 1 : 0); |
60 | } |
61 | |
62 | static void panel_encoder_prepare(struct drm_encoder *encoder) |
63 | { |
64 | panel_encoder_dpms(encoder, DRM_MODE_DPMS_OFF); |
65 | } |
66 | |
67 | static void panel_encoder_commit(struct drm_encoder *encoder) |
68 | { |
69 | panel_encoder_dpms(encoder, DRM_MODE_DPMS_ON); |
70 | } |
71 | |
72 | static void panel_encoder_mode_set(struct drm_encoder *encoder, |
73 | struct drm_display_mode *mode, |
74 | struct drm_display_mode *adjusted_mode) |
75 | { |
76 | /* nothing needed */ |
77 | } |
78 | |
79 | static const struct drm_encoder_helper_funcs panel_encoder_helper_funcs = { |
80 | .dpms = panel_encoder_dpms, |
81 | .prepare = panel_encoder_prepare, |
82 | .commit = panel_encoder_commit, |
83 | .mode_set = panel_encoder_mode_set, |
84 | }; |
85 | |
86 | static struct drm_encoder *panel_encoder_create(struct drm_device *dev, |
87 | struct panel_module *mod) |
88 | { |
89 | struct panel_encoder *panel_encoder; |
90 | struct drm_encoder *encoder; |
91 | int ret; |
92 | |
93 | panel_encoder = devm_kzalloc(dev: dev->dev, size: sizeof(*panel_encoder), |
94 | GFP_KERNEL); |
95 | if (!panel_encoder) |
96 | return NULL; |
97 | |
98 | panel_encoder->mod = mod; |
99 | |
100 | encoder = &panel_encoder->base; |
101 | encoder->possible_crtcs = 1; |
102 | |
103 | ret = drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_LVDS); |
104 | if (ret < 0) |
105 | goto fail; |
106 | |
107 | drm_encoder_helper_add(encoder, funcs: &panel_encoder_helper_funcs); |
108 | |
109 | return encoder; |
110 | |
111 | fail: |
112 | drm_encoder_cleanup(encoder); |
113 | return NULL; |
114 | } |
115 | |
116 | /* |
117 | * Connector: |
118 | */ |
119 | |
120 | struct panel_connector { |
121 | struct drm_connector base; |
122 | |
123 | struct drm_encoder *encoder; /* our connected encoder */ |
124 | struct panel_module *mod; |
125 | }; |
126 | #define to_panel_connector(x) container_of(x, struct panel_connector, base) |
127 | |
128 | |
129 | static void panel_connector_destroy(struct drm_connector *connector) |
130 | { |
131 | drm_connector_unregister(connector); |
132 | drm_connector_cleanup(connector); |
133 | } |
134 | |
135 | static int panel_connector_get_modes(struct drm_connector *connector) |
136 | { |
137 | struct drm_device *dev = connector->dev; |
138 | struct panel_connector *panel_connector = to_panel_connector(connector); |
139 | struct display_timings *timings = panel_connector->mod->timings; |
140 | int i; |
141 | |
142 | for (i = 0; i < timings->num_timings; i++) { |
143 | struct drm_display_mode *mode; |
144 | struct videomode vm; |
145 | |
146 | if (videomode_from_timings(disp: timings, vm: &vm, index: i)) |
147 | break; |
148 | |
149 | mode = drm_mode_create(dev); |
150 | if (!mode) |
151 | break; |
152 | |
153 | drm_display_mode_from_videomode(vm: &vm, dmode: mode); |
154 | |
155 | mode->type = DRM_MODE_TYPE_DRIVER; |
156 | |
157 | if (timings->native_mode == i) |
158 | mode->type |= DRM_MODE_TYPE_PREFERRED; |
159 | |
160 | drm_mode_set_name(mode); |
161 | drm_mode_probed_add(connector, mode); |
162 | } |
163 | |
164 | return i; |
165 | } |
166 | |
167 | static struct drm_encoder *panel_connector_best_encoder( |
168 | struct drm_connector *connector) |
169 | { |
170 | struct panel_connector *panel_connector = to_panel_connector(connector); |
171 | return panel_connector->encoder; |
172 | } |
173 | |
174 | static const struct drm_connector_funcs panel_connector_funcs = { |
175 | .destroy = panel_connector_destroy, |
176 | .fill_modes = drm_helper_probe_single_connector_modes, |
177 | .reset = drm_atomic_helper_connector_reset, |
178 | .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, |
179 | .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, |
180 | }; |
181 | |
182 | static const struct drm_connector_helper_funcs panel_connector_helper_funcs = { |
183 | .get_modes = panel_connector_get_modes, |
184 | .best_encoder = panel_connector_best_encoder, |
185 | }; |
186 | |
187 | static struct drm_connector *panel_connector_create(struct drm_device *dev, |
188 | struct panel_module *mod, struct drm_encoder *encoder) |
189 | { |
190 | struct panel_connector *panel_connector; |
191 | struct drm_connector *connector; |
192 | int ret; |
193 | |
194 | panel_connector = devm_kzalloc(dev: dev->dev, size: sizeof(*panel_connector), |
195 | GFP_KERNEL); |
196 | if (!panel_connector) |
197 | return NULL; |
198 | |
199 | panel_connector->encoder = encoder; |
200 | panel_connector->mod = mod; |
201 | |
202 | connector = &panel_connector->base; |
203 | |
204 | drm_connector_init(dev, connector, funcs: &panel_connector_funcs, |
205 | DRM_MODE_CONNECTOR_LVDS); |
206 | drm_connector_helper_add(connector, funcs: &panel_connector_helper_funcs); |
207 | |
208 | connector->interlace_allowed = 0; |
209 | connector->doublescan_allowed = 0; |
210 | |
211 | ret = drm_connector_attach_encoder(connector, encoder); |
212 | if (ret) |
213 | goto fail; |
214 | |
215 | return connector; |
216 | |
217 | fail: |
218 | panel_connector_destroy(connector); |
219 | return NULL; |
220 | } |
221 | |
222 | /* |
223 | * Module: |
224 | */ |
225 | |
226 | static int panel_modeset_init(struct tilcdc_module *mod, struct drm_device *dev) |
227 | { |
228 | struct panel_module *panel_mod = to_panel_module(mod); |
229 | struct tilcdc_drm_private *priv = dev->dev_private; |
230 | struct drm_encoder *encoder; |
231 | struct drm_connector *connector; |
232 | |
233 | encoder = panel_encoder_create(dev, mod: panel_mod); |
234 | if (!encoder) |
235 | return -ENOMEM; |
236 | |
237 | connector = panel_connector_create(dev, mod: panel_mod, encoder); |
238 | if (!connector) |
239 | return -ENOMEM; |
240 | |
241 | priv->encoders[priv->num_encoders++] = encoder; |
242 | priv->connectors[priv->num_connectors++] = connector; |
243 | |
244 | tilcdc_crtc_set_panel_info(crtc: priv->crtc, |
245 | to_panel_encoder(encoder)->mod->info); |
246 | |
247 | return 0; |
248 | } |
249 | |
250 | static const struct tilcdc_module_ops panel_module_ops = { |
251 | .modeset_init = panel_modeset_init, |
252 | }; |
253 | |
254 | /* |
255 | * Device: |
256 | */ |
257 | |
258 | /* maybe move this somewhere common if it is needed by other outputs? */ |
259 | static struct tilcdc_panel_info *of_get_panel_info(struct device_node *np) |
260 | { |
261 | struct device_node *info_np; |
262 | struct tilcdc_panel_info *info; |
263 | int ret = 0; |
264 | |
265 | if (!np) { |
266 | pr_err("%s: no devicenode given\n" , __func__); |
267 | return NULL; |
268 | } |
269 | |
270 | info_np = of_get_child_by_name(node: np, name: "panel-info" ); |
271 | if (!info_np) { |
272 | pr_err("%s: could not find panel-info node\n" , __func__); |
273 | return NULL; |
274 | } |
275 | |
276 | info = kzalloc(size: sizeof(*info), GFP_KERNEL); |
277 | if (!info) |
278 | goto put_node; |
279 | |
280 | ret |= of_property_read_u32(np: info_np, propname: "ac-bias" , out_value: &info->ac_bias); |
281 | ret |= of_property_read_u32(np: info_np, propname: "ac-bias-intrpt" , out_value: &info->ac_bias_intrpt); |
282 | ret |= of_property_read_u32(np: info_np, propname: "dma-burst-sz" , out_value: &info->dma_burst_sz); |
283 | ret |= of_property_read_u32(np: info_np, propname: "bpp" , out_value: &info->bpp); |
284 | ret |= of_property_read_u32(np: info_np, propname: "fdd" , out_value: &info->fdd); |
285 | ret |= of_property_read_u32(np: info_np, propname: "sync-edge" , out_value: &info->sync_edge); |
286 | ret |= of_property_read_u32(np: info_np, propname: "sync-ctrl" , out_value: &info->sync_ctrl); |
287 | ret |= of_property_read_u32(np: info_np, propname: "raster-order" , out_value: &info->raster_order); |
288 | ret |= of_property_read_u32(np: info_np, propname: "fifo-th" , out_value: &info->fifo_th); |
289 | |
290 | /* optional: */ |
291 | info->tft_alt_mode = of_property_read_bool(np: info_np, propname: "tft-alt-mode" ); |
292 | info->invert_pxl_clk = of_property_read_bool(np: info_np, propname: "invert-pxl-clk" ); |
293 | |
294 | if (ret) { |
295 | pr_err("%s: error reading panel-info properties\n" , __func__); |
296 | kfree(objp: info); |
297 | info = NULL; |
298 | } |
299 | |
300 | put_node: |
301 | of_node_put(node: info_np); |
302 | return info; |
303 | } |
304 | |
305 | static int panel_probe(struct platform_device *pdev) |
306 | { |
307 | struct device_node *node = pdev->dev.of_node; |
308 | struct backlight_device *backlight; |
309 | struct panel_module *panel_mod; |
310 | struct tilcdc_module *mod; |
311 | struct pinctrl *pinctrl; |
312 | int ret; |
313 | |
314 | /* bail out early if no DT data: */ |
315 | if (!node) { |
316 | dev_err(&pdev->dev, "device-tree data is missing\n" ); |
317 | return -ENXIO; |
318 | } |
319 | |
320 | panel_mod = devm_kzalloc(dev: &pdev->dev, size: sizeof(*panel_mod), GFP_KERNEL); |
321 | if (!panel_mod) |
322 | return -ENOMEM; |
323 | |
324 | backlight = devm_of_find_backlight(dev: &pdev->dev); |
325 | if (IS_ERR(ptr: backlight)) |
326 | return PTR_ERR(ptr: backlight); |
327 | panel_mod->backlight = backlight; |
328 | |
329 | panel_mod->enable_gpio = devm_gpiod_get_optional(dev: &pdev->dev, con_id: "enable" , |
330 | flags: GPIOD_OUT_LOW); |
331 | if (IS_ERR(ptr: panel_mod->enable_gpio)) { |
332 | ret = PTR_ERR(ptr: panel_mod->enable_gpio); |
333 | dev_err(&pdev->dev, "failed to request enable GPIO\n" ); |
334 | goto fail_backlight; |
335 | } |
336 | |
337 | if (panel_mod->enable_gpio) |
338 | dev_info(&pdev->dev, "found enable GPIO\n" ); |
339 | |
340 | mod = &panel_mod->base; |
341 | pdev->dev.platform_data = mod; |
342 | |
343 | tilcdc_module_init(mod, name: "panel" , funcs: &panel_module_ops); |
344 | |
345 | pinctrl = devm_pinctrl_get_select_default(dev: &pdev->dev); |
346 | if (IS_ERR(ptr: pinctrl)) |
347 | dev_warn(&pdev->dev, "pins are not configured\n" ); |
348 | |
349 | panel_mod->timings = of_get_display_timings(np: node); |
350 | if (!panel_mod->timings) { |
351 | dev_err(&pdev->dev, "could not get panel timings\n" ); |
352 | ret = -EINVAL; |
353 | goto fail_free; |
354 | } |
355 | |
356 | panel_mod->info = of_get_panel_info(np: node); |
357 | if (!panel_mod->info) { |
358 | dev_err(&pdev->dev, "could not get panel info\n" ); |
359 | ret = -EINVAL; |
360 | goto fail_timings; |
361 | } |
362 | |
363 | return 0; |
364 | |
365 | fail_timings: |
366 | display_timings_release(disp: panel_mod->timings); |
367 | |
368 | fail_free: |
369 | tilcdc_module_cleanup(mod); |
370 | |
371 | fail_backlight: |
372 | if (panel_mod->backlight) |
373 | put_device(dev: &panel_mod->backlight->dev); |
374 | return ret; |
375 | } |
376 | |
377 | static void panel_remove(struct platform_device *pdev) |
378 | { |
379 | struct tilcdc_module *mod = dev_get_platdata(dev: &pdev->dev); |
380 | struct panel_module *panel_mod = to_panel_module(mod); |
381 | struct backlight_device *backlight = panel_mod->backlight; |
382 | |
383 | if (backlight) |
384 | put_device(dev: &backlight->dev); |
385 | |
386 | display_timings_release(disp: panel_mod->timings); |
387 | |
388 | tilcdc_module_cleanup(mod); |
389 | kfree(objp: panel_mod->info); |
390 | } |
391 | |
392 | static const struct of_device_id panel_of_match[] = { |
393 | { .compatible = "ti,tilcdc,panel" , }, |
394 | { }, |
395 | }; |
396 | |
397 | static struct platform_driver panel_driver = { |
398 | .probe = panel_probe, |
399 | .remove_new = panel_remove, |
400 | .driver = { |
401 | .name = "tilcdc-panel" , |
402 | .of_match_table = panel_of_match, |
403 | }, |
404 | }; |
405 | |
406 | int __init tilcdc_panel_init(void) |
407 | { |
408 | return platform_driver_register(&panel_driver); |
409 | } |
410 | |
411 | void __exit tilcdc_panel_fini(void) |
412 | { |
413 | platform_driver_unregister(&panel_driver); |
414 | } |
415 | |