firmware/drivers/lcd-16bit.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Dave Chapman
  11  *
  12  * Rockbox driver for 16-bit colour LCDs
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "config.h"
  24
  25 #include "cpu.h"
  26 #include "lcd.h"
  27 #include "kernel.h"
  28 #include "thread.h"
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include "memory.h"
  32 #include "file.h"
  33 #include "debug.h"
  34 #include "system.h"
  35 #include "font.h"
  36 #include "rbunicode.h"
  37 #include "bidi.h"
  38 #include "scroll_engine.h"
  39
  40 enum fill_opt {
  41     OPT_NONE = 0,
  42     OPT_SET,
  43     OPT_COPY
  44 };
  45
  46 /*** globals ***/
  47 fb_data lcd_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH]
  48     IRAM_LCDFRAMEBUFFER CACHEALIGN_AT_LEAST_ATTR(16);
  49
  50
  51 static fb_data* lcd_backdrop = NULL;
  52 static long lcd_backdrop_offset IDATA_ATTR = 0;
  53
  54 static struct viewport default_vp =
  55 {
  56     .x        = 0,
  57     .y        = 0,
  58     .width    = LCD_WIDTH,
  59     .height   = LCD_HEIGHT,
  60     .font     = FONT_SYSFIXED,
  61     .drawmode = DRMODE_SOLID,
  62     .fg_pattern = LCD_DEFAULT_FG,
  63     .bg_pattern = LCD_DEFAULT_BG,
  64     .lss_pattern = LCD_DEFAULT_BG,
  65     .lse_pattern = LCD_DEFAULT_BG,
  66     .lst_pattern = LCD_DEFAULT_BG,
  67 };
  68
  69 /* The Gigabeat target build requires access to the current fg_pattern
  70    in lcd-meg-fx.c */
  71 #if (!defined(TOSHIBA_GIGABEAT_F)&& !defined(TOSHIBA_GIGABEAT_S)) || defined(SIMULATOR)
  72 static struct viewport* current_vp IDATA_ATTR = &default_vp;
  73 #else
  74 struct viewport* current_vp IDATA_ATTR = &default_vp;
  75 #endif
  76
  77
  78 /*** Helpers - consolidate optional code ***/
  79 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  80 static void (*lcd_activation_hook)(void) = NULL;
  81
  82 void lcd_activation_set_hook(void (*func)(void))
  83 {
  84     lcd_activation_hook = func;
  85 }
  86
  87 /* To be called by target driver after enabling display and refreshing it */
  88 void lcd_activation_call_hook(void)
  89 {
  90     void (*func)(void) = lcd_activation_hook;
  91
  92     if (func != NULL)
  93         func();
  94 }
  95
  96 #endif
  97
  98 /* LCD init */
  99 void lcd_init(void)
 100 {
 101     lcd_clear_display();
 102
 103     /* Call device specific init */
 104     lcd_init_device();
 105     scroll_init();
 106 }
 107 /*** Viewports ***/
 108
 109 void lcd_set_viewport(struct viewport* vp)
 110 {
 111     if (vp == NULL)
 112         current_vp = &default_vp;
 113     else
 114         current_vp = vp;
 115 }
 116
 117 void lcd_update_viewport(void)
 118 {
 119     lcd_update_rect(current_vp->x, current_vp->y,
 120                     current_vp->width, current_vp->height);
 121 }
 122
 123 void lcd_update_viewport_rect(int x, int y, int width, int height)
 124 {
 125     lcd_update_rect(current_vp->x + x, current_vp->y + y, width, height);
 126 }
 127
 128 /*** parameter handling ***/
 129
 130 void lcd_set_drawmode(int mode)
 131 {
 132     current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
 133 }
 134
 135 int lcd_get_drawmode(void)
 136 {
 137     return current_vp->drawmode;
 138 }
 139
 140 void lcd_set_foreground(unsigned color)
 141 {
 142     current_vp->fg_pattern = color;
 143 }
 144
 145 unsigned lcd_get_foreground(void)
 146 {
 147     return current_vp->fg_pattern;
 148 }
 149
 150 void lcd_set_background(unsigned color)
 151 {
 152     current_vp->bg_pattern = color;
 153 }
 154
 155 unsigned lcd_get_background(void)
 156 {
 157     return current_vp->bg_pattern;
 158 }
 159
 160 void lcd_set_selector_start(unsigned color)
 161 {
 162     current_vp->lss_pattern = color;
 163 }
 164
 165 void lcd_set_selector_end(unsigned color)
 166 {
 167     current_vp->lse_pattern = color;
 168 }
 169
 170 void lcd_set_selector_text(unsigned color)
 171 {
 172     current_vp->lst_pattern = color;
 173 }
 174
 175 void lcd_set_drawinfo(int mode, unsigned fg_color, unsigned bg_color)
 176 {
 177     lcd_set_drawmode(mode);
 178     current_vp->fg_pattern = fg_color;
 179     current_vp->bg_pattern = bg_color;
 180 }
 181
 182 int lcd_getwidth(void)
 183 {
 184     return current_vp->width;
 185 }
 186
 187 int lcd_getheight(void)
 188 {
 189     return current_vp->height;
 190 }
 191
 192 void lcd_setfont(int newfont)
 193 {
 194     current_vp->font = newfont;
 195 }
 196
 197 int lcd_getfont(void)
 198 {
 199     return current_vp->font;
 200 }
 201
 202 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
 203 {
 204     return font_getstringsize(str, w, h, current_vp->font);
 205 }
 206
 207 /*** low-level drawing functions ***/
 208
 209 #define LCDADDR(x, y) (&lcd_framebuffer[(y)][(x)])
 210
 211 static void ICODE_ATTR setpixel(fb_data *address)
 212 {
 213     *address = current_vp->fg_pattern;
 214 }
 215
 216 static void ICODE_ATTR clearpixel(fb_data *address)
 217 {
 218     *address = current_vp->bg_pattern;
 219 }
 220
 221 static void ICODE_ATTR clearimgpixel(fb_data *address)
 222 {
 223     *address = *(fb_data *)((long)address + lcd_backdrop_offset);
 224 }
 225
 226 static void ICODE_ATTR flippixel(fb_data *address)
 227 {
 228     *address = ~(*address);
 229 }
 230
 231 static void ICODE_ATTR nopixel(fb_data *address)
 232 {
 233     (void)address;
 234 }
 235
 236 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_bgcolor[8] = {
 237     flippixel, nopixel, setpixel, setpixel,
 238     nopixel, clearpixel, nopixel, clearpixel
 239 };
 240
 241 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_backdrop[8] = {
 242     flippixel, nopixel, setpixel, setpixel,
 243     nopixel, clearimgpixel, nopixel, clearimgpixel
 244 };
 245
 246 lcd_fastpixelfunc_type* const * lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
 247
 248 void lcd_set_backdrop(fb_data* backdrop)
 249 {
 250     lcd_backdrop = backdrop;
 251     if (backdrop)
 252     {
 253         lcd_backdrop_offset = (long)backdrop - (long)&lcd_framebuffer[0][0];
 254         lcd_fastpixelfuncs = lcd_fastpixelfuncs_backdrop;
 255     }
 256     else
 257     {
 258         lcd_backdrop_offset = 0;
 259         lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
 260     }
 261 }
 262
 263 fb_data* lcd_get_backdrop(void)
 264 {
 265     return lcd_backdrop;
 266 }
 267
 268 /*** drawing functions ***/
 269
 270 /* Clear the current viewport */
 271 void lcd_clear_viewport(void)
 272 {
 273     fb_data *dst, *dst_end;
 274
 275     dst = LCDADDR(current_vp->x, current_vp->y);
 276     dst_end = dst + current_vp->height * LCD_WIDTH;
 277
 278     if (current_vp->drawmode & DRMODE_INVERSEVID)
 279     {
 280         do
 281         {
 282             memset16(dst, current_vp->fg_pattern, current_vp->width);
 283             dst += LCD_WIDTH;
 284         }
 285         while (dst < dst_end);
 286     }
 287     else
 288     {
 289         if (!lcd_backdrop)
 290         {
 291             do
 292             {
 293                 memset16(dst, current_vp->bg_pattern, current_vp->width);
 294                 dst += LCD_WIDTH;
 295             }
 296             while (dst < dst_end);
 297         }
 298         else
 299         {
 300             do
 301             {
 302                 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 303                        current_vp->width * sizeof(fb_data));
 304                 dst += LCD_WIDTH;
 305             }
 306             while (dst < dst_end);
 307         }
 308     }
 309
 310     if (current_vp == &default_vp)
 311     {
 312         lcd_scroll_info.lines = 0;
 313     }
 314     else
 315     {
 316         lcd_scroll_stop(current_vp);
 317     }
 318 }
 319
 320 /* Clear the whole display */
 321 void lcd_clear_display(void)
 322 {
 323     struct viewport* old_vp = current_vp;
 324
 325     current_vp = &default_vp;
 326
 327     lcd_clear_viewport();
 328
 329     current_vp = old_vp;
 330 }
 331
 332 /* Set a single pixel */
 333 void lcd_drawpixel(int x, int y)
 334 {
 335     if (((unsigned)x < (unsigned)current_vp->width) &&
 336         ((unsigned)y < (unsigned)current_vp->height))
 337         lcd_fastpixelfuncs[current_vp->drawmode](LCDADDR(current_vp->x+x, current_vp->y+y));
 338 }
 339
 340 /* Draw a line */
 341 void lcd_drawline(int x1, int y1, int x2, int y2)
 342 {
 343     int numpixels;
 344     int i;
 345     int deltax, deltay;
 346     int d, dinc1, dinc2;
 347     int x, xinc1, xinc2;
 348     int y, yinc1, yinc2;
 349     lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
 350
 351     deltay = abs(y2 - y1);
 352     if (deltay == 0)
 353     {
 354         DEBUGF("lcd_drawline() called for horizontal line - optimisation.\n");
 355         lcd_hline(x1, x2, y1);
 356         return;
 357     }
 358     deltax = abs(x2 - x1);
 359     if (deltax == 0)
 360     {
 361         DEBUGF("lcd_drawline() called for vertical line - optimisation.\n");
 362         lcd_vline(x1, y1, y2);
 363         return;
 364     }
 365     xinc2 = 1;
 366     yinc2 = 1;
 367
 368     if (deltax >= deltay)
 369     {
 370         numpixels = deltax;
 371         d = 2 * deltay - deltax;
 372         dinc1 = deltay * 2;
 373         dinc2 = (deltay - deltax) * 2;
 374         xinc1 = 1;
 375         yinc1 = 0;
 376     }
 377     else
 378     {
 379         numpixels = deltay;
 380         d = 2 * deltax - deltay;
 381         dinc1 = deltax * 2;
 382         dinc2 = (deltax - deltay) * 2;
 383         xinc1 = 0;
 384         yinc1 = 1;
 385     }
 386     numpixels++; /* include endpoints */
 387
 388     if (x1 > x2)
 389     {
 390         xinc1 = -xinc1;
 391         xinc2 = -xinc2;
 392     }
 393
 394     if (y1 > y2)
 395     {
 396         yinc1 = -yinc1;
 397         yinc2 = -yinc2;
 398     }
 399
 400     x = x1;
 401     y = y1;
 402
 403     for (i = 0; i < numpixels; i++)
 404     {
 405         if (((unsigned)x < (unsigned)current_vp->width) && ((unsigned)y < (unsigned)current_vp->height))
 406             pfunc(LCDADDR(x + current_vp->x, y + current_vp->y));
 407
 408         if (d < 0)
 409         {
 410             d += dinc1;
 411             x += xinc1;
 412             y += yinc1;
 413         }
 414         else
 415         {
 416             d += dinc2;
 417             x += xinc2;
 418             y += yinc2;
 419         }
 420     }
 421 }
 422
 423 /* Draw a horizontal line (optimised) */
 424 void lcd_hline(int x1, int x2, int y)
 425 {
 426     int x, width;
 427     unsigned bits = 0;
 428     enum fill_opt fillopt = OPT_NONE;
 429     fb_data *dst, *dst_end;
 430
 431     /* direction flip */
 432     if (x2 < x1)
 433     {
 434         x = x1;
 435         x1 = x2;
 436         x2 = x;
 437     }
 438
 439     /* nothing to draw? */
 440     if (((unsigned)y >= (unsigned)current_vp->height) ||
 441         (x1 >= current_vp->width) ||
 442         (x2 < 0))
 443         return;
 444
 445     /* drawmode and optimisation */
 446     if (current_vp->drawmode & DRMODE_INVERSEVID)
 447     {
 448         if (current_vp->drawmode & DRMODE_BG)
 449         {
 450             if (!lcd_backdrop)
 451             {
 452                 fillopt = OPT_SET;
 453                 bits = current_vp->bg_pattern;
 454             }
 455             else
 456                 fillopt = OPT_COPY;
 457         }
 458     }
 459     else
 460     {
 461         if (current_vp->drawmode & DRMODE_FG)
 462         {
 463             fillopt = OPT_SET;
 464             bits = current_vp->fg_pattern;
 465         }
 466     }
 467     if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
 468         return;
 469
 470     /* clipping */
 471     if (x1 < 0)
 472         x1 = 0;
 473     if (x2 >= current_vp->width)
 474         x2 = current_vp->width-1;
 475
 476     width = x2 - x1 + 1;
 477
 478     /* Adjust x1 and y to viewport */
 479     x1 += current_vp->x;
 480     y += current_vp->y;
 481
 482     dst = LCDADDR(x1, y);
 483
 484     switch (fillopt)
 485     {
 486       case OPT_SET:
 487         memset16(dst, bits, width);
 488         break;
 489
 490       case OPT_COPY:
 491         memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 492                width * sizeof(fb_data));
 493         break;
 494
 495       case OPT_NONE:  /* DRMODE_COMPLEMENT */
 496         dst_end = dst + width;
 497         do
 498             *dst = ~(*dst);
 499         while (++dst < dst_end);
 500         break;
 501     }
 502 }
 503
 504 /* Draw a vertical line (optimised) */
 505 void lcd_vline(int x, int y1, int y2)
 506 {
 507     int y;
 508     fb_data *dst, *dst_end;
 509     lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
 510
 511     /* direction flip */
 512     if (y2 < y1)
 513     {
 514         y = y1;
 515         y1 = y2;
 516         y2 = y;
 517     }
 518
 519     /* nothing to draw? */
 520     if (((unsigned)x >= (unsigned)current_vp->width) ||
 521         (y1 >= current_vp->height) ||
 522         (y2 < 0))
 523         return;
 524
 525     /* clipping */
 526     if (y1 < 0)
 527         y1 = 0;
 528     if (y2 >= current_vp->height)
 529         y2 = current_vp->height-1;
 530
 531     dst = LCDADDR(x + current_vp->x, y1 + current_vp->y);
 532     dst_end = dst + (y2 - y1) * LCD_WIDTH;
 533
 534     do
 535     {
 536         pfunc(dst);
 537         dst += LCD_WIDTH;
 538     }
 539     while (dst <= dst_end);
 540 }
 541
 542 /* Draw a rectangular box */
 543 void lcd_drawrect(int x, int y, int width, int height)
 544 {
 545     if ((width <= 0) || (height <= 0))
 546         return;
 547
 548     int x2 = x + width - 1;
 549     int y2 = y + height - 1;
 550
 551     lcd_vline(x, y, y2);
 552     lcd_vline(x2, y, y2);
 553     lcd_hline(x, x2, y);
 554     lcd_hline(x, x2, y2);
 555 }
 556
 557 /* Fill a rectangular area */
 558 void lcd_fillrect(int x, int y, int width, int height)
 559 {
 560     unsigned bits = 0;
 561     enum fill_opt fillopt = OPT_NONE;
 562     fb_data *dst, *dst_end;
 563
 564     /* nothing to draw? */
 565     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 566         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 567         return;
 568
 569     /* drawmode and optimisation */
 570     if (current_vp->drawmode & DRMODE_INVERSEVID)
 571     {
 572         if (current_vp->drawmode & DRMODE_BG)
 573         {
 574             if (!lcd_backdrop)
 575             {
 576                 fillopt = OPT_SET;
 577                 bits = current_vp->bg_pattern;
 578             }
 579             else
 580                 fillopt = OPT_COPY;
 581         }
 582     }
 583     else
 584     {
 585         if (current_vp->drawmode & DRMODE_FG)
 586         {
 587             fillopt = OPT_SET;
 588             bits = current_vp->fg_pattern;
 589         }
 590     }
 591     if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
 592         return;
 593
 594     /* clipping */
 595     if (x < 0)
 596     {
 597         width += x;
 598         x = 0;
 599     }
 600     if (y < 0)
 601     {
 602         height += y;
 603         y = 0;
 604     }
 605     if (x + width > current_vp->width)
 606         width = current_vp->width - x;
 607     if (y + height > current_vp->height)
 608         height = current_vp->height - y;
 609
 610     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 611     dst_end = dst + height * LCD_WIDTH;
 612
 613     do
 614     {
 615         fb_data *dst_row, *row_end;
 616
 617         switch (fillopt)
 618         {
 619           case OPT_SET:
 620             memset16(dst, bits, width);
 621             break;
 622
 623           case OPT_COPY:
 624             memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 625                    width * sizeof(fb_data));
 626             break;
 627
 628           case OPT_NONE:  /* DRMODE_COMPLEMENT */
 629             dst_row = dst;
 630             row_end = dst_row + width;
 631             do
 632                 *dst_row = ~(*dst_row);
 633             while (++dst_row < row_end);
 634             break;
 635         }
 636         dst += LCD_WIDTH;
 637     }
 638     while (dst < dst_end);
 639 }
 640
 641 /* About Rockbox' internal monochrome bitmap format:
 642  *
 643  * A bitmap contains one bit for every pixel that defines if that pixel is
 644  * black (1) or white (0). Bits within a byte are arranged vertically, LSB
 645  * at top.
 646  * The bytes are stored in row-major order, with byte 0 being top left,
 647  * byte 1 2nd from left etc. The first row of bytes defines pixel rows
 648  * 0..7, the second row defines pixel row 8..15 etc.
 649  *
 650  * This is the mono bitmap format used on all other targets so far; the
 651  * pixel packing doesn't really matter on a 8bit+ target. */
 652
 653 /* Draw a partial monochrome bitmap */
 654
 655 void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x,
 656                                      int src_y, int stride, int x, int y,
 657                                      int width, int height)
 658 {
 659     const unsigned char *src_end;
 660     fb_data *dst, *dst_end;
 661     unsigned dmask = 0x100; /* bit 8 == sentinel */
 662     int drmode = current_vp->drawmode;
 663
 664     /* nothing to draw? */
 665     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 666         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 667         return;
 668
 669     /* clipping */
 670     if (x < 0)
 671     {
 672         width += x;
 673         src_x -= x;
 674         x = 0;
 675     }
 676     if (y < 0)
 677     {
 678         height += y;
 679         src_y -= y;
 680         y = 0;
 681     }
 682     if (x + width > current_vp->width)
 683         width = current_vp->width - x;
 684     if (y + height > current_vp->height)
 685         height = current_vp->height - y;
 686
 687     src += stride * (src_y >> 3) + src_x; /* move starting point */
 688     src_y  &= 7;
 689     src_end = src + width;
 690     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 691     dst_end = dst + height * LCD_WIDTH;
 692
 693     if (drmode & DRMODE_INVERSEVID)
 694     {
 695         dmask = 0x1ff;          /* bit 8 == sentinel */
 696         drmode &= DRMODE_SOLID; /* mask out inversevid */
 697     }
 698
 699     do
 700     {
 701         const unsigned char *src_col = src++;
 702         unsigned data = (*src_col ^ dmask) >> src_y;
 703         fb_data *dst_col = dst++;
 704         int fg, bg;
 705         long bo;
 706
 707 #define UPDATE_SRC  do {                  \
 708             data >>= 1;                   \
 709             if (data == 0x001) {          \
 710                 src_col += stride;        \
 711                 data = *src_col ^ dmask;  \
 712             }                             \
 713         } while (0)
 714
 715         switch (drmode)
 716         {
 717           case DRMODE_COMPLEMENT:
 718             do
 719             {
 720                 if (data & 0x01)
 721                     *dst_col = ~(*dst_col);
 722
 723                 dst_col += LCD_WIDTH;
 724                 UPDATE_SRC;
 725             }
 726             while (dst_col < dst_end);
 727             break;
 728
 729           case DRMODE_BG:
 730             if (lcd_backdrop)
 731             {
 732                 bo = lcd_backdrop_offset;
 733                 do
 734                 {
 735                     if (!(data & 0x01))
 736                         *dst_col = *(fb_data *)((long)dst_col + bo);
 737
 738                     dst_col += LCD_WIDTH;
 739                     UPDATE_SRC;
 740                 }
 741                 while (dst_col < dst_end);
 742             }
 743             else
 744             {
 745                 bg = current_vp->bg_pattern;
 746                 do
 747                 {
 748                     if (!(data & 0x01))
 749                         *dst_col = bg;
 750
 751                     dst_col += LCD_WIDTH;
 752                     UPDATE_SRC;
 753                 }
 754                 while (dst_col < dst_end);
 755             }
 756             break;
 757
 758           case DRMODE_FG:
 759             fg = current_vp->fg_pattern;
 760             do
 761             {
 762                 if (data & 0x01)
 763                     *dst_col = fg;
 764
 765                 dst_col += LCD_WIDTH;
 766                 UPDATE_SRC;
 767             }
 768             while (dst_col < dst_end);
 769             break;
 770
 771           case DRMODE_SOLID:
 772             fg = current_vp->fg_pattern;
 773             if (lcd_backdrop)
 774             {
 775                 bo = lcd_backdrop_offset;
 776                 do
 777                 {
 778                     *dst_col = (data & 0x01) ? fg
 779                                : *(fb_data *)((long)dst_col + bo);
 780                     dst_col += LCD_WIDTH;
 781                     UPDATE_SRC;
 782                 }
 783                 while (dst_col < dst_end);
 784             }
 785             else
 786             {
 787                 bg = current_vp->bg_pattern;
 788                 do
 789                 {
 790                     *dst_col = (data & 0x01) ? fg : bg;
 791                     dst_col += LCD_WIDTH;
 792                     UPDATE_SRC;
 793                 }
 794                 while (dst_col < dst_end);
 795             }
 796             break;
 797         }
 798     }
 799     while (src < src_end);
 800 }
 801 /* Draw a full monochrome bitmap */
 802 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
 803 {
 804     lcd_mono_bitmap_part(src, 0, 0, width, x, y, width, height);
 805 }
 806
 807 /* draw alpha bitmap for anti-alias font */
 808 #define ALPHA_COLOR_FONT_DEPTH 2
 809 #define ALPHA_COLOR_LOOKUP_SHIFT (1 << ALPHA_COLOR_FONT_DEPTH)
 810 #define ALPHA_COLOR_LOOKUP_SIZE ((1 << ALPHA_COLOR_LOOKUP_SHIFT) - 1)
 811 #define ALPHA_COLOR_PIXEL_PER_BYTE (8 >> ALPHA_COLOR_FONT_DEPTH)
 812 #define ALPHA_COLOR_PIXEL_PER_WORD (32 >> ALPHA_COLOR_FONT_DEPTH)
 813 #ifdef CPU_ARM
 814 #define BLEND_INIT do {} while (0)
 815 #define BLEND_START(acc, color, alpha) \
 816     asm volatile("mul %0, %1, %2" : "=&r" (acc) : "r" (color), "r" (alpha))
 817 #define BLEND_CONT(acc, color, alpha) \
 818     asm volatile("mla %0, %1, %2, %0" : "+&r" (acc) : "r" (color), "r" (alpha))
 819 #define BLEND_OUT(acc) do {} while (0)
 820 #elif defined(CPU_COLDFIRE)
 821 #define ALPHA_BITMAP_READ_WORDS
 822 #define BLEND_INIT coldfire_set_macsr(EMAC_UNSIGNED)
 823 #define BLEND_START(acc, color, alpha) \
 824     asm volatile("mac.l %0, %1, %%acc0" :: "%d" (color), "d" (alpha))
 825 #define BLEND_CONT BLEND_START
 826 #define BLEND_OUT(acc) asm volatile("movclr.l %%acc0, %0" : "=d" (acc))
 827 #else
 828 #define BLEND_INIT do {} while (0)
 829 #define BLEND_START(acc, color, alpha) ((acc) = (color) * (alpha))
 830 #define BLEND_CONT(acc, color, alpha) ((acc) += (color) * (alpha))
 831 #define BLEND_OUT(acc) do {} while (0)
 832 #endif
 833
 834 /* Blend the given two colors */
 835 static inline unsigned blend_two_colors(unsigned c1, unsigned c2, unsigned a)
 836 {
 837     a += a >> (ALPHA_COLOR_LOOKUP_SHIFT - 1);
 838 #if (LCD_PIXELFORMAT == RGB565SWAPPED)
 839     c1 = swap16(c1);
 840     c2 = swap16(c2);
 841 #endif
 842     unsigned c1l = (c1 | (c1 << 16)) & 0x07e0f81f;
 843     unsigned c2l = (c2 | (c2 << 16)) & 0x07e0f81f;
 844     unsigned p;
 845     BLEND_START(p, c1l, a);
 846     BLEND_CONT(p, c2l, ALPHA_COLOR_LOOKUP_SIZE + 1 - a);
 847     BLEND_OUT(p);
 848     p = (p >> ALPHA_COLOR_LOOKUP_SHIFT) & 0x07e0f81f;
 849     p |= (p >> 16);
 850 #if (LCD_PIXELFORMAT == RGB565SWAPPED)
 851     return swap16(p);
 852 #else
 853     return p;
 854 #endif
 855 }
 856
 857 /* Blend the given color with the value from the alpha_color_lookup table */
 858 static inline unsigned blend_color(unsigned c, unsigned a)
 859 {
 860     return blend_two_colors(c, current_vp->fg_pattern, a);
 861 }
 862
 863 void ICODE_ATTR lcd_alpha_bitmap_part(const unsigned char *src, int src_x,
 864                                       int src_y, int stride, int x, int y,
 865                                       int width, int height)
 866 {
 867     fb_data *dst, *backdrop;
 868     unsigned dmask = 0x00000000;
 869     int drmode = current_vp->drawmode;
 870     /* nothing to draw? */
 871     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 872          (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 873         return;
 874
 875     /* initialize blending */
 876     BLEND_INIT;
 877
 878     /* clipping */
 879     if (x < 0)
 880     {
 881         width += x;
 882         src_x -= x;
 883         x = 0;
 884     }
 885     if (y < 0)
 886     {
 887         height += y;
 888         src_y -= y;
 889         y = 0;
 890     }
 891     if (x + width > current_vp->width)
 892         width = current_vp->width - x;
 893     if (y + height > current_vp->height)
 894         height = current_vp->height - y;
 895
 896     if (drmode & DRMODE_INVERSEVID)
 897     {
 898         dmask = 0xffffffff;
 899         drmode &= DRMODE_SOLID; /* mask out inversevid */
 900     }
 901     if (drmode == DRMODE_BG)
 902     {
 903         dmask = ~dmask;
 904     }
 905
 906     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 907
 908     int col, row = height;
 909     unsigned data, pixels;
 910     unsigned skip_end = (stride - width);
 911     unsigned skip_start = src_y * stride + src_x;
 912
 913 #ifdef ALPHA_BITMAP_READ_WORDS
 914     uint32_t *src_w = (uint32_t *)((uintptr_t)src & ~3);
 915     skip_start += ALPHA_COLOR_PIXEL_PER_BYTE * ((uintptr_t)src & 3);
 916     src_w += skip_start / ALPHA_COLOR_PIXEL_PER_WORD;
 917     data = letoh32(*src_w++) ^ dmask;
 918 #else
 919     src += skip_start / ALPHA_COLOR_PIXEL_PER_BYTE;
 920     data = *src ^ dmask;
 921 #endif
 922     pixels = skip_start % ALPHA_COLOR_PIXEL_PER_WORD;
 923     data >>= pixels * ALPHA_COLOR_LOOKUP_SHIFT;
 924 #ifdef ALPHA_BITMAP_READ_WORDS
 925     pixels = 8 - pixels;
 926 #endif
 927
 928     do
 929     {
 930         col = width;
 931 #ifdef ALPHA_BITMAP_READ_WORDS
 932 #define UPDATE_SRC_ALPHA    do { \
 933             if (--pixels) \
 934                 data >>= ALPHA_COLOR_LOOKUP_SHIFT; \
 935             else \
 936             { \
 937                 data = letoh32(*src_w++) ^ dmask; \
 938                 pixels = ALPHA_COLOR_PIXEL_PER_WORD; \
 939             } \
 940         } while (0)
 941 #elif ALPHA_COLOR_PIXEL_PER_BYTE == 2
 942 #define UPDATE_SRC_ALPHA    do { \
 943             if (pixels ^= 1) \
 944                 data >>= ALPHA_COLOR_LOOKUP_SHIFT; \
 945             else \
 946                 data = *(++src) ^ dmask; \
 947         } while (0)
 948 #else
 949 #define UPDATE_SRC_ALPHA    do { \
 950             if (pixels = (++pixels % ALPHA_COLOR_PIXEL_PER_BYTE)) \
 951                 data >>= ALPHA_COLOR_LOOKUP_SHIFT; \
 952             else \
 953                 data = *(++src) ^ dmask; \
 954         } while (0)
 955 #endif
 956         /* we don't want to have this in our inner
 957          * loop and the codesize increase is minimal */
 958         switch (drmode)
 959         {
 960             case DRMODE_COMPLEMENT:
 961                 do
 962                 {
 963                     *dst=blend_two_colors(*dst, ~(*dst),
 964                                 data & ALPHA_COLOR_LOOKUP_SIZE );
 965                     dst++;
 966                     UPDATE_SRC_ALPHA;
 967                 }
 968                 while (--col);
 969                 break;
 970             case DRMODE_BG:
 971                 if(lcd_backdrop)
 972                 {
 973                     backdrop = (fb_data *)((long)dst+lcd_backdrop_offset);
 974                     do
 975                     {
 976                         *dst=blend_two_colors(*dst, *(backdrop++),
 977                                     data & ALPHA_COLOR_LOOKUP_SIZE );
 978                         dst++;
 979                         UPDATE_SRC_ALPHA;
 980                     }
 981                     while (--col);
 982                 }
 983                 else
 984                 {
 985                     do
 986                     {
 987                         *dst=blend_two_colors(*dst, current_vp->bg_pattern,
 988                                     data & ALPHA_COLOR_LOOKUP_SIZE );
 989                         dst++;
 990                         UPDATE_SRC_ALPHA;
 991                     }
 992                     while (--col);
 993                 }
 994                 break;
 995             case DRMODE_FG:
 996                 do
 997                 {
 998                     *dst=blend_color(*dst, data & ALPHA_COLOR_LOOKUP_SIZE );
 999                     dst++;
1000                     UPDATE_SRC_ALPHA;
1001                 }
1002                 while (--col);
1003                 break;
1004             case DRMODE_SOLID:
1005                 if(lcd_backdrop)
1006                 {
1007                     backdrop = (fb_data *)((long)dst+lcd_backdrop_offset);
1008                     do
1009                     {
1010                         *(dst++)=blend_color(*(backdrop++),
1011                                         data & ALPHA_COLOR_LOOKUP_SIZE );
1012                         UPDATE_SRC_ALPHA;
1013                     }
1014                     while (--col);
1015                 }
1016                 else
1017                 {
1018                     do
1019                     {
1020                         *(dst++)=blend_color(current_vp->bg_pattern,
1021                                         data & ALPHA_COLOR_LOOKUP_SIZE );
1022                         UPDATE_SRC_ALPHA;
1023                     }
1024                     while (--col);
1025                 }
1026                 break;
1027         }
1028 #ifdef ALPHA_BITMAP_READ_WORDS
1029         if (skip_end < pixels)
1030         {
1031             pixels -= skip_end;
1032             data >>= skip_end * ALPHA_COLOR_LOOKUP_SHIFT;
1033         } else {
1034             pixels = skip_end - pixels;
1035             src_w += pixels / ALPHA_COLOR_PIXEL_PER_WORD;
1036             pixels %= ALPHA_COLOR_PIXEL_PER_WORD;
1037             data = letoh32(*src_w++) ^ dmask;
1038             data >>= pixels * ALPHA_COLOR_LOOKUP_SHIFT;
1039             pixels = 8 - pixels;
1040         }
1041 #else
1042         if (skip_end)
1043         {
1044             pixels += skip_end;
1045             if (pixels >= ALPHA_COLOR_PIXEL_PER_BYTE)
1046             {
1047                 src += pixels / ALPHA_COLOR_PIXEL_PER_BYTE;
1048                 pixels %= ALPHA_COLOR_PIXEL_PER_BYTE;
1049                 data = *src ^ dmask;
1050                 data >>= pixels * ALPHA_COLOR_LOOKUP_SHIFT;
1051             } else
1052                 data >>= skip_end * ALPHA_COLOR_LOOKUP_SHIFT;
1053         }
1054 #endif
1055         dst += LCD_WIDTH - width;
1056     } while (--row);
1057 }
1058
1059 /* Draw a partial native bitmap */
1060 void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
1061                                 int stride, int x, int y, int width,
1062                                 int height)
1063 {
1064     fb_data *dst, *dst_end;
1065
1066     /* nothing to draw? */
1067     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
1068         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
1069         return;
1070
1071     /* clipping */
1072     if (x < 0)
1073     {
1074         width += x;
1075         src_x -= x;
1076         x = 0;
1077     }
1078     if (y < 0)
1079     {
1080         height += y;
1081         src_y -= y;
1082         y = 0;
1083     }
1084     if (x + width > current_vp->width)
1085         width = current_vp->width - x;
1086     if (y + height > current_vp->height)
1087         height = current_vp->height - y;
1088
1089     src += stride * src_y + src_x; /* move starting point */
1090     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
1091     dst_end = dst + height * LCD_WIDTH;
1092
1093     do
1094     {
1095         memcpy(dst, src, width * sizeof(fb_data));
1096         src += stride;
1097         dst += LCD_WIDTH;
1098     }
1099     while (dst < dst_end);
1100 }
1101
1102 /* Draw a full native bitmap */
1103 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
1104 {
1105     lcd_bitmap_part(src, 0, 0, width, x, y, width, height);
1106 }
1107
1108 #if !defined(TOSHIBA_GIGABEAT_F) && !defined(TOSHIBA_GIGABEAT_S) \
1109     || defined(SIMULATOR)
1110 /* Draw a partial native bitmap */
1111 void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x,
1112                                             int src_y, int stride, int x,
1113                                             int y, int width, int height)
1114 {
1115     fb_data *dst, *dst_end;
1116
1117     /* nothing to draw? */
1118     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
1119         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
1120         return;
1121
1122     /* clipping */
1123     if (x < 0)
1124     {
1125         width += x;
1126         src_x -= x;
1127         x = 0;
1128     }
1129     if (y < 0)
1130     {
1131         height += y;
1132         src_y -= y;
1133         y = 0;
1134     }
1135     if (x + width > current_vp->width)
1136         width = current_vp->width - x;
1137     if (y + height > current_vp->height)
1138         height = current_vp->height - y;
1139
1140     src += stride * src_y + src_x; /* move starting point */
1141     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
1142     dst_end = dst + height * LCD_WIDTH;
1143
1144     do
1145     {
1146         int i;
1147         for(i = 0;i < width;i++)
1148         {
1149             if (src[i] == REPLACEWITHFG_COLOR)
1150                 dst[i] = current_vp->fg_pattern;
1151             else if(src[i] != TRANSPARENT_COLOR)
1152                 dst[i] = src[i];
1153         }
1154         src += stride;
1155         dst += LCD_WIDTH;
1156     }
1157     while (dst < dst_end);
1158 }
1159 #endif /* !defined(TOSHIBA_GIGABEAT_F) || defined(SIMULATOR) */
1160
1161 /* Draw a full native bitmap with a transparent color */
1162 void lcd_bitmap_transparent(const fb_data *src, int x, int y,
1163                             int width, int height)
1164 {
1165     lcd_bitmap_transparent_part(src, 0, 0, width, x, y, width, height);
1166 }
1167
1168 #include "lcd-bitmap-common.c"