[linux-2.6-block.git] / drivers / gpu / drm / rcar-du / rcar_du_writeback.c

// SPDX-License-Identifier: GPL-2.0
/*
 * rcar_du_writeback.c  --  R-Car Display Unit Writeback Support
 *
 * Copyright (C) 2019 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
 */

#include <drm/drm_atomic_helper.h>
#include <drm/drm_device.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_writeback.h>

#include "rcar_du_crtc.h"
#include "rcar_du_drv.h"
#include "rcar_du_kms.h"
#include "rcar_du_writeback.h"

/**
 * struct rcar_du_wb_conn_state - Driver-specific writeback connector state
 * @state: base DRM connector state
 * @format: format of the writeback framebuffer
 */
struct rcar_du_wb_conn_state {
	struct drm_connector_state state;
	const struct rcar_du_format_info *format;
};

#define to_rcar_wb_conn_state(s) \
	container_of(s, struct rcar_du_wb_conn_state, state)

/**
 * struct rcar_du_wb_job - Driver-private data for writeback jobs
 * @sg_tables: scatter-gather tables for the framebuffer memory
 */
struct rcar_du_wb_job {
	struct sg_table sg_tables[3];
};

static int rcar_du_wb_conn_get_modes(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;

	return drm_add_modes_noedid(connector, dev->mode_config.max_width,
				    dev->mode_config.max_height);
}

static int rcar_du_wb_prepare_job(struct drm_writeback_connector *connector,
				  struct drm_writeback_job *job)
{
	struct rcar_du_crtc *rcrtc = wb_to_rcar_crtc(connector);
	struct rcar_du_wb_job *rjob;
	int ret;

	if (!job->fb)
		return 0;

	rjob = kzalloc(sizeof(*rjob), GFP_KERNEL);
	if (!rjob)
		return -ENOMEM;

	/* Map the framebuffer to the VSP. */
	ret = rcar_du_vsp_map_fb(rcrtc->vsp, job->fb, rjob->sg_tables);
	if (ret < 0) {
		kfree(rjob);
		return ret;
	}

	job->priv = rjob;
	return 0;
}

static void rcar_du_wb_cleanup_job(struct drm_writeback_connector *connector,
				   struct drm_writeback_job *job)
{
	struct rcar_du_crtc *rcrtc = wb_to_rcar_crtc(connector);
	struct rcar_du_wb_job *rjob = job->priv;

	if (!job->fb)
		return;

	rcar_du_vsp_unmap_fb(rcrtc->vsp, job->fb, rjob->sg_tables);
	kfree(rjob);
}

static const struct drm_connector_helper_funcs rcar_du_wb_conn_helper_funcs = {
	.get_modes = rcar_du_wb_conn_get_modes,
	.prepare_writeback_job = rcar_du_wb_prepare_job,
	.cleanup_writeback_job = rcar_du_wb_cleanup_job,
};

static struct drm_connector_state *
rcar_du_wb_conn_duplicate_state(struct drm_connector *connector)
{
	struct rcar_du_wb_conn_state *copy;

	if (WARN_ON(!connector->state))
		return NULL;

	copy = kzalloc(sizeof(*copy), GFP_KERNEL);
	if (!copy)
		return NULL;

	__drm_atomic_helper_connector_duplicate_state(connector, &copy->state);

	return &copy->state;
}

static void rcar_du_wb_conn_destroy_state(struct drm_connector *connector,
					  struct drm_connector_state *state)
{
	__drm_atomic_helper_connector_destroy_state(state);
	kfree(to_rcar_wb_conn_state(state));
}

static void rcar_du_wb_conn_reset(struct drm_connector *connector)
{
	struct rcar_du_wb_conn_state *state;

	if (connector->state) {
		rcar_du_wb_conn_destroy_state(connector, connector->state);
		connector->state = NULL;
	}

	state = kzalloc(sizeof(*state), GFP_KERNEL);
	if (state == NULL)
		return;

	__drm_atomic_helper_connector_reset(connector, &state->state);
}

static const struct drm_connector_funcs rcar_du_wb_conn_funcs = {
	.reset = rcar_du_wb_conn_reset,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.destroy = drm_connector_cleanup,
	.atomic_duplicate_state = rcar_du_wb_conn_duplicate_state,
	.atomic_destroy_state = rcar_du_wb_conn_destroy_state,
};

