1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * i.MX drm driver - parallel display implementation
4 *
5 * Copyright (C) 2012 Sascha Hauer, Pengutronix
6 */
7
8 #include <linux/component.h>
9 #include <linux/media-bus-format.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/platform_device.h>
13 #include <linux/videodev2.h>
14
15 #include <drm/drm_atomic_helper.h>
16 #include <drm/drm_bridge.h>
17 #include <drm/drm_bridge_connector.h>
18 #include <drm/drm_managed.h>
19 #include <drm/drm_of.h>
20 #include <drm/drm_probe_helper.h>
21 #include <drm/drm_simple_kms_helper.h>
22 #include <drm/bridge/imx.h>
23
24 #include "imx-drm.h"
25
26 struct imx_parallel_display_encoder {
27 struct drm_encoder encoder;
28 struct drm_bridge bridge;
29 struct imx_parallel_display *pd;
30 };
31
32 struct imx_parallel_display {
33 struct device *dev;
34 u32 bus_format;
35 struct drm_bridge *next_bridge;
36 };
37
bridge_to_imxpd(struct drm_bridge * b)38 static inline struct imx_parallel_display *bridge_to_imxpd(struct drm_bridge *b)
39 {
40 return container_of(b, struct imx_parallel_display_encoder, bridge)->pd;
41 }
42
43 static const u32 imx_pd_bus_fmts[] = {
44 MEDIA_BUS_FMT_RGB888_1X24,
45 MEDIA_BUS_FMT_BGR888_1X24,
46 MEDIA_BUS_FMT_GBR888_1X24,
47 MEDIA_BUS_FMT_RGB666_1X18,
48 MEDIA_BUS_FMT_RGB666_1X24_CPADHI,
49 MEDIA_BUS_FMT_RGB565_1X16,
50 };
51
52 static u32 *
imx_pd_bridge_atomic_get_output_bus_fmts(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state,unsigned int * num_output_fmts)53 imx_pd_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge,
54 struct drm_bridge_state *bridge_state,
55 struct drm_crtc_state *crtc_state,
56 struct drm_connector_state *conn_state,
57 unsigned int *num_output_fmts)
58 {
59 struct drm_display_info *di = &conn_state->connector->display_info;
60 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge);
61 u32 *output_fmts;
62
63 if (!imxpd->bus_format && !di->num_bus_formats) {
64 *num_output_fmts = ARRAY_SIZE(imx_pd_bus_fmts);
65 return kmemdup(imx_pd_bus_fmts, sizeof(imx_pd_bus_fmts),
66 GFP_KERNEL);
67 }
68
69 *num_output_fmts = 1;
70 output_fmts = kmalloc(sizeof(*output_fmts), GFP_KERNEL);
71 if (!output_fmts)
72 return NULL;
73
74 if (!imxpd->bus_format && di->num_bus_formats)
75 output_fmts[0] = di->bus_formats[0];
76 else
77 output_fmts[0] = imxpd->bus_format;
78
79 return output_fmts;
80 }
81
imx_pd_format_supported(u32 output_fmt)82 static bool imx_pd_format_supported(u32 output_fmt)
83 {
84 unsigned int i;
85
86 for (i = 0; i < ARRAY_SIZE(imx_pd_bus_fmts); i++) {
87 if (imx_pd_bus_fmts[i] == output_fmt)
88 return true;
89 }
90
91 return false;
92 }
93
94 static u32 *
imx_pd_bridge_atomic_get_input_bus_fmts(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state,u32 output_fmt,unsigned int * num_input_fmts)95 imx_pd_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge,
96 struct drm_bridge_state *bridge_state,
97 struct drm_crtc_state *crtc_state,
98 struct drm_connector_state *conn_state,
99 u32 output_fmt,
100 unsigned int *num_input_fmts)
101 {
102 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge);
103 u32 *input_fmts;
104
105 /*
106 * If the next bridge does not support bus format negotiation, let's
107 * use the static bus format definition (imxpd->bus_format) if it's
108 * specified, RGB888 when it's not.
109 */
110 if (output_fmt == MEDIA_BUS_FMT_FIXED)
111 output_fmt = imxpd->bus_format ? : MEDIA_BUS_FMT_RGB888_1X24;
112
113 /* Now make sure the requested output format is supported. */
114 if ((imxpd->bus_format && imxpd->bus_format != output_fmt) ||
115 !imx_pd_format_supported(output_fmt)) {
116 *num_input_fmts = 0;
117 return NULL;
118 }
119
120 *num_input_fmts = 1;
121 input_fmts = kmalloc(sizeof(*input_fmts), GFP_KERNEL);
122 if (!input_fmts)
123 return NULL;
124
125 input_fmts[0] = output_fmt;
126 return input_fmts;
127 }
128
imx_pd_bridge_atomic_check(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state)129 static int imx_pd_bridge_atomic_check(struct drm_bridge *bridge,
130 struct drm_bridge_state *bridge_state,
131 struct drm_crtc_state *crtc_state,
132 struct drm_connector_state *conn_state)
133 {
134 struct imx_crtc_state *imx_crtc_state = to_imx_crtc_state(crtc_state);
135 struct drm_display_info *di = &conn_state->connector->display_info;
136 struct drm_bridge_state *next_bridge_state = NULL;
137 struct drm_bridge *next_bridge;
138 u32 bus_flags, bus_fmt;
139
140 next_bridge = drm_bridge_get_next_bridge(bridge);
141 if (next_bridge)
142 next_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
143 next_bridge);
144
145 if (next_bridge_state)
146 bus_flags = next_bridge_state->input_bus_cfg.flags;
147 else
148 bus_flags = di->bus_flags;
149
150 bus_fmt = bridge_state->input_bus_cfg.format;
151 if (!imx_pd_format_supported(bus_fmt))
152 return -EINVAL;
153
154 bridge_state->output_bus_cfg.flags = bus_flags;
155 bridge_state->input_bus_cfg.flags = bus_flags;
156 imx_crtc_state->bus_flags = bus_flags;
157 imx_crtc_state->bus_format = bridge_state->input_bus_cfg.format;
158 imx_crtc_state->di_hsync_pin = 2;
159 imx_crtc_state->di_vsync_pin = 3;
160
161 return 0;
162 }
163
imx_pd_bridge_attach(struct drm_bridge * bridge,struct drm_encoder * encoder,enum drm_bridge_attach_flags flags)164 static int imx_pd_bridge_attach(struct drm_bridge *bridge,
165 struct drm_encoder *encoder,
166 enum drm_bridge_attach_flags flags)
167 {
168 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge);
169
170 return drm_bridge_attach(encoder, imxpd->next_bridge, bridge, flags);
171 }
172
173 static const struct drm_bridge_funcs imx_pd_bridge_funcs = {
174 .attach = imx_pd_bridge_attach,
175 .atomic_reset = drm_atomic_helper_bridge_reset,
176 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
177 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
178 .atomic_check = imx_pd_bridge_atomic_check,
179 .atomic_get_input_bus_fmts = imx_pd_bridge_atomic_get_input_bus_fmts,
180 .atomic_get_output_bus_fmts = imx_pd_bridge_atomic_get_output_bus_fmts,
181 };
182
imx_pd_bind(struct device * dev,struct device * master,void * data)183 static int imx_pd_bind(struct device *dev, struct device *master, void *data)
184 {
185 struct drm_device *drm = data;
186 struct imx_parallel_display *imxpd = dev_get_drvdata(dev);
187 struct imx_parallel_display_encoder *imxpd_encoder;
188 struct drm_connector *connector;
189 struct drm_encoder *encoder;
190 struct drm_bridge *bridge;
191 int ret;
192
193 imxpd_encoder = drmm_simple_encoder_alloc(drm, struct imx_parallel_display_encoder,
194 encoder, DRM_MODE_ENCODER_NONE);
195 if (IS_ERR(imxpd_encoder))
196 return PTR_ERR(imxpd_encoder);
197
198 imxpd_encoder->pd = imxpd;
199 encoder = &imxpd_encoder->encoder;
200 bridge = &imxpd_encoder->bridge;
201
202 ret = imx_drm_encoder_parse_of(drm, encoder, imxpd->dev->of_node);
203 if (ret)
204 return ret;
205
206 bridge->funcs = &imx_pd_bridge_funcs;
207 drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR);
208
209 connector = drm_bridge_connector_init(drm, encoder);
210 if (IS_ERR(connector))
211 return PTR_ERR(connector);
212
213 drm_connector_attach_encoder(connector, encoder);
214
215 return 0;
216 }
217
218 static const struct component_ops imx_pd_ops = {
219 .bind = imx_pd_bind,
220 };
221
imx_pd_probe(struct platform_device * pdev)222 static int imx_pd_probe(struct platform_device *pdev)
223 {
224 struct device *dev = &pdev->dev;
225 struct device_node *np = dev->of_node;
226 struct imx_parallel_display *imxpd;
227 int ret;
228 u32 bus_format = 0;
229 const char *fmt;
230
231 imxpd = devm_kzalloc(dev, sizeof(*imxpd), GFP_KERNEL);
232 if (!imxpd)
233 return -ENOMEM;
234
235 /* port@1 is the output port */
236 imxpd->next_bridge = devm_drm_of_get_bridge(dev, np, 1, 0);
237 if (imxpd->next_bridge == ERR_PTR(-ENODEV))
238 imxpd->next_bridge = devm_imx_drm_legacy_bridge(dev, np, DRM_MODE_CONNECTOR_DPI);
239 if (IS_ERR(imxpd->next_bridge)) {
240 ret = PTR_ERR(imxpd->next_bridge);
241 return ret;
242 }
243
244 ret = of_property_read_string(np, "interface-pix-fmt", &fmt);
245 if (!ret) {
246 if (!strcmp(fmt, "rgb24"))
247 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
248 else if (!strcmp(fmt, "rgb565"))
249 bus_format = MEDIA_BUS_FMT_RGB565_1X16;
250 else if (!strcmp(fmt, "bgr666"))
251 bus_format = MEDIA_BUS_FMT_RGB666_1X18;
252 else if (!strcmp(fmt, "lvds666"))
253 bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI;
254 }
255 imxpd->bus_format = bus_format;
256
257 imxpd->dev = dev;
258
259 platform_set_drvdata(pdev, imxpd);
260
261 return component_add(dev, &imx_pd_ops);
262 }
263
imx_pd_remove(struct platform_device * pdev)264 static void imx_pd_remove(struct platform_device *pdev)
265 {
266 component_del(&pdev->dev, &imx_pd_ops);
267 }
268
269 static const struct of_device_id imx_pd_dt_ids[] = {
270 { .compatible = "fsl,imx-parallel-display", },
271 { /* sentinel */ }
272 };
273 MODULE_DEVICE_TABLE(of, imx_pd_dt_ids);
274
275 static struct platform_driver imx_pd_driver = {
276 .probe = imx_pd_probe,
277 .remove = imx_pd_remove,
278 .driver = {
279 .of_match_table = imx_pd_dt_ids,
280 .name = "imx-parallel-display",
281 },
282 };
283
284 module_platform_driver(imx_pd_driver);
285
286 MODULE_DESCRIPTION("i.MX parallel display driver");
287 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
288 MODULE_LICENSE("GPL");
289 MODULE_ALIAS("platform:imx-parallel-display");
290