[deliverable/linux.git] / drivers / gpu / drm / rockchip / rockchip_drm_fb.c

/*
 * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
 * Author:Mark Yao <mark.yao@rock-chips.com>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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/kernel.h>
#include <drm/drm.h>
#include <drm/drmP.h>
#include <drm/drm_atomic.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_crtc_helper.h>

#include "rockchip_drm_drv.h"
#include "rockchip_drm_gem.h"

#define to_rockchip_fb(x) container_of(x, struct rockchip_drm_fb, fb)

struct rockchip_drm_fb {
	struct drm_framebuffer fb;
	struct drm_gem_object *obj[ROCKCHIP_MAX_FB_BUFFER];
};

struct drm_gem_object *rockchip_fb_get_gem_obj(struct drm_framebuffer *fb,
					       unsigned int plane)
{
	struct rockchip_drm_fb *rk_fb = to_rockchip_fb(fb);

	if (plane >= ROCKCHIP_MAX_FB_BUFFER)
		return NULL;

	return rk_fb->obj[plane];
}

static void rockchip_drm_fb_destroy(struct drm_framebuffer *fb)
{
	struct rockchip_drm_fb *rockchip_fb = to_rockchip_fb(fb);
	struct drm_gem_object *obj;
	int i;

	for (i = 0; i < ROCKCHIP_MAX_FB_BUFFER; i++) {
		obj = rockchip_fb->obj[i];
		if (obj)
			drm_gem_object_unreference_unlocked(obj);
	}

	drm_framebuffer_cleanup(fb);
	kfree(rockchip_fb);
}

static int rockchip_drm_fb_create_handle(struct drm_framebuffer *fb,
					 struct drm_file *file_priv,
					 unsigned int *handle)
{
	struct rockchip_drm_fb *rockchip_fb = to_rockchip_fb(fb);

	return drm_gem_handle_create(file_priv,
				     rockchip_fb->obj[0], handle);
}

static const struct drm_framebuffer_funcs rockchip_drm_fb_funcs = {
	.destroy	= rockchip_drm_fb_destroy,
	.create_handle	= rockchip_drm_fb_create_handle,
};

static struct rockchip_drm_fb *
rockchip_fb_alloc(struct drm_device *dev, const struct drm_mode_fb_cmd2 *mode_cmd,
		  struct drm_gem_object **obj, unsigned int num_planes)
{
	struct rockchip_drm_fb *rockchip_fb;
	int ret;
	int i;

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

	drm_helper_mode_fill_fb_struct(&rockchip_fb->fb, mode_cmd);

	for (i = 0; i < num_planes; i++)
		rockchip_fb->obj[i] = obj[i];

	ret = drm_framebuffer_init(dev, &rockchip_fb->fb,
				   &rockchip_drm_fb_funcs);
	if (ret) {
		dev_err(dev->dev, "Failed to initialize framebuffer: %d\n",
			ret);
		kfree(rockchip_fb);
		return ERR_PTR(ret);
	}

	return rockchip_fb;
}

static struct drm_framebuffer *
rockchip_user_fb_create(struct drm_device *dev, struct drm_file *file_priv,
			const struct drm_mode_fb_cmd2 *mode_cmd)
{
	struct rockchip_drm_fb *rockchip_fb;
	struct drm_gem_object *objs[ROCKCHIP_MAX_FB_BUFFER];
	struct drm_gem_object *obj;
	unsigned int hsub;
	unsigned int vsub;
	int num_planes;
	int ret;
	int i;

	hsub = drm_format_horz_chroma_subsampling(mode_cmd->pixel_format);
	vsub = drm_format_vert_chroma_subsampling(mode_cmd->pixel_format);
	num_planes = min(drm_format_num_planes(mode_cmd->pixel_format),
			 ROCKCHIP_MAX_FB_BUFFER);

	for (i = 0; i < num_planes; i++) {
		unsigned int width = mode_cmd->width / (i ? hsub : 1);
		unsigned int height = mode_cmd->height / (i ? vsub : 1);
		unsigned int min_size;

		obj = drm_gem_object_lookup(dev, file_priv,
					    mode_cmd->handles[i]);
		if (!obj) {
			dev_err(dev->dev, "Failed to lookup GEM object\n");
			ret = -ENXIO;
			goto err_gem_object_unreference;
		}

		min_size = (height - 1) * mode_cmd->pitches[i] +
			mode_cmd->offsets[i] +
			width * drm_format_plane_cpp(mode_cmd->pixel_format, i);

		if (obj->size < min_size) {
			drm_gem_object_unreference_unlocked(obj);
			ret = -EINVAL;
			goto err_gem_object_unreference;
		}
		objs[i] = obj;
	}

	rockchip_fb = rockchip_fb_alloc(dev, mode_cmd, objs, i);
	if (IS_ERR(rockchip_fb)) {
		ret = PTR_ERR(rockchip_fb);
		goto err_gem_object_unreference;
	}

	return &rockchip_fb->fb;

err_gem_object_unreference:
	for (i--; i >= 0; i--)
		drm_gem_object_unreference_unlocked(objs[i]);
	return ERR_PTR(ret);
}

static void rockchip_drm_output_poll_changed(struct drm_device *dev)
{
	struct rockchip_drm_private *private = dev->dev_private;
	struct drm_fb_helper *fb_helper = &private->fbdev_helper;

	if (fb_helper)
		drm_fb_helper_hotplug_event(fb_helper);
}

static void rockchip_crtc_wait_for_update(struct drm_crtc *crtc)
{
	struct rockchip_drm_private *priv = crtc->dev->dev_private;
	int pipe = drm_crtc_index(crtc);
	const struct rockchip_crtc_funcs *crtc_funcs = priv->crtc_funcs[pipe];

	if (crtc_funcs && crtc_funcs->wait_for_update)
		crtc_funcs->wait_for_update(crtc);
}

static void
rockchip_atomic_wait_for_complete(struct drm_device *dev, struct drm_atomic_state *old_state)
{
	struct drm_crtc_state *old_crtc_state;
	struct drm_crtc *crtc;
	int i, ret;

	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
		/* No one cares about the old state, so abuse it for tracking
		 * and store whether we hold a vblank reference (and should do a
		 * vblank wait) in the ->enable boolean.
		 */
		old_crtc_state->enable = false;

		if (!crtc->state->active)
			continue;

		if (!drm_atomic_helper_framebuffer_changed(dev,
				old_state, crtc))
			continue;

		ret = drm_crtc_vblank_get(crtc);
		if (ret != 0)
			continue;

		old_crtc_state->enable = true;
	}

	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
		if (!old_crtc_state->enable)
			continue;

		rockchip_crtc_wait_for_update(crtc);
		drm_crtc_vblank_put(crtc);
	}
}

