[deliverable/linux.git] / drivers / gpu / drm / bochs / bochs_kms.c

/*
 * 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.
 */

#include "bochs.h"
#include <drm/drm_plane_helper.h>

static int defx = 1024;
static int defy = 768;

module_param(defx, int, 0444);
module_param(defy, int, 0444);
MODULE_PARM_DESC(defx, "default x resolution");
MODULE_PARM_DESC(defy, "default y resolution");

/* ---------------------------------------------------------------------- */

static void bochs_crtc_dpms(struct drm_crtc *crtc, int mode)
{
	switch (mode) {
	case DRM_MODE_DPMS_ON:
	case DRM_MODE_DPMS_STANDBY:
	case DRM_MODE_DPMS_SUSPEND:
	case DRM_MODE_DPMS_OFF:
	default:
		return;
	}
}

static int bochs_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
				    struct drm_framebuffer *old_fb)
{
	struct bochs_device *bochs =
		container_of(crtc, struct bochs_device, crtc);
	struct bochs_framebuffer *bochs_fb;
	struct bochs_bo *bo;
	u64 gpu_addr = 0;
	int ret;

	if (old_fb) {
		bochs_fb = to_bochs_framebuffer(old_fb);
		bo = gem_to_bochs_bo(bochs_fb->obj);
		ret = ttm_bo_reserve(&bo->bo, true, false, NULL);
		if (ret) {
			DRM_ERROR("failed to reserve old_fb bo\n");
		} else {
			bochs_bo_unpin(bo);
			ttm_bo_unreserve(&bo->bo);
		}
	}

	if (WARN_ON(crtc->primary->fb == NULL))
		return -EINVAL;

	bochs_fb = to_bochs_framebuffer(crtc->primary->fb);
	bo = gem_to_bochs_bo(bochs_fb->obj);
	ret = ttm_bo_reserve(&bo->bo, true, false, NULL);
	if (ret)
		return ret;

	ret = bochs_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr);
	if (ret) {
		ttm_bo_unreserve(&bo->bo);
		return ret;
	}

	ttm_bo_unreserve(&bo->bo);
	bochs_hw_setbase(bochs, x, y, gpu_addr);
	return 0;
}

static int bochs_crtc_mode_set(struct drm_crtc *crtc,
			       struct drm_display_mode *mode,
			       struct drm_display_mode *adjusted_mode,
			       int x, int y, struct drm_framebuffer *old_fb)
{
	struct bochs_device *bochs =
		container_of(crtc, struct bochs_device, crtc);

	bochs_hw_setmode(bochs, mode);
	bochs_crtc_mode_set_base(crtc, x, y, old_fb);
	return 0;
}

static void bochs_crtc_prepare(struct drm_crtc *crtc)
{
}

static void bochs_crtc_commit(struct drm_crtc *crtc)
{
}

static int bochs_crtc_page_flip(struct drm_crtc *crtc,
				struct drm_framebuffer *fb,
				struct drm_pending_vblank_event *event,
				uint32_t page_flip_flags)
{
	struct bochs_device *bochs =
		container_of(crtc, struct bochs_device, crtc);
	struct drm_framebuffer *old_fb = crtc->primary->fb;
	unsigned long irqflags;

	crtc->primary->fb = fb;
	bochs_crtc_mode_set_base(crtc, 0, 0, old_fb);
	if (event) {
		spin_lock_irqsave(&bochs->dev->event_lock, irqflags);
		drm_crtc_send_vblank_event(crtc, event);
		spin_unlock_irqrestore(&bochs->dev->event_lock, irqflags);
	}
	return 0;
}

/* These provide the minimum set of functions required to handle a CRTC */
static const struct drm_crtc_funcs bochs_crtc_funcs = {
	.set_config = drm_crtc_helper_set_config,
	.destroy = drm_crtc_cleanup,
	.page_flip = bochs_crtc_page_flip,
};

static const struct drm_crtc_helper_funcs bochs_helper_funcs = {
	.dpms = bochs_crtc_dpms,
	.mode_set = bochs_crtc_mode_set,
	.mode_set_base = bochs_crtc_mode_set_base,
	.prepare = bochs_crtc_prepare,
	.commit = bochs_crtc_commit,
};

