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"
  9#include <drm/drm_plane_helper.h>
 10
 11static int defx = 1024;
 12static int defy = 768;
 13
 14module_param(defx, int, 0444);
 15module_param(defy, int, 0444);
 16MODULE_PARM_DESC(defx, "default x resolution");
 17MODULE_PARM_DESC(defy, "default y resolution");
 18
 19/* ---------------------------------------------------------------------- */
 20
 21static 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
 33static 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);
 46		ret = ttm_bo_reserve(&bo->bo, true, false, false, NULL);
 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
 55	if (WARN_ON(crtc->primary->fb == NULL))
 56		return -EINVAL;
 57
 58	bochs_fb = to_bochs_framebuffer(crtc->primary->fb);
 59	bo = gem_to_bochs_bo(bochs_fb->obj);
 60	ret = ttm_bo_reserve(&bo->bo, true, false, false, NULL);
 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
 75static 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
 88static void bochs_crtc_prepare(struct drm_crtc *crtc)
 89{
 90}
 91
 92static void bochs_crtc_commit(struct drm_crtc *crtc)
 93{
 94}
 95
 96static void bochs_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green,
 97				 u16 *blue, uint32_t start, uint32_t size)
 98{
 99}
100
101static int bochs_crtc_page_flip(struct drm_crtc *crtc,
102				struct drm_framebuffer *fb,
103				struct drm_pending_vblank_event *event,
104				uint32_t page_flip_flags)
105{
106	struct bochs_device *bochs =
107		container_of(crtc, struct bochs_device, crtc);
108	struct drm_framebuffer *old_fb = crtc->primary->fb;
109	unsigned long irqflags;
110
111	crtc->primary->fb = fb;
112	bochs_crtc_mode_set_base(crtc, 0, 0, old_fb);
113	if (event) {
114		spin_lock_irqsave(&bochs->dev->event_lock, irqflags);
115		drm_crtc_send_vblank_event(crtc, event);
116		spin_unlock_irqrestore(&bochs->dev->event_lock, irqflags);
117	}
118	return 0;
119}
120
121/* These provide the minimum set of functions required to handle a CRTC */
122static const struct drm_crtc_funcs bochs_crtc_funcs = {
123	.gamma_set = bochs_crtc_gamma_set,
124	.set_config = drm_crtc_helper_set_config,
125	.destroy = drm_crtc_cleanup,
126	.page_flip = bochs_crtc_page_flip,
127};
128
129static const struct drm_crtc_helper_funcs bochs_helper_funcs = {
130	.dpms = bochs_crtc_dpms,
131	.mode_set = bochs_crtc_mode_set,
132	.mode_set_base = bochs_crtc_mode_set_base,
133	.prepare = bochs_crtc_prepare,
134	.commit = bochs_crtc_commit,
135};
136
137static void bochs_crtc_init(struct drm_device *dev)
138{
139	struct bochs_device *bochs = dev->dev_private;
140	struct drm_crtc *crtc = &bochs->crtc;
141
142	drm_crtc_init(dev, crtc, &bochs_crtc_funcs);
143	drm_mode_crtc_set_gamma_size(crtc, 256);
144	drm_crtc_helper_add(crtc, &bochs_helper_funcs);
145}
146
147static void bochs_encoder_mode_set(struct drm_encoder *encoder,
148				   struct drm_display_mode *mode,
149				   struct drm_display_mode *adjusted_mode)
150{
151}
152
153static void bochs_encoder_dpms(struct drm_encoder *encoder, int state)
154{
155}
156
157static void bochs_encoder_prepare(struct drm_encoder *encoder)
158{
159}
160
161static void bochs_encoder_commit(struct drm_encoder *encoder)
162{
163}
164
165static const struct drm_encoder_helper_funcs bochs_encoder_helper_funcs = {
166	.dpms = bochs_encoder_dpms,
167	.mode_set = bochs_encoder_mode_set,
168	.prepare = bochs_encoder_prepare,
169	.commit = bochs_encoder_commit,
170};
171
172static const struct drm_encoder_funcs bochs_encoder_encoder_funcs = {
173	.destroy = drm_encoder_cleanup,
174};
175
176static void bochs_encoder_init(struct drm_device *dev)
177{
178	struct bochs_device *bochs = dev->dev_private;
179	struct drm_encoder *encoder = &bochs->encoder;
180
181	encoder->possible_crtcs = 0x1;
182	drm_encoder_init(dev, encoder, &bochs_encoder_encoder_funcs,
183			 DRM_MODE_ENCODER_DAC, NULL);
184	drm_encoder_helper_add(encoder, &bochs_encoder_helper_funcs);
185}
186
187
188int bochs_connector_get_modes(struct drm_connector *connector)
189{
190	int count;
191
192	count = drm_add_modes_noedid(connector, 8192, 8192);
193	drm_set_preferred_mode(connector, defx, defy);
194	return count;
195}
196
197static int bochs_connector_mode_valid(struct drm_connector *connector,
198				      struct drm_display_mode *mode)
199{
200	struct bochs_device *bochs =
201		container_of(connector, struct bochs_device, connector);
202	unsigned long size = mode->hdisplay * mode->vdisplay * 4;
203
204	/*
205	 * Make sure we can fit two framebuffers into video memory.
206	 * This allows up to 1600x1200 with 16 MB (default size).
207	 * If you want more try this:
208	 *     'qemu -vga std -global VGA.vgamem_mb=32 $otherargs'
209	 */
210	if (size * 2 > bochs->fb_size)
211		return MODE_BAD;
212
213	return MODE_OK;
214}
215
216static struct drm_encoder *
217bochs_connector_best_encoder(struct drm_connector *connector)
218{
219	int enc_id = connector->encoder_ids[0];
220	/* pick the encoder ids */
221	if (enc_id)
222		return drm_encoder_find(connector->dev, enc_id);
223	return NULL;
224}
225
226static enum drm_connector_status bochs_connector_detect(struct drm_connector
227							*connector, bool force)
228{
229	return connector_status_connected;
230}
231
232static const struct drm_connector_helper_funcs bochs_connector_connector_helper_funcs = {
233	.get_modes = bochs_connector_get_modes,
234	.mode_valid = bochs_connector_mode_valid,
235	.best_encoder = bochs_connector_best_encoder,
236};
237
238static const struct drm_connector_funcs bochs_connector_connector_funcs = {
239	.dpms = drm_helper_connector_dpms,
240	.detect = bochs_connector_detect,
241	.fill_modes = drm_helper_probe_single_connector_modes,
242	.destroy = drm_connector_cleanup,
243};
244
245static void bochs_connector_init(struct drm_device *dev)
246{
247	struct bochs_device *bochs = dev->dev_private;
248	struct drm_connector *connector = &bochs->connector;
249
250	drm_connector_init(dev, connector, &bochs_connector_connector_funcs,
251			   DRM_MODE_CONNECTOR_VIRTUAL);
252	drm_connector_helper_add(connector,
253				 &bochs_connector_connector_helper_funcs);
254	drm_connector_register(connector);
255}
256
257
258int bochs_kms_init(struct bochs_device *bochs)
259{
260	drm_mode_config_init(bochs->dev);
261	bochs->mode_config_initialized = true;
262
263	bochs->dev->mode_config.max_width = 8192;
264	bochs->dev->mode_config.max_height = 8192;
265
266	bochs->dev->mode_config.fb_base = bochs->fb_base;
267	bochs->dev->mode_config.preferred_depth = 24;
268	bochs->dev->mode_config.prefer_shadow = 0;
269
270	bochs->dev->mode_config.funcs = &bochs_mode_funcs;
271
272	bochs_crtc_init(bochs->dev);
273	bochs_encoder_init(bochs->dev);
274	bochs_connector_init(bochs->dev);
275	drm_mode_connector_attach_encoder(&bochs->connector,
276					  &bochs->encoder);
277
278	return 0;
279}
280
281void bochs_kms_fini(struct bochs_device *bochs)
282{
283	if (bochs->mode_config_initialized) {
284		drm_mode_config_cleanup(bochs->dev);
285		bochs->mode_config_initialized = false;
286	}
287}