static void
rockchip_atomic_commit_complete(struct rockchip_atomic_commit *commit)
{
	struct drm_atomic_state *state = commit->state;
	struct drm_device *dev = commit->dev;

	/*
	 * TODO: do fence wait here.
	 */

	/*
	 * Rockchip crtc support runtime PM, can't update display planes
	 * when crtc is disabled.
	 *
	 * drm_atomic_helper_commit comments detail that:
	 *     For drivers supporting runtime PM the recommended sequence is
	 *
	 *     drm_atomic_helper_commit_modeset_disables(dev, state);
	 *
	 *     drm_atomic_helper_commit_modeset_enables(dev, state);
	 *
	 *     drm_atomic_helper_commit_planes(dev, state, true);
	 *
	 * See the kerneldoc entries for these three functions for more details.
	 */
	drm_atomic_helper_commit_modeset_disables(dev, state);

	drm_atomic_helper_commit_modeset_enables(dev, state);

	drm_atomic_helper_commit_planes(dev, state, true);

	rockchip_atomic_wait_for_complete(dev, state);

	drm_atomic_helper_cleanup_planes(dev, state);

	drm_atomic_state_free(state);
}

void rockchip_drm_atomic_work(struct work_struct *work)
{
	struct rockchip_atomic_commit *commit = container_of(work,
					struct rockchip_atomic_commit, work);

	rockchip_atomic_commit_complete(commit);
}