static void bochs_crtc_init(struct drm_device *dev)
{
	struct bochs_device *bochs = dev->dev_private;
	struct drm_crtc *crtc = &bochs->crtc;

	drm_crtc_init(dev, crtc, &bochs_crtc_funcs);
	drm_crtc_helper_add(crtc, &bochs_helper_funcs);
}

static void bochs_encoder_mode_set(struct drm_encoder *encoder,
				   struct drm_display_mode *mode,
				   struct drm_display_mode *adjusted_mode)
{
}

static void bochs_encoder_dpms(struct drm_encoder *encoder, int state)
{
}

static void bochs_encoder_prepare(struct drm_encoder *encoder)
{
}

static void bochs_encoder_commit(struct drm_encoder *encoder)
{
}

static const struct drm_encoder_helper_funcs bochs_encoder_helper_funcs = {
	.dpms = bochs_encoder_dpms,
	.mode_set = bochs_encoder_mode_set,
	.prepare = bochs_encoder_prepare,
	.commit = bochs_encoder_commit,
};

static const struct drm_encoder_funcs bochs_encoder_encoder_funcs = {
	.destroy = drm_encoder_cleanup,
};

static void bochs_encoder_init(struct drm_device *dev)
{
	struct bochs_device *bochs = dev->dev_private;
	struct drm_encoder *encoder = &bochs->encoder;

	encoder->possible_crtcs = 0x1;
	drm_encoder_init(dev, encoder, &bochs_encoder_encoder_funcs,
			 DRM_MODE_ENCODER_DAC, NULL);
	drm_encoder_helper_add(encoder, &bochs_encoder_helper_funcs);
}


int bochs_connector_get_modes(struct drm_connector *connector)
{
	int count;

	count = drm_add_modes_noedid(connector, 8192, 8192);
	drm_set_preferred_mode(connector, defx, defy);
	return count;
}

static int bochs_connector_mode_valid(struct drm_connector *connector,
				      struct drm_display_mode *mode)
{
	struct bochs_device *bochs =
		container_of(connector, struct bochs_device, connector);
	unsigned long size = mode->hdisplay * mode->vdisplay * 4;

	/*
	 * Make sure we can fit two framebuffers into video memory.
	 * This allows up to 1600x1200 with 16 MB (default size).
	 * If you want more try this:
	 *     'qemu -vga std -global VGA.vgamem_mb=32 $otherargs'
	 */
	if (size * 2 > bochs->fb_size)
		return MODE_BAD;

	return MODE_OK;
}

static struct drm_encoder *
bochs_connector_best_encoder(struct drm_connector *connector)
{
	int enc_id = connector->encoder_ids[0];
	/* pick the encoder ids */
	if (enc_id)
		return drm_encoder_find(connector->dev, enc_id);
	return NULL;
}

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

static const struct drm_connector_helper_funcs bochs_connector_connector_helper_funcs = {
	.get_modes = bochs_connector_get_modes,
	.mode_valid = bochs_connector_mode_valid,
	.best_encoder = bochs_connector_best_encoder,
};

static const struct drm_connector_funcs bochs_connector_connector_funcs = {
	.dpms = drm_helper_connector_dpms,
	.detect = bochs_connector_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.destroy = drm_connector_cleanup,
};

static void bochs_connector_init(struct drm_device *dev)
{
	struct bochs_device *bochs = dev->dev_private;
	struct drm_connector *connector = &bochs->connector;

	drm_connector_init(dev, connector, &bochs_connector_connector_funcs,
			   DRM_MODE_CONNECTOR_VIRTUAL);
	drm_connector_helper_add(connector,
				 &bochs_connector_connector_helper_funcs);
	drm_connector_register(connector);
}