static int rcar_du_wb_enc_atomic_check(struct drm_encoder *encoder,
				       struct drm_crtc_state *crtc_state,
				       struct drm_connector_state *conn_state)
{
	struct rcar_du_wb_conn_state *wb_state =
		to_rcar_wb_conn_state(conn_state);
	const struct drm_display_mode *mode = &crtc_state->mode;
	struct drm_device *dev = encoder->dev;
	struct drm_framebuffer *fb;

	if (!conn_state->writeback_job || !conn_state->writeback_job->fb)
		return 0;

	fb = conn_state->writeback_job->fb;

	/*
	 * Verify that the framebuffer format is supported and that its size
	 * matches the current mode.
	 */
	if (fb->width != mode->hdisplay || fb->height != mode->vdisplay) {
		dev_dbg(dev->dev, "%s: invalid framebuffer size %ux%u\n",
			__func__, fb->width, fb->height);
		return -EINVAL;
	}

	wb_state->format = rcar_du_format_info(fb->format->format);
	if (wb_state->format == NULL) {
		dev_dbg(dev->dev, "%s: unsupported format %08x\n", __func__,
			fb->format->format);
		return -EINVAL;
	}

	return 0;
}

static const struct drm_encoder_helper_funcs rcar_du_wb_enc_helper_funcs = {
	.atomic_check = rcar_du_wb_enc_atomic_check,
};

/*
 * Only RGB formats are currently supported as the VSP outputs RGB to the DU
 * and can't convert to YUV separately for writeback.
 */
static const u32 writeback_formats[] = {
	DRM_FORMAT_RGB332,
	DRM_FORMAT_ARGB4444,
	DRM_FORMAT_XRGB4444,
	DRM_FORMAT_ARGB1555,
	DRM_FORMAT_XRGB1555,
	DRM_FORMAT_RGB565,
	DRM_FORMAT_BGR888,
	DRM_FORMAT_RGB888,
	DRM_FORMAT_BGRA8888,
	DRM_FORMAT_BGRX8888,
	DRM_FORMAT_ARGB8888,
	DRM_FORMAT_XRGB8888,
};

int rcar_du_writeback_init(struct rcar_du_device *rcdu,
			   struct rcar_du_crtc *rcrtc)
{
	struct drm_writeback_connector *wb_conn = &rcrtc->writeback;

	wb_conn->encoder.possible_crtcs = 1 << drm_crtc_index(&rcrtc->crtc);
	drm_connector_helper_add(&wb_conn->base,
				 &rcar_du_wb_conn_helper_funcs);

	return drm_writeback_connector_init(rcdu->ddev, wb_conn,
					    &rcar_du_wb_conn_funcs,
					    &rcar_du_wb_enc_helper_funcs,
					    writeback_formats,
					    ARRAY_SIZE(writeback_formats));
}

void rcar_du_writeback_setup(struct rcar_du_crtc *rcrtc,
			     struct vsp1_du_writeback_config *cfg)
{
	struct rcar_du_wb_conn_state *wb_state;
	struct drm_connector_state *state;
	struct rcar_du_wb_job *rjob;
	struct drm_framebuffer *fb;
	unsigned int i;

	state = rcrtc->writeback.base.state;
	if (!state || !state->writeback_job || !state->writeback_job->fb)
		return;

	fb = state->writeback_job->fb;
	rjob = state->writeback_job->priv;
	wb_state = to_rcar_wb_conn_state(state);

	cfg->pixelformat = wb_state->format->v4l2;
	cfg->pitch = fb->pitches[0];

	for (i = 0; i < wb_state->format->planes; ++i)
		cfg->mem[i] = sg_dma_address(rjob->sg_tables[i].sgl)
			    + fb->offsets[i];

	drm_writeback_queue_job(&rcrtc->writeback, state);
}

void rcar_du_writeback_complete(struct rcar_du_crtc *rcrtc)
{
	drm_writeback_signal_completion(&rcrtc->writeback, 0);
}
Commit	Line	Data
12e32f55 LP	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* rcar_du_writeback.c -- R-Car Display Unit Writeback Support
	4	*
	5	* Copyright (C) 2019 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
	6	*/
	7
	8	#include <drm/drm_atomic_helper.h>
	9	#include <drm/drm_device.h>
	10	#include <drm/drm_fourcc.h>
	11	#include <drm/drm_probe_helper.h>
	12	#include <drm/drm_writeback.h>
	13
	14	#include "rcar_du_crtc.h"
	15	#include "rcar_du_drv.h"
	16	#include "rcar_du_kms.h"
