?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix use of uninitialized memory in xlcd_scroll_left() / xlcd_scroll_right() in specia...
[maemo-rb.git] / apps / plugins / lib / xlcd_scroll.c
blob8f55f4153ea2457de676e3a574b21cae00b79431
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Additional LCD routines not present in the rockbox core
11 * Scrolling functions
12 *
13 * Copyright (C) 2005 Jens Arnold
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 * KIND, either express or implied.
22 *
23 ****************************************************************************/
24
25 #include "plugin.h"
26
27 #include "xlcd.h"
28
29 #if (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
30 static const unsigned short patterns[4] = {0xFFFF, 0xFF00, 0x00FF, 0x0000};
31 #endif
32
33 #if defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE
34 void xlcd_scroll_left(int count)
35 {
36 int length, oldmode;
37
38 if ((unsigned)count >= LCD_WIDTH)
39 {
40 rb->lcd_clear_display();
41 return;
42 }
43
44 length = (LCD_WIDTH-count)*LCD_FBHEIGHT;
45
46 rb->memmove(rb->lcd_framebuffer, rb->lcd_framebuffer + LCD_HEIGHT*count,
47 length * sizeof(fb_data));
48
49 oldmode = rb->lcd_get_drawmode();
50 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
51 rb->lcd_fillrect(LCD_WIDTH-count, 0, count, LCD_HEIGHT);
52 rb->lcd_set_drawmode(oldmode);
53 }
54
55 /* Scroll right */
56 void xlcd_scroll_right(int count)
57 {
58 int length, oldmode;
59
60 if ((unsigned)count >= LCD_WIDTH)
61 {
62 rb->lcd_clear_display();
63 return;
64 }
65
66 length = (LCD_WIDTH-count)*LCD_FBHEIGHT;
67
68 rb->memmove(rb->lcd_framebuffer + LCD_HEIGHT*count,
69 rb->lcd_framebuffer, length * sizeof(fb_data));
70
71 oldmode = rb->lcd_get_drawmode();
72 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
73 rb->lcd_fillrect(0, 0, count, LCD_HEIGHT);
74 rb->lcd_set_drawmode(oldmode);
75 }
76
77 /* Scroll up */
78 void xlcd_scroll_up(int count)
79 {
80 int width, length, oldmode;
81
82 fb_data *data;
83
84 if ((unsigned)count >= LCD_HEIGHT)
85 {
86 rb->lcd_clear_display();
87 return;
88 }
89
90 length = LCD_HEIGHT - count;
91
92 width = LCD_WIDTH-1;
93 data = rb->lcd_framebuffer;
94
95 do {
96 rb->memmove(data,data + count,length * sizeof(fb_data));
97 data += LCD_HEIGHT;
98 } while(width--);
99
100 oldmode = rb->lcd_get_drawmode();
101 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
102 rb->lcd_fillrect(0, length, LCD_WIDTH, count);
103 rb->lcd_set_drawmode(oldmode);
104 }
105
106 /* Scroll down */
107 void xlcd_scroll_down(int count)
108 {
109 int width, length, oldmode;
110
111 fb_data *data;
112
113 if ((unsigned)count >= LCD_HEIGHT)
114 {
115 rb->lcd_clear_display();
116 return;
117 }
118
119 length = LCD_HEIGHT - count;
120
121 width = LCD_WIDTH-1;
122 data = rb->lcd_framebuffer;
123
124 do {
125 rb->memmove(data + count, data, length * sizeof(fb_data));
126 data += LCD_HEIGHT;
127 } while(width--);
128
129 oldmode = rb->lcd_get_drawmode();
130 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
131 rb->lcd_fillrect(0, 0, LCD_WIDTH, count);
132 rb->lcd_set_drawmode(oldmode);
133 }
134 #else
135
136 #if (LCD_PIXELFORMAT == HORIZONTAL_PACKING) && (LCD_DEPTH < 8)
137
138 /* Scroll left */
139 void xlcd_scroll_left(int count)
140 {
141 int bitcount=0, oldmode;
142 int blockcount=0, blocklen;
143
144 if ((unsigned) count >= LCD_WIDTH)
145 {
146 rb->lcd_clear_display();
147 return;
148 }
149
150 #if LCD_DEPTH == 2
151 blockcount = count >> 2;
152 blocklen = LCD_FBWIDTH - blockcount;
153 bitcount = 2 * (count & 3);
154 #endif
155
156 if (blockcount)
157 {
158 unsigned char *data = rb->lcd_framebuffer;
159 unsigned char *data_end = data + LCD_FBWIDTH*LCD_HEIGHT;
160
161 do
162 {
163 rb->memmove(data, data + blockcount, blocklen);
164 data += LCD_FBWIDTH;
165 }
166 while (data < data_end);
167 }
168 if (bitcount)
169 {
170 int bx, y;
171 unsigned char *addr = rb->lcd_framebuffer + blocklen;
172 #if LCD_DEPTH == 2
173 unsigned fill = (0x55 * (~rb->lcd_get_background() & 3)) << bitcount;
174 #endif
175
176 for (y = 0; y < LCD_HEIGHT; y++)
177 {
178 unsigned char *row_addr = addr;
179 unsigned data = fill;
180
181 for (bx = 0; bx < blocklen; bx++)
182 {
183 --row_addr;
184 data = (data >> 8) | (*row_addr << bitcount);
185 *row_addr = data;
186 }
187 addr += LCD_FBWIDTH;
188 }
189 }
190 oldmode = rb->lcd_get_drawmode();
191 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
192 rb->lcd_fillrect(LCD_WIDTH - count, 0, count, LCD_HEIGHT);
193 rb->lcd_set_drawmode(oldmode);
194 }
195
196 /* Scroll right */
197 void xlcd_scroll_right(int count)
198 {
199 int bitcount=0, oldmode;
200 int blockcount=0, blocklen;
201
202 if ((unsigned) count >= LCD_WIDTH)
203 {
204 rb->lcd_clear_display();
205 return;
206 }
207
208 #if LCD_DEPTH == 2
209 blockcount = count >> 2;
210 blocklen = LCD_FBWIDTH - blockcount;
211 bitcount = 2 * (count & 3);
212 #endif
213
214 if (blockcount)
215 {
216 unsigned char *data = rb->lcd_framebuffer;
217 unsigned char *data_end = data + LCD_FBWIDTH*LCD_HEIGHT;
218
219 do
220 {
221 rb->memmove(data + blockcount, data, blocklen);
222 data += LCD_FBWIDTH;
223 }
224 while (data < data_end);
225 }
226 if (bitcount)
227 {
228 int bx, y;
229 unsigned char *addr = rb->lcd_framebuffer + blockcount;
230 #if LCD_DEPTH == 2
231 unsigned fill = 0x55 * (~rb->lcd_get_background() & 3);
232 #endif
233
234 for (y = 0; y < LCD_HEIGHT; y++)
235 {
236 unsigned char *row_addr = addr;
237 unsigned data = fill;
238
239 for (bx = 0; bx < blocklen; bx++)
240 {
241 data = (data << 8) | *row_addr;
242 *row_addr = data >> bitcount;
243 row_addr++;
244 }
245 addr += LCD_FBWIDTH;
246 }
247 }
248 oldmode = rb->lcd_get_drawmode();
249 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
250 rb->lcd_fillrect(0, 0, count, LCD_HEIGHT);
251 rb->lcd_set_drawmode(oldmode);
252 }
253
254 #else /* LCD_PIXELFORMAT vertical packed or >= 8bit / pixel */
255
256 /* Scroll left */
257 void xlcd_scroll_left(int count)
258 {
259 fb_data *data, *data_end;
260 int length, oldmode;
261
262 if ((unsigned)count >= LCD_WIDTH)
263 {
264 rb->lcd_clear_display();
265 return;
266 }
267
268 data = rb->lcd_framebuffer;
269 data_end = data + LCD_WIDTH*LCD_FBHEIGHT;
270 length = LCD_WIDTH - count;
271
272 do
273 {
274 rb->memmove(data, data + count, length * sizeof(fb_data));
275 data += LCD_WIDTH;
276 }
277 while (data < data_end);
278
279 oldmode = rb->lcd_get_drawmode();
280 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
281 rb->lcd_fillrect(length, 0, count, LCD_HEIGHT);
282 rb->lcd_set_drawmode(oldmode);
283 }
284
285 /* Scroll right */
286 void xlcd_scroll_right(int count)
287 {
288 fb_data *data, *data_end;
289 int length, oldmode;
290
291 if ((unsigned)count >= LCD_WIDTH)
292 {
293 rb->lcd_clear_display();
294 return;
295 }
296
297 data = rb->lcd_framebuffer;
298 data_end = data + LCD_WIDTH*LCD_FBHEIGHT;
299 length = LCD_WIDTH - count;
300
301 do
302 {
303 rb->memmove(data + count, data, length * sizeof(fb_data));
304 data += LCD_WIDTH;
305 }
306 while (data < data_end);
307
308 oldmode = rb->lcd_get_drawmode();
309 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
310 rb->lcd_fillrect(0, 0, count, LCD_HEIGHT);
311 rb->lcd_set_drawmode(oldmode);
312 }
313
314 #endif /* LCD_PIXELFORMAT, LCD_DEPTH */
315
316 #if (LCD_PIXELFORMAT == HORIZONTAL_PACKING) || (LCD_DEPTH >= 8)
317
318 /* Scroll up */
319 void xlcd_scroll_up(int count)
320 {
321 int length, oldmode;
322
323 if ((unsigned)count >= LCD_HEIGHT)
324 {
325 rb->lcd_clear_display();
326 return;
327 }
328
329 length = LCD_HEIGHT - count;
330
331 rb->memmove(rb->lcd_framebuffer,
332 rb->lcd_framebuffer + count * LCD_FBWIDTH,
333 length * LCD_FBWIDTH * sizeof(fb_data));
334
335 oldmode = rb->lcd_get_drawmode();
336 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
337 rb->lcd_fillrect(0, length, LCD_WIDTH, count);
338 rb->lcd_set_drawmode(oldmode);
339 }
340
341 /* Scroll down */
342 void xlcd_scroll_down(int count)
343 {
344 int length, oldmode;
345
346 if ((unsigned)count >= LCD_HEIGHT)
347 {
348 rb->lcd_clear_display();
349 return;
350 }
351
352 length = LCD_HEIGHT - count;
353
354 rb->memmove(rb->lcd_framebuffer + count * LCD_FBWIDTH,
355 rb->lcd_framebuffer,
356 length * LCD_FBWIDTH * sizeof(fb_data));
357
358 oldmode = rb->lcd_get_drawmode();
359 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
360 rb->lcd_fillrect(0, 0, LCD_WIDTH, count);
361 rb->lcd_set_drawmode(oldmode);
362 }
363
364 #else /* LCD_PIXELFORMAT == VERTICAL_PACKING,
365 LCD_PIXELFORMAT == VERTICAL_INTERLEAVED */
366
367 /* Scroll up */
368 void xlcd_scroll_up(int count)
369 {
370 int bitcount, oldmode;
371 int blockcount, blocklen;
372
373 if ((unsigned) count >= LCD_HEIGHT)
374 {
375 rb->lcd_clear_display();
376 return;
377 }
378
379 #if (LCD_DEPTH == 1) \
380 || (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
381 blockcount = count >> 3;
382 bitcount = count & 7;
383 #elif (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_PACKING)
384 blockcount = count >> 2;
385 bitcount = 2 * (count & 3);
386 #endif
387 blocklen = LCD_FBHEIGHT - blockcount;
388
389 if (blockcount)
390 {
391 rb->memmove(rb->lcd_framebuffer,
392 rb->lcd_framebuffer + blockcount * LCD_FBWIDTH,
393 blocklen * LCD_FBWIDTH * sizeof(fb_data));
394 }
395 if (bitcount)
396 {
397 #if LCD_PIXELFORMAT == VERTICAL_PACKING
398
399 #if (CONFIG_CPU == SH7034) && (LCD_DEPTH == 1)
400 asm (
401 "mov #0,r4 \n" /* x = 0 */
402 "mova .su_shifttbl,r0 \n" /* calculate jump destination for */
403 "mov.b @(r0,%[cnt]),%[cnt] \n" /* shift amount from table */
404 "bra .su_cloop \n" /* skip table */
405 "add r0,%[cnt] \n"
406
407 ".align 2 \n"
408 ".su_shifttbl: \n" /* shift jump offset table */
409 ".byte .su_shift0 - .su_shifttbl \n"
410 ".byte .su_shift1 - .su_shifttbl \n"
411 ".byte .su_shift2 - .su_shifttbl \n"
412 ".byte .su_shift3 - .su_shifttbl \n"
413 ".byte .su_shift4 - .su_shifttbl \n"
414 ".byte .su_shift5 - .su_shifttbl \n"
415 ".byte .su_shift6 - .su_shifttbl \n"
416 ".byte .su_shift7 - .su_shifttbl \n"
417
418 ".su_cloop: \n" /* repeat for every column */
419 "mov %[addr],r2 \n" /* get start address */
420 "mov #0,r3 \n" /* current_row = 0 */
421 "mov #0,r1 \n" /* fill with zero */
422
423 ".su_iloop: \n" /* repeat for all rows */
424 "sub %[wide],r2 \n" /* address -= width */
425 "mov.b @r2,r0 \n" /* get data byte */
426 "shll8 r1 \n" /* old data to 2nd byte */
427 "extu.b r0,r0 \n" /* extend unsigned */
428 "or r1,r0 \n" /* combine old data */
429 "jmp @%[cnt] \n" /* jump into shift "path" */
430 "extu.b r0,r1 \n" /* store data for next round */
431
432 ".su_shift6: \n" /* shift right by 0..7 bits */
433 "shll2 r0 \n"
434 "bra .su_shift0 \n"
435 "shlr8 r0 \n"
436 ".su_shift4: \n"
437 "shlr2 r0 \n"
438 ".su_shift2: \n"
439 "bra .su_shift0 \n"
440 "shlr2 r0 \n"
441 ".su_shift7: \n"
442 "shlr2 r0 \n"
443 ".su_shift5: \n"
444 "shlr2 r0 \n"
445 ".su_shift3: \n"
446 "shlr2 r0 \n"
447 ".su_shift1: \n"
448 "shlr r0 \n"
449 ".su_shift0: \n"
450
451 "mov.b r0,@r2 \n" /* store data */
452 "add #1,r3 \n" /* current_row++ */
453 "cmp/hi r3,%[rows] \n" /* current_row < bheight - shift ? */
454 "bt .su_iloop \n"
455
456 "add #1,%[addr] \n" /* start_address++ */
457 "add #1,r4 \n" /* x++ */
458 "cmp/hi r4,%[wide] \n" /* x < width ? */
459 "bt .su_cloop \n"
460 : /* outputs */
461 : /* inputs */
462 [addr]"r"(rb->lcd_framebuffer + blocklen * LCD_FBWIDTH),
463 [wide]"r"(LCD_FBWIDTH),
464 [rows]"r"(blocklen),
465 [cnt] "r"(bitcount)
466 : /* clobbers */
467 "r0", "r1", "r2", "r3", "r4"
468 );
469 #elif defined(CPU_COLDFIRE) && (LCD_DEPTH == 2)
470 asm (
471 "move.l %[wide],%%d3\n" /* columns = width */
472
473 ".su_cloop: \n" /* repeat for every column */
474 "move.l %[addr],%%a1\n" /* get start address */
475 "move.l %[rows],%%d2\n" /* rows = row_count */
476 "move.l %[bkg],%%d1 \n" /* fill with background */
477
478 ".su_iloop: \n" /* repeat for all rows */
479 "sub.l %[wide],%%a1\n" /* address -= width */
480
481 "lsl.l #8,%%d1 \n" /* old data to 2nd byte */
482 "move.b (%%a1),%%d1 \n" /* combine with new data byte */
483 "move.l %%d1,%%d0 \n" /* keep data for next round */
484 "lsr.l %[cnt],%%d0 \n" /* shift right */
485 "move.b %%d0,(%%a1) \n" /* store data */
486
487 "subq.l #1,%%d2 \n" /* rows-- */
488 "bne.b .su_iloop \n"
489
490 "addq.l #1,%[addr] \n" /* start_address++ */
491 "subq.l #1,%%d3 \n" /* columns-- */
492 "bne.b .su_cloop \n"
493 : /* outputs */
494 : /* inputs */
495 [wide]"r"(LCD_FBWIDTH),
496 [rows]"r"(blocklen),
497 [addr]"a"(rb->lcd_framebuffer + blocklen * LCD_FBWIDTH),
498 [cnt] "d"(bitcount),
499 [bkg] "d"(0x55 * (~rb->lcd_get_background() & 3))
500 : /* clobbers */
501 "a1", "d0", "d1", "d2", "d3"
502 );
503 #else /* C version */
504 int x, by;
505 unsigned char *addr = rb->lcd_framebuffer + blocklen * LCD_FBWIDTH;
506 #if LCD_DEPTH == 2
507 unsigned fill = 0x55 * (~rb->lcd_get_background() & 3);
508 #else
509 const unsigned fill = 0;
510 #endif
511
512 for (x = 0; x < LCD_WIDTH; x++)
513 {
514 unsigned char *col_addr = addr++;
515 unsigned data = fill;
516
517 for (by = 0; by < blocklen; by++)
518 {
519 col_addr -= LCD_FBWIDTH;
520 data = (data << 8) | *col_addr;
521 *col_addr = data >> bitcount;
522 }
523 }
524 #endif /* CPU, LCD_DEPTH */
525
526 #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED
527
528 #if LCD_DEPTH == 2
529 int x, by;
530 fb_data *addr = rb->lcd_framebuffer + blocklen * LCD_FBWIDTH;
531 unsigned fill, mask;
532
533 fill = patterns[rb->lcd_get_background() & 3] << 8;
534 mask = (0xFFu >> bitcount) << bitcount;
535 mask |= mask << 8;
536
537 for (x = 0; x < LCD_WIDTH; x++)
538 {
539 fb_data *col_addr = addr++;
540 unsigned olddata = fill;
541 unsigned data;
542
543 for (by = 0; by < blocklen; by++)
544 {
545 col_addr -= LCD_FBWIDTH;
546 data = *col_addr;
547 *col_addr = (olddata ^ ((data ^ olddata) & mask)) >> bitcount;
548 olddata = data << 8;
549 }
550 }
551 #endif /* LCD_DEPTH == 2 */
552
553 #endif /* LCD_PIXELFORMAT */
554 }
555 oldmode = rb->lcd_get_drawmode();
556 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
557 rb->lcd_fillrect(0, LCD_HEIGHT - count, LCD_WIDTH, count);
558 rb->lcd_set_drawmode(oldmode);
559 }
560
561 /* Scroll up */
562 void xlcd_scroll_down(int count)
563 {
564 int bitcount, oldmode;
565 int blockcount, blocklen;
566
567 if ((unsigned) count >= LCD_HEIGHT)
568 {
569 rb->lcd_clear_display();
570 return;
571 }
572
573 #if (LCD_DEPTH == 1) \
574 || (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
575 blockcount = count >> 3;
576 bitcount = count & 7;
577 #elif (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_PACKING)
578 blockcount = count >> 2;
579 bitcount = 2 * (count & 3);
580 #endif
581 blocklen = LCD_FBHEIGHT - blockcount;
582
583 if (blockcount)
584 {
585 rb->memmove(rb->lcd_framebuffer + blockcount * LCD_FBWIDTH,
586 rb->lcd_framebuffer,
587 blocklen * LCD_FBWIDTH * sizeof(fb_data));
588 }
589 if (bitcount)
590 {
591 #if LCD_PIXELFORMAT == VERTICAL_PACKING
592
593 #if (CONFIG_CPU == SH7034) && (LCD_DEPTH == 1)
594 asm (
595 "mov #0,r4 \n" /* x = 0 */
596 "mova .sd_shifttbl,r0 \n" /* calculate jump destination for */
597 "mov.b @(r0,%[cnt]),%[cnt] \n" /* shift amount from table */
598 "bra .sd_cloop \n" /* skip table */
599 "add r0,%[cnt] \n"
600
601 ".align 2 \n"
602 ".sd_shifttbl: \n" /* shift jump offset table */
603 ".byte .sd_shift0 - .sd_shifttbl \n"
604 ".byte .sd_shift1 - .sd_shifttbl \n"
605 ".byte .sd_shift2 - .sd_shifttbl \n"
606 ".byte .sd_shift3 - .sd_shifttbl \n"
607 ".byte .sd_shift4 - .sd_shifttbl \n"
608 ".byte .sd_shift5 - .sd_shifttbl \n"
609 ".byte .sd_shift6 - .sd_shifttbl \n"
610 ".byte .sd_shift7 - .sd_shifttbl \n"
611
612 ".sd_cloop: \n" /* repeat for every column */
613 "mov %[addr],r2 \n" /* get start address */
614 "mov #0,r3 \n" /* current_row = 0 */
615 "mov #0,r1 \n" /* fill with zero */
616
617 ".sd_iloop: \n" /* repeat for all rows */
618 "shlr8 r1 \n" /* shift right to get residue */
619 "mov.b @r2,r0 \n" /* get data byte */
620 "jmp @%[cnt] \n" /* jump into shift "path" */
621 "extu.b r0,r0 \n" /* extend unsigned */
622
623 ".sd_shift6: \n" /* shift left by 0..7 bits */
624 "shll8 r0 \n"
625 "bra .sd_shift0 \n"
626 "shlr2 r0 \n"
627 ".sd_shift4: \n"
628 "shll2 r0 \n"
629 ".sd_shift2: \n"
630 "bra .sd_shift0 \n"
631 "shll2 r0 \n"
632 ".sd_shift7: \n"
633 "shll2 r0 \n"
634 ".sd_shift5: \n"
635 "shll2 r0 \n"
636 ".sd_shift3: \n"
637 "shll2 r0 \n"
638 ".sd_shift1: \n"
639 "shll r0 \n"
640 ".sd_shift0: \n"
641
642 "or r0,r1 \n" /* combine with last residue */
643 "mov.b r1,@r2 \n" /* store data */
644 "add %[wide],r2 \n" /* address += width */
645 "add #1,r3 \n" /* current_row++ */
646 "cmp/hi r3,%[rows] \n" /* current_row < bheight - shift ? */
647 "bt .sd_iloop \n"
648
649 "add #1,%[addr] \n" /* start_address++ */
650 "add #1,r4 \n" /* x++ */
651 "cmp/hi r4,%[wide] \n" /* x < width ? */
652 "bt .sd_cloop \n"
653 : /* outputs */
654 : /* inputs */
655 [addr]"r"(rb->lcd_framebuffer + blockcount * LCD_FBWIDTH),
656 [wide]"r"(LCD_WIDTH),
657 [rows]"r"(blocklen),
658 [cnt] "r"(bitcount)
659 : /* clobbers */
660 "r0", "r1", "r2", "r3", "r4"
661 );
662 #elif defined(CPU_COLDFIRE) && (LCD_DEPTH == 2)
663 asm (
664 "move.l %[wide],%%d3\n" /* columns = width */
665
666 ".sd_cloop: \n" /* repeat for every column */
667 "move.l %[addr],%%a1\n" /* get start address */
668 "move.l %[rows],%%d2\n" /* rows = row_count */
669 "move.l %[bkg],%%d1 \n" /* fill with background */
670
671 ".sd_iloop: \n" /* repeat for all rows */
672 "lsr.l #8,%%d1 \n" /* shift right to get residue */
673 "clr.l %%d0 \n"
674 "move.b (%%a1),%%d0 \n" /* get data byte */
675 "lsl.l %[cnt],%%d0 \n"
676 "or.l %%d0,%%d1 \n" /* combine with last residue */
677 "move.b %%d1,(%%a1) \n" /* store data */
678
679 "add.l %[wide],%%a1\n" /* address += width */
680 "subq.l #1,%%d2 \n" /* rows-- */
681 "bne.b .sd_iloop \n"
682
683 "lea.l (1,%[addr]),%[addr] \n" /* start_address++ */
684 "subq.l #1,%%d3 \n" /* columns-- */
685 "bne.b .sd_cloop \n"
686 : /* outputs */
687 : /* inputs */
688 [wide]"r"(LCD_WIDTH),
689 [rows]"r"(blocklen),
690 [addr]"a"(rb->lcd_framebuffer + blockcount * LCD_FBWIDTH),
691 [cnt] "d"(bitcount),
692 [bkg] "d"((0x55 * (~rb->lcd_get_background() & 3)) << bitcount)
693 : /* clobbers */
694 "a1", "d0", "d1", "d2", "d3"
695 );
696 #else /* C version */
697 int x, by;
698 unsigned char *addr = rb->lcd_framebuffer + blockcount * LCD_FBWIDTH;
699 #if LCD_DEPTH == 2
700 unsigned fill = (0x55 * (~rb->lcd_get_background() & 3)) << bitcount;
701 #else
702 const unsigned fill = 0;
703 #endif
704
705 for (x = 0; x < LCD_WIDTH; x++)
706 {
707 unsigned char *col_addr = addr++;
708 unsigned data = fill;
709
710 for (by = 0; by < blocklen; by++)
711 {
712 data = (data >> 8) | (*col_addr << bitcount);
713 *col_addr = data;
714 col_addr += LCD_FBWIDTH;
715 }
716 }
717 #endif /* CPU, LCD_DEPTH */
718
719 #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED
720
721 #if LCD_DEPTH == 2
722 int x, by;
723 fb_data *addr = rb->lcd_framebuffer + blockcount * LCD_FBWIDTH;
724 unsigned fill, mask;
725
726 fill = patterns[rb->lcd_get_background() & 3] >> (8 - bitcount);
727 mask = (0xFFu >> bitcount) << bitcount;
728 mask |= mask << 8;
729
730 for (x = 0; x < LCD_WIDTH; x++)
731 {
732 fb_data *col_addr = addr++;
733 unsigned olddata = fill;
734 unsigned data;
735
736 for (by = 0; by < blocklen; by++)
737 {
738 data = *col_addr << bitcount;
739 *col_addr = olddata ^ ((data ^ olddata) & mask);
740 olddata = data >> 8;
741 col_addr += LCD_FBWIDTH;
742 }
743 }
744 #endif /* LCD_DEPTH == 2 */
745
746 #endif /* LCD_PIXELFORMAT */
747 }
748 oldmode = rb->lcd_get_drawmode();
749 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
750 rb->lcd_fillrect(0, 0, LCD_WIDTH, count);
751 rb->lcd_set_drawmode(oldmode);
752 }
753
754 #endif /* LCD_PIXELFORMAT, LCD_DEPTH */
755 #endif /* defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE */
thomasjfox's rockbox modifications (mameo port)