int bochs_kms_init(struct bochs_device *bochs)
{
	drm_mode_config_init(bochs->dev);
	bochs->mode_config_initialized = true;

	bochs->dev->mode_config.max_width = 8192;
	bochs->dev->mode_config.max_height = 8192;

	bochs->dev->mode_config.fb_base = bochs->fb_base;
	bochs->dev->mode_config.preferred_depth = 24;
	bochs->dev->mode_config.prefer_shadow = 0;

	bochs->dev->mode_config.funcs = &bochs_mode_funcs;

	bochs_crtc_init(bochs->dev);
	bochs_encoder_init(bochs->dev);
	bochs_connector_init(bochs->dev);
	drm_mode_connector_attach_encoder(&bochs->connector,
					  &bochs->encoder);

	return 0;
}

void bochs_kms_fini(struct bochs_device *bochs)
{
	if (bochs->mode_config_initialized) {
		drm_mode_config_cleanup(bochs->dev);
		bochs->mode_config_initialized = false;
	}
}
Commit	Line	Data
0a6659bd GH	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License as published by
	4	* the Free Software Foundation; either version 2 of the License, or
	5	* (at your option) any later version.
	6	*/
	7
	8	#include "bochs.h"
3cb9ae4f	9	#include <drm/drm_plane_helper.h>
0a6659bd GH	10
	11	static int defx = 1024;
	12	static int defy = 768;
	13
	14	module_param(defx, int, 0444);
	15	module_param(defy, int, 0444);
	16	MODULE_PARM_DESC(defx, "default x resolution");
	17	MODULE_PARM_DESC(defy, "default y resolution");
	18
	19	/* ---------------------------------------------------------------------- */
	20
0a6659bd GH	21	static void bochs_crtc_dpms(struct drm_crtc *crtc, int mode)
	22	{
	23	switch (mode) {
	24	case DRM_MODE_DPMS_ON:
	25	case DRM_MODE_DPMS_STANDBY:
	26	case DRM_MODE_DPMS_SUSPEND:
	27	case DRM_MODE_DPMS_OFF:
	28	default:
	29	return;
	30	}
	31	}
	32
0a6659bd GH	33	static int bochs_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
	34	struct drm_framebuffer *old_fb)
	35	{
	36	struct bochs_device *bochs =
	37	container_of(crtc, struct bochs_device, crtc);
	38	struct bochs_framebuffer *bochs_fb;
	39	struct bochs_bo *bo;
	40	u64 gpu_addr = 0;
	41	int ret;
	42
	43	if (old_fb) {
	44	bochs_fb = to_bochs_framebuffer(old_fb);
	45	bo = gem_to_bochs_bo(bochs_fb->obj);
dfd5e50e	46	ret = ttm_bo_reserve(&bo->bo, true, false, NULL);
0a6659bd GH	47	if (ret) {
	48	DRM_ERROR("failed to reserve old_fb bo\n");
	49	} else {
	50	bochs_bo_unpin(bo);
	51	ttm_bo_unreserve(&bo->bo);
	52	}
	53	}
	54
f4510a27	55	if (WARN_ON(crtc->primary->fb == NULL))
0a6659bd GH	56	return -EINVAL;
0a6659bd GH	57
f4510a27	58	bochs_fb = to_bochs_framebuffer(crtc->primary->fb);
0a6659bd	59	bo = gem_to_bochs_bo(bochs_fb->obj);
dfd5e50e	60	ret = ttm_bo_reserve(&bo->bo, true, false, NULL);
0a6659bd GH	61	if (ret)
	62	return ret;
	63
	64	ret = bochs_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr);
	65	if (ret) {
	66	ttm_bo_unreserve(&bo->bo);
	67	return ret;
	68	}
	69
	70	ttm_bo_unreserve(&bo->bo);
	71	bochs_hw_setbase(bochs, x, y, gpu_addr);
	72	return 0;
	73	}
	74
	75	static int bochs_crtc_mode_set(struct drm_crtc *crtc,
	76	struct drm_display_mode *mode,
	77	struct drm_display_mode *adjusted_mode,
	78	int x, int y, struct drm_framebuffer *old_fb)
	79	{
	80	struct bochs_device *bochs =
	81	container_of(crtc, struct bochs_device, crtc);
	82
	83	bochs_hw_setmode(bochs, mode);
	84	bochs_crtc_mode_set_base(crtc, x, y, old_fb);
	85	return 0;
	86	}
	87
	88	static void bochs_crtc_prepare(struct drm_crtc *crtc)
	89	{
	90	}
	91
	92	static void bochs_crtc_commit(struct drm_crtc *crtc)
	93	{
	94	}
	95