int rockchip_drm_atomic_commit(struct drm_device *dev,
			       struct drm_atomic_state *state,
			       bool async)
{
	struct rockchip_drm_private *private = dev->dev_private;
	struct rockchip_atomic_commit *commit = &private->commit;
	int ret;

	ret = drm_atomic_helper_prepare_planes(dev, state);
	if (ret)
		return ret;

	/* serialize outstanding asynchronous commits */
	mutex_lock(&commit->lock);
	flush_work(&commit->work);

	drm_atomic_helper_swap_state(dev, state);

	commit->dev = dev;
	commit->state = state;

	if (async)
		schedule_work(&commit->work);
	else
		rockchip_atomic_commit_complete(commit);

	mutex_unlock(&commit->lock);

	return 0;
}

static const struct drm_mode_config_funcs rockchip_drm_mode_config_funcs = {
	.fb_create = rockchip_user_fb_create,
	.output_poll_changed = rockchip_drm_output_poll_changed,
	.atomic_check = drm_atomic_helper_check,
	.atomic_commit = rockchip_drm_atomic_commit,
};

struct drm_framebuffer *
rockchip_drm_framebuffer_init(struct drm_device *dev,
			      const struct drm_mode_fb_cmd2 *mode_cmd,
			      struct drm_gem_object *obj)
{
	struct rockchip_drm_fb *rockchip_fb;

	rockchip_fb = rockchip_fb_alloc(dev, mode_cmd, &obj, 1);
	if (IS_ERR(rockchip_fb))
		return NULL;

	return &rockchip_fb->fb;
}

