[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / atmel-hlcdc / atmel_hlcdc_output.c

/*
 * Copyright (C) 2014 Traphandler
 * Copyright (C) 2014 Free Electrons
 * Copyright (C) 2014 Atmel
 *
 * Author: Jean-Jacques Hiblot <jjhiblot@traphandler.com>
 * Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/of_graph.h>

#include <drm/drmP.h>
#include <drm/drm_of.h>

#include "atmel_hlcdc_dc.h"

/**
 * Atmel HLCDC RGB connector structure
 *
 * This structure stores RGB slave device information.
 *
 * @connector: DRM connector
 * @encoder: DRM encoder
 * @dc: pointer to the atmel_hlcdc_dc structure
 * @panel: panel connected on the RGB output
 */
struct atmel_hlcdc_rgb_output {
	struct drm_connector connector;
	struct drm_encoder encoder;
	struct atmel_hlcdc_dc *dc;
	struct drm_panel *panel;
};

static inline struct atmel_hlcdc_rgb_output *
drm_connector_to_atmel_hlcdc_rgb_output(struct drm_connector *connector)
{
	return container_of(connector, struct atmel_hlcdc_rgb_output,
			    connector);
}

static inline struct atmel_hlcdc_rgb_output *
drm_encoder_to_atmel_hlcdc_rgb_output(struct drm_encoder *encoder)
{
	return container_of(encoder, struct atmel_hlcdc_rgb_output, encoder);
}

static void atmel_hlcdc_rgb_encoder_enable(struct drm_encoder *encoder)
{
	struct atmel_hlcdc_rgb_output *rgb =
			drm_encoder_to_atmel_hlcdc_rgb_output(encoder);

	if (rgb->panel) {
		drm_panel_prepare(rgb->panel);
		drm_panel_enable(rgb->panel);
	}
}

static void atmel_hlcdc_rgb_encoder_disable(struct drm_encoder *encoder)
{
	struct atmel_hlcdc_rgb_output *rgb =
			drm_encoder_to_atmel_hlcdc_rgb_output(encoder);

	if (rgb->panel) {
		drm_panel_disable(rgb->panel);
		drm_panel_unprepare(rgb->panel);
	}
}

static const struct drm_encoder_helper_funcs atmel_hlcdc_panel_encoder_helper_funcs = {
	.disable = atmel_hlcdc_rgb_encoder_disable,
	.enable = atmel_hlcdc_rgb_encoder_enable,
};

static void atmel_hlcdc_rgb_encoder_destroy(struct drm_encoder *encoder)
{
	drm_encoder_cleanup(encoder);
	memset(encoder, 0, sizeof(*encoder));
}

static const struct drm_encoder_funcs atmel_hlcdc_panel_encoder_funcs = {
	.destroy = atmel_hlcdc_rgb_encoder_destroy,
};

static int atmel_hlcdc_panel_get_modes(struct drm_connector *connector)
{
	struct atmel_hlcdc_rgb_output *rgb =
			drm_connector_to_atmel_hlcdc_rgb_output(connector);

	if (rgb->panel)
		return rgb->panel->funcs->get_modes(rgb->panel);

	return 0;
}

static int atmel_hlcdc_rgb_mode_valid(struct drm_connector *connector,
				      struct drm_display_mode *mode)
{
	struct atmel_hlcdc_rgb_output *rgb =
			drm_connector_to_atmel_hlcdc_rgb_output(connector);

	return atmel_hlcdc_dc_mode_valid(rgb->dc, mode);
}

static const struct drm_connector_helper_funcs atmel_hlcdc_panel_connector_helper_funcs = {
	.get_modes = atmel_hlcdc_panel_get_modes,
	.mode_valid = atmel_hlcdc_rgb_mode_valid,
};

static enum drm_connector_status
atmel_hlcdc_panel_connector_detect(struct drm_connector *connector, bool force)
{
	struct atmel_hlcdc_rgb_output *rgb =
			drm_connector_to_atmel_hlcdc_rgb_output(connector);

	if (rgb->panel)
		return connector_status_connected;

	return connector_status_disconnected;
}

static void
atmel_hlcdc_panel_connector_destroy(struct drm_connector *connector)
{
	struct atmel_hlcdc_rgb_output *rgb =
			drm_connector_to_atmel_hlcdc_rgb_output(connector);

	if (rgb->panel)
		drm_panel_detach(rgb->panel);

	drm_connector_cleanup(connector);
}

static const struct drm_connector_funcs atmel_hlcdc_panel_connector_funcs = {
	.dpms = drm_atomic_helper_connector_dpms,
	.detect = atmel_hlcdc_panel_connector_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.destroy = atmel_hlcdc_panel_connector_destroy,
	.reset = drm_atomic_helper_connector_reset,
	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};

static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, int endpoint)
{
	struct atmel_hlcdc_dc *dc = dev->dev_private;
	struct atmel_hlcdc_rgb_output *output;
	struct drm_panel *panel;
	struct drm_bridge *bridge;
	int ret;

	ret = drm_of_find_panel_or_bridge(dev->dev->of_node, 0, endpoint,
					  &panel, &bridge);
	if (ret)
		return ret;

	output = devm_kzalloc(dev->dev, sizeof(*output), GFP_KERNEL);
	if (!output)
		return -EINVAL;

	output->dc = dc;

	drm_encoder_helper_add(&output->encoder,
			       &atmel_hlcdc_panel_encoder_helper_funcs);
	ret = drm_encoder_init(dev, &output->encoder,
			       &atmel_hlcdc_panel_encoder_funcs,
			       DRM_MODE_ENCODER_NONE, NULL);
	if (ret)
		return ret;

	output->encoder.possible_crtcs = 0x1;

	if (panel) {
		output->connector.dpms = DRM_MODE_DPMS_OFF;
		output->connector.polled = DRM_CONNECTOR_POLL_CONNECT;
		drm_connector_helper_add(&output->connector,
				&atmel_hlcdc_panel_connector_helper_funcs);
		ret = drm_connector_init(dev, &output->connector,
					 &atmel_hlcdc_panel_connector_funcs,
					 DRM_MODE_CONNECTOR_Unknown);
		if (ret)
			goto err_encoder_cleanup;

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

		ret = drm_panel_attach(panel, &output->connector);
		if (ret) {
			drm_connector_cleanup(&output->connector);
			goto err_encoder_cleanup;
		}

		output->panel = panel;

		return 0;
	}

	if (bridge) {
		ret = drm_bridge_attach(&output->encoder, bridge, NULL);
		if (!ret)
			return 0;
	}

err_encoder_cleanup:
	drm_encoder_cleanup(&output->encoder);

	return ret;
}

