firm/sample/simple_mp3_player/bootload/sg12232c.c

   1 #include "sg12232c.h"
   2 #include "defines.h"
   3
   4 static const uint8 FONT_X = 5;
   5 static const uint8 FONT_Y = 7;
   6 static const uint16 FONT_MIN_CODE = 0x20;
   7 static const uint16 FONT_MAX_CODE = 0x7F;
   8
   9 #define swap(a,b) {int c=a;a=b;b=c;}
  10 #define abs(n) (((int)(n) < 0) ? ((int)(n) * (-1)) : (n))
  11
  12 #define H8_3069F_P4DDR  ((volatile uint8 *)0xFEE003)
  13 #define H8_3069F_P4DR   ((volatile uint8 *)0xFFFFD3)
  14 #define H8_3069F_CSCR   ((volatile uint8 *)0xFEE01F)
  15
  16 #define LCD_ADDR_LEFT   ((volatile uint8 *)0x800000)
  17 #define LCD_ADDR_RIGHT  ((volatile uint8 *)0xA00000)
  18 #define LCD_AOFS_CMD    (0)
  19 #define LCD_AOFS_DAT    (1 << 3)
  20
  21 #define BIT_LCD_RES     (1 << 7)
  22 #define BIT_SDC_CS      (1 << 0)
  23 #define BIT_VSCCS       (1 << 2)
  24 #define BIT_VSDCS       (1 << 3)
  25 #define BIT_VSRST       (1 << 5)
  26
  27 #define LCD1_CMD(VAL) \
  28   do { \
  29     *(LCD_ADDR_LEFT + LCD_AOFS_CMD) = (VAL); \
  30   } while (0)
  31
  32 #define LCD1_DAT_WRITE(VAL) \
  33   do { \
  34     *(LCD_ADDR_LEFT + LCD_AOFS_DAT) = (VAL); \
  35   } while (0)
  36
  37 #define LCD1_DAT_READ() (*(LCD_ADDR_LEFT + LCD_AOFS_DAT))
  38
  39 #define LCD2_CMD(VAL) \
  40   do { \
  41     *(LCD_ADDR_RIGHT + LCD_AOFS_CMD) = (VAL); \
  42   } while (0)
  43
  44 #define LCD2_DAT_WRITE(VAL) \
  45   do { \
  46     *(LCD_ADDR_RIGHT + LCD_AOFS_DAT) = (VAL); \
  47   } while (0)
  48
  49 #define LCD2_DAT_READ() (*(LCD_ADDR_RIGHT + LCD_AOFS_DAT))
  50
  51 static const uint8 font5x7_data[] = {
  52   0x00, 0x00, 0x00, 0x00, 0x00, // (white space)
  53   0x00, 0x00, 0x5F, 0x00, 0x00, // !
  54   0x00, 0x07, 0x00, 0x07, 0x00, // "
  55   0x14, 0x7F, 0x14, 0x7F, 0x14, // #
  56   0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
  57   0x23, 0x13, 0x08, 0x64, 0x62, // %
  58   0x36, 0x49, 0x55, 0x22, 0x50, // &
  59   0x00, 0x05, 0x03, 0x00, 0x00, // '
  60   0x00, 0x1C, 0x22, 0x41, 0x00, // (
  61   0x00, 0x41, 0x22, 0x1C, 0x00, // )
  62   0x08, 0x2A, 0x1C, 0x2A, 0x08, // *
  63   0x08, 0x08, 0x3E, 0x08, 0x08, // +
  64   0x00, 0x50, 0x30, 0x00, 0x00, // ,
  65   0x08, 0x08, 0x08, 0x08, 0x08, // -
  66   0x00, 0x60, 0x60, 0x00, 0x00, // .
  67   0x20, 0x10, 0x08, 0x04, 0x02, // /
  68   0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
  69   0x00, 0x42, 0x7F, 0x40, 0x00, // 1
  70   0x42, 0x61, 0x51, 0x49, 0x46, // 2
  71   0x21, 0x41, 0x45, 0x4B, 0x31, // 3
  72   0x18, 0x14, 0x12, 0x7F, 0x10, // 4
  73   0x27, 0x45, 0x45, 0x45, 0x39, // 5
  74   0x3C, 0x4A, 0x49, 0x49, 0x30, // 6
  75   0x01, 0x71, 0x09, 0x05, 0x03, // 7
  76   0x36, 0x49, 0x49, 0x49, 0x36, // 8
  77   0x06, 0x49, 0x49, 0x29, 0x1E, // 9
  78   0x00, 0x36, 0x36, 0x00, 0x00, // :
  79   0x00, 0x56, 0x36, 0x00, 0x00, // ;
  80   0x00, 0x08, 0x14, 0x22, 0x41, // <
  81   0x14, 0x14, 0x14, 0x14, 0x14, // =
  82   0x41, 0x22, 0x14, 0x08, 0x00, // >
  83   0x02, 0x01, 0x51, 0x09, 0x06, // ?
  84   0x32, 0x49, 0x79, 0x41, 0x3E, // @
  85   0x7E, 0x11, 0x11, 0x11, 0x7E, // A
  86   0x7F, 0x49, 0x49, 0x49, 0x36, // B
  87   0x3E, 0x41, 0x41, 0x41, 0x22, // C
  88   0x7F, 0x41, 0x41, 0x22, 0x1C, // D
  89   0x7F, 0x49, 0x49, 0x49, 0x41, // E
  90   0x7F, 0x09, 0x09, 0x01, 0x01, // F
  91   0x3E, 0x41, 0x41, 0x51, 0x32, // G
  92   0x7F, 0x08, 0x08, 0x08, 0x7F, // H
  93   0x00, 0x41, 0x7F, 0x41, 0x00, // I
  94   0x20, 0x40, 0x41, 0x3F, 0x01, // J
  95   0x7F, 0x08, 0x14, 0x22, 0x41, // K
  96   0x7F, 0x40, 0x40, 0x40, 0x40, // L
  97   0x7F, 0x02, 0x04, 0x02, 0x7F, // M
  98   0x7F, 0x04, 0x08, 0x10, 0x7F, // N
  99   0x3E, 0x41, 0x41, 0x41, 0x3E, // O
 100   0x7F, 0x09, 0x09, 0x09, 0x06, // P
 101   0x3E, 0x41, 0x51, 0x21, 0x5E, // Q
 102   0x7F, 0x09, 0x19, 0x29, 0x46, // R
 103   0x46, 0x49, 0x49, 0x49, 0x31, // S
 104   0x01, 0x01, 0x7F, 0x01, 0x01, // T
 105   0x3F, 0x40, 0x40, 0x40, 0x3F, // U
 106   0x1F, 0x20, 0x40, 0x20, 0x1F, // V
 107   0x7F, 0x20, 0x18, 0x20, 0x7F, // W
 108   0x63, 0x14, 0x08, 0x14, 0x63, // X
 109   0x03, 0x04, 0x78, 0x04, 0x03, // Y
 110   0x61, 0x51, 0x49, 0x45, 0x43, // Z
 111   0x00, 0x00, 0x7F, 0x41, 0x41, // [
 112   0x02, 0x04, 0x08, 0x10, 0x20, // /
 113   0x41, 0x41, 0x7F, 0x00, 0x00, // ]
 114   0x04, 0x02, 0x01, 0x02, 0x04, // ^
 115   0x40, 0x40, 0x40, 0x40, 0x40, // _
 116   0x00, 0x01, 0x02, 0x04, 0x00, // `
 117   0x20, 0x54, 0x54, 0x54, 0x78, // a
 118   0x7F, 0x48, 0x44, 0x44, 0x38, // b
 119   0x38, 0x44, 0x44, 0x44, 0x20, // c
 120   0x38, 0x44, 0x44, 0x48, 0x7F, // d
 121   0x38, 0x54, 0x54, 0x54, 0x18, // e
 122   0x08, 0x7E, 0x09, 0x01, 0x02, // f
 123   0x08, 0x14, 0x54, 0x54, 0x3C, // g
 124   0x7F, 0x08, 0x04, 0x04, 0x78, // h
 125   0x00, 0x44, 0x7D, 0x40, 0x00, // i
 126   0x20, 0x40, 0x44, 0x3D, 0x00, // j
 127   0x00, 0x7F, 0x10, 0x28, 0x44, // k
 128   0x00, 0x41, 0x7F, 0x40, 0x00, // l
 129   0x7C, 0x04, 0x18, 0x04, 0x78, // m
 130   0x7C, 0x08, 0x04, 0x04, 0x78, // n
 131   0x38, 0x44, 0x44, 0x44, 0x38, // o
 132   0x7C, 0x14, 0x14, 0x14, 0x08, // p
 133   0x08, 0x14, 0x14, 0x18, 0x7C, // q
 134   0x7C, 0x08, 0x04, 0x04, 0x08, // r
 135   0x48, 0x54, 0x54, 0x54, 0x20, // s
 136   0x04, 0x3F, 0x44, 0x40, 0x20, // t
 137   0x3C, 0x40, 0x40, 0x20, 0x7C, // u
 138   0x1C, 0x20, 0x40, 0x20, 0x1C, // v
 139   0x3C, 0x40, 0x30, 0x40, 0x3C, // w
 140   0x44, 0x28, 0x10, 0x28, 0x44, // x
 141   0x0C, 0x50, 0x50, 0x50, 0x3C, // y
 142   0x44, 0x64, 0x54, 0x4C, 0x44, // z
 143   0x00, 0x08, 0x36, 0x41, 0x00, // {
 144   0x00, 0x00, 0x7F, 0x00, 0x00, // |
 145   0x00, 0x41, 0x36, 0x08, 0x00, // }
 146   0x08, 0x08, 0x2A, 0x1C, 0x08, // ->
 147   0x08, 0x1C, 0x2A, 0x08, 0x08  // <-
 148 };
 149
 150 void sg12232c_init(void)
 151 {
 152   *H8_3069F_P4DDR = BIT_LCD_RES | BIT_SDC_CS | BIT_VSCCS | BIT_VSDCS | BIT_VSRST;
 153
 154   /*
 155    * L->H : 68K mode.
 156    */
 157   *H8_3069F_P4DR &= ~BIT_LCD_RES;
 158   asm volatile ("nop");
 159   asm volatile ("nop");
 160   asm volatile ("nop");
 161   asm volatile ("nop");
 162   *H8_3069F_P4DR |= BIT_LCD_RES;
 163
 164   *H8_3069F_CSCR = 0x3F;
 165
 166   LCD1_CMD(0xE2);   // Reset
 167   LCD1_CMD(0xA4);   // Static Drive Off
 168   LCD1_CMD(0xC0);   // Display Start Line
 169   LCD1_CMD(0xAF);   // Display On
 170   LCD1_CMD(0xB8);   // Page Address Setup
 171   LCD1_CMD(0x00);   // Column Address
 172
 173   LCD2_CMD(0xE2);   // Reset
 174   LCD2_CMD(0xA4);   // Static Drive Off
 175   LCD2_CMD(0xC0);   // Display Start Line
 176   LCD2_CMD(0xAF);   // Display On
 177   LCD2_CMD(0xB8);   // Page Address Setup
 178   LCD2_CMD(0x00);   // Column Address
 179 }
 180
 181 void sg12232c_clear(void)
 182 {
 183   int p, c;
 184
 185   for (p = 0; p <= 3; p++) {
 186     LCD1_CMD(0xB8 | (p & 0x03));  // Page Address Setup
 187     LCD1_CMD(0x00 | (0 & 0x7F));  // Column Address
 188     for (c = 0; c < 62; c++) {
 189       LCD1_DAT_WRITE(0);
 190     }
 191
 192     LCD2_CMD(0xB8 | (p & 0x03));  // Page Address Setup
 193     LCD2_CMD(0x00 | (0 & 0x7F));  // Column Address
 194     for (c = 0; c < 62; c++) {
 195       LCD2_DAT_WRITE(0);
 196     }
 197   }
 198 }
 199
 200 void sg12232c_set_pixel(int x, int y, int reverse)
 201 {
 202   volatile uint8 dat;
 203   int p, c;
 204
 205   if (x <= 60) {
 206     p = y / 8;
 207     c = x;
 208     LCD1_CMD(0xB8 | (p & 0x03));  // Page Address Setup
 209     LCD1_CMD(0x00 | (c & 0x7F));  // Column Address
 210     LCD1_CMD(0xE0);
 211     dat = LCD1_DAT_READ();    // Dummy Read
 212     dat = LCD1_DAT_READ();    // Real Read
 213     if (reverse) {
 214       dat |= (1 << (y % 8));
 215     } else {
 216       dat &= ~(1 << (y % 8));
 217     }
 218     LCD1_DAT_WRITE(dat);
 219     LCD1_CMD(0xEE);
 220   } else {
 221     p = y / 8;
 222     c = x - 61;
 223     LCD2_CMD(0xB8 | (p & 0x03));  // Page Address Setup
 224     LCD2_CMD(0x00 | (c & 0x7F));  // Column Address
 225     LCD2_CMD(0xE0);
 226     dat = LCD2_DAT_READ();    // Dummy Read
 227     dat = LCD2_DAT_READ();    // Real Read
 228     if (reverse) {
 229       dat |= (1 << (y % 8));
 230     } else {
 231       dat &= ~(1 << (y % 8));
 232     }
 233     LCD2_DAT_WRITE(dat);
 234     LCD2_CMD(0xEE);
 235   }
 236 }
 237
 238 void sg12232c_draw_line(uint16 x1, uint16 y1, uint16 x2, uint16 y2, uint8 reverse)
 239 {
 240   int x;
 241   /*
 242    * Bresenham's line algorithm
 243    */
 244   uint8 steep = abs(y2 - y1) > abs(x2 - x1);
 245   if (steep) {
 246     swap(x1, y1);
 247     swap(x2, y2);
 248   }
 249   if (x1 > x2) {
 250     swap(x1, x2);
 251     swap(y1, y2);
 252   }
 253   int deltax = x2 - x1;
 254   int deltay = abs(y2 - y1);
 255   int error = deltax / 2;
 256   int ystep;
 257   int y = y1;
 258   if (y1 < y2) {
 259     ystep = 1;
 260   } else {
 261     ystep = -1;
 262   }
 263   for (x = x1; x <= x2; x++) {
 264     if (steep) {
 265       if (reverse) {
 266         sg12232c_set_pixel(y, x, 0);
 267       } else {
 268         sg12232c_set_pixel(y, x, 1);
 269       }
 270     } else {
 271       if (reverse) {
 272         sg12232c_set_pixel(x, y, 0);
 273       } else {
 274         sg12232c_set_pixel(x, y, 1);
 275       }
 276     }
 277     error = error - deltay;
 278     if (error < 0) {
 279       y = y + ystep;
 280       error = error + deltax;
 281     }
 282   }
 283 }
 284
 285 void sg12232c_draw_box(uint16 x1, uint16 y1, uint16 x2, uint16 y2, uint8 reverse)
 286 {
 287   int x, y;
 288   for (x = x1; x <= x2; x++) {
 289     if (reverse) {
 290       sg12232c_set_pixel(x, y1, 0);
 291       sg12232c_set_pixel(x, y2, 0);
 292     } else {
 293       sg12232c_set_pixel(x, y1, 1);
 294       sg12232c_set_pixel(x, y2, 1);
 295     }
 296   }
 297   for (y = y1; y <= y2; y++) {
 298     if (reverse) {
 299       sg12232c_set_pixel(x1, y, 0);
 300       sg12232c_set_pixel(x2, y, 0);
 301     } else {
 302       sg12232c_set_pixel(x1, y, 1);
 303       sg12232c_set_pixel(x2, y, 1);
 304     }
 305   }
 306 }
 307
 308 void sg12232c_fill_box(uint16 x1, uint16 y1, uint16 x2, uint16 y2, uint8 reverse)
 309 {
 310   int x, y;
 311   for (x = x1; x <= x2; x++) {
 312     for (y = y1; y <= y2; y++) {
 313       if (reverse) {
 314         sg12232c_set_pixel(x, y, 0);
 315       } else {
 316         sg12232c_set_pixel(x, y, 1);
 317       }
 318     }
 319   }
 320 }
 321
 322 void sg12232c_draw_string(uint8 x, uint8 y, char *str, uint8 reverse)
 323 {
 324   char *p = str;
 325   int cnt = 0;
 326   while (*p) {
 327     sg12232c_draw_char(x + (FONT_X * cnt), y, *p, reverse);
 328     p++;
 329     cnt++;
 330   }
 331 }
 332
 333 void sg12232c_draw_char(uint8 x, uint8 y, char c, uint8 reverse)
 334 {
 335   int i, j;
 336   if ((FONT_MIN_CODE <= c) &&(c <= FONT_MAX_CODE)) {
 337     int aofs = (c - FONT_MIN_CODE) * FONT_X;
 338     for (i = 0; i < FONT_X; i++) {
 339       uint8 pat = font5x7_data[aofs + i];
 340       for (j = 0; j < FONT_Y; j++) {
 341         if (pat & (1 << j)) {
 342           if (reverse) {
 343             sg12232c_set_pixel(x + i, y + j, 0);
 344           } else {
 345             sg12232c_set_pixel(x + i, y + j, 1);
 346           }
 347         } else {
 348           if (reverse) {
 349             sg12232c_set_pixel(x + i, y + j, 1);
 350           } else {
 351             sg12232c_set_pixel(x + i, y + j, 0);
 352           }
 353         }
 354       }
 355     }
 356   } else {
 357     for (i = 0; i < FONT_X; i++) {
 358       uint8 pat = (i % 2) ? 0x55 : 0xAA;
 359       for (j = 0; j < FONT_Y; j++) {
 360         if (pat & (1 << j)) {
 361           if (reverse) {
 362             sg12232c_set_pixel(x + i, y + j, 0);
 363           } else {
 364             sg12232c_set_pixel(x + i, y + j, 1);
 365           }
 366         } else {
 367           if (reverse) {
 368             sg12232c_set_pixel(x + i, y + j, 1);
 369           } else {
 370             sg12232c_set_pixel(x + i, y + j, 0);
 371           }
 372         }
 373       }
 374     }
 375   }
 376 }
 377
 378 void sg12232c_draw_checkbox(
 379     uint16 x1, uint16 y1, uint16 x2, uint16 y2, uint8 state, uint8 reverse)
 380 {
 381   sg12232c_draw_box(x1, y1, x2, y2, reverse);
 382   if (state) {
 383     sg12232c_draw_line(x1, y1, x2, y2, reverse);
 384     sg12232c_draw_line(x1, y2, x2, y1, reverse);
 385   }
 386 }
 387
 388 void sg12232c_draw_progressbar(
 389     uint16 x1, uint16 y1, uint16 x2, uint16 y2,
 390     int min, int max, int value, uint8 reverse)
 391 {
 392   sg12232c_draw_box(x1, y1, x2, y2, reverse);
 393   if ((value < min) || (max < value)) {
 394     return;
 395   }
 396   int tmp_max = max - min;
 397   int tmp_val = value - min;
 398   int pix = ((x2 - x1) * tmp_val) / tmp_max;
 399   sg12232c_fill_box(x1 + 1, y1 + 1, x1 + pix - 1, y2 - 1, reverse);
 400   if (pix > 0) {
 401       sg12232c_fill_box(x1 + pix, y1 + 1, x2 - 1, y2 - 1, !reverse);
 402   }
 403 }
 404