[linux-2.6-block.git] / drivers / gpu / drm / imx / parallel-display.c

/*
 * i.MX drm driver - parallel display implementation
 *
 * Copyright (C) 2012 Sascha Hauer, Pengutronix
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/component.h>
#include <linux/module.h>
#include <drm/drmP.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_panel.h>
#include <linux/videodev2.h>
#include <video/of_display_timing.h>
#include <linux/of_graph.h>

#include "imx-drm.h"

#define con_to_imxpd(x) container_of(x, struct imx_parallel_display, connector)
#define enc_to_imxpd(x) container_of(x, struct imx_parallel_display, encoder)

struct imx_parallel_display {
	struct drm_connector connector;
	struct drm_encoder encoder;
	struct device *dev;
	void *edid;
	int edid_len;
	u32 bus_format;
	int mode_valid;
	struct drm_display_mode mode;
	struct drm_panel *panel;
};

static enum drm_connector_status imx_pd_connector_detect(
		struct drm_connector *connector, bool force)
{
	return connector_status_connected;
}

static int imx_pd_connector_get_modes(struct drm_connector *connector)
{
	struct imx_parallel_display *imxpd = con_to_imxpd(connector);
	struct device_node *np = imxpd->dev->of_node;
	int num_modes = 0;

	if (imxpd->panel && imxpd->panel->funcs &&
	    imxpd->panel->funcs->get_modes) {
		num_modes = imxpd->panel->funcs->get_modes(imxpd->panel);
		if (num_modes > 0)
			return num_modes;
	}

	if (imxpd->edid) {
		drm_mode_connector_update_edid_property(connector, imxpd->edid);
		num_modes = drm_add_edid_modes(connector, imxpd->edid);
	}

	if (imxpd->mode_valid) {
		struct drm_display_mode *mode = drm_mode_create(connector->dev);

		if (!mode)
			return -EINVAL;
		drm_mode_copy(mode, &imxpd->mode);
		mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
		drm_mode_probed_add(connector, mode);
		num_modes++;
	}

	if (np) {
		struct drm_display_mode *mode = drm_mode_create(connector->dev);

		if (!mode)
			return -EINVAL;
		of_get_drm_display_mode(np, &imxpd->mode, OF_USE_NATIVE_MODE);
		drm_mode_copy(mode, &imxpd->mode);
		mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
		drm_mode_probed_add(connector, mode);
		num_modes++;
	}

	return num_modes;
}

static struct drm_encoder *imx_pd_connector_best_encoder(
		struct drm_connector *connector)
{
	struct imx_parallel_display *imxpd = con_to_imxpd(connector);

	return &imxpd->encoder;
}

static void imx_pd_encoder_dpms(struct drm_encoder *encoder, int mode)
{
	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);

	if (mode != DRM_MODE_DPMS_ON)
		drm_panel_disable(imxpd->panel);
	else
		drm_panel_enable(imxpd->panel);
}

static bool imx_pd_encoder_mode_fixup(struct drm_encoder *encoder,
			   const struct drm_display_mode *mode,
			   struct drm_display_mode *adjusted_mode)
{
	return true;
}

static void imx_pd_encoder_prepare(struct drm_encoder *encoder)
{
	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);

	imx_drm_set_bus_format(encoder, imxpd->bus_format);
}

static void imx_pd_encoder_commit(struct drm_encoder *encoder)
{
	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);

	drm_panel_prepare(imxpd->panel);
	drm_panel_enable(imxpd->panel);
}

static void imx_pd_encoder_mode_set(struct drm_encoder *encoder,
			 struct drm_display_mode *orig_mode,
			 struct drm_display_mode *mode)
{
}

static void imx_pd_encoder_disable(struct drm_encoder *encoder)
{
	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);

	drm_panel_disable(imxpd->panel);
	drm_panel_unprepare(imxpd->panel);
}

static struct drm_connector_funcs imx_pd_connector_funcs = {
	.dpms = drm_helper_connector_dpms,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.detect = imx_pd_connector_detect,
	.destroy = imx_drm_connector_destroy,
};

static struct drm_connector_helper_funcs imx_pd_connector_helper_funcs = {
	.get_modes = imx_pd_connector_get_modes,
	.best_encoder = imx_pd_connector_best_encoder,
};

static struct drm_encoder_funcs imx_pd_encoder_funcs = {
	.destroy = imx_drm_encoder_destroy,
};

static struct drm_encoder_helper_funcs imx_pd_encoder_helper_funcs = {
	.dpms = imx_pd_encoder_dpms,
	.mode_fixup = imx_pd_encoder_mode_fixup,
	.prepare = imx_pd_encoder_prepare,
	.commit = imx_pd_encoder_commit,
	.mode_set = imx_pd_encoder_mode_set,
	.disable = imx_pd_encoder_disable,
};

static int imx_pd_register(struct drm_device *drm,
	struct imx_parallel_display *imxpd)
{
	int ret;

	ret = imx_drm_encoder_parse_of(drm, &imxpd->encoder,
				       imxpd->dev->of_node);
	if (ret)
		return ret;

	/* set the connector's dpms to OFF so that
	 * drm_helper_connector_dpms() won't return
	 * immediately since the current state is ON
	 * at this point.
	 */
	imxpd->connector.dpms = DRM_MODE_DPMS_OFF;

	drm_encoder_helper_add(&imxpd->encoder, &imx_pd_encoder_helper_funcs);
	drm_encoder_init(drm, &imxpd->encoder, &imx_pd_encoder_funcs,
			 DRM_MODE_ENCODER_NONE);

	drm_connector_helper_add(&imxpd->connector,
			&imx_pd_connector_helper_funcs);
	drm_connector_init(drm, &imxpd->connector, &imx_pd_connector_funcs,
			   DRM_MODE_CONNECTOR_VGA);

	if (imxpd->panel)
		drm_panel_attach(imxpd->panel, &imxpd->connector);

	drm_mode_connector_attach_encoder(&imxpd->connector, &imxpd->encoder);

	imxpd->connector.encoder = &imxpd->encoder;

	return 0;
}