3ce733b9 GH	96	static int bochs_crtc_page_flip(struct drm_crtc *crtc,
	97	struct drm_framebuffer *fb,
	98	struct drm_pending_vblank_event *event,
	99	uint32_t page_flip_flags)
	100	{
	101	struct bochs_device *bochs =
	102	container_of(crtc, struct bochs_device, crtc);
	103	struct drm_framebuffer *old_fb = crtc->primary->fb;
	104	unsigned long irqflags;
	105
	106	crtc->primary->fb = fb;
	107	bochs_crtc_mode_set_base(crtc, 0, 0, old_fb);
	108	if (event) {
	109	spin_lock_irqsave(&bochs->dev->event_lock, irqflags);
20143598	110	drm_crtc_send_vblank_event(crtc, event);
3ce733b9 GH	111	spin_unlock_irqrestore(&bochs->dev->event_lock, irqflags);
	112	}
	113	return 0;
	114	}
	115
0a6659bd GH	116	/* These provide the minimum set of functions required to handle a CRTC */
0a6659bd GH	117	static const struct drm_crtc_funcs bochs_crtc_funcs = {
0a6659bd GH	118	.set_config = drm_crtc_helper_set_config,
0a6659bd GH	119	.destroy = drm_crtc_cleanup,
3ce733b9	120	.page_flip = bochs_crtc_page_flip,
0a6659bd GH	121	};
	122
	123	static const struct drm_crtc_helper_funcs bochs_helper_funcs = {
	124	.dpms = bochs_crtc_dpms,
0a6659bd GH	125	.mode_set = bochs_crtc_mode_set,
	126	.mode_set_base = bochs_crtc_mode_set_base,
	127	.prepare = bochs_crtc_prepare,
	128	.commit = bochs_crtc_commit,
0a6659bd GH	129	};
	130
	131	static void bochs_crtc_init(struct drm_device *dev)
	132	{
	133	struct bochs_device *bochs = dev->dev_private;
	134	struct drm_crtc *crtc = &bochs->crtc;
	135
	136	drm_crtc_init(dev, crtc, &bochs_crtc_funcs);
0a6659bd GH	137	drm_crtc_helper_add(crtc, &bochs_helper_funcs);
	138	}
	139