void rockchip_drm_mode_config_init(struct drm_device *dev)
{
	dev->mode_config.min_width = 0;
	dev->mode_config.min_height = 0;

	/*
	 * set max width and height as default value(4096x4096).
	 * this value would be used to check framebuffer size limitation
	 * at drm_mode_addfb().
	 */
	dev->mode_config.max_width = 4096;
	dev->mode_config.max_height = 4096;

	dev->mode_config.funcs = &rockchip_drm_mode_config_funcs;
}
Commit	Line	Data
2048e328 MY	1	/*
	2	* Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
	3	* Author:Mark Yao <mark.yao@rock-chips.com>
	4	*
	5	* This software is licensed under the terms of the GNU General Public
	6	* License version 2, as published by the Free Software Foundation, and
	7	* may be copied, distributed, and modified under those terms.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <drm/drm.h>
	17	#include <drm/drmP.h>
63ebb9fa	18	#include <drm/drm_atomic.h>
2048e328 MY	19	#include <drm/drm_fb_helper.h>
	20	#include <drm/drm_crtc_helper.h>
	21
	22	#include "rockchip_drm_drv.h"
	23	#include "rockchip_drm_gem.h"
	24
	25	#define to_rockchip_fb(x) container_of(x, struct rockchip_drm_fb, fb)
	26
	27	struct rockchip_drm_fb {
	28	struct drm_framebuffer fb;
	29	struct drm_gem_object *obj[ROCKCHIP_MAX_FB_BUFFER];
	30	};
	31
	32	struct drm_gem_object rockchip_fb_get_gem_obj(struct drm_framebuffer fb,
	33	unsigned int plane)
	34	{
	35	struct rockchip_drm_fb *rk_fb = to_rockchip_fb(fb);
	36
	37	if (plane >= ROCKCHIP_MAX_FB_BUFFER)
	38	return NULL;
	39
	40	return rk_fb->obj[plane];
	41	}
2048e328 MY	42
	43	static void rockchip_drm_fb_destroy(struct drm_framebuffer *fb)
	44	{
	45	struct rockchip_drm_fb *rockchip_fb = to_rockchip_fb(fb);
	46	struct drm_gem_object *obj;
	47	int i;
	48
	49	for (i = 0; i < ROCKCHIP_MAX_FB_BUFFER; i++) {
	50	obj = rockchip_fb->obj[i];
	51	if (obj)
	52	drm_gem_object_unreference_unlocked(obj);
	53	}
	54
	55	drm_framebuffer_cleanup(fb);
	56	kfree(rockchip_fb);
	57	}
	58
	59	static int rockchip_drm_fb_create_handle(struct drm_framebuffer *fb,
	60	struct drm_file *file_priv,
	61	unsigned int *handle)
	62	{
	63	struct rockchip_drm_fb *rockchip_fb = to_rockchip_fb(fb);
	64
	65	return drm_gem_handle_create(file_priv,
	66	rockchip_fb->obj[0], handle);
	67	}
	68
28c508ec	69	static const struct drm_framebuffer_funcs rockchip_drm_fb_funcs = {
2048e328 MY	70	.destroy = rockchip_drm_fb_destroy,
	71	.create_handle = rockchip_drm_fb_create_handle,
	72	};
	73
	74	static struct rockchip_drm_fb *
1eb83451	75	rockchip_fb_alloc(struct drm_device dev, const struct drm_mode_fb_cmd2 mode_cmd,
2048e328 MY	76	struct drm_gem_object **obj, unsigned int num_planes)
	77	{
	78	struct rockchip_drm_fb *rockchip_fb;
	79	int ret;
	80	int i;
	81
	82	rockchip_fb = kzalloc(sizeof(*rockchip_fb), GFP_KERNEL);
	83	if (!rockchip_fb)
	84	return ERR_PTR(-ENOMEM);
	85
	86	drm_helper_mode_fill_fb_struct(&rockchip_fb->fb, mode_cmd);
	87
	88	for (i = 0; i < num_planes; i++)
	89	rockchip_fb->obj[i] = obj[i];
	90
	91	ret = drm_framebuffer_init(dev, &rockchip_fb->fb,
	92	&rockchip_drm_fb_funcs);
	93	if (ret) {
	94	dev_err(dev->dev, "Failed to initialize framebuffer: %d\n",
	95	ret);
	96	kfree(rockchip_fb);
	97	return ERR_PTR(ret);
	98	}
	99
	100	return rockchip_fb;
	101	}
	102
	103	static struct drm_framebuffer *
	104	rockchip_user_fb_create(struct drm_device dev, struct drm_file file_priv,
1eb83451	105	const struct drm_mode_fb_cmd2 *mode_cmd)
2048e328 MY	106	{
	107	struct rockchip_drm_fb *rockchip_fb;
	108	struct drm_gem_object *objs[ROCKCHIP_MAX_FB_BUFFER];
	109	struct drm_gem_object *obj;
	110	unsigned int hsub;
	111	unsigned int vsub;
	112	int num_planes;
	113	int ret;
	114	int i;
	115
	116	hsub = drm_format_horz_chroma_subsampling(mode_cmd->pixel_format);
	117	vsub = drm_format_vert_chroma_subsampling(mode_cmd->pixel_format);
	118	num_planes = min(drm_format_num_planes(mode_cmd->pixel_format),
	119	ROCKCHIP_MAX_FB_BUFFER);
	120
	121	for (i = 0; i < num_planes; i++) {
	122	unsigned int width = mode_cmd->width / (i ? hsub : 1);
	123	unsigned int height = mode_cmd->height / (i ? vsub : 1);
	124	unsigned int min_size;
	125
	126	obj = drm_gem_object_lookup(dev, file_priv,
	127	mode_cmd->handles[i]);
	128	if (!obj) {
	129	dev_err(dev->dev, "Failed to lookup GEM object\n");
	130	ret = -ENXIO;
	131	goto err_gem_object_unreference;
	132	}
	133
	134	min_size = (height - 1) * mode_cmd->pitches[i] +
	135	mode_cmd->offsets[i] +
	136	width * drm_format_plane_cpp(mode_cmd->pixel_format, i);
	137
	138	if (obj->size < min_size) {
	139	drm_gem_object_unreference_unlocked(obj);
	140	ret = -EINVAL;
	141	goto err_gem_object_unreference;
	142	}
	143	objs[i] = obj;
	144	}
	145
	146	rockchip_fb = rockchip_fb_alloc(dev, mode_cmd, objs, i);
	147	if (IS_ERR(rockchip_fb)) {
	148	ret = PTR_ERR(rockchip_fb);
	149	goto err_gem_object_unreference;
	150	}
	151
	152	return &rockchip_fb->fb;
	153
	154	err_gem_object_unreference:
	155	for (i--; i >= 0; i--)
	156	drm_gem_object_unreference_unlocked(objs[i]);
	157	return ERR_PTR(ret);
	158	}
	159
	160	static void rockchip_drm_output_poll_changed(struct drm_device *dev)
	161	{
	162	struct rockchip_drm_private *private = dev->dev_private;
	163	struct drm_fb_helper *fb_helper = &private->fbdev_helper;
	164
765c35bb HS	165	if (fb_helper)
765c35bb HS	166	drm_fb_helper_hotplug_event(fb_helper);
2048e328 MY	167	}
2048e328 MY	168
63ebb9fa MY	169	static void rockchip_crtc_wait_for_update(struct drm_crtc *crtc)
	170	{
	171	struct rockchip_drm_private *priv = crtc->dev->dev_private;
	172	int pipe = drm_crtc_index(crtc);
	173	const struct rockchip_crtc_funcs *crtc_funcs = priv->crtc_funcs[pipe];
	174
	175	if (crtc_funcs && crtc_funcs->wait_for_update)
	176	crtc_funcs->wait_for_update(crtc);
	177	}
	178
	179	static void
f2227f46	180	rockchip_atomic_wait_for_complete(struct drm_device dev, struct drm_atomic_state old_state)
63ebb9fa MY	181	{
	182	struct drm_crtc_state *old_crtc_state;
	183	struct drm_crtc *crtc;
	184	int i, ret;
	185
	186	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
	187	/* No one cares about the old state, so abuse it for tracking
	188	* and store whether we hold a vblank reference (and should do a
	189	* vblank wait) in the ->enable boolean.
	190	*/
	191	old_crtc_state->enable = false;
	192
	193	if (!crtc->state->active)
	194	continue;
	195
