diff options
Diffstat (limited to 'meta-extras/packages/xorg-xserver/xserver-kdrive-glamo/kdrive-1.3-18bpp.patch')
-rw-r--r-- | meta-extras/packages/xorg-xserver/xserver-kdrive-glamo/kdrive-1.3-18bpp.patch | 419 |
1 files changed, 419 insertions, 0 deletions
diff --git a/meta-extras/packages/xorg-xserver/xserver-kdrive-glamo/kdrive-1.3-18bpp.patch b/meta-extras/packages/xorg-xserver/xserver-kdrive-glamo/kdrive-1.3-18bpp.patch new file mode 100644 index 0000000000..714536934c --- /dev/null +++ b/meta-extras/packages/xorg-xserver/xserver-kdrive-glamo/kdrive-1.3-18bpp.patch | |||
@@ -0,0 +1,419 @@ | |||
1 | diff -Nurd xorg-server-1.3.0.0/hw/kdrive/fbdev/fbdev.c xorg-server-1.3.0.0.patched/hw/kdrive/fbdev/fbdev.c | ||
2 | --- xorg-server-1.3.0.0/hw/kdrive/fbdev/fbdev.c 2006-11-16 19:01:23.000000000 +0100 | ||
3 | +++ xorg-server-1.3.0.0.patched/hw/kdrive/fbdev/fbdev.c 2007-09-15 16:53:20.152045000 +0200 | ||
4 | @@ -213,6 +213,24 @@ | ||
5 | |||
6 | /* Now get the new screeninfo */ | ||
7 | ioctl (priv->fd, FBIOGET_VSCREENINFO, &priv->var); | ||
8 | + /* Special treatment of 18bpp */ | ||
9 | + if ((priv->var.red.length == 6) && (priv->var.green.length == 6) && | ||
10 | + (priv->var.blue.length == 6)) | ||
11 | + { | ||
12 | + priv->var.red.length = 8; | ||
13 | + if (priv->var.red.offset != 0) | ||
14 | + priv->var.red.offset = 16; | ||
15 | + priv->var.green.length = 8; | ||
16 | + priv->var.green.offset = 8; | ||
17 | + priv->var.blue.length = 8; | ||
18 | + if (priv->var.blue.offset != 0) | ||
19 | + priv->var.blue.offset = 16; | ||
20 | + priv->var.bits_per_pixel = 32; | ||
21 | + priv->Have18Bpp = TRUE; | ||
22 | + } | ||
23 | + else | ||
24 | + priv->Have18Bpp = FALSE; | ||
25 | + | ||
26 | depth = priv->var.bits_per_pixel; | ||
27 | gray = priv->var.grayscale; | ||
28 | |||
29 | @@ -334,7 +352,7 @@ | ||
30 | KdMouseMatrix m; | ||
31 | FbdevPriv *priv = screen->card->driver; | ||
32 | |||
33 | - if (scrpriv->randr != RR_Rotate_0) | ||
34 | + if (scrpriv->randr != RR_Rotate_0 || priv->Have18Bpp) | ||
35 | scrpriv->shadow = TRUE; | ||
36 | else | ||
37 | scrpriv->shadow = FALSE; | ||
38 | @@ -398,6 +416,354 @@ | ||
39 | return TRUE; | ||
40 | } | ||
41 | |||
42 | +void | ||
43 | +shadowUpdatePacked18 (ScreenPtr pScreen, | ||
44 | + shadowBufPtr pBuf) | ||
45 | +{ | ||
46 | + RegionPtr damage = shadowDamage (pBuf); | ||
47 | + PixmapPtr pShadow = pBuf->pPixmap; | ||
48 | + int nbox = REGION_NUM_RECTS (damage); | ||
49 | + BoxPtr pbox = REGION_RECTS (damage); | ||
50 | + FbBits *shaBase, *shaLine, *sha; | ||
51 | + FbStride shaStride; | ||
52 | + int scrBase, scrLine, scr; | ||
53 | + int shaBpp; | ||
54 | + int shaXoff, shaYoff; /* XXX assumed to be zero */ | ||
55 | + int x, y, w, h, width; | ||
56 | + int i; | ||
57 | + char *winBase = NULL, *win; | ||
58 | + CARD32 winSize; | ||
59 | + | ||
60 | + fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); | ||
61 | + while (nbox--) | ||
62 | + { | ||
63 | + x = pbox->x1 * shaBpp; | ||
64 | + y = pbox->y1; | ||
65 | + w = (pbox->x2 - pbox->x1) * shaBpp; | ||
66 | + h = pbox->y2 - pbox->y1; | ||
67 | + | ||
68 | + scrLine = (x >> FB_SHIFT); | ||
69 | + shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); | ||
70 | + | ||
71 | + x &= FB_MASK; | ||
72 | + w = (w + x + FB_MASK) >> FB_SHIFT; | ||
73 | + | ||
74 | + while (h--) | ||
75 | + { | ||
76 | + winSize = 0; | ||
77 | + scrBase = 0; | ||
78 | + width = w; | ||
79 | + scr = scrLine; | ||
80 | + sha = shaLine; | ||
81 | + while (width) { | ||
82 | + /* how much remains in this window */ | ||
83 | + i = scrBase + winSize - scr; | ||
84 | + if (i <= 0 || scr < scrBase) | ||
85 | + { | ||
86 | + winBase = (char *) (*pBuf->window) (pScreen, | ||
87 | + y, | ||
88 | + scr * 3, | ||
89 | + SHADOW_WINDOW_WRITE, | ||
90 | + &winSize, | ||
91 | + pBuf->closure); | ||
92 | + if(!winBase) | ||
93 | + return; | ||
94 | + scrBase = scr; | ||
95 | + winSize /= 3; | ||
96 | + i = winSize; | ||
97 | + } | ||
98 | + win = winBase + (scr - scrBase); | ||
99 | + if (i > width) | ||
100 | + i = width; | ||
101 | + width -= i; | ||
102 | + scr += i; | ||
103 | +#define PickBit(a,i) (((a) >> (i)) & 1) | ||
104 | + while (i--) | ||
105 | + { | ||
106 | + FbBits bits = *sha++; | ||
107 | + *win++ = ((bits & 0xFC) >> 2) | | ||
108 | + ((bits & 0xC00) >> 4); | ||
109 | + *win++ = ((bits & 0xF000) >> 12) | | ||
110 | + ((bits & 0x3C0000) >> 14); | ||
111 | + *win++ = (bits & 0xC00000) >> 22; | ||
112 | + } | ||
113 | + } | ||
114 | + shaLine += shaStride; | ||
115 | + y++; | ||
116 | + } | ||
117 | + pbox++; | ||
118 | + } | ||
119 | +} | ||
120 | + | ||
121 | +#define LEFT_TO_RIGHT 1 | ||
122 | +#define RIGHT_TO_LEFT -1 | ||
123 | +#define TOP_TO_BOTTOM 2 | ||
124 | +#define BOTTOM_TO_TOP -2 | ||
125 | + | ||
126 | +void | ||
127 | +shadowUpdateRotatePacked18 (ScreenPtr pScreen, | ||
128 | + shadowBufPtr pBuf) | ||
129 | +{ | ||
130 | + RegionPtr damage = shadowDamage (pBuf); | ||
131 | + PixmapPtr pShadow = pBuf->pPixmap; | ||
132 | + int nbox = REGION_NUM_RECTS (damage); | ||
133 | + BoxPtr pbox = REGION_RECTS (damage); | ||
134 | + FbBits *shaBits; | ||
135 | + FbStride shaStride; | ||
136 | + int shaBpp; | ||
137 | + int shaXoff, shaYoff; | ||
138 | + int box_x1, box_x2, box_y1, box_y2; | ||
139 | + int sha_x1 = 0, sha_y1 = 0; | ||
140 | + int scr_x1 = 0, scr_x2 = 0, scr_y1 = 0, scr_y2 = 0, scr_w, scr_h; | ||
141 | + int scr_x, scr_y; | ||
142 | + int w; | ||
143 | + int pixelsPerBits; | ||
144 | + int pixelsMask; | ||
145 | + FbStride shaStepOverY = 0, shaStepDownY = 0; | ||
146 | + FbStride shaStepOverX = 0, shaStepDownX = 0; | ||
147 | + FbBits *shaLine, *sha; | ||
148 | + int shaHeight = pShadow->drawable.height; | ||
149 | + int shaWidth = pShadow->drawable.width; | ||
150 | + FbBits shaMask; | ||
151 | + int shaFirstShift, shaShift; | ||
152 | + int o_x_dir; | ||
153 | + int o_y_dir; | ||
154 | + int x_dir; | ||
155 | + int y_dir; | ||
156 | + | ||
157 | + fbGetDrawable (&pShadow->drawable, shaBits, shaStride, shaBpp, shaXoff, shaYoff); | ||
158 | + pixelsPerBits = (sizeof (FbBits) * 8) / shaBpp; | ||
159 | + pixelsMask = ~(pixelsPerBits - 1); | ||
160 | + shaMask = FbBitsMask (FB_UNIT-shaBpp, shaBpp); | ||
161 | + /* | ||
162 | + * Compute rotation related constants to walk the shadow | ||
163 | + */ | ||
164 | + o_x_dir = LEFT_TO_RIGHT; | ||
165 | + o_y_dir = TOP_TO_BOTTOM; | ||
166 | + if (pBuf->randr & SHADOW_REFLECT_X) | ||
167 | + o_x_dir = -o_x_dir; | ||
168 | + if (pBuf->randr & SHADOW_REFLECT_Y) | ||
169 | + o_y_dir = -o_y_dir; | ||
170 | + switch (pBuf->randr & (SHADOW_ROTATE_ALL)) { | ||
171 | + case SHADOW_ROTATE_0: /* upper left shadow -> upper left screen */ | ||
172 | + default: | ||
173 | + x_dir = o_x_dir; | ||
174 | + y_dir = o_y_dir; | ||
175 | + break; | ||
176 | + case SHADOW_ROTATE_90: /* upper right shadow -> upper left screen */ | ||
177 | + x_dir = o_y_dir; | ||
178 | + y_dir = -o_x_dir; | ||
179 | + break; | ||
180 | + case SHADOW_ROTATE_180: /* lower right shadow -> upper left screen */ | ||
181 | + x_dir = -o_x_dir; | ||
182 | + y_dir = -o_y_dir; | ||
183 | + break; | ||
184 | + case SHADOW_ROTATE_270: /* lower left shadow -> upper left screen */ | ||
185 | + x_dir = -o_y_dir; | ||
186 | + y_dir = o_x_dir; | ||
187 | + break; | ||
188 | + } | ||
189 | + switch (x_dir) { | ||
190 | + case LEFT_TO_RIGHT: | ||
191 | + shaStepOverX = shaBpp; | ||
192 | + shaStepOverY = 0; | ||
193 | + break; | ||
194 | + case TOP_TO_BOTTOM: | ||
195 | + shaStepOverX = 0; | ||
196 | + shaStepOverY = shaStride; | ||
197 | + break; | ||
198 | + case RIGHT_TO_LEFT: | ||
199 | + shaStepOverX = -shaBpp; | ||
200 | + shaStepOverY = 0; | ||
201 | + break; | ||
202 | + case BOTTOM_TO_TOP: | ||
203 | + shaStepOverX = 0; | ||
204 | + shaStepOverY = -shaStride; | ||
205 | + break; | ||
206 | + } | ||
207 | + switch (y_dir) { | ||
208 | + case TOP_TO_BOTTOM: | ||
209 | + shaStepDownX = 0; | ||
210 | + shaStepDownY = shaStride; | ||
211 | + break; | ||
212 | + case RIGHT_TO_LEFT: | ||
213 | + shaStepDownX = -shaBpp; | ||
214 | + shaStepDownY = 0; | ||
215 | + break; | ||
216 | + case BOTTOM_TO_TOP: | ||
217 | + shaStepDownX = 0; | ||
218 | + shaStepDownY = -shaStride; | ||
219 | + break; | ||
220 | + case LEFT_TO_RIGHT: | ||
221 | + shaStepDownX = shaBpp; | ||
222 | + shaStepDownY = 0; | ||
223 | + break; | ||
224 | + } | ||
225 | + | ||
226 | + while (nbox--) | ||
227 | + { | ||
228 | + box_x1 = pbox->x1; | ||
229 | + box_y1 = pbox->y1; | ||
230 | + box_x2 = pbox->x2; | ||
231 | + box_y2 = pbox->y2; | ||
232 | + pbox++; | ||
233 | + | ||
234 | + /* | ||
235 | + * Compute screen and shadow locations for this box | ||
236 | + */ | ||
237 | + switch (x_dir) { | ||
238 | + case LEFT_TO_RIGHT: | ||
239 | + scr_x1 = box_x1 & pixelsMask; | ||
240 | + scr_x2 = (box_x2 + pixelsPerBits - 1) & pixelsMask; | ||
241 | + | ||
242 | + sha_x1 = scr_x1; | ||
243 | + break; | ||
244 | + case TOP_TO_BOTTOM: | ||
245 | + scr_x1 = box_y1 & pixelsMask; | ||
246 | + scr_x2 = (box_y2 + pixelsPerBits - 1) & pixelsMask; | ||
247 | + | ||
248 | + sha_y1 = scr_x1; | ||
249 | + break; | ||
250 | + case RIGHT_TO_LEFT: | ||
251 | + scr_x1 = (shaWidth - box_x2) & pixelsMask; | ||
252 | + scr_x2 = (shaWidth - box_x1 + pixelsPerBits - 1) & pixelsMask; | ||
253 | + | ||
254 | + sha_x1 = (shaWidth - scr_x1 - 1); | ||
255 | + break; | ||
256 | + case BOTTOM_TO_TOP: | ||
257 | + scr_x1 = (shaHeight - box_y2) & pixelsMask; | ||
258 | + scr_x2 = (shaHeight - box_y1 + pixelsPerBits - 1) & pixelsMask; | ||
259 | + | ||
260 | + sha_y1 = (shaHeight - scr_x1 - 1); | ||
261 | + break; | ||
262 | + } | ||
263 | + switch (y_dir) { | ||
264 | + case TOP_TO_BOTTOM: | ||
265 | + scr_y1 = box_y1; | ||
266 | + scr_y2 = box_y2; | ||
267 | + | ||
268 | + sha_y1 = scr_y1; | ||
269 | + break; | ||
270 | + case RIGHT_TO_LEFT: | ||
271 | + scr_y1 = (shaWidth - box_x2); | ||
272 | + scr_y2 = (shaWidth - box_x1); | ||
273 | + | ||
274 | + sha_x1 = box_x2 - 1; | ||
275 | + break; | ||
276 | + case BOTTOM_TO_TOP: | ||
277 | + scr_y1 = shaHeight - box_y2; | ||
278 | + scr_y2 = shaHeight - box_y1; | ||
279 | + | ||
280 | + sha_y1 = box_y2 - 1; | ||
281 | + break; | ||
282 | + case LEFT_TO_RIGHT: | ||
283 | + scr_y1 = box_x1; | ||
284 | + scr_y2 = box_x2; | ||
285 | + | ||
286 | + sha_x1 = box_x1; | ||
287 | + break; | ||
288 | + } | ||
289 | + scr_w = ((scr_x2 - scr_x1) * shaBpp) >> FB_SHIFT; | ||
290 | + scr_h = scr_y2 - scr_y1; | ||
291 | + scr_y = scr_y1; | ||
292 | + | ||
293 | + /* shift amount for first pixel on screen */ | ||
294 | + shaFirstShift = FB_UNIT - ((sha_x1 * shaBpp) & FB_MASK) - shaBpp; | ||
295 | + | ||
296 | + /* pointer to shadow data first placed on screen */ | ||
297 | + shaLine = (shaBits + | ||
298 | + sha_y1 * shaStride + | ||
299 | + ((sha_x1 * shaBpp) >> FB_SHIFT)); | ||
300 | + | ||
301 | + /* | ||
302 | + * Copy the bits, always write across the physical frame buffer | ||
303 | + * to take advantage of write combining. | ||
304 | + */ | ||
305 | + while (scr_h--) | ||
306 | + { | ||
307 | + int p; | ||
308 | + FbBits bits; | ||
309 | + char *win; | ||
310 | + int i; | ||
311 | + CARD32 winSize; | ||
312 | + | ||
313 | + sha = shaLine; | ||
314 | + shaShift = shaFirstShift; | ||
315 | + w = scr_w; | ||
316 | + scr_x = scr_x1 * shaBpp >> FB_SHIFT; | ||
317 | + | ||
318 | + while (w) | ||
319 | + { | ||
320 | + /* | ||
321 | + * Map some of this line | ||
322 | + */ | ||
323 | + win = (char *) (*pBuf->window) (pScreen, | ||
324 | + scr_y, | ||
325 | + scr_x * 3, | ||
326 | + SHADOW_WINDOW_WRITE, | ||
327 | + &winSize, | ||
328 | + pBuf->closure); | ||
329 | + i = winSize / 3; | ||
330 | + if (i > w) | ||
331 | + i = w; | ||
332 | + w -= i; | ||
333 | + scr_x += i; | ||
334 | + /* | ||
335 | + * Copy the portion of the line mapped | ||
336 | + */ | ||
337 | + while (i--) | ||
338 | + { | ||
339 | + bits = 0; | ||
340 | + p = pixelsPerBits; | ||
341 | + /* | ||
342 | + * Build one word of output from multiple inputs | ||
343 | + * | ||
344 | + * Note that for 90/270 rotations, this will walk | ||
345 | + * down the shadow hitting each scanline once. | ||
346 | + * This is probably not very efficient. | ||
347 | + */ | ||
348 | + while (p--) | ||
349 | + { | ||
350 | + bits = FbScrLeft(bits, shaBpp); | ||
351 | + bits |= FbScrRight (*sha, shaShift) & shaMask; | ||
352 | + | ||
353 | + shaShift -= shaStepOverX; | ||
354 | + if (shaShift >= FB_UNIT) | ||
355 | + { | ||
356 | + shaShift -= FB_UNIT; | ||
357 | + sha--; | ||
358 | + } | ||
359 | + else if (shaShift < 0) | ||
360 | + { | ||
361 | + shaShift += FB_UNIT; | ||
362 | + sha++; | ||
363 | + } | ||
364 | + sha += shaStepOverY; | ||
365 | + } | ||
366 | + *win++ = ((bits & 0xFC) >> 2) | | ||
367 | + ((bits & 0xC00) >> 4); | ||
368 | + *win++ = ((bits & 0xF000) >> 12) | | ||
369 | + ((bits & 0x3C0000) >> 14); | ||
370 | + *win++ = (bits & 0xC00000) >> 22; | ||
371 | + } | ||
372 | + } | ||
373 | + scr_y++; | ||
374 | + shaFirstShift -= shaStepDownX; | ||
375 | + if (shaFirstShift >= FB_UNIT) | ||
376 | + { | ||
377 | + shaFirstShift -= FB_UNIT; | ||
378 | + shaLine--; | ||
379 | + } | ||
380 | + else if (shaFirstShift < 0) | ||
381 | + { | ||
382 | + shaFirstShift += FB_UNIT; | ||
383 | + shaLine++; | ||
384 | + } | ||
385 | + shaLine += shaStepDownY; | ||
386 | + } | ||
387 | + } | ||
388 | +} | ||
389 | + | ||
390 | Bool | ||
391 | fbdevSetShadow (ScreenPtr pScreen) | ||
392 | { | ||
393 | @@ -418,7 +784,14 @@ | ||
394 | |||
395 | window = fbdevWindowLinear; | ||
396 | update = 0; | ||
397 | - if (scrpriv->randr) | ||
398 | + if (priv->Have18Bpp) | ||
399 | + { | ||
400 | + if (scrpriv->randr != RR_Rotate_0) | ||
401 | + update = shadowUpdateRotatePacked18; | ||
402 | + else | ||
403 | + update = shadowUpdatePacked18; | ||
404 | + } | ||
405 | + else if (scrpriv->randr) | ||
406 | if (priv->var.bits_per_pixel == 16) { | ||
407 | switch (scrpriv->randr) { | ||
408 | case RR_Rotate_90: | ||
409 | diff -Nurd xorg-server-1.3.0.0/hw/kdrive/fbdev/fbdev.h xorg-server-1.3.0.0.patched/hw/kdrive/fbdev/fbdev.h | ||
410 | --- xorg-server-1.3.0.0/hw/kdrive/fbdev/fbdev.h 2006-09-18 08:04:17.000000000 +0200 | ||
411 | +++ xorg-server-1.3.0.0.patched/hw/kdrive/fbdev/fbdev.h 2007-09-15 16:45:07.362045000 +0200 | ||
412 | @@ -44,6 +44,7 @@ | ||
413 | int fd; | ||
414 | char *fb; | ||
415 | char *fb_base; | ||
416 | + Bool Have18Bpp; | ||
417 | } FbdevPriv; | ||
418 | |||
419 | typedef struct _fbdevScrPriv { | ||