int atmel_hlcdc_create_outputs(struct drm_device *dev)
{
	int endpoint, ret = 0;

	for (endpoint = 0; !ret; endpoint++)
		ret = atmel_hlcdc_attach_endpoint(dev, endpoint);

	/* At least one device was successfully attached.*/
	if (ret == -ENODEV && endpoint)
		return 0;

	return ret;
}
Commit	Line	Data
1a396789 BB	1	/*
	2	* Copyright (C) 2014 Traphandler
	3	* Copyright (C) 2014 Free Electrons
	4	* Copyright (C) 2014 Atmel
	5	*
	6	* Author: Jean-Jacques Hiblot <jjhiblot@traphandler.com>
	7	* Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License version 2 as published by
	11	* the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope that it will be useful, but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	16	* more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along with
	19	* this program. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
	22	#include <linux/of_graph.h>
	23
	24	#include <drm/drmP.h>
ebc94461	25	#include <drm/drm_of.h>
1a396789 BB	26
	27	#include "atmel_hlcdc_dc.h"
	28
1a396789 BB	29	/**
	30	* Atmel HLCDC RGB connector structure
	31	*
	32	* This structure stores RGB slave device information.
	33	*
	34	* @connector: DRM connector
	35	* @encoder: DRM encoder
	36	* @dc: pointer to the atmel_hlcdc_dc structure
17a8e03e	37	* @panel: panel connected on the RGB output
1a396789 BB	38	*/
	39	struct atmel_hlcdc_rgb_output {
	40	struct drm_connector connector;
	41	struct drm_encoder encoder;
	42	struct atmel_hlcdc_dc *dc;
17a8e03e	43	struct drm_panel *panel;
1a396789 BB	44	};
	45
	46	static inline struct atmel_hlcdc_rgb_output *
	47	drm_connector_to_atmel_hlcdc_rgb_output(struct drm_connector *connector)
	48	{
	49	return container_of(connector, struct atmel_hlcdc_rgb_output,
	50	connector);
	51	}
	52
	53	static inline struct atmel_hlcdc_rgb_output *
	54	drm_encoder_to_atmel_hlcdc_rgb_output(struct drm_encoder *encoder)
	55	{
	56	return container_of(encoder, struct atmel_hlcdc_rgb_output, encoder);
	57	}
	58
