diff options
Diffstat (limited to 'meta/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch')
-rw-r--r-- | meta/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch | 756 |
1 files changed, 0 insertions, 756 deletions
diff --git a/meta/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch b/meta/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch deleted file mode 100644 index ed5b6f05cb..0000000000 --- a/meta/packages/xorg-xserver/xserver-kdrive/kdrive-vidmemarea.patch +++ /dev/null | |||
@@ -1,756 +0,0 @@ | |||
1 | |||
2 | # Author : Manuel Teira <manuel.teira@telefonica.net> (sirfred in #oe) | ||
3 | # Description: Support for multiple memory video zones in kdrive. Make offscreen | ||
4 | # areas aware of the memory video zone it belongs to. Change the fbdev driver to | ||
5 | # honour this new model. | ||
6 | |||
7 | # | ||
8 | # Patch managed by http://www.holgerschurig.de/patcher.html | ||
9 | # | ||
10 | |||
11 | --- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.c~kdrive-vidmemarea | ||
12 | +++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.c | ||
13 | @@ -908,9 +908,10 @@ | ||
14 | ret = (*pScreen->CloseScreen) (index, pScreen); | ||
15 | else | ||
16 | ret = TRUE; | ||
17 | - | ||
18 | - if (screen->off_screen_base < screen->memory_size) | ||
19 | - KdOffscreenFini (pScreen); | ||
20 | + | ||
21 | + if (KdHasOffscreen(screen)) { | ||
22 | + KdOffscreenFini(pScreen); | ||
23 | + } | ||
24 | |||
25 | if (pScreenPriv->dpmsState != KD_DPMS_NORMAL) | ||
26 | (*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL); | ||
27 | @@ -1219,8 +1220,9 @@ | ||
28 | if (!(*card->cfuncs->initAccel) (pScreen)) | ||
29 | screen->dumb = TRUE; | ||
30 | |||
31 | - if (screen->off_screen_base < screen->memory_size) | ||
32 | - KdOffscreenInit (pScreen); | ||
33 | + if (KdHasOffscreen(screen)) { | ||
34 | + KdOffscreenInit(pScreen); | ||
35 | + } | ||
36 | |||
37 | #ifdef PSEUDO8 | ||
38 | (void) p8Init (pScreen, PSEUDO8_USE_DEFAULT); | ||
39 | --- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.h~kdrive-vidmemarea | ||
40 | +++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kdrive.h | ||
41 | @@ -63,6 +63,9 @@ | ||
42 | #define KD_MAX_CARD_ADDRESS 8 | ||
43 | #endif | ||
44 | |||
45 | +#define KD_VIDMEM_MINPRIO 0 | ||
46 | +#define KD_VIDMEM_MAXPRIO 255 | ||
47 | + | ||
48 | /* | ||
49 | * Configuration information per video card | ||
50 | */ | ||
51 | @@ -115,6 +118,13 @@ | ||
52 | |||
53 | typedef void (*KdOffscreenSaveProc) (ScreenPtr pScreen, KdOffscreenArea *area); | ||
54 | |||
55 | +typedef struct _KdVideoMemArea { | ||
56 | + CARD8 priority; | ||
57 | + CARD8 *base; | ||
58 | + CARD32 size; | ||
59 | + CARD32 available_offset; | ||
60 | +} KdVideoMemArea; | ||
61 | + | ||
62 | typedef enum _KdOffscreenState { | ||
63 | KdOffscreenAvail, | ||
64 | KdOffscreenRemovable, | ||
65 | @@ -127,7 +137,8 @@ | ||
66 | int size; | ||
67 | int score; | ||
68 | pointer privData; | ||
69 | - | ||
70 | + KdVideoMemArea *vidmem; | ||
71 | + int pool; | ||
72 | KdOffscreenSaveProc save; | ||
73 | |||
74 | KdOffscreenState state; | ||
75 | @@ -138,6 +149,7 @@ | ||
76 | #define RR_Rotate_All (RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270) | ||
77 | #define RR_Reflect_All (RR_Reflect_X|RR_Reflect_Y) | ||
78 | |||
79 | + | ||
80 | typedef struct _KdScreenInfo { | ||
81 | struct _KdScreenInfo *next; | ||
82 | KdCardInfo *card; | ||
83 | @@ -155,9 +167,8 @@ | ||
84 | int mynum; | ||
85 | DDXPointRec origin; | ||
86 | KdFrameBuffer fb[KD_MAX_FB]; | ||
87 | - CARD8 *memory_base; | ||
88 | - unsigned long memory_size; | ||
89 | - unsigned long off_screen_base; | ||
90 | + KdVideoMemArea **videomem_areas; | ||
91 | + int num_videomem_areas; | ||
92 | } KdScreenInfo; | ||
93 | |||
94 | typedef struct _KdCardFuncs { | ||
95 | @@ -187,7 +198,6 @@ | ||
96 | |||
97 | void (*getColors) (ScreenPtr, int, int, xColorItem *); | ||
98 | void (*putColors) (ScreenPtr, int, int, xColorItem *); | ||
99 | - | ||
100 | } KdCardFuncs; | ||
101 | |||
102 | #define KD_MAX_PSEUDO_DEPTH 8 | ||
103 | @@ -203,7 +213,8 @@ | ||
104 | |||
105 | int dpmsState; | ||
106 | |||
107 | - KdOffscreenArea *off_screen_areas; | ||
108 | + KdOffscreenArea **offscreen_pools; | ||
109 | + int num_offscreen_pools; | ||
110 | |||
111 | ColormapPtr pInstalledmap[KD_MAX_FB]; /* current colormap */ | ||
112 | xColorItem systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */ | ||
113 | @@ -881,6 +892,15 @@ | ||
114 | KdOffscreenInit (ScreenPtr pScreen); | ||
115 | |||
116 | KdOffscreenArea * | ||
117 | +KdOffscreenAllocPrio (ScreenPtr pScreen, int size, int align, | ||
118 | + Bool locked, | ||
119 | + KdOffscreenSaveProc save, | ||
120 | + pointer privData, | ||
121 | + int minPriority, | ||
122 | + int maxPriority, | ||
123 | + Bool allowEviction); | ||
124 | + | ||
125 | +KdOffscreenArea * | ||
126 | KdOffscreenAlloc (ScreenPtr pScreen, int size, int align, | ||
127 | Bool locked, | ||
128 | KdOffscreenSaveProc save, | ||
129 | --- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kaa.c~kdrive-vidmemarea | ||
130 | +++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/kaa.c | ||
131 | @@ -160,7 +160,7 @@ | ||
132 | pPixmap->drawable.width, | ||
133 | pPixmap->drawable.height)); | ||
134 | pPixmap->devKind = pitch; | ||
135 | - pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pScreenPriv->screen->memory_base + pKaaPixmap->area->offset); | ||
136 | + pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pKaaPixmap->area->vidmem->base + pKaaPixmap->area->offset); | ||
137 | pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; | ||
138 | return TRUE; | ||
139 | } | ||
140 | @@ -198,7 +198,7 @@ | ||
141 | |||
142 | dst = pPixmap->devPrivate.ptr; | ||
143 | dst_pitch = pPixmap->devKind; | ||
144 | - | ||
145 | + | ||
146 | bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; | ||
147 | |||
148 | kaaWaitSync (pPixmap->drawable.pScreen); | ||
149 | @@ -336,10 +336,16 @@ | ||
150 | { | ||
151 | ScreenPtr pScreen = p->drawable.pScreen; | ||
152 | KdScreenPriv(pScreen); | ||
153 | + int index; | ||
154 | |||
155 | - return ((unsigned long) ((CARD8 *) p->devPrivate.ptr - | ||
156 | - (CARD8 *) pScreenPriv->screen->memory_base) < | ||
157 | - pScreenPriv->screen->memory_size); | ||
158 | + for (index = 0; index < pScreenPriv->screen->num_videomem_areas; index++) { | ||
159 | + KdVideoMemArea *vidmem = pScreenPriv->screen->videomem_areas[index]; | ||
160 | + if ((((CARD8 *)p->devPrivate.ptr) >= vidmem->base) && | ||
161 | + (((CARD8 *)p->devPrivate.ptr) <= (vidmem->base + vidmem->size))) { | ||
162 | + return TRUE; | ||
163 | + } | ||
164 | + } | ||
165 | + return FALSE; | ||
166 | } | ||
167 | |||
168 | PixmapPtr | ||
169 | @@ -1060,6 +1066,7 @@ | ||
170 | KdCheckPaintWindow (pWin, pRegion, what); | ||
171 | } | ||
172 | |||
173 | + | ||
174 | Bool | ||
175 | kaaDrawInit (ScreenPtr pScreen, | ||
176 | KaaScreenInfoPtr pScreenInfo) | ||
177 | @@ -1109,7 +1116,7 @@ | ||
178 | * Hookup offscreen pixmaps | ||
179 | */ | ||
180 | if ((pKaaScr->info->flags & KAA_OFFSCREEN_PIXMAPS) && | ||
181 | - screen->off_screen_base < screen->memory_size) | ||
182 | + KdHasOffscreen(screen)) | ||
183 | { | ||
184 | if (!AllocatePixmapPrivate(pScreen, kaaPixmapPrivateIndex, | ||
185 | sizeof (KaaPixmapPrivRec))) | ||
186 | --- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/koffscreen.c~kdrive-vidmemarea | ||
187 | +++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/src/koffscreen.c | ||
188 | @@ -41,16 +41,20 @@ | ||
189 | { | ||
190 | KdScreenPriv (pScreen); | ||
191 | KdOffscreenArea *prev = 0, *area; | ||
192 | - | ||
193 | - assert (pScreenPriv->screen->off_screen_areas->area.offset == 0); | ||
194 | - for (area = pScreenPriv->off_screen_areas; area; area = area->next) | ||
195 | - { | ||
196 | - if (prev) | ||
197 | - assert (prev->offset + prev->size == area->offset); | ||
198 | + int index; | ||
199 | + | ||
200 | + for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) { | ||
201 | + area = pScreenPriv->offscreen_pools[index]; | ||
202 | + assert (area->vidmem->available_offset - area.offset == 0); | ||
203 | + while(area) { | ||
204 | + if (prev) | ||
205 | + assert (prev->offset + prev->size == area->offset); | ||
206 | |||
207 | - prev = area; | ||
208 | + prev = area; | ||
209 | + area = area->next; | ||
210 | + } | ||
211 | + assert (prev->offset + prev->size == prev->vidmem->size); | ||
212 | } | ||
213 | - assert (prev->offset + prev->size == pScreenPriv->screen->memory_size); | ||
214 | } | ||
215 | #else | ||
216 | #define KdOffscreenValidate(s) | ||
217 | @@ -65,101 +69,133 @@ | ||
218 | } | ||
219 | |||
220 | KdOffscreenArea * | ||
221 | -KdOffscreenAlloc (ScreenPtr pScreen, int size, int align, | ||
222 | - Bool locked, | ||
223 | - KdOffscreenSaveProc save, | ||
224 | - pointer privData) | ||
225 | +KdOffscreenAllocPrio (ScreenPtr pScreen, int size, int align, | ||
226 | + Bool locked, | ||
227 | + KdOffscreenSaveProc save, | ||
228 | + pointer privData, | ||
229 | + int minPriority, | ||
230 | + int maxPriority, | ||
231 | + Bool allowEviction) | ||
232 | { | ||
233 | KdOffscreenArea *area, *begin, *best; | ||
234 | KdScreenPriv (pScreen); | ||
235 | int tmp, real_size = 0, best_score; | ||
236 | + int index; | ||
237 | + Bool canFit = FALSE; | ||
238 | |||
239 | - KdOffscreenValidate (pScreen); | ||
240 | if (!align) | ||
241 | align = 1; | ||
242 | |||
243 | if (!size) | ||
244 | { | ||
245 | - DBG_OFFSCREEN (("Alloc 0x%x -> EMPTY\n", size)); | ||
246 | + DBG_OFFSCREEN(("Alloc 0x%x -> EMPTY\n", size)); | ||
247 | return NULL; | ||
248 | } | ||
249 | |||
250 | /* throw out requests that cannot fit */ | ||
251 | - if (size > (pScreenPriv->screen->memory_size - pScreenPriv->screen->off_screen_base)) | ||
252 | - { | ||
253 | - DBG_OFFSCREEN (("Alloc 0x%x -> TOBIG\n", size)); | ||
254 | - return NULL; | ||
255 | + for (index = 0; index < pScreenPriv->screen->num_videomem_areas; index++) { | ||
256 | + KdVideoMemArea *vidmem = pScreenPriv->screen->videomem_areas[index]; | ||
257 | + if ((vidmem->priority <= maxPriority) && | ||
258 | + (vidmem->priority >= minPriority)) { | ||
259 | + if (size <= (vidmem->size - vidmem->available_offset)) { | ||
260 | + canFit = TRUE; | ||
261 | + break; | ||
262 | + } | ||
263 | + } | ||
264 | } | ||
265 | - | ||
266 | - /* Try to find a free space that'll fit. */ | ||
267 | - for (area = pScreenPriv->off_screen_areas; area; area = area->next) | ||
268 | + if (!canFit) | ||
269 | { | ||
270 | - /* skip allocated areas */ | ||
271 | - if (area->state != KdOffscreenAvail) | ||
272 | - continue; | ||
273 | + DBG_OFFSCREEN(("Alloc 0x%x -> TOOBIG\n", size)); | ||
274 | + return NULL; | ||
275 | + } | ||
276 | |||
277 | - /* adjust size to match alignment requirement */ | ||
278 | - real_size = size; | ||
279 | - tmp = area->offset % align; | ||
280 | - if (tmp) | ||
281 | - real_size += (align - tmp); | ||
282 | - | ||
283 | - /* does it fit? */ | ||
284 | - if (real_size <= area->size) | ||
285 | - break; | ||
286 | + for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) { | ||
287 | + /* Look just in the head, as all the areas of the pool have | ||
288 | + the same vidmem */ | ||
289 | + area = pScreenPriv->offscreen_pools[index]; | ||
290 | + if ((area->vidmem->priority > maxPriority) || | ||
291 | + (area->vidmem->priority < minPriority)) | ||
292 | + continue; | ||
293 | + | ||
294 | + /* Try to find a free space that'll fit. */ | ||
295 | + for (area = pScreenPriv->offscreen_pools[index]; area; | ||
296 | + area = area->next) { | ||
297 | + /* skip allocated areas */ | ||
298 | + if (area->state != KdOffscreenAvail) | ||
299 | + continue; | ||
300 | + | ||
301 | + /* adjust size to match alignment requirement */ | ||
302 | + real_size = size; | ||
303 | + tmp = area->offset % align; | ||
304 | + if (tmp) | ||
305 | + real_size += (align - tmp); | ||
306 | + | ||
307 | + /* does it fit? */ | ||
308 | + if (real_size <= area->size) | ||
309 | + break; | ||
310 | + } | ||
311 | + if (area) | ||
312 | + break; | ||
313 | } | ||
314 | - | ||
315 | - if (!area) | ||
316 | - { | ||
317 | + | ||
318 | + if (!area && allowEviction) { | ||
319 | /* | ||
320 | * Kick out existing users to make space. | ||
321 | * | ||
322 | * First, locate a region which can hold the desired object. | ||
323 | */ | ||
324 | + for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) { | ||
325 | + if ((area->vidmem->priority > maxPriority) || | ||
326 | + (area->vidmem->priority < minPriority)) | ||
327 | + continue; | ||
328 | |||
329 | - /* prev points at the first object to boot */ | ||
330 | - best = NULL; | ||
331 | - best_score = MAXINT; | ||
332 | - for (begin = pScreenPriv->off_screen_areas; begin != NULL; | ||
333 | - begin = begin->next) | ||
334 | - { | ||
335 | - int avail, score; | ||
336 | - KdOffscreenArea *scan; | ||
337 | + /* prev points at the first object to boot */ | ||
338 | + best = NULL; | ||
339 | + best_score = MAXINT; | ||
340 | |||
341 | - if (begin->state == KdOffscreenLocked) | ||
342 | - continue; | ||
343 | + for (begin = pScreenPriv->offscreen_pools[index]; begin != NULL; | ||
344 | + begin = begin->next) { | ||
345 | + int avail, score; | ||
346 | + KdOffscreenArea *scan; | ||
347 | |||
348 | - /* adjust size to match alignment requirement */ | ||
349 | - real_size = size; | ||
350 | - tmp = begin->offset % align; | ||
351 | - if (tmp) | ||
352 | - real_size += (align - tmp); | ||
353 | + if (begin->state == KdOffscreenLocked) | ||
354 | + continue; | ||
355 | + | ||
356 | + /* adjust size to match alignment requirement */ | ||
357 | + real_size = size; | ||
358 | + tmp = begin->offset % align; | ||
359 | + if (tmp) | ||
360 | + real_size += (align - tmp); | ||
361 | |||
362 | - avail = 0; | ||
363 | - score = 0; | ||
364 | - /* now see if we can make room here, and how "costly" it'll be. */ | ||
365 | - for (scan = begin; scan != NULL; scan = scan->next) | ||
366 | - { | ||
367 | - if (scan->state == KdOffscreenLocked) { | ||
368 | - /* Can't make room here, start after this locked area. */ | ||
369 | - begin = scan->next; | ||
370 | - break; | ||
371 | - } | ||
372 | - /* Score should only be non-zero for KdOffscreenRemovable */ | ||
373 | - score += scan->score; | ||
374 | - avail += scan->size; | ||
375 | - if (avail >= real_size) | ||
376 | - break; | ||
377 | - } | ||
378 | - /* Is it the best option we've found so far? */ | ||
379 | - if (avail >= real_size && score < best_score) { | ||
380 | - best = begin; | ||
381 | - best_score = score; | ||
382 | - } | ||
383 | - } | ||
384 | - area = best; | ||
385 | - if (!area) | ||
386 | - { | ||
387 | + avail = 0; | ||
388 | + score = 0; | ||
389 | + /* now see if we can make room here, | ||
390 | + and how "costly" it'll be. */ | ||
391 | + for (scan = begin; scan != NULL; scan = scan->next) { | ||
392 | + if (scan->state == KdOffscreenLocked) { | ||
393 | + /* Can't make room here, | ||
394 | + start after this locked area. */ | ||
395 | + begin = scan->next; | ||
396 | + break; | ||
397 | + } | ||
398 | + /* Score should only be non-zero for KdOffscreenRemovable */ | ||
399 | + score += scan->score; | ||
400 | + avail += scan->size; | ||
401 | + if (avail >= real_size) | ||
402 | + break; | ||
403 | + } | ||
404 | + /* Is it the best option we've found so far? */ | ||
405 | + if (avail >= real_size && score < best_score) { | ||
406 | + best = begin; | ||
407 | + best_score = score; | ||
408 | + } | ||
409 | + } | ||
410 | + area = best; | ||
411 | + if (area) | ||
412 | + break; | ||
413 | + } | ||
414 | + | ||
415 | + if (!area) { | ||
416 | DBG_OFFSCREEN (("Alloc 0x%x -> NOSPACE\n", size)); | ||
417 | /* Could not allocate memory */ | ||
418 | KdOffscreenValidate (pScreen); | ||
419 | @@ -180,16 +216,14 @@ | ||
420 | /* | ||
421 | * Now get the system to merge the other needed areas together | ||
422 | */ | ||
423 | - while (area->size < real_size) | ||
424 | - { | ||
425 | - assert (area->next && area->next->state == KdOffscreenRemovable); | ||
426 | + while (area->size < real_size) { | ||
427 | + assert (area->next && area->next->state == KdOffscreenRemovable); | ||
428 | (void) KdOffscreenKickOut (pScreen, area->next); | ||
429 | } | ||
430 | } | ||
431 | - | ||
432 | + | ||
433 | /* save extra space in new area */ | ||
434 | - if (real_size < area->size) | ||
435 | - { | ||
436 | + if (real_size < area->size) { | ||
437 | KdOffscreenArea *new_area = xalloc (sizeof (KdOffscreenArea)); | ||
438 | if (!new_area) | ||
439 | return NULL; | ||
440 | @@ -198,9 +232,14 @@ | ||
441 | new_area->state = KdOffscreenAvail; | ||
442 | new_area->save = 0; | ||
443 | new_area->score = 0; | ||
444 | + new_area->vidmem = area->vidmem; | ||
445 | + new_area->pool = area->pool; | ||
446 | new_area->next = area->next; | ||
447 | area->next = new_area; | ||
448 | area->size = real_size; | ||
449 | + DBG_OFFSCREEN (("New OffscreenArea at %p (offset:0x%08x, size:0x%08x, pool:%d\n", area, area->offset, area->size, area->pool)); | ||
450 | + | ||
451 | + | ||
452 | } | ||
453 | /* | ||
454 | * Mark this area as in use | ||
455 | @@ -212,42 +251,80 @@ | ||
456 | area->privData = privData; | ||
457 | area->save = save; | ||
458 | area->score = 0; | ||
459 | - | ||
460 | + | ||
461 | area->save_offset = area->offset; | ||
462 | { | ||
463 | int tmp = area->offset % align; | ||
464 | if (tmp) | ||
465 | area->offset += (align - tmp); | ||
466 | } | ||
467 | - | ||
468 | + | ||
469 | KdOffscreenValidate (pScreen); | ||
470 | |||
471 | DBG_OFFSCREEN (("Alloc 0x%x -> 0x%x\n", size, area->offset)); | ||
472 | return area; | ||
473 | } | ||
474 | |||
475 | +Bool | ||
476 | +KdHasOffscreen(KdScreenInfo *screen) | ||
477 | +{ | ||
478 | + int index; | ||
479 | + DBG_OFFSCREEN (("KdHasOffscreen\n")); | ||
480 | + | ||
481 | + for (index = 0; index < screen->num_videomem_areas; index++) { | ||
482 | + KdVideoMemArea *vidmem = screen->videomem_areas[index]; | ||
483 | + if (vidmem->available_offset < vidmem->size) { | ||
484 | + return TRUE; | ||
485 | + } | ||
486 | + } | ||
487 | + return FALSE; | ||
488 | +} | ||
489 | + | ||
490 | +KdOffscreenArea * | ||
491 | +KdOffscreenAlloc (ScreenPtr pScreen, int size, int align, | ||
492 | + Bool locked, | ||
493 | + KdOffscreenSaveProc save, | ||
494 | + pointer privData) | ||
495 | +{ | ||
496 | + DBG_OFFSCREEN (("KdOffscreenAlloc(size:%d, align:%d, locked:%d)\n", | ||
497 | + size, align, locked)); | ||
498 | + return KdOffscreenAllocPrio(pScreen, size, align, | ||
499 | + locked, | ||
500 | + save, | ||
501 | + privData, | ||
502 | + KD_VIDMEM_MINPRIO, | ||
503 | + KD_VIDMEM_MAXPRIO, | ||
504 | + TRUE); | ||
505 | +} | ||
506 | + | ||
507 | void | ||
508 | KdOffscreenSwapOut (ScreenPtr pScreen) | ||
509 | { | ||
510 | KdScreenPriv (pScreen); | ||
511 | + int index; | ||
512 | + | ||
513 | + DBG_OFFSCREEN (("KdOffscreenSwapOut\n")); | ||
514 | |||
515 | KdOffscreenValidate (pScreen); | ||
516 | - /* loop until a single free area spans the space */ | ||
517 | - for (;;) | ||
518 | - { | ||
519 | - KdOffscreenArea *area = pScreenPriv->off_screen_areas; | ||
520 | + | ||
521 | + for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) { | ||
522 | + /* loop until a single free area spans the space */ | ||
523 | + for (;;) | ||
524 | + { | ||
525 | + KdOffscreenArea *area = pScreenPriv->offscreen_pools[index]; | ||
526 | |||
527 | - if (!area) | ||
528 | - break; | ||
529 | - if (area->state == KdOffscreenAvail) | ||
530 | - { | ||
531 | - area = area->next; | ||
532 | - if (!area) | ||
533 | - break; | ||
534 | - } | ||
535 | - assert (area->state != KdOffscreenAvail); | ||
536 | - (void) KdOffscreenKickOut (pScreen, area); | ||
537 | - KdOffscreenValidate (pScreen); | ||
538 | + if (!area) | ||
539 | + break; | ||
540 | + if (area->state == KdOffscreenAvail) | ||
541 | + { | ||
542 | + area = area->next; | ||
543 | + if (!area) | ||
544 | + break; | ||
545 | + } | ||
546 | + assert (area->state != KdOffscreenAvail); | ||
547 | + (void) KdOffscreenKickOut (pScreen, area); | ||
548 | + KdOffscreenValidate (pScreen); | ||
549 | + } | ||
550 | } | ||
551 | KdOffscreenValidate (pScreen); | ||
552 | KdOffscreenFini (pScreen); | ||
553 | @@ -256,6 +333,8 @@ | ||
554 | void | ||
555 | KdOffscreenSwapIn (ScreenPtr pScreen) | ||
556 | { | ||
557 | + KdScreenPriv (pScreen); | ||
558 | + DBG_OFFSCREEN (("KdOffscreenSwapIn\n")); | ||
559 | KdOffscreenInit (pScreen); | ||
560 | } | ||
561 | |||
562 | @@ -264,7 +343,7 @@ | ||
563 | KdOffscreenMerge (KdOffscreenArea *area) | ||
564 | { | ||
565 | KdOffscreenArea *next = area->next; | ||
566 | - | ||
567 | + //DBG_OFFSCREEN (("KdOffscreenMerge %p\n", area)); | ||
568 | /* account for space */ | ||
569 | area->size += next->size; | ||
570 | /* frob pointer */ | ||
571 | @@ -278,8 +357,9 @@ | ||
572 | KdScreenPriv(pScreen); | ||
573 | KdOffscreenArea *next = area->next; | ||
574 | KdOffscreenArea *prev; | ||
575 | - | ||
576 | - DBG_OFFSCREEN (("Free 0x%x -> 0x%x\n", area->size, area->offset)); | ||
577 | + | ||
578 | + DBG_OFFSCREEN (("KdOffscreenFree 0x%x -> 0x%x\n", | ||
579 | + area->size, area->offset)); | ||
580 | KdOffscreenValidate (pScreen); | ||
581 | |||
582 | area->state = KdOffscreenAvail; | ||
583 | @@ -290,10 +370,11 @@ | ||
584 | /* | ||
585 | * Find previous area | ||
586 | */ | ||
587 | - if (area == pScreenPriv->off_screen_areas) | ||
588 | + if (area == pScreenPriv->offscreen_pools[area->pool]) | ||
589 | prev = 0; | ||
590 | else | ||
591 | - for (prev = pScreenPriv->off_screen_areas; prev; prev = prev->next) | ||
592 | + for (prev = pScreenPriv->offscreen_pools[area->pool]; | ||
593 | + prev; prev = prev->next) | ||
594 | if (prev->next == area) | ||
595 | break; | ||
596 | |||
597 | @@ -317,21 +398,30 @@ | ||
598 | { | ||
599 | KaaPixmapPriv (pPixmap); | ||
600 | KdScreenPriv (pPixmap->drawable.pScreen); | ||
601 | + int index; | ||
602 | static int iter = 0; | ||
603 | |||
604 | + | ||
605 | if (!pKaaPixmap->area) | ||
606 | return; | ||
607 | |||
608 | + /* | ||
609 | + DBG_OFFSCREEN(("KdOffscreenMarkUsed(offset:0x%08x, pool:%d)\n", | ||
610 | + pKaaPixmap->area->offset, | ||
611 | + pKaaPixmap->area->pool)); | ||
612 | + */ | ||
613 | /* The numbers here are arbitrary. We may want to tune these. */ | ||
614 | pKaaPixmap->area->score += 100; | ||
615 | if (++iter == 10) { | ||
616 | KdOffscreenArea *area; | ||
617 | - for (area = pScreenPriv->off_screen_areas; area != NULL; | ||
618 | - area = area->next) | ||
619 | - { | ||
620 | - if (area->state == KdOffscreenRemovable) | ||
621 | - area->score = (area->score * 7) / 8; | ||
622 | - } | ||
623 | + for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) { | ||
624 | + for (area = pScreenPriv->offscreen_pools[index]; area != NULL; | ||
625 | + area = area->next) | ||
626 | + { | ||
627 | + if (area->state == KdOffscreenRemovable) | ||
628 | + area->score = (area->score * 7) / 8; | ||
629 | + } | ||
630 | + } | ||
631 | } | ||
632 | } | ||
633 | |||
634 | @@ -340,23 +430,41 @@ | ||
635 | { | ||
636 | KdScreenPriv (pScreen); | ||
637 | KdOffscreenArea *area; | ||
638 | + KdVideoMemArea *vidmem; | ||
639 | + int index, num_offscreen; | ||
640 | |||
641 | - /* Allocate a big free area */ | ||
642 | - area = xalloc (sizeof (KdOffscreenArea)); | ||
643 | + DBG_OFFSCREEN (("KdOffscreenInit\n")); | ||
644 | + num_offscreen = 0; | ||
645 | + pScreenPriv->num_offscreen_pools = 0; | ||
646 | + pScreenPriv->offscreen_pools = NULL; | ||
647 | |||
648 | - if (!area) | ||
649 | - return FALSE; | ||
650 | + for (index = 0; index < pScreenPriv->screen->num_videomem_areas; index++) { | ||
651 | + vidmem = pScreenPriv->screen->videomem_areas[index]; | ||
652 | + DBG_OFFSCREEN (("Searching vidmemarea base:0x%p, size:0x%08x, available_offset:0x%08x\n", vidmem->base, vidmem->size, vidmem->available_offset)); | ||
653 | + if (vidmem->available_offset < vidmem->size) { | ||
654 | + pScreenPriv->offscreen_pools = xrealloc(pScreenPriv->offscreen_pools, | ||
655 | + sizeof(KdOffscreenArea*) * (pScreenPriv->num_offscreen_pools + 1)); | ||
656 | + if (!pScreenPriv->offscreen_pools) { | ||
657 | + return FALSE; | ||
658 | + } | ||
659 | + pScreenPriv->offscreen_pools[pScreenPriv->num_offscreen_pools] = | ||
660 | + area = xcalloc(sizeof(KdOffscreenArea), 1); | ||
661 | + if (!area) | ||
662 | + return FALSE; | ||
663 | + | ||
664 | + area->state = KdOffscreenAvail; | ||
665 | + area->vidmem = vidmem; | ||
666 | + area->offset = vidmem->available_offset; | ||
667 | + area->size = vidmem->size - vidmem->available_offset; | ||
668 | + area->save = 0; | ||
669 | + area->pool = pScreenPriv->num_offscreen_pools; | ||
670 | + area->next = NULL; | ||
671 | + area->score = 0; | ||
672 | + pScreenPriv->num_offscreen_pools++; | ||
673 | + DBG_OFFSCREEN (("New OffscreenArea at %p (offset:0x%08x, size:0x%08x, pool:%d)\n", area, area->offset, area->size, area->pool)); | ||
674 | + } | ||
675 | + } | ||
676 | |||
677 | - area->state = KdOffscreenAvail; | ||
678 | - area->offset = pScreenPriv->screen->off_screen_base; | ||
679 | - area->size = pScreenPriv->screen->memory_size - area->offset; | ||
680 | - area->save = 0; | ||
681 | - area->next = NULL; | ||
682 | - area->score = 0; | ||
683 | - | ||
684 | - /* Add it to the free areas */ | ||
685 | - pScreenPriv->off_screen_areas = area; | ||
686 | - | ||
687 | KdOffscreenValidate (pScreen); | ||
688 | |||
689 | return TRUE; | ||
690 | @@ -367,11 +475,17 @@ | ||
691 | { | ||
692 | KdScreenPriv (pScreen); | ||
693 | KdOffscreenArea *area; | ||
694 | - | ||
695 | - /* just free all of the area records */ | ||
696 | - while ((area = pScreenPriv->off_screen_areas)) | ||
697 | - { | ||
698 | - pScreenPriv->off_screen_areas = area->next; | ||
699 | - xfree (area); | ||
700 | + int index; | ||
701 | + | ||
702 | + DBG_OFFSCREEN (("KdOffscreenFini\n")); | ||
703 | + for (index = 0; index < pScreenPriv->num_offscreen_pools; index++) { | ||
704 | + /* just free all of the area records */ | ||
705 | + while ((area = pScreenPriv->offscreen_pools[index])) { | ||
706 | + pScreenPriv->offscreen_pools[index] = area->next; | ||
707 | + xfree (area); | ||
708 | + } | ||
709 | } | ||
710 | + xfree(pScreenPriv->offscreen_pools); | ||
711 | + pScreenPriv->offscreen_pools = NULL; | ||
712 | + pScreenPriv->num_offscreen_pools = 0; | ||
713 | } | ||
714 | --- xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/fbdev/fbdev.c~kdrive-vidmemarea | ||
715 | +++ xorg-server-X11R7.1-1.1.0.orig/hw/kdrive/fbdev/fbdev.c | ||
716 | @@ -330,6 +330,7 @@ | ||
717 | FbdevScrPriv *scrpriv = screen->driver; | ||
718 | KdMouseMatrix m; | ||
719 | FbdevPriv *priv = screen->card->driver; | ||
720 | + KdVideoMemArea *vidmem; | ||
721 | |||
722 | if (scrpriv->randr != RR_Rotate_0) | ||
723 | scrpriv->shadow = TRUE; | ||
724 | @@ -342,15 +343,20 @@ | ||
725 | |||
726 | screen->width = priv->var.xres; | ||
727 | screen->height = priv->var.yres; | ||
728 | - screen->memory_base = (CARD8 *) (priv->fb); | ||
729 | - screen->memory_size = priv->fix.smem_len; | ||
730 | + screen->videomem_areas = xcalloc(sizeof(KdVideoMemArea*), 1); | ||
731 | + screen->videomem_areas[0] = vidmem = xcalloc(sizeof(KdVideoMemArea), 1); | ||
732 | + screen->num_videomem_areas = 1; | ||
733 | + | ||
734 | + vidmem->priority = KD_VIDMEM_MINPRIO; | ||
735 | + vidmem->base = (CARD8 *) (priv->fb); | ||
736 | + vidmem->size = priv->fix.smem_len; | ||
737 | |||
738 | if (scrpriv->shadow) | ||
739 | { | ||
740 | if (!KdShadowFbAlloc (screen, 0, | ||
741 | scrpriv->randr & (RR_Rotate_90|RR_Rotate_270))) | ||
742 | return FALSE; | ||
743 | - screen->off_screen_base = screen->memory_size; | ||
744 | + vidmem->available_offset = vidmem->size; | ||
745 | } | ||
746 | else | ||
747 | { | ||
748 | @@ -358,7 +364,7 @@ | ||
749 | screen->fb[0].pixelStride = (priv->fix.line_length * 8 / | ||
750 | priv->var.bits_per_pixel); | ||
751 | screen->fb[0].frameBuffer = (CARD8 *) (priv->fb); | ||
752 | - screen->off_screen_base = screen->fb[0].byteStride * screen->height; | ||
753 | + vidmem->available_offset = screen->fb[0].byteStride * screen->height; | ||
754 | } | ||
755 | |||
756 | return TRUE; | ||