static int imx_pd_bind(struct device *dev, struct device *master, void *data)
{
	struct drm_device *drm = data;
	struct device_node *np = dev->of_node;
	struct device_node *port;
	const u8 *edidp;
	struct imx_parallel_display *imxpd;
	int ret;
	const char *fmt;

	imxpd = devm_kzalloc(dev, sizeof(*imxpd), GFP_KERNEL);
	if (!imxpd)
		return -ENOMEM;

	edidp = of_get_property(np, "edid", &imxpd->edid_len);
	if (edidp)
		imxpd->edid = kmemdup(edidp, imxpd->edid_len, GFP_KERNEL);

	ret = of_property_read_string(np, "interface-pix-fmt", &fmt);
	if (!ret) {
		if (!strcmp(fmt, "rgb24"))
			imxpd->bus_format = MEDIA_BUS_FMT_RGB888_1X24;
		else if (!strcmp(fmt, "rgb565"))
			imxpd->bus_format = MEDIA_BUS_FMT_RGB565_1X16;
		else if (!strcmp(fmt, "bgr666"))
			imxpd->bus_format = MEDIA_BUS_FMT_RGB666_1X18;
		else if (!strcmp(fmt, "lvds666"))
			imxpd->bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI;
	}

	/* port@1 is the output port */
	port = of_graph_get_port_by_id(np, 1);
	if (port) {
		struct device_node *endpoint, *remote;

		endpoint = of_get_child_by_name(port, "endpoint");
		if (endpoint) {
			remote = of_graph_get_remote_port_parent(endpoint);
			if (remote)
				imxpd->panel = of_drm_find_panel(remote);
			if (!imxpd->panel)
				return -EPROBE_DEFER;
		}
	}

	imxpd->dev = dev;

	ret = imx_pd_register(drm, imxpd);
	if (ret)
		return ret;

	dev_set_drvdata(dev, imxpd);

	return 0;
}

static void imx_pd_unbind(struct device *dev, struct device *master,
	void *data)
{
	struct imx_parallel_display *imxpd = dev_get_drvdata(dev);

	imxpd->encoder.funcs->destroy(&imxpd->encoder);
	imxpd->connector.funcs->destroy(&imxpd->connector);

	kfree(imxpd->edid);
}

static const struct component_ops imx_pd_ops = {
	.bind	= imx_pd_bind,
	.unbind	= imx_pd_unbind,
};

static int imx_pd_probe(struct platform_device *pdev)
{
	return component_add(&pdev->dev, &imx_pd_ops);
}

static int imx_pd_remove(struct platform_device *pdev)
{
	component_del(&pdev->dev, &imx_pd_ops);

	return 0;
}

