fake.c revision 706f2543 
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
28extern int KdTsPhyScreen;
29
30Bool
31fakeInitialize (KdCardInfo *card, FakePriv *priv)
32{
33    priv->base = 0;
34    priv->bytes_per_line = 0;
35    return TRUE;
36}
37
38Bool
39fakeCardInit (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    {
49	free(priv);
50	return FALSE;
51    }
52    card->driver = priv;
53
54    return TRUE;
55}
56
57Bool
58fakeScreenInitialize (KdScreenInfo *screen, FakeScrPriv *scrpriv)
59{
60    if (!screen->width || !screen->height)
61    {
62	screen->width = 1024;
63	screen->height = 768;
64	screen->rate = 72;
65    }
66
67    if (screen->width <= 0)
68	screen->width = 1;
69    if (screen->height <= 0)
70	screen->height = 1;
71
72    if (!screen->fb.depth)
73	screen->fb.depth = 16;
74
75    if (screen->fb.depth <= 8)
76    {
77	screen->fb.visuals = ((1 << StaticGray) |
78			      (1 << GrayScale) |
79			      (1 << StaticColor) |
80			      (1 << PseudoColor) |
81			      (1 << TrueColor) |
82			      (1 << DirectColor));
83    }
84    else
85    {
86	screen->fb.visuals = (1 << TrueColor);
87#define Mask(o,l)   (((1 << l) - 1) << o)
88	if (screen->fb.depth <= 15)
89	{
90	    screen->fb.depth = 15;
91	    screen->fb.bitsPerPixel = 16;
92	    screen->fb.redMask = Mask (10, 5);
93	    screen->fb.greenMask = Mask (5, 5);
94	    screen->fb.blueMask = Mask (0, 5);
95	}
96	else if (screen->fb.depth <= 16)
97	{
98	    screen->fb.depth = 16;
99	    screen->fb.bitsPerPixel = 16;
100	    screen->fb.redMask = Mask (11, 5);
101	    screen->fb.greenMask = Mask (5, 6);
102	    screen->fb.blueMask = Mask (0, 5);
103	}
104	else
105	{
106	    screen->fb.depth = 24;
107	    screen->fb.bitsPerPixel = 32;
108	    screen->fb.redMask = Mask (16, 8);
109	    screen->fb.greenMask = Mask (8, 8);
110	    screen->fb.blueMask = Mask (0, 8);
111	}
112    }
113
114    scrpriv->randr = screen->randr;
115
116    return fakeMapFramebuffer (screen);
117}
118
119Bool
120fakeScreenInit (KdScreenInfo *screen)
121{
122    FakeScrPriv *scrpriv;
123
124    scrpriv = calloc(1, sizeof (FakeScrPriv));
125    if (!scrpriv)
126	return FALSE;
127    screen->driver = scrpriv;
128    if (!fakeScreenInitialize (screen, scrpriv))
129    {
130	screen->driver = 0;
131	free(scrpriv);
132	return FALSE;
133    }
134    return TRUE;
135}
136
137void *
138fakeWindowLinear (ScreenPtr	pScreen,
139		   CARD32	row,
140		   CARD32	offset,
141		   int		mode,
142		   CARD32	*size,
143		   void		*closure)
144{
145    KdScreenPriv(pScreen);
146    FakePriv	    *priv = pScreenPriv->card->driver;
147
148    if (!pScreenPriv->enabled)
149	return 0;
150    *size = priv->bytes_per_line;
151    return priv->base + row * priv->bytes_per_line;
152}
153
154Bool
155fakeMapFramebuffer (KdScreenInfo *screen)
156{
157    FakeScrPriv	*scrpriv = screen->driver;
158    KdPointerMatrix	m;
159    FakePriv		*priv = screen->card->driver;
160
161    if (scrpriv->randr != RR_Rotate_0)
162	scrpriv->shadow = TRUE;
163    else
164	scrpriv->shadow = FALSE;
165
166    KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
167
168    KdSetPointerMatrix (&m);
169
170    priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
171    free(priv->base);
172    priv->base = malloc (priv->bytes_per_line * screen->height);
173
174    if (scrpriv->shadow)
175    {
176	if (!KdShadowFbAlloc (screen, scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
177	    return FALSE;
178    }
179    else
180    {
181        screen->fb.byteStride = priv->bytes_per_line;
182        screen->fb.pixelStride = (priv->bytes_per_line * 8/
183				     screen->fb.bitsPerPixel);
184        screen->fb.frameBuffer = (CARD8 *) (priv->base);
185    }
186
187    return TRUE;
188}
189
190void
191fakeSetScreenSizes (ScreenPtr pScreen)
192{
193    KdScreenPriv(pScreen);
194    KdScreenInfo	*screen = pScreenPriv->screen;
195    FakeScrPriv	*scrpriv = screen->driver;
196
197    if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))
198    {
199	pScreen->width = screen->width;
200	pScreen->height = screen->height;
201	pScreen->mmWidth = screen->width_mm;
202	pScreen->mmHeight = screen->height_mm;
203    }
204    else
205    {
206	pScreen->width = screen->width;
207	pScreen->height = screen->height;
208	pScreen->mmWidth = screen->height_mm;
209	pScreen->mmHeight = screen->width_mm;
210    }
211}
212
213Bool
214fakeUnmapFramebuffer (KdScreenInfo *screen)
215{
216    FakePriv		*priv = screen->card->driver;
217    KdShadowFbFree (screen);
218    free(priv->base);
219    priv->base = NULL;
220    return TRUE;
221}
222
223Bool
224fakeSetShadow (ScreenPtr pScreen)
225{
226    KdScreenPriv(pScreen);
227    KdScreenInfo	*screen = pScreenPriv->screen;
228    FakeScrPriv	*scrpriv = screen->driver;
229    ShadowUpdateProc	update;
230    ShadowWindowProc	window;
231
232    window = fakeWindowLinear;
233    update = 0;
234    if (scrpriv->randr)
235	update = shadowUpdateRotatePacked;
236    else
237	update = shadowUpdatePacked;
238    return KdShadowSet (pScreen, scrpriv->randr, update, window);
239}
240
241
242#ifdef RANDR
243Bool
244fakeRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
245{
246    KdScreenPriv(pScreen);
247    KdScreenInfo	    *screen = pScreenPriv->screen;
248    FakeScrPriv	    *scrpriv = screen->driver;
249    RRScreenSizePtr	    pSize;
250    Rotation		    randr;
251    int			    n;
252
253    *rotations = RR_Rotate_All|RR_Reflect_All;
254
255    for (n = 0; n < pScreen->numDepths; n++)
256	if (pScreen->allowedDepths[n].numVids)
257	    break;
258    if (n == pScreen->numDepths)
259	return FALSE;
260
261    pSize = RRRegisterSize (pScreen,
262			    screen->width,
263			    screen->height,
264			    screen->width_mm,
265			    screen->height_mm);
266
267    randr = KdSubRotation (scrpriv->randr, screen->randr);
268
269    RRSetCurrentConfig (pScreen, randr, 0, pSize);
270
271    return TRUE;
272}
273
274Bool
275fakeRandRSetConfig (ScreenPtr		pScreen,
276		     Rotation		randr,
277		     int		rate,
278		     RRScreenSizePtr	pSize)
279{
280    KdScreenPriv(pScreen);
281    KdScreenInfo	*screen = pScreenPriv->screen;
282    FakeScrPriv	*scrpriv = screen->driver;
283    Bool		wasEnabled = pScreenPriv->enabled;
284    FakeScrPriv	oldscr;
285    int			oldwidth;
286    int			oldheight;
287    int			oldmmwidth;
288    int			oldmmheight;
289    int			newwidth, newheight;
290
291    if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
292    {
293	newwidth = pSize->width;
294	newheight = pSize->height;
295    }
296    else
297    {
298	newwidth = pSize->height;
299	newheight = pSize->width;
300    }
301
302    if (wasEnabled)
303	KdDisableScreen (pScreen);
304
305    oldscr = *scrpriv;
306
307    oldwidth = screen->width;
308    oldheight = screen->height;
309    oldmmwidth = pScreen->mmWidth;
310    oldmmheight = pScreen->mmHeight;
311
312    /*
313     * Set new configuration
314     */
315
316    scrpriv->randr = KdAddRotation (screen->randr, randr);
317
318    fakeUnmapFramebuffer (screen);
319
320    if (!fakeMapFramebuffer (screen))
321	goto bail4;
322
323    KdShadowUnset (screen->pScreen);
324
325    if (!fakeSetShadow (screen->pScreen))
326	goto bail4;
327
328    fakeSetScreenSizes (screen->pScreen);
329
330    /*
331     * Set frame buffer mapping
332     */
333    (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
334				    pScreen->width,
335				    pScreen->height,
336				    screen->fb.depth,
337				    screen->fb.bitsPerPixel,
338				    screen->fb.byteStride,
339				    screen->fb.frameBuffer);
340
341    /* set the subpixel order */
342
343    KdSetSubpixelOrder (pScreen, scrpriv->randr);
344    if (wasEnabled)
345	KdEnableScreen (pScreen);
346
347    return TRUE;
348
349bail4:
350    fakeUnmapFramebuffer (screen);
351    *scrpriv = oldscr;
352    (void) fakeMapFramebuffer (screen);
353    pScreen->width = oldwidth;
354    pScreen->height = oldheight;
355    pScreen->mmWidth = oldmmwidth;
356    pScreen->mmHeight = oldmmheight;
357
358    if (wasEnabled)
359	KdEnableScreen (pScreen);
360    return FALSE;
361}
362
363Bool
364fakeRandRInit (ScreenPtr pScreen)
365{
366    rrScrPrivPtr    pScrPriv;
367
368    if (!RRScreenInit (pScreen))
369	return FALSE;
370
371    pScrPriv = rrGetScrPriv(pScreen);
372    pScrPriv->rrGetInfo = fakeRandRGetInfo;
373    pScrPriv->rrSetConfig = fakeRandRSetConfig;
374    return TRUE;
375}
376#endif
377
378Bool
379fakeCreateColormap (ColormapPtr pmap)
380{
381    return fbInitializeColormap (pmap);
382}
383
384Bool
385fakeInitScreen (ScreenPtr pScreen)
386{
387#ifdef TOUCHSCREEN
388    KdTsPhyScreen = pScreen->myNum;
389#endif
390
391    pScreen->CreateColormap = fakeCreateColormap;
392    return TRUE;
393}
394
395Bool
396fakeFinishInitScreen (ScreenPtr pScreen)
397{
398    if (!shadowSetup (pScreen))
399	return FALSE;
400
401#ifdef RANDR
402    if (!fakeRandRInit (pScreen))
403	return FALSE;
404#endif
405
406    return TRUE;
407}
408
409
410Bool
411fakeCreateResources (ScreenPtr pScreen)
412{
413    return fakeSetShadow (pScreen);
414}
415
416void
417fakePreserve (KdCardInfo *card)
418{
419}
420
421Bool
422fakeEnable (ScreenPtr pScreen)
423{
424    return TRUE;
425}
426
427Bool
428fakeDPMS (ScreenPtr pScreen, int mode)
429{
430    return TRUE;
431}
432
433void
434fakeDisable (ScreenPtr pScreen)
435{
436}
437
438void
439fakeRestore (KdCardInfo *card)
440{
441}
442
443void
444fakeScreenFini (KdScreenInfo *screen)
445{
446}
447
448void
449fakeCardFini (KdCardInfo *card)
450{
451    FakePriv	*priv = card->driver;
452
453    free (priv->base);
454    free(priv);
455}
456
457void
458fakeGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
459{
460    while (n--)
461    {
462	pdefs->red = 0;
463	pdefs->green = 0;
464	pdefs->blue = 0;
465	pdefs++;
466    }
467}
468
469void
470fakePutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
471{
472}
473