Commit | Line | Data |
---|---|---|
a09e091a JB |
1 | /* |
2 | * Copyright © 2004 Keith Packard | |
3 | * | |
4 | * Permission to use, copy, modify, distribute, and sell this software and its | |
5 | * documentation for any purpose is hereby granted without fee, provided that | |
6 | * the above copyright notice appear in all copies and that both that | |
7 | * copyright notice and this permission notice appear in supporting | |
8 | * documentation, and that the name of Keith Packard not be used in | |
9 | * advertising or publicity pertaining to distribution of the software without | |
10 | * specific, written prior permission. Keith Packard makes no | |
11 | * representations about the suitability of this software for any purpose. It | |
12 | * is provided "as is" without express or implied warranty. | |
13 | * | |
14 | * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, | |
15 | * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO | |
16 | * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR | |
17 | * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, | |
18 | * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER | |
19 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR | |
20 | * PERFORMANCE OF THIS SOFTWARE. | |
21 | */ | |
22 | ||
23 | #ifdef HAVE_CONFIG_H | |
24 | #include <kdrive-config.h> | |
25 | #endif | |
26 | #include "fake.h" | |
27 | ||
28 | extern int KdTsPhyScreen; | |
29 | ||
30 | Bool | |
31 | fakeInitialize(KdCardInfo * card, FakePriv * priv) | |
32 | { | |
33 | priv->base = 0; | |
34 | priv->bytes_per_line = 0; | |
35 | return TRUE; | |
36 | } | |
37 | ||
38 | Bool | |
39 | fakeCardInit(KdCardInfo * card) | |
40 | { | |
41 | FakePriv *priv; | |
42 | ||
43 | priv = (FakePriv *) malloc(sizeof(FakePriv)); | |
44 | if (!priv) | |
45 | return FALSE; | |
46 | ||
47 | if (!fakeInitialize(card, priv)) { | |
48 | free(priv); | |
49 | return FALSE; | |
50 | } | |
51 | card->driver = priv; | |
52 | ||
53 | return TRUE; | |
54 | } | |
55 | ||
56 | Bool | |
57 | fakeScreenInitialize(KdScreenInfo * screen, FakeScrPriv * scrpriv) | |
58 | { | |
59 | if (!screen->width || !screen->height) { | |
60 | screen->width = 1024; | |
61 | screen->height = 768; | |
62 | screen->rate = 72; | |
63 | } | |
64 | ||
65 | if (screen->width <= 0) | |
66 | screen->width = 1; | |
67 | if (screen->height <= 0) | |
68 | screen->height = 1; | |
69 | ||
70 | if (!screen->fb.depth) | |
71 | screen->fb.depth = 16; | |
72 | ||
73 | if (screen->fb.depth <= 8) { | |
74 | screen->fb.visuals = ((1 << StaticGray) | | |
75 | (1 << GrayScale) | | |
76 | (1 << StaticColor) | | |
77 | (1 << PseudoColor) | | |
78 | (1 << TrueColor) | (1 << DirectColor)); | |
79 | } | |
80 | else { | |
81 | screen->fb.visuals = (1 << TrueColor); | |
82 | #define Mask(o,l) (((1 << l) - 1) << o) | |
83 | if (screen->fb.depth <= 15) { | |
84 | screen->fb.depth = 15; | |
85 | screen->fb.bitsPerPixel = 16; | |
86 | screen->fb.redMask = Mask (10, 5); | |
87 | screen->fb.greenMask = Mask (5, 5); | |
88 | screen->fb.blueMask = Mask (0, 5); | |
89 | } | |
90 | else if (screen->fb.depth <= 16) { | |
91 | screen->fb.depth = 16; | |
92 | screen->fb.bitsPerPixel = 16; | |
93 | screen->fb.redMask = Mask (11, 5); | |
94 | screen->fb.greenMask = Mask (5, 6); | |
95 | screen->fb.blueMask = Mask (0, 5); | |
96 | } | |
97 | else { | |
98 | screen->fb.depth = 24; | |
99 | screen->fb.bitsPerPixel = 32; | |
100 | screen->fb.redMask = Mask (16, 8); | |
101 | screen->fb.greenMask = Mask (8, 8); | |
102 | screen->fb.blueMask = Mask (0, 8); | |
103 | } | |
104 | } | |
105 | ||
106 | scrpriv->randr = screen->randr; | |
107 | ||
108 | return fakeMapFramebuffer(screen); | |
109 | } | |
110 | ||
111 | Bool | |
112 | fakeScreenInit(KdScreenInfo * screen) | |
113 | { | |
114 | FakeScrPriv *scrpriv; | |
115 | ||
116 | scrpriv = calloc(1, sizeof(FakeScrPriv)); | |
117 | if (!scrpriv) | |
118 | return FALSE; | |
119 | screen->driver = scrpriv; | |
120 | if (!fakeScreenInitialize(screen, scrpriv)) { | |
121 | screen->driver = 0; | |
122 | free(scrpriv); | |
123 | return FALSE; | |
124 | } | |
125 | return TRUE; | |
126 | } | |
127 | ||
128 | void * | |
129 | fakeWindowLinear(ScreenPtr pScreen, | |
130 | CARD32 row, | |
131 | CARD32 offset, int mode, CARD32 *size, void *closure) | |
132 | { | |
133 | KdScreenPriv(pScreen); | |
134 | FakePriv *priv = pScreenPriv->card->driver; | |
135 | ||
136 | if (!pScreenPriv->enabled) | |
137 | return 0; | |
138 | *size = priv->bytes_per_line; | |
139 | return priv->base + row * priv->bytes_per_line; | |
140 | } | |
141 | ||
142 | Bool | |
143 | fakeMapFramebuffer(KdScreenInfo * screen) | |
144 | { | |
145 | FakeScrPriv *scrpriv = screen->driver; | |
146 | KdPointerMatrix m; | |
147 | FakePriv *priv = screen->card->driver; | |
148 | ||
149 | if (scrpriv->randr != RR_Rotate_0) | |
150 | scrpriv->shadow = TRUE; | |
151 | else | |
152 | scrpriv->shadow = FALSE; | |
153 | ||
154 | KdComputePointerMatrix(&m, scrpriv->randr, screen->width, screen->height); | |
155 | ||
156 | KdSetPointerMatrix(&m); | |
157 | ||
158 | priv->bytes_per_line = | |
159 | ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2; | |
160 | free(priv->base); | |
161 | priv->base = malloc(priv->bytes_per_line * screen->height); | |
162 | ||
163 | if (scrpriv->shadow) { | |
164 | if (!KdShadowFbAlloc | |
165 | (screen, scrpriv->randr & (RR_Rotate_90 | RR_Rotate_270))) | |
166 | return FALSE; | |
167 | } | |
168 | else { | |
169 | screen->fb.byteStride = priv->bytes_per_line; | |
170 | screen->fb.pixelStride = (priv->bytes_per_line * 8 / | |
171 | screen->fb.bitsPerPixel); | |
172 | screen->fb.frameBuffer = (CARD8 *) (priv->base); | |
173 | } | |
174 | ||
175 | return TRUE; | |
176 | } | |
177 | ||
178 | void | |
179 | fakeSetScreenSizes(ScreenPtr pScreen) | |
180 | { | |
181 | KdScreenPriv(pScreen); | |
182 | KdScreenInfo *screen = pScreenPriv->screen; | |
183 | FakeScrPriv *scrpriv = screen->driver; | |
184 | ||
185 | if (scrpriv->randr & (RR_Rotate_0 | RR_Rotate_180)) { | |
186 | pScreen->width = screen->width; | |
187 | pScreen->height = screen->height; | |
188 | pScreen->mmWidth = screen->width_mm; | |
189 | pScreen->mmHeight = screen->height_mm; | |
190 | } | |
191 | else { | |
192 | pScreen->width = screen->width; | |
193 | pScreen->height = screen->height; | |
194 | pScreen->mmWidth = screen->height_mm; | |
195 | pScreen->mmHeight = screen->width_mm; | |
196 | } | |
197 | } | |
198 | ||
199 | Bool | |
200 | fakeUnmapFramebuffer(KdScreenInfo * screen) | |
201 | { | |
202 | FakePriv *priv = screen->card->driver; | |
203 | ||
204 | KdShadowFbFree(screen); | |
205 | free(priv->base); | |
206 | priv->base = NULL; | |
207 | return TRUE; | |
208 | } | |
209 | ||
210 | Bool | |
211 | fakeSetShadow(ScreenPtr pScreen) | |
212 | { | |
213 | KdScreenPriv(pScreen); | |
214 | KdScreenInfo *screen = pScreenPriv->screen; | |
215 | FakeScrPriv *scrpriv = screen->driver; | |
216 | ShadowUpdateProc update; | |
217 | ShadowWindowProc window; | |
218 | ||
219 | window = fakeWindowLinear; | |
220 | update = 0; | |
221 | if (scrpriv->randr) | |
222 | update = shadowUpdateRotatePacked; | |
223 | else | |
224 | update = shadowUpdatePacked; | |
225 | return KdShadowSet(pScreen, scrpriv->randr, update, window); | |
226 | } | |
227 | ||
228 | #ifdef RANDR | |
229 | Bool | |
230 | fakeRandRGetInfo(ScreenPtr pScreen, Rotation * rotations) | |
231 | { | |
232 | KdScreenPriv(pScreen); | |
233 | KdScreenInfo *screen = pScreenPriv->screen; | |
234 | FakeScrPriv *scrpriv = screen->driver; | |
235 | RRScreenSizePtr pSize; | |
236 | Rotation randr; | |
237 | int n; | |
238 | ||
239 | *rotations = RR_Rotate_All | RR_Reflect_All; | |
240 | ||
241 | for (n = 0; n < pScreen->numDepths; n++) | |
242 | if (pScreen->allowedDepths[n].numVids) | |
243 | break; | |
244 | if (n == pScreen->numDepths) | |
245 | return FALSE; | |
246 | ||
247 | pSize = RRRegisterSize(pScreen, | |
248 | screen->width, | |
249 | screen->height, screen->width_mm, screen->height_mm); | |
250 | ||
251 | randr = KdSubRotation(scrpriv->randr, screen->randr); | |
252 | ||
253 | RRSetCurrentConfig(pScreen, randr, 0, pSize); | |
254 | ||
255 | return TRUE; | |
256 | } | |
257 | ||
258 | Bool | |
259 | fakeRandRSetConfig(ScreenPtr pScreen, | |
260 | Rotation randr, int rate, RRScreenSizePtr pSize) | |
261 | { | |
262 | KdScreenPriv(pScreen); | |
263 | KdScreenInfo *screen = pScreenPriv->screen; | |
264 | FakeScrPriv *scrpriv = screen->driver; | |
265 | Bool wasEnabled = pScreenPriv->enabled; | |
266 | FakeScrPriv oldscr; | |
267 | int oldwidth; | |
268 | int oldheight; | |
269 | int oldmmwidth; | |
270 | int oldmmheight; | |
271 | int newwidth, newheight; | |
272 | ||
273 | if (screen->randr & (RR_Rotate_0 | RR_Rotate_180)) { | |
274 | newwidth = pSize->width; | |
275 | newheight = pSize->height; | |
276 | } | |
277 | else { | |
278 | newwidth = pSize->height; | |
279 | newheight = pSize->width; | |
280 | } | |
281 | ||
282 | if (wasEnabled) | |
283 | KdDisableScreen(pScreen); | |
284 | ||
285 | oldscr = *scrpriv; | |
286 | ||
287 | oldwidth = screen->width; | |
288 | oldheight = screen->height; | |
289 | oldmmwidth = pScreen->mmWidth; | |
290 | oldmmheight = pScreen->mmHeight; | |
291 | ||
292 | /* | |
293 | * Set new configuration | |
294 | */ | |
295 | ||
296 | scrpriv->randr = KdAddRotation(screen->randr, randr); | |
297 | ||
298 | fakeUnmapFramebuffer(screen); | |
299 | ||
300 | if (!fakeMapFramebuffer(screen)) | |
301 | goto bail4; | |
302 | ||
303 | KdShadowUnset(screen->pScreen); | |
304 | ||
305 | if (!fakeSetShadow(screen->pScreen)) | |
306 | goto bail4; | |
307 | ||
308 | fakeSetScreenSizes(screen->pScreen); | |
309 | ||
310 | /* | |
311 | * Set frame buffer mapping | |
312 | */ | |
313 | (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap(pScreen), | |
314 | pScreen->width, | |
315 | pScreen->height, | |
316 | screen->fb.depth, | |
317 | screen->fb.bitsPerPixel, | |
318 | screen->fb.byteStride, | |
319 | screen->fb.frameBuffer); | |
320 | ||
321 | /* set the subpixel order */ | |
322 | ||
323 | KdSetSubpixelOrder(pScreen, scrpriv->randr); | |
324 | if (wasEnabled) | |
325 | KdEnableScreen(pScreen); | |
326 | ||
327 | return TRUE; | |
328 | ||
329 | bail4: | |
330 | fakeUnmapFramebuffer(screen); | |
331 | *scrpriv = oldscr; | |
332 | (void) fakeMapFramebuffer(screen); | |
333 | pScreen->width = oldwidth; | |
334 | pScreen->height = oldheight; | |
335 | pScreen->mmWidth = oldmmwidth; | |
336 | pScreen->mmHeight = oldmmheight; | |
337 | ||
338 | if (wasEnabled) | |
339 | KdEnableScreen(pScreen); | |
340 | return FALSE; | |
341 | } | |
342 | ||
343 | Bool | |
344 | fakeRandRInit(ScreenPtr pScreen) | |
345 | { | |
346 | rrScrPrivPtr pScrPriv; | |
347 | ||
348 | if (!RRScreenInit(pScreen)) | |
349 | return FALSE; | |
350 | ||
351 | pScrPriv = rrGetScrPriv(pScreen); | |
352 | pScrPriv->rrGetInfo = fakeRandRGetInfo; | |
353 | pScrPriv->rrSetConfig = fakeRandRSetConfig; | |
354 | return TRUE; | |
355 | } | |
356 | #endif | |
357 | ||
358 | Bool | |
359 | fakeCreateColormap(ColormapPtr pmap) | |
360 | { | |
361 | return fbInitializeColormap(pmap); | |
362 | } | |
363 | ||
364 | Bool | |
365 | fakeInitScreen(ScreenPtr pScreen) | |
366 | { | |
367 | #ifdef TOUCHSCREEN | |
368 | KdTsPhyScreen = pScreen->myNum; | |
369 | #endif | |
370 | ||
371 | pScreen->CreateColormap = fakeCreateColormap; | |
372 | return TRUE; | |
373 | } | |
374 | ||
375 | Bool | |
376 | fakeFinishInitScreen(ScreenPtr pScreen) | |
377 | { | |
378 | if (!shadowSetup(pScreen)) | |
379 | return FALSE; | |
380 | ||
381 | #ifdef RANDR | |
382 | if (!fakeRandRInit(pScreen)) | |
383 | return FALSE; | |
384 | #endif | |
385 | ||
386 | return TRUE; | |
387 | } | |
388 | ||
389 | Bool | |
390 | fakeCreateResources(ScreenPtr pScreen) | |
391 | { | |
392 | return fakeSetShadow(pScreen); | |
393 | } | |
394 | ||
395 | void | |
396 | fakePreserve(KdCardInfo * card) | |
397 | { | |
398 | } | |
399 | ||
400 | Bool | |
401 | fakeEnable(ScreenPtr pScreen) | |
402 | { | |
403 | return TRUE; | |
404 | } | |
405 | ||
406 | Bool | |
407 | fakeDPMS(ScreenPtr pScreen, int mode) | |
408 | { | |
409 | return TRUE; | |
410 | } | |
411 | ||
412 | void | |
413 | fakeDisable(ScreenPtr pScreen) | |
414 | { | |
415 | } | |
416 | ||
417 | void | |
418 | fakeRestore(KdCardInfo * card) | |
419 | { | |
420 | } | |
421 | ||
422 | void | |
423 | fakeScreenFini(KdScreenInfo * screen) | |
424 | { | |
425 | } | |
426 | ||
427 | void | |
428 | fakeCardFini(KdCardInfo * card) | |
429 | { | |
430 | FakePriv *priv = card->driver; | |
431 | ||
432 | free(priv->base); | |
433 | free(priv); | |
434 | } | |
435 | ||
436 | void | |
437 | fakeGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs) | |
438 | { | |
439 | while (n--) { | |
440 | pdefs->red = 0; | |
441 | pdefs->green = 0; | |
442 | pdefs->blue = 0; | |
443 | pdefs++; | |
444 | } | |
445 | } | |
446 | ||
447 | void | |
448 | fakePutColors(ScreenPtr pScreen, int n, xColorItem * pdefs) | |
449 | { | |
450 | } |