0a6659bd GH	140	static void bochs_encoder_mode_set(struct drm_encoder *encoder,
	141	struct drm_display_mode *mode,
	142	struct drm_display_mode *adjusted_mode)
	143	{
	144	}
	145
	146	static void bochs_encoder_dpms(struct drm_encoder *encoder, int state)
	147	{
	148	}
	149
	150	static void bochs_encoder_prepare(struct drm_encoder *encoder)
	151	{
	152	}
	153
	154	static void bochs_encoder_commit(struct drm_encoder *encoder)
	155	{
	156	}
	157
	158	static const struct drm_encoder_helper_funcs bochs_encoder_helper_funcs = {
	159	.dpms = bochs_encoder_dpms,
0a6659bd GH	160	.mode_set = bochs_encoder_mode_set,
	161	.prepare = bochs_encoder_prepare,
	162	.commit = bochs_encoder_commit,
	163	};
	164
	165	static const struct drm_encoder_funcs bochs_encoder_encoder_funcs = {
	166	.destroy = drm_encoder_cleanup,
	167	};
	168
	169	static void bochs_encoder_init(struct drm_device *dev)
	170	{
	171	struct bochs_device *bochs = dev->dev_private;
	172	struct drm_encoder *encoder = &bochs->encoder;
	173
	174	encoder->possible_crtcs = 0x1;
	175	drm_encoder_init(dev, encoder, &bochs_encoder_encoder_funcs,
13a3d91f	176	DRM_MODE_ENCODER_DAC, NULL);
0a6659bd GH	177	drm_encoder_helper_add(encoder, &bochs_encoder_helper_funcs);
	178	}
	179
	180
	181	int bochs_connector_get_modes(struct drm_connector *connector)
	182	{
	183	int count;
	184
	185	count = drm_add_modes_noedid(connector, 8192, 8192);
	186	drm_set_preferred_mode(connector, defx, defy);
	187	return count;
	188	}
	189
	190	static int bochs_connector_mode_valid(struct drm_connector *connector,
	191	struct drm_display_mode *mode)
	192	{
	193	struct bochs_device *bochs =
	194	container_of(connector, struct bochs_device, connector);
	195	unsigned long size = mode->hdisplay * mode->vdisplay * 4;
	196
	197	/*
	198	* Make sure we can fit two framebuffers into video memory.
	199	* This allows up to 1600x1200 with 16 MB (default size).
	200	* If you want more try this:
	201	* 'qemu -vga std -global VGA.vgamem_mb=32 $otherargs'
	202	*/
	203	if (size * 2 > bochs->fb_size)
	204	return MODE_BAD;
	205
	206	return MODE_OK;
	207	}
	208
	209	static struct drm_encoder *
	210	bochs_connector_best_encoder(struct drm_connector *connector)
	211	{
	212	int enc_id = connector->encoder_ids[0];
0a6659bd	213	/* pick the encoder ids */
fc22d96d RC	214	if (enc_id)
fc22d96d RC	215	return drm_encoder_find(connector->dev, enc_id);
0a6659bd GH	216	return NULL;
	217	}
	218
	219	static enum drm_connector_status bochs_connector_detect(struct drm_connector
	220	*connector, bool force)
	221	{
	222	return connector_status_connected;
	223	}
	224
4c717d0f	225	static const struct drm_connector_helper_funcs bochs_connector_connector_helper_funcs = {
0a6659bd GH	226	.get_modes = bochs_connector_get_modes,
	227	.mode_valid = bochs_connector_mode_valid,
	228	.best_encoder = bochs_connector_best_encoder,
	229	};
	230
4c717d0f	231	static const struct drm_connector_funcs bochs_connector_connector_funcs = {
0a6659bd GH	232	.dpms = drm_helper_connector_dpms,
	233	.detect = bochs_connector_detect,
	234	.fill_modes = drm_helper_probe_single_connector_modes,
	235	.destroy = drm_connector_cleanup,
	236	};
	237
	238	static void bochs_connector_init(struct drm_device *dev)
	239	{
	240	struct bochs_device *bochs = dev->dev_private;
	241	struct drm_connector *connector = &bochs->connector;
	242
	243	drm_connector_init(dev, connector, &bochs_connector_connector_funcs,
	244	DRM_MODE_CONNECTOR_VIRTUAL);
	245	drm_connector_helper_add(connector,
	246	&bochs_connector_connector_helper_funcs);
b1fb0124	247	drm_connector_register(connector);
0a6659bd GH	248	}
	249
	250
	251	int bochs_kms_init(struct bochs_device *bochs)
	252	{
	253	drm_mode_config_init(bochs->dev);
	254	bochs->mode_config_initialized = true;
	255
	256	bochs->dev->mode_config.max_width = 8192;
	257	bochs->dev->mode_config.max_height = 8192;
	258
	259	bochs->dev->mode_config.fb_base = bochs->fb_base;
	260	bochs->dev->mode_config.preferred_depth = 24;
	261	bochs->dev->mode_config.prefer_shadow = 0;
	262
4c717d0f	263	bochs->dev->mode_config.funcs = &bochs_mode_funcs;
0a6659bd GH	264
	265	bochs_crtc_init(bochs->dev);
	266	bochs_encoder_init(bochs->dev);
	267	bochs_connector_init(bochs->dev);
	268	drm_mode_connector_attach_encoder(&bochs->connector,
	269	&bochs->encoder);
	270
	271	return 0;
	272	}
	273
	274	void bochs_kms_fini(struct bochs_device *bochs)
	275	{
	276	if (bochs->mode_config_initialized) {
	277	drm_mode_config_cleanup(bochs->dev);
	278	bochs->mode_config_initialized = false;
	279	}
	280	}