f2227f46 JK	196	if (!drm_atomic_helper_framebuffer_changed(dev,
	197	old_state, crtc))
	198	continue;
	199
63ebb9fa MY	200	ret = drm_crtc_vblank_get(crtc);
	201	if (ret != 0)
	202	continue;
	203
	204	old_crtc_state->enable = true;
	205	}
	206
	207	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
	208	if (!old_crtc_state->enable)
	209	continue;
	210
	211	rockchip_crtc_wait_for_update(crtc);
	212	drm_crtc_vblank_put(crtc);
	213	}
	214	}
	215
f32fad51 MY	216	static void
f32fad51 MY	217	rockchip_atomic_commit_complete(struct rockchip_atomic_commit *commit)
63ebb9fa	218	{
f32fad51 MY	219	struct drm_atomic_state *state = commit->state;
f32fad51 MY	220	struct drm_device *dev = commit->dev;
63ebb9fa MY	221
	222	/*
	223	* TODO: do fence wait here.
	224	*/
	225
	226	/*
	227	* Rockchip crtc support runtime PM, can't update display planes
	228	* when crtc is disabled.
	229	*
	230	* drm_atomic_helper_commit comments detail that:
	231	* For drivers supporting runtime PM the recommended sequence is
	232	*
	233	* drm_atomic_helper_commit_modeset_disables(dev, state);
	234	*
	235	* drm_atomic_helper_commit_modeset_enables(dev, state);
	236	*
	237	* drm_atomic_helper_commit_planes(dev, state, true);
	238	*
	239	* See the kerneldoc entries for these three functions for more details.
	240	*/
	241	drm_atomic_helper_commit_modeset_disables(dev, state);
	242
	243	drm_atomic_helper_commit_modeset_enables(dev, state);
	244
	245	drm_atomic_helper_commit_planes(dev, state, true);
	246
f2227f46	247	rockchip_atomic_wait_for_complete(dev, state);
63ebb9fa MY	248
	249	drm_atomic_helper_cleanup_planes(dev, state);
	250
	251	drm_atomic_state_free(state);
f32fad51 MY	252	}
	253
	254	void rockchip_drm_atomic_work(struct work_struct *work)
	255	{
	256	struct rockchip_atomic_commit *commit = container_of(work,
	257	struct rockchip_atomic_commit, work);
	258
	259	rockchip_atomic_commit_complete(commit);
	260	}
	261
	262	int rockchip_drm_atomic_commit(struct drm_device *dev,
	263	struct drm_atomic_state *state,
	264	bool async)
	265	{
	266	struct rockchip_drm_private *private = dev->dev_private;
	267	struct rockchip_atomic_commit *commit = &private->commit;
	268	int ret;
	269
	270	ret = drm_atomic_helper_prepare_planes(dev, state);
	271	if (ret)
	272	return ret;
	273
	274	/* serialize outstanding asynchronous commits */
	275	mutex_lock(&commit->lock);
	276	flush_work(&commit->work);
	277
	278	drm_atomic_helper_swap_state(dev, state);
	279
	280	commit->dev = dev;
	281	commit->state = state;
	282
	283	if (async)
	284	schedule_work(&commit->work);
	285	else
	286	rockchip_atomic_commit_complete(commit);
	287
	288	mutex_unlock(&commit->lock);
63ebb9fa MY	289
	290	return 0;
	291	}
	292