static const struct of_device_id imx_pd_dt_ids[] = {
	{ .compatible = "fsl,imx-parallel-display", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, imx_pd_dt_ids);

static struct platform_driver imx_pd_driver = {
	.probe		= imx_pd_probe,
	.remove		= imx_pd_remove,
	.driver		= {
		.of_match_table = imx_pd_dt_ids,
		.name	= "imx-parallel-display",
	},
};

module_platform_driver(imx_pd_driver);

MODULE_DESCRIPTION("i.MX parallel display driver");
MODULE_AUTHOR("Sascha Hauer, Pengutronix");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:imx-parallel-display");
Commit	Line	Data
19022aaa SH	1	/*
	2	* i.MX drm driver - parallel display implementation
	3	*
	4	* Copyright (C) 2012 Sascha Hauer, Pengutronix
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version 2
	9	* of the License, or (at your option) any later version.
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
19022aaa SH	14	*/
19022aaa SH	15
17b5001b	16	#include <linux/component.h>
19022aaa SH	17	#include <linux/module.h>
	18	#include <drm/drmP.h>
	19	#include <drm/drm_fb_helper.h>
	20	#include <drm/drm_crtc_helper.h>
628f435b	21	#include <drm/drm_panel.h>
19022aaa	22	#include <linux/videodev2.h>
075c457b	23	#include <video/of_display_timing.h>
553a59fc	24	#include <linux/of_graph.h>
19022aaa SH	25
	26	#include "imx-drm.h"
	27
	28	#define con_to_imxpd(x) container_of(x, struct imx_parallel_display, connector)
	29	#define enc_to_imxpd(x) container_of(x, struct imx_parallel_display, encoder)
	30
	31	struct imx_parallel_display {
	32	struct drm_connector connector;
19022aaa	33	struct drm_encoder encoder;
19022aaa SH	34	struct device *dev;
	35	void *edid;
	36	int edid_len;
2872c807	37	u32 bus_format;
19022aaa SH	38	int mode_valid;
19022aaa SH	39	struct drm_display_mode mode;
628f435b	40	struct drm_panel *panel;
19022aaa SH	41	};
	42
	43	static enum drm_connector_status imx_pd_connector_detect(
	44	struct drm_connector *connector, bool force)
	45	{
	46	return connector_status_connected;
	47	}
	48
19022aaa SH	49	static int imx_pd_connector_get_modes(struct drm_connector *connector)
	50	{
	51	struct imx_parallel_display *imxpd = con_to_imxpd(connector);
afb12edf	52	struct device_node *np = imxpd->dev->of_node;
19022aaa SH	53	int num_modes = 0;
19022aaa SH	54
628f435b PZ	55	if (imxpd->panel && imxpd->panel->funcs &&
	56	imxpd->panel->funcs->get_modes) {
	57	num_modes = imxpd->panel->funcs->get_modes(imxpd->panel);
	58	if (num_modes > 0)
	59	return num_modes;
	60	}
	61
19022aaa SH	62	if (imxpd->edid) {
	63	drm_mode_connector_update_edid_property(connector, imxpd->edid);
	64	num_modes = drm_add_edid_modes(connector, imxpd->edid);
	65	}
	66
	67	if (imxpd->mode_valid) {
	68	struct drm_display_mode *mode = drm_mode_create(connector->dev);
63bc5164	69
39dcf4f7 FE	70	if (!mode)
39dcf4f7 FE	71	return -EINVAL;
19022aaa SH	72	drm_mode_copy(mode, &imxpd->mode);
19022aaa SH	73	mode->type \|= DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED,
afb12edf MV	74	drm_mode_probed_add(connector, mode);
	75	num_modes++;
	76	}
	77
	78	if (np) {
	79	struct drm_display_mode *mode = drm_mode_create(connector->dev);
63bc5164	80
39dcf4f7 FE	81	if (!mode)
39dcf4f7 FE	82	return -EINVAL;
075c457b	83	of_get_drm_display_mode(np, &imxpd->mode, OF_USE_NATIVE_MODE);
afb12edf MV	84	drm_mode_copy(mode, &imxpd->mode);
afb12edf MV	85	mode->type \|= DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED,
19022aaa SH	86	drm_mode_probed_add(connector, mode);
	87	num_modes++;
	88	}
	89
	90	return num_modes;
	91	}
	92
19022aaa SH	93	static struct drm_encoder *imx_pd_connector_best_encoder(
	94	struct drm_connector *connector)
	95	{
	96	struct imx_parallel_display *imxpd = con_to_imxpd(connector);
	97
	98	return &imxpd->encoder;
	99	}
	100
	101	static void imx_pd_encoder_dpms(struct drm_encoder *encoder, int mode)
	102	{
628f435b PZ	103	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);
	104
	105	if (mode != DRM_MODE_DPMS_ON)
	106	drm_panel_disable(imxpd->panel);
	107	else
	108	drm_panel_enable(imxpd->panel);
19022aaa SH	109	}
	110
	111	static bool imx_pd_encoder_mode_fixup(struct drm_encoder *encoder,
	112	const struct drm_display_mode *mode,
	113	struct drm_display_mode *adjusted_mode)
	114	{
	115	return true;
	116	}
	117
	118	static void imx_pd_encoder_prepare(struct drm_encoder *encoder)
	119	{
	120	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);
	121
