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 | ||
21 | static void bochs_crtc_load_lut(struct drm_crtc *crtc) | |
22 | { | |
23 | } | |
24 | ||
25 | static void bochs_crtc_dpms(struct drm_crtc *crtc, int mode) | |
26 | { | |
27 | switch (mode) { | |
28 | case DRM_MODE_DPMS_ON: | |
29 | case DRM_MODE_DPMS_STANDBY: | |
30 | case DRM_MODE_DPMS_SUSPEND: | |
31 | case DRM_MODE_DPMS_OFF: | |
32 | default: | |
33 | return; | |
34 | } | |
35 | } | |
36 | ||
37 | static bool bochs_crtc_mode_fixup(struct drm_crtc *crtc, | |
38 | const struct drm_display_mode *mode, | |
39 | struct drm_display_mode *adjusted_mode) | |
40 | { | |
41 | return true; | |
42 | } | |
43 | ||
44 | static int bochs_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y, | |
45 | struct drm_framebuffer *old_fb) | |
46 | { | |
47 | struct bochs_device *bochs = | |
48 | container_of(crtc, struct bochs_device, crtc); | |
49 | struct bochs_framebuffer *bochs_fb; | |
50 | struct bochs_bo *bo; | |
51 | u64 gpu_addr = 0; | |
52 | int ret; | |
53 | ||
54 | if (old_fb) { | |
55 | bochs_fb = to_bochs_framebuffer(old_fb); | |
56 | bo = gem_to_bochs_bo(bochs_fb->obj); | |
ee3939e0 | 57 | ret = ttm_bo_reserve(&bo->bo, true, false, false, NULL); |
0a6659bd GH |
58 | if (ret) { |
59 | DRM_ERROR("failed to reserve old_fb bo\n"); | |
60 | } else { | |
61 | bochs_bo_unpin(bo); | |
62 | ttm_bo_unreserve(&bo->bo); | |
63 | } | |
64 | } | |
65 | ||
f4510a27 | 66 | if (WARN_ON(crtc->primary->fb == NULL)) |
0a6659bd GH |
67 | return -EINVAL; |
68 | ||
f4510a27 | 69 | bochs_fb = to_bochs_framebuffer(crtc->primary->fb); |
0a6659bd | 70 | bo = gem_to_bochs_bo(bochs_fb->obj); |
ee3939e0 | 71 | ret = ttm_bo_reserve(&bo->bo, true, false, false, NULL); |
0a6659bd GH |
72 | if (ret) |
73 | return ret; | |
74 | ||
75 | ret = bochs_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr); | |
76 | if (ret) { | |
77 | ttm_bo_unreserve(&bo->bo); | |
78 | return ret; | |
79 | } | |
80 | ||
81 | ttm_bo_unreserve(&bo->bo); | |
82 | bochs_hw_setbase(bochs, x, y, gpu_addr); | |
83 | return 0; | |
84 | } | |
85 | ||
86 | static int bochs_crtc_mode_set(struct drm_crtc *crtc, | |
87 | struct drm_display_mode *mode, | |
88 | struct drm_display_mode *adjusted_mode, | |
89 | int x, int y, struct drm_framebuffer *old_fb) | |
90 | { | |
91 | struct bochs_device *bochs = | |
92 | container_of(crtc, struct bochs_device, crtc); | |
93 | ||
94 | bochs_hw_setmode(bochs, mode); | |
95 | bochs_crtc_mode_set_base(crtc, x, y, old_fb); | |
96 | return 0; | |
97 | } | |
98 | ||
99 | static void bochs_crtc_prepare(struct drm_crtc *crtc) | |
100 | { | |
101 | } | |
102 | ||
103 | static void bochs_crtc_commit(struct drm_crtc *crtc) | |
104 | { | |
105 | } | |
106 | ||
107 | static void bochs_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | |
108 | u16 *blue, uint32_t start, uint32_t size) | |
109 | { | |
110 | } | |
111 | ||
112 | /* These provide the minimum set of functions required to handle a CRTC */ | |
113 | static const struct drm_crtc_funcs bochs_crtc_funcs = { | |
114 | .gamma_set = bochs_crtc_gamma_set, | |
115 | .set_config = drm_crtc_helper_set_config, | |
116 | .destroy = drm_crtc_cleanup, | |
117 | }; | |
118 | ||
119 | static const struct drm_crtc_helper_funcs bochs_helper_funcs = { | |
120 | .dpms = bochs_crtc_dpms, | |
121 | .mode_fixup = bochs_crtc_mode_fixup, | |
122 | .mode_set = bochs_crtc_mode_set, | |
123 | .mode_set_base = bochs_crtc_mode_set_base, | |
124 | .prepare = bochs_crtc_prepare, | |
125 | .commit = bochs_crtc_commit, | |
126 | .load_lut = bochs_crtc_load_lut, | |
127 | }; | |
128 | ||
129 | static void bochs_crtc_init(struct drm_device *dev) | |
130 | { | |
131 | struct bochs_device *bochs = dev->dev_private; | |
132 | struct drm_crtc *crtc = &bochs->crtc; | |
133 | ||
134 | drm_crtc_init(dev, crtc, &bochs_crtc_funcs); | |
135 | drm_mode_crtc_set_gamma_size(crtc, 256); | |
136 | drm_crtc_helper_add(crtc, &bochs_helper_funcs); | |
137 | } | |
138 | ||
139 | static bool bochs_encoder_mode_fixup(struct drm_encoder *encoder, | |
140 | const struct drm_display_mode *mode, | |
141 | struct drm_display_mode *adjusted_mode) | |
142 | { | |
143 | return true; | |
144 | } | |
145 | ||
146 | static void bochs_encoder_mode_set(struct drm_encoder *encoder, | |
147 | struct drm_display_mode *mode, | |
148 | struct drm_display_mode *adjusted_mode) | |
149 | { | |
150 | } | |
151 | ||
152 | static void bochs_encoder_dpms(struct drm_encoder *encoder, int state) | |
153 | { | |
154 | } | |
155 | ||
156 | static void bochs_encoder_prepare(struct drm_encoder *encoder) | |
157 | { | |
158 | } | |
159 | ||
160 | static void bochs_encoder_commit(struct drm_encoder *encoder) | |
161 | { | |
162 | } | |
163 | ||
164 | static const struct drm_encoder_helper_funcs bochs_encoder_helper_funcs = { | |
165 | .dpms = bochs_encoder_dpms, | |
166 | .mode_fixup = bochs_encoder_mode_fixup, | |
167 | .mode_set = bochs_encoder_mode_set, | |
168 | .prepare = bochs_encoder_prepare, | |
169 | .commit = bochs_encoder_commit, | |
170 | }; | |
171 | ||
172 | static const struct drm_encoder_funcs bochs_encoder_encoder_funcs = { | |
173 | .destroy = drm_encoder_cleanup, | |
174 | }; | |
175 | ||
176 | static 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); | |
184 | drm_encoder_helper_add(encoder, &bochs_encoder_helper_funcs); | |
185 | } | |
186 | ||
187 | ||
188 | int 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 | ||
197 | static 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 | ||
216 | static struct drm_encoder * | |
217 | bochs_connector_best_encoder(struct drm_connector *connector) | |
218 | { | |
219 | int enc_id = connector->encoder_ids[0]; | |
0a6659bd | 220 | /* pick the encoder ids */ |
fc22d96d RC |
221 | if (enc_id) |
222 | return drm_encoder_find(connector->dev, enc_id); | |
0a6659bd GH |
223 | return NULL; |
224 | } | |
225 | ||
226 | static enum drm_connector_status bochs_connector_detect(struct drm_connector | |
227 | *connector, bool force) | |
228 | { | |
229 | return connector_status_connected; | |
230 | } | |
231 | ||
232 | 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 | ||
238 | 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 | ||
245 | static 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); | |
b1fb0124 | 254 | drm_connector_register(connector); |
0a6659bd GH |
255 | } |
256 | ||
257 | ||
258 | int 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 = (void *)&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 | ||
281 | void 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 | } |