66659d9d	17	#include "rcar_du_writeback.h"
12e32f55 LP	18
	19	/**
	20	* struct rcar_du_wb_conn_state - Driver-specific writeback connector state
	21	* @state: base DRM connector state
	22	* @format: format of the writeback framebuffer
	23	*/
	24	struct rcar_du_wb_conn_state {
	25	struct drm_connector_state state;
	26	const struct rcar_du_format_info *format;
	27	};
	28
	29	#define to_rcar_wb_conn_state(s) \
	30	container_of(s, struct rcar_du_wb_conn_state, state)
	31
	32	/**
	33	* struct rcar_du_wb_job - Driver-private data for writeback jobs
	34	* @sg_tables: scatter-gather tables for the framebuffer memory
	35	*/
	36	struct rcar_du_wb_job {
	37	struct sg_table sg_tables[3];
	38	};
	39
	40	static int rcar_du_wb_conn_get_modes(struct drm_connector *connector)
	41	{
	42	struct drm_device *dev = connector->dev;
	43
	44	return drm_add_modes_noedid(connector, dev->mode_config.max_width,
	45	dev->mode_config.max_height);
	46	}
	47
	48	static int rcar_du_wb_prepare_job(struct drm_writeback_connector *connector,
	49	struct drm_writeback_job *job)
	50	{
	51	struct rcar_du_crtc *rcrtc = wb_to_rcar_crtc(connector);
	52	struct rcar_du_wb_job *rjob;
	53	int ret;
	54
	55	if (!job->fb)
	56	return 0;
	57
	58	rjob = kzalloc(sizeof(*rjob), GFP_KERNEL);
	59	if (!rjob)
	60	return -ENOMEM;
	61
	62	/* Map the framebuffer to the VSP. */
	63	ret = rcar_du_vsp_map_fb(rcrtc->vsp, job->fb, rjob->sg_tables);
	64	if (ret < 0) {
	65	kfree(rjob);
	66	return ret;
	67	}
	68
	69	job->priv = rjob;
	70	return 0;
	71	}
	72
	73	static void rcar_du_wb_cleanup_job(struct drm_writeback_connector *connector,
	74	struct drm_writeback_job *job)
	75	{
	76	struct rcar_du_crtc *rcrtc = wb_to_rcar_crtc(connector);
	77	struct rcar_du_wb_job *rjob = job->priv;
	78
	79	if (!job->fb)
	80	return;
	81
82	rcar_du_vsp_unmap_fb(rcrtc->vsp, job->fb, rjob->sg_tables);
83	kfree(rjob);
84	}
85
86	static const struct drm_connector_helper_funcs rcar_du_wb_conn_helper_funcs = {
87	.get_modes = rcar_du_wb_conn_get_modes,
88	.prepare_writeback_job = rcar_du_wb_prepare_job,
89	.cleanup_writeback_job = rcar_du_wb_cleanup_job,
90	};
91
92	static struct drm_connector_state *
93	rcar_du_wb_conn_duplicate_state(struct drm_connector *connector)
94	{
95	struct rcar_du_wb_conn_state *copy;
96
97	if (WARN_ON(!connector->state))
98	return NULL;
99
100	copy = kzalloc(sizeof(*copy), GFP_KERNEL);
101	if (!copy)
102	return NULL;
103
104	__drm_atomic_helper_connector_duplicate_state(connector, &copy->state);
105
106	return &copy->state;
107	}
108
109	static void rcar_du_wb_conn_destroy_state(struct drm_connector *connector,
110	struct drm_connector_state *state)
111	{
112	__drm_atomic_helper_connector_destroy_state(state);
113	kfree(to_rcar_wb_conn_state(state));
114	}
115
116	static void rcar_du_wb_conn_reset(struct drm_connector *connector)
117	{
118	struct rcar_du_wb_conn_state *state;
119
120	if (connector->state) {
121	rcar_du_wb_conn_destroy_state(connector, connector->state);
122	connector->state = NULL;
123	}
124
125	state = kzalloc(sizeof(*state), GFP_KERNEL);
126	if (state == NULL)
127	return;
128
129	__drm_atomic_helper_connector_reset(connector, &state->state);
130	}
131
132	static const struct drm_connector_funcs rcar_du_wb_conn_funcs = {
133	.reset = rcar_du_wb_conn_reset,
134	.fill_modes = drm_helper_probe_single_connector_modes,
135	.destroy = drm_connector_cleanup,
136	.atomic_duplicate_state = rcar_du_wb_conn_duplicate_state,
137	.atomic_destroy_state = rcar_du_wb_conn_destroy_state,
138	};
139
140	static int rcar_du_wb_enc_atomic_check(struct drm_encoder *encoder,
141	struct drm_crtc_state *crtc_state,
142	struct drm_connector_state *conn_state)
143	{
144	struct rcar_du_wb_conn_state *wb_state =
145	to_rcar_wb_conn_state(conn_state);
146	const struct drm_display_mode *mode = &crtc_state->mode;
147	struct drm_device *dev = encoder->dev;
148	struct drm_framebuffer *fb;
149
150	if (!conn_state->writeback_job \|\| !conn_state->writeback_job->fb)
151	return 0;
152
153	fb = conn_state->writeback_job->fb;
154
155	/*
156	* Verify that the framebuffer format is supported and that its size
157	* matches the current mode.
158	*/
159	if (fb->width != mode->hdisplay \|\| fb->height != mode->vdisplay) {
160	dev_dbg(dev->dev, "%s: invalid framebuffer size %ux%u\n",
161	__func__, fb->width, fb->height);
162	return -EINVAL;
163	}
164
165	wb_state->format = rcar_du_format_info(fb->format->format);
166	if (wb_state->format == NULL) {
167	dev_dbg(dev->dev, "%s: unsupported format %08x\n", __func__,
168	fb->format->format);
169	return -EINVAL;
170	}
171
172	return 0;
173	}
174
175	static const struct drm_encoder_helper_funcs rcar_du_wb_enc_helper_funcs = {
176	.atomic_check = rcar_du_wb_enc_atomic_check,
177	};
178
179	/*
180	* Only RGB formats are currently supported as the VSP outputs RGB to the DU
181	* and can't convert to YUV separately for writeback.
182	*/
183	static const u32 writeback_formats[] = {
184	DRM_FORMAT_RGB332,
185	DRM_FORMAT_ARGB4444,
186	DRM_FORMAT_XRGB4444,
187	DRM_FORMAT_ARGB1555,
188	DRM_FORMAT_XRGB1555,
189	DRM_FORMAT_RGB565,
190	DRM_FORMAT_BGR888,
191	DRM_FORMAT_RGB888,
192	DRM_FORMAT_BGRA8888,
193	DRM_FORMAT_BGRX8888,
194	DRM_FORMAT_ARGB8888,
195	DRM_FORMAT_XRGB8888,
196	};
197
198	int rcar_du_writeback_init(struct rcar_du_device *rcdu,
199	struct rcar_du_crtc *rcrtc)
200	{
201	struct drm_writeback_connector *wb_conn = &rcrtc->writeback;
202
203	wb_conn->encoder.possible_crtcs = 1 << drm_crtc_index(&rcrtc->crtc);
204	drm_connector_helper_add(&wb_conn->base,
205	&rcar_du_wb_conn_helper_funcs);
206
207	return drm_writeback_connector_init(rcdu->ddev, wb_conn,
208	&rcar_du_wb_conn_funcs,
209	&rcar_du_wb_enc_helper_funcs,
210	writeback_formats,
211	ARRAY_SIZE(writeback_formats));
212	}
213
214	void rcar_du_writeback_setup(struct rcar_du_crtc *rcrtc,
215	struct vsp1_du_writeback_config *cfg)
216	{
217	struct rcar_du_wb_conn_state *wb_state;
218	struct drm_connector_state *state;
219	struct rcar_du_wb_job *rjob;
220	struct drm_framebuffer *fb;
221	unsigned int i;
222
223	state = rcrtc->writeback.base.state;
224	if (!state \|\| !state->writeback_job \|\| !state->writeback_job->fb)
225	return;
226
227	fb = state->writeback_job->fb;
228	rjob = state->writeback_job->priv;
229	wb_state = to_rcar_wb_conn_state(state);
230
231	cfg->pixelformat = wb_state->format->v4l2;
232	cfg->pitch = fb->pitches[0];
233
234	for (i = 0; i < wb_state->format->planes; ++i)
235	cfg->mem[i] = sg_dma_address(rjob->sg_tables[i].sgl)
236	+ fb->offsets[i];
237
238	drm_writeback_queue_job(&rcrtc->writeback, state);
239	}
240
241	void rcar_du_writeback_complete(struct rcar_du_crtc *rcrtc)
242	{
243	drm_writeback_signal_completion(&rcrtc->writeback, 0);
244	}