2872c807	122	imx_drm_set_bus_format(encoder, imxpd->bus_format);
19022aaa SH	123	}
	124
	125	static void imx_pd_encoder_commit(struct drm_encoder *encoder)
	126	{
ad92c8bf PZ	127	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);
	128
	129	drm_panel_prepare(imxpd->panel);
	130	drm_panel_enable(imxpd->panel);
19022aaa SH	131	}
	132
	133	static void imx_pd_encoder_mode_set(struct drm_encoder *encoder,
eb10d635 SL	134	struct drm_display_mode *orig_mode,
eb10d635 SL	135	struct drm_display_mode *mode)
19022aaa SH	136	{
	137	}
	138
	139	static void imx_pd_encoder_disable(struct drm_encoder *encoder)
	140	{
ad92c8bf PZ	141	struct imx_parallel_display *imxpd = enc_to_imxpd(encoder);
	142
	143	drm_panel_disable(imxpd->panel);
	144	drm_panel_unprepare(imxpd->panel);
19022aaa SH	145	}
19022aaa SH	146
19022aaa SH	147	static struct drm_connector_funcs imx_pd_connector_funcs = {
	148	.dpms = drm_helper_connector_dpms,
	149	.fill_modes = drm_helper_probe_single_connector_modes,
	150	.detect = imx_pd_connector_detect,
1b3f7675	151	.destroy = imx_drm_connector_destroy,
19022aaa SH	152	};
	153
	154	static struct drm_connector_helper_funcs imx_pd_connector_helper_funcs = {
	155	.get_modes = imx_pd_connector_get_modes,
	156	.best_encoder = imx_pd_connector_best_encoder,
19022aaa SH	157	};
	158
	159	static struct drm_encoder_funcs imx_pd_encoder_funcs = {
1b3f7675	160	.destroy = imx_drm_encoder_destroy,
19022aaa SH	161	};
	162
	163	static struct drm_encoder_helper_funcs imx_pd_encoder_helper_funcs = {
	164	.dpms = imx_pd_encoder_dpms,
	165	.mode_fixup = imx_pd_encoder_mode_fixup,
	166	.prepare = imx_pd_encoder_prepare,
	167	.commit = imx_pd_encoder_commit,
	168	.mode_set = imx_pd_encoder_mode_set,
	169	.disable = imx_pd_encoder_disable,
	170	};
	171
1b3f7675 RK	172	static int imx_pd_register(struct drm_device *drm,
1b3f7675 RK	173	struct imx_parallel_display *imxpd)
19022aaa SH	174	{
	175	int ret;
	176
1b3f7675 RK	177	ret = imx_drm_encoder_parse_of(drm, &imxpd->encoder,
	178	imxpd->dev->of_node);
	179	if (ret)
	180	return ret;
19022aaa	181
c026a3f3 DC	182	/* set the connector's dpms to OFF so that
	183	* drm_helper_connector_dpms() won't return
	184	* immediately since the current state is ON
	185	* at this point.
	186	*/
	187	imxpd->connector.dpms = DRM_MODE_DPMS_OFF;
	188
19022aaa	189	drm_encoder_helper_add(&imxpd->encoder, &imx_pd_encoder_helper_funcs);
1b3f7675 RK	190	drm_encoder_init(drm, &imxpd->encoder, &imx_pd_encoder_funcs,
1b3f7675 RK	191	DRM_MODE_ENCODER_NONE);
19022aaa SH	192
	193	drm_connector_helper_add(&imxpd->connector,
	194	&imx_pd_connector_helper_funcs);
1b3f7675 RK	195	drm_connector_init(drm, &imxpd->connector, &imx_pd_connector_funcs,
1b3f7675 RK	196	DRM_MODE_CONNECTOR_VGA);
19022aaa	197
628f435b PZ	198	if (imxpd->panel)
	199	drm_panel_attach(imxpd->panel, &imxpd->connector);
	200
1b3f7675	201	drm_mode_connector_attach_encoder(&imxpd->connector, &imxpd->encoder);
19022aaa SH	202
	203	imxpd->connector.encoder = &imxpd->encoder;
	204
	205	return 0;
	206	}
	207
17b5001b	208	static int imx_pd_bind(struct device dev, struct device master, void *data)
19022aaa	209	{
1b3f7675	210	struct drm_device *drm = data;
17b5001b	211	struct device_node *np = dev->of_node;
553a59fc	212	struct device_node *port;
19022aaa SH	213	const u8 *edidp;
	214	struct imx_parallel_display *imxpd;
	215	int ret;
	216	const char *fmt;
	217
17b5001b	218	imxpd = devm_kzalloc(dev, sizeof(*imxpd), GFP_KERNEL);
19022aaa SH	219	if (!imxpd)
	220	return -ENOMEM;
	221
	222	edidp = of_get_property(np, "edid", &imxpd->edid_len);
	223	if (edidp)
	224	imxpd->edid = kmemdup(edidp, imxpd->edid_len, GFP_KERNEL);
	225
	226	ret = of_property_read_string(np, "interface-pix-fmt", &fmt);
	227	if (!ret) {
	228	if (!strcmp(fmt, "rgb24"))
2872c807	229	imxpd->bus_format = MEDIA_BUS_FMT_RGB888_1X24;
19022aaa	230	else if (!strcmp(fmt, "rgb565"))
2872c807	231	imxpd->bus_format = MEDIA_BUS_FMT_RGB565_1X16;
7d0a66c0	232	else if (!strcmp(fmt, "bgr666"))
2872c807	233	imxpd->bus_format = MEDIA_BUS_FMT_RGB666_1X18;
9e74d292	234	else if (!strcmp(fmt, "lvds666"))
2872c807	235	imxpd->bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI;
19022aaa SH	236	}
19022aaa SH	237
553a59fc PZ	238	/* port@1 is the output port */
	239	port = of_graph_get_port_by_id(np, 1);
	240	if (port) {
	241	struct device_node endpoint, remote;
	242
	243	endpoint = of_get_child_by_name(port, "endpoint");
	244	if (endpoint) {
	245	remote = of_graph_get_remote_port_parent(endpoint);
	246	if (remote)
	247	imxpd->panel = of_drm_find_panel(remote);
	248	if (!imxpd->panel)
	249	return -EPROBE_DEFER;
	250	}
d70e96ae	251	}
628f435b	252
17b5001b	253	imxpd->dev = dev;
19022aaa	254
1b3f7675	255	ret = imx_pd_register(drm, imxpd);
19022aaa SH	256	if (ret)
	257	return ret;
	258
17b5001b	259	dev_set_drvdata(dev, imxpd);
19022aaa SH	260
	261	return 0;
	262	}
	263
17b5001b RK	264	static void imx_pd_unbind(struct device dev, struct device master,
17b5001b RK	265	void *data)
19022aaa	266	{
17b5001b	267	struct imx_parallel_display *imxpd = dev_get_drvdata(dev);
19022aaa	268
1b3f7675 RK	269	imxpd->encoder.funcs->destroy(&imxpd->encoder);
1b3f7675 RK	270	imxpd->connector.funcs->destroy(&imxpd->connector);
dcbc9eb1 PS	271
dcbc9eb1 PS	272	kfree(imxpd->edid);
17b5001b	273	}
19022aaa	274
17b5001b RK	275	static const struct component_ops imx_pd_ops = {
	276	.bind = imx_pd_bind,
	277	.unbind = imx_pd_unbind,
	278	};
	279
	280	static int imx_pd_probe(struct platform_device *pdev)
	281	{
	282	return component_add(&pdev->dev, &imx_pd_ops);
	283	}
	284
	285	static int imx_pd_remove(struct platform_device *pdev)
	286	{
	287	component_del(&pdev->dev, &imx_pd_ops);
dcbc9eb1	288
19022aaa SH	289	return 0;
	290	}
	291
	292	static const struct of_device_id imx_pd_dt_ids[] = {
	293	{ .compatible = "fsl,imx-parallel-display", },
	294	{ /* sentinel */ }
	295	};
fa45f2c7	296	MODULE_DEVICE_TABLE(of, imx_pd_dt_ids);
19022aaa SH	297
	298	static struct platform_driver imx_pd_driver = {
	299	.probe = imx_pd_probe,
99c28f10	300	.remove = imx_pd_remove,
19022aaa SH	301	.driver = {
	302	.of_match_table = imx_pd_dt_ids,
	303	.name = "imx-parallel-display",
19022aaa SH	304	},
	305	};
	306
	307	module_platform_driver(imx_pd_driver);
	308
	309	MODULE_DESCRIPTION("i.MX parallel display driver");
	310	MODULE_AUTHOR("Sascha Hauer, Pengutronix");
	311	MODULE_LICENSE("GPL");
b2da05ff	312	MODULE_ALIAS("platform:imx-parallel-display");