17a8e03e	59	static void atmel_hlcdc_rgb_encoder_enable(struct drm_encoder *encoder)
1a396789 BB	60	{
	61	struct atmel_hlcdc_rgb_output *rgb =
	62	drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
17a8e03e BB	63
	64	if (rgb->panel) {
	65	drm_panel_prepare(rgb->panel);
	66	drm_panel_enable(rgb->panel);
	67	}
2389fc13	68	}
1a396789	69
17a8e03e	70	static void atmel_hlcdc_rgb_encoder_disable(struct drm_encoder *encoder)
2389fc13 BB	71	{
	72	struct atmel_hlcdc_rgb_output *rgb =
	73	drm_encoder_to_atmel_hlcdc_rgb_output(encoder);
1a396789	74
17a8e03e BB	75	if (rgb->panel) {
	76	drm_panel_disable(rgb->panel);
	77	drm_panel_unprepare(rgb->panel);
	78	}
1a396789 BB	79	}
1a396789 BB	80
e9becd46	81	static const struct drm_encoder_helper_funcs atmel_hlcdc_panel_encoder_helper_funcs = {
17a8e03e BB	82	.disable = atmel_hlcdc_rgb_encoder_disable,
17a8e03e BB	83	.enable = atmel_hlcdc_rgb_encoder_enable,
1a396789 BB	84	};
	85
	86	static void atmel_hlcdc_rgb_encoder_destroy(struct drm_encoder *encoder)
	87	{
	88	drm_encoder_cleanup(encoder);
	89	memset(encoder, 0, sizeof(*encoder));
	90	}
	91
	92	static const struct drm_encoder_funcs atmel_hlcdc_panel_encoder_funcs = {
	93	.destroy = atmel_hlcdc_rgb_encoder_destroy,
	94	};
	95
	96	static int atmel_hlcdc_panel_get_modes(struct drm_connector *connector)
	97	{
	98	struct atmel_hlcdc_rgb_output *rgb =
	99	drm_connector_to_atmel_hlcdc_rgb_output(connector);
1a396789	100
17a8e03e BB	101	if (rgb->panel)
	102	return rgb->panel->funcs->get_modes(rgb->panel);
	103
	104	return 0;
1a396789 BB	105	}
	106
	107	static int atmel_hlcdc_rgb_mode_valid(struct drm_connector *connector,
	108	struct drm_display_mode *mode)
	109	{
	110	struct atmel_hlcdc_rgb_output *rgb =
	111	drm_connector_to_atmel_hlcdc_rgb_output(connector);
	112
	113	return atmel_hlcdc_dc_mode_valid(rgb->dc, mode);
	114	}
	115
e9becd46	116	static const struct drm_connector_helper_funcs atmel_hlcdc_panel_connector_helper_funcs = {
1a396789 BB	117	.get_modes = atmel_hlcdc_panel_get_modes,
1a396789 BB	118	.mode_valid = atmel_hlcdc_rgb_mode_valid,
1a396789 BB	119	};
	120
	121	static enum drm_connector_status
	122	atmel_hlcdc_panel_connector_detect(struct drm_connector *connector, bool force)
	123	{
17a8e03e BB	124	struct atmel_hlcdc_rgb_output *rgb =
	125	drm_connector_to_atmel_hlcdc_rgb_output(connector);
	126
	127	if (rgb->panel)
	128	return connector_status_connected;
	129
	130	return connector_status_disconnected;
1a396789 BB	131	}
	132
	133	static void
	134	atmel_hlcdc_panel_connector_destroy(struct drm_connector *connector)
	135	{
	136	struct atmel_hlcdc_rgb_output *rgb =
	137	drm_connector_to_atmel_hlcdc_rgb_output(connector);
1a396789	138
17a8e03e BB	139	if (rgb->panel)
	140	drm_panel_detach(rgb->panel);
	141
1a396789 BB	142	drm_connector_cleanup(connector);
	143	}
	144
	145	static const struct drm_connector_funcs atmel_hlcdc_panel_connector_funcs = {
2389fc13	146	.dpms = drm_atomic_helper_connector_dpms,
1a396789 BB	147	.detect = atmel_hlcdc_panel_connector_detect,
	148	.fill_modes = drm_helper_probe_single_connector_modes,
	149	.destroy = atmel_hlcdc_panel_connector_destroy,
2389fc13 BB	150	.reset = drm_atomic_helper_connector_reset,
	151	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	152	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1a396789 BB	153	};