2048e328 MY	293	static const struct drm_mode_config_funcs rockchip_drm_mode_config_funcs = {
	294	.fb_create = rockchip_user_fb_create,
	295	.output_poll_changed = rockchip_drm_output_poll_changed,
63ebb9fa MY	296	.atomic_check = drm_atomic_helper_check,
63ebb9fa MY	297	.atomic_commit = rockchip_drm_atomic_commit,
2048e328 MY	298	};
	299
	300	struct drm_framebuffer *
	301	rockchip_drm_framebuffer_init(struct drm_device *dev,
1eb83451	302	const struct drm_mode_fb_cmd2 *mode_cmd,
2048e328 MY	303	struct drm_gem_object *obj)
	304	{
	305	struct rockchip_drm_fb *rockchip_fb;
	306
	307	rockchip_fb = rockchip_fb_alloc(dev, mode_cmd, &obj, 1);
	308	if (IS_ERR(rockchip_fb))
	309	return NULL;
	310
	311	return &rockchip_fb->fb;
	312	}
	313
	314	void rockchip_drm_mode_config_init(struct drm_device *dev)
	315	{
	316	dev->mode_config.min_width = 0;
	317	dev->mode_config.min_height = 0;
	318
	319	/*
	320	* set max width and height as default value(4096x4096).
	321	* this value would be used to check framebuffer size limitation
	322	* at drm_mode_addfb().
	323	*/
	324	dev->mode_config.max_width = 4096;
	325	dev->mode_config.max_height = 4096;
	326
	327	dev->mode_config.funcs = &rockchip_drm_mode_config_funcs;
	328	}