parallel-display.c

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