1a396789 BB	154
6bee9b78	155	static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, int endpoint)
17a8e03e BB	156	{
	157	struct atmel_hlcdc_dc *dc = dev->dev_private;
	158	struct atmel_hlcdc_rgb_output *output;
17a8e03e BB	159	struct drm_panel *panel;
	160	struct drm_bridge *bridge;
	161	int ret;
1a396789	162
6bee9b78 BB	163	ret = drm_of_find_panel_or_bridge(dev->dev->of_node, 0, endpoint,
	164	&panel, &bridge);
	165	if (ret)
	166	return ret;
	167
17a8e03e BB	168	output = devm_kzalloc(dev->dev, sizeof(*output), GFP_KERNEL);
	169	if (!output)
	170	return -EINVAL;
1a396789	171
17a8e03e	172	output->dc = dc;
1a396789	173
17a8e03e	174	drm_encoder_helper_add(&output->encoder,
1a396789	175	&atmel_hlcdc_panel_encoder_helper_funcs);
17a8e03e	176	ret = drm_encoder_init(dev, &output->encoder,
1a396789	177	&atmel_hlcdc_panel_encoder_funcs,
abfc936e	178	DRM_MODE_ENCODER_NONE, NULL);
1a396789 BB	179	if (ret)
	180	return ret;
	181
17a8e03e BB	182	output->encoder.possible_crtcs = 0x1;
17a8e03e BB	183
17a8e03e	184	if (panel) {
17a8e03e BB	185	output->connector.dpms = DRM_MODE_DPMS_OFF;
	186	output->connector.polled = DRM_CONNECTOR_POLL_CONNECT;
	187	drm_connector_helper_add(&output->connector,
	188	&atmel_hlcdc_panel_connector_helper_funcs);
	189	ret = drm_connector_init(dev, &output->connector,
	190	&atmel_hlcdc_panel_connector_funcs,
	191	DRM_MODE_CONNECTOR_Unknown);
	192	if (ret)
	193	goto err_encoder_cleanup;
1a396789	194
17a8e03e BB	195	drm_mode_connector_attach_encoder(&output->connector,
	196	&output->encoder);
	197
	198	ret = drm_panel_attach(panel, &output->connector);
	199	if (ret) {
	200	drm_connector_cleanup(&output->connector);
	201	goto err_encoder_cleanup;
	202	}
	203
	204	output->panel = panel;
	205
	206	return 0;
	207	}
	208
17a8e03e	209	if (bridge) {
3bb80f24	210	ret = drm_bridge_attach(&output->encoder, bridge, NULL);
17a8e03e BB	211	if (!ret)
	212	return 0;
	213	}
1a396789 BB	214
1a396789 BB	215	err_encoder_cleanup:
17a8e03e	216	drm_encoder_cleanup(&output->encoder);
1a396789 BB	217
	218	return ret;
	219	}
	220
	221	int atmel_hlcdc_create_outputs(struct drm_device *dev)
	222	{
6bee9b78 BB	223	int endpoint, ret = 0;
	224
	225	for (endpoint = 0; !ret; endpoint++)
	226	ret = atmel_hlcdc_attach_endpoint(dev, endpoint);
	227
	228	/* At least one device was successfully attached.*/
	229	if (ret == -ENODEV && endpoint)
	230	return 0;
1a396789	231
ebc94461	232	return ret;
1a396789	233	}