firmware/target/arm/as3525/sansa-fuze/lcd-fuze.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 by Dave Chapman
  11  *
  12  * LCD driver for the Sansa Fuze - controller unknown
  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 "file.h"
  28 #include "debug.h"
  29 #include "system.h"
  30 #include "clock-target.h"
  31
  32 /* The controller is unknown, but some registers appear to be the same as the
  33    HD66789R */
  34
  35 #define R_ENTRY_MODE            0x03
  36 #define R_RAM_ADDR_SET          0x21
  37 #define R_WRITE_DATA_2_GRAM     0x22
  38
  39 #define R_ENTRY_MODE_HORZ 0x7030
  40 #define R_ENTRY_MODE_VERT 0x7038
  41
  42 static unsigned lcd_yuv_options = 0;
  43 static bool display_on = false; /* is the display turned on? */
  44 static bool display_flipped = false;
  45 static int xoffset = 20; /* needed for flip */
  46 /* we need to write a red pixel for correct button reads
  47  * (see lcd_button_support()), but that must not happen while the lcd is updating
  48  * so block lcd_button_support the during updates */
  49 static bool lcd_busy = false;
  50
  51 static void as3525_dbop_init(void)
  52 {
  53     CGU_DBOP = (1<<3) | AS3525_DBOP_DIV;
  54
  55     DBOP_TIMPOL_01 = 0xe167e167;
  56     DBOP_TIMPOL_23 = 0xe167006e;
  57     DBOP_CTRL = 0x41008;
  58
  59     GPIOB_AFSEL = 0xfc;
  60     GPIOC_AFSEL = 0xff;
  61
  62     DBOP_TIMPOL_23 = 0x6000e;
  63     DBOP_CTRL = 0x51008;
  64     DBOP_TIMPOL_01 = 0x6e167;
  65     DBOP_TIMPOL_23 = 0xa167e06f;
  66
  67     /* TODO: The OF calls some other functions here, but maybe not important */
  68 }
  69
  70 static void lcd_write_cmd(int cmd)
  71 {
  72     int x;
  73
  74     /* Write register */
  75     DBOP_CTRL &= ~(1<<14);
  76
  77     DBOP_TIMPOL_23 = 0xa167006e;
  78
  79     DBOP_DOUT = cmd;
  80
  81     /* Wait for fifo to empty */
  82     while ((DBOP_STAT & (1<<10)) == 0);
  83
  84     /* This loop is unique to the Fuze */
  85     x = 0;
  86     do {
  87         asm volatile ("nop\n");
  88     } while (x++ < 4);
  89
  90
  91     DBOP_TIMPOL_23 = 0xa167e06f;
  92 }
  93
  94 void lcd_write_data(const fb_data* p_bytes, int count)
  95 {
  96     while (count--)
  97     {
  98         DBOP_DOUT = *p_bytes++;
  99
 100         /* Wait for fifo to empty */
 101         while ((DBOP_STAT & (1<<10)) == 0);
 102     }
 103 }
 104
 105 static void lcd_write_reg(int reg, int value)
 106 {
 107     unsigned short data = value;
 108
 109     lcd_write_cmd(reg);
 110     lcd_write_data(&data, 1);
 111 }
 112
 113 /* turn the display upside down (call lcd_update() afterwards) */
 114 void lcd_set_flip(bool yesno)
 115 {
 116     display_flipped = yesno;
 117     xoffset = yesno ? 0 : 20;   /* TODO: Implement flipped mode */
 118
 119     /* TODO */
 120 }
 121
 122
 123 static void _display_on(void)
 124 {
 125     /* Initialise in the same way as the original firmare */
 126
 127     lcd_write_reg(0x07, 0);
 128     lcd_write_reg(0x13, 0);
 129
 130     lcd_write_reg(0x11, 0x3704);
 131     lcd_write_reg(0x14, 0x1a1b);
 132     lcd_write_reg(0x10, 0x3860);
 133     lcd_write_reg(0x13, 0x40);
 134
 135     lcd_write_reg(0x13, 0x60);
 136
 137     lcd_write_reg(0x13, 0x70);
 138     lcd_write_reg(0x01, 277);
 139     lcd_write_reg(0x02, (7<<8));
 140     lcd_write_reg(R_ENTRY_MODE, R_ENTRY_MODE_HORZ);
 141     lcd_write_reg(0x08, 0x01);
 142     lcd_write_reg(0x0b, (1<<10));
 143     lcd_write_reg(0x0c, 0);
 144
 145     lcd_write_reg(0x30, 0x40);
 146     lcd_write_reg(0x31, 0x0687);
 147     lcd_write_reg(0x32, 0x0306);
 148     lcd_write_reg(0x33, 0x104);
 149     lcd_write_reg(0x34, 0x0585);
 150     lcd_write_reg(0x35, 255+66);
 151     lcd_write_reg(0x36, 0x0687+128);
 152     lcd_write_reg(0x37, 259);
 153     lcd_write_reg(0x38, 0);
 154     lcd_write_reg(0x39, 0);
 155
 156     lcd_write_reg(0x42, (LCD_WIDTH - 1));
 157     lcd_write_reg(0x43, 0);
 158     lcd_write_reg(0x44, (LCD_WIDTH - 1));
 159     lcd_write_reg(0x45, 0);
 160     lcd_write_reg(0x46, (((LCD_WIDTH - 1) + xoffset) << 8) | xoffset);
 161     lcd_write_reg(0x47, (LCD_HEIGHT - 1));
 162     lcd_write_reg(0x48, 0x0);
 163
 164     lcd_write_reg(0x07, 0x11);
 165     lcd_write_reg(0x07, 0x17);
 166
 167     display_on = true;  /* must be done before calling lcd_update() */
 168     lcd_update();
 169 }
 170
 171 #if defined(HAVE_LCD_ENABLE)
 172 void lcd_enable(bool on)
 173 {
 174     if (display_on == on)
 175         return; /* nothing to do */
 176     if(on)
 177     {
 178         lcd_write_reg(0, 1);
 179         lcd_write_reg(0x10, 0);
 180         lcd_write_reg(0x11, 0x3704);
 181         lcd_write_reg(0x14, 0x1a1b);
 182         lcd_write_reg(0x10, 0x3860);
 183         lcd_write_reg(0x13, 0x40);
 184         lcd_write_reg(0x13, 0x60);
 185         lcd_write_reg(0x13, 112);
 186         lcd_write_reg(0x07, 0x11);
 187         lcd_write_reg(0x07, 0x17);
 188         display_on = true;
 189         /* a bit of delay before returning to
 190          * avoid irritating flash on backlight on */
 191         lcd_update();      /* Resync display */
 192         lcd_activation_call_hook();
 193         sleep(0);
 194
 195     }
 196     else
 197     {
 198         lcd_write_reg(0x07, 0x22);
 199         lcd_write_reg(0x07, 0);
 200         lcd_write_reg(0x10, 1);
 201         display_on = false;
 202     }
 203 }
 204 #endif
 205
 206 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 207 bool lcd_active(void)
 208 {
 209     return display_on;
 210 }
 211 #endif
 212
 213 /*** update functions ***/
 214
 215 /* Set horizontal window addresses */
 216 static void lcd_window_x(int xmin, int xmax)
 217 {
 218     xmin += xoffset;
 219     xmax += xoffset;
 220     lcd_write_reg(0x46, (xmax << 8) | xmin);
 221     lcd_write_reg(0x20, xmin);
 222 }
 223
 224 /* Set vertical window addresses */
 225 static void lcd_window_y(int ymin, int ymax)
 226 {
 227     lcd_write_reg(0x47, ymax);
 228     lcd_write_reg(0x48, ymin);
 229     lcd_write_reg(0x21, ymin);
 230 }
 231
 232 void lcd_yuv_set_options(unsigned options)
 233 {
 234     lcd_yuv_options = options;
 235 }
 236
 237 /* Line write helper function for lcd_yuv_blit. Write two lines of yuv420. */
 238 extern void lcd_write_yuv420_lines(unsigned char const * const src[3],
 239                                    int width,
 240                                    int stride);
 241 extern void lcd_write_yuv420_lines_odither(unsigned char const * const src[3],
 242                                            int width,
 243                                            int stride,
 244                                            int x_screen, /* To align dither pattern */
 245                                            int y_screen);
 246 /* Performance function to blit a YUV bitmap directly to the LCD */
 247 void lcd_blit_yuv(unsigned char * const src[3],
 248                   int src_x, int src_y, int stride,
 249                   int x, int y, int width, int height)
 250 {
 251     unsigned char const * yuv_src[3];
 252     off_t z;
 253
 254     lcd_busy = true;
 255
 256     lcd_write_reg(R_ENTRY_MODE, R_ENTRY_MODE_VERT);
 257
 258     /* Sorry, but width and height must be >= 2 or else */
 259     width &= ~1;
 260     height >>= 1;
 261
 262     z = stride*src_y;
 263     yuv_src[0] = src[0] + z + src_x;
 264     yuv_src[1] = src[1] + (z >> 2) + (src_x >> 1);
 265     yuv_src[2] = src[2] + (yuv_src[1] - src[1]);
 266
 267     lcd_window_x(x, x + width - 1);
 268
 269     if (lcd_yuv_options & LCD_YUV_DITHER)
 270     {
 271         do
 272         {
 273             lcd_window_y(y, y + 1);
 274             /* Start write to GRAM */
 275             lcd_write_cmd(R_WRITE_DATA_2_GRAM);
 276
 277             lcd_write_yuv420_lines_odither(yuv_src, width, stride, x, y);
 278             yuv_src[0] += stride << 1; /* Skip down two luma lines */
 279             yuv_src[1] += stride >> 1; /* Skip down one chroma line */
 280             yuv_src[2] += stride >> 1;
 281             y += 2;
 282         }
 283          while (--height > 0);
 284     }
 285     else
 286     {
 287         do
 288         {
 289             lcd_window_y(y, y + 1);
 290             /* Start write to GRAM */
 291             lcd_write_cmd(R_WRITE_DATA_2_GRAM);
 292
 293             lcd_write_yuv420_lines(yuv_src, width, stride);
 294             yuv_src[0] += stride << 1; /* Skip down two luma lines */
 295             yuv_src[1] += stride >> 1; /* Skip down one chroma line */
 296             yuv_src[2] += stride >> 1;
 297             y += 2;
 298         }
 299          while (--height > 0);
 300     }
 301
 302     lcd_busy = false;
 303 }
 304
 305 void lcd_init_device()
 306 {
 307     as3525_dbop_init();
 308
 309     GPIOA_DIR |= (1<<5|1<<4|1<<3);
 310     GPIOA_PIN(5) = 0;
 311     GPIOA_PIN(3) = (1<<3);
 312     GPIOA_PIN(4) = 0;
 313     GPIOA_PIN(5) = (1<<5);
 314
 315     _display_on();
 316 }
 317
 318 /* Update the display.
 319    This must be called after all other LCD functions that change the display. */
 320 void lcd_update(void)
 321 {
 322     if (!display_on)
 323         return;
 324
 325     lcd_write_reg(R_ENTRY_MODE, R_ENTRY_MODE_HORZ);
 326
 327     lcd_busy = true;
 328     lcd_window_x(0, LCD_WIDTH - 1);
 329     lcd_window_y(0, LCD_HEIGHT - 1);
 330
 331     /* Start write to GRAM */
 332     lcd_write_cmd(R_WRITE_DATA_2_GRAM);
 333
 334     /* Write data */
 335     lcd_write_data((unsigned short *)lcd_framebuffer, LCD_WIDTH*LCD_HEIGHT);
 336     lcd_busy = false;
 337 }
 338
 339 /* Update a fraction of the display. */
 340 void lcd_update_rect(int x, int y, int width, int height)
 341 {
 342     int xmax, ymax;
 343     const unsigned short *ptr;
 344
 345     if (!display_on)
 346         return;
 347
 348     xmax = x + width;
 349     if (xmax >= LCD_WIDTH)
 350         xmax = LCD_WIDTH - 1; /* Clip right */
 351     if (x < 0)
 352         x = 0;                /* Clip left */
 353     if (x >= xmax)
 354         return; /* nothing left to do */
 355
 356     width = xmax - x + 1;     /* Fix width */
 357
 358     ymax = y + height;
 359     if (ymax >= LCD_HEIGHT)
 360         ymax = LCD_HEIGHT - 1; /* Clip bottom */
 361     if (y < 0)
 362         y = 0; /* Clip top */
 363     if (y >= ymax)
 364         return; /* nothing left to do */
 365
 366     lcd_write_reg(R_ENTRY_MODE, R_ENTRY_MODE_HORZ);
 367
 368     lcd_busy = true;
 369     lcd_window_x(x, xmax);
 370     lcd_window_y(y, ymax);
 371
 372     /* Start write to GRAM */
 373     lcd_write_cmd(R_WRITE_DATA_2_GRAM);
 374
 375     ptr = (unsigned short *)&lcd_framebuffer[y][x];
 376
 377     do
 378     {
 379         lcd_write_data(ptr, width);
 380         ptr += LCD_WIDTH;
 381     }
 382     while (++y <= ymax);
 383     lcd_busy = false;
 384 }
 385
 386 /* writes one read pixel outside the visible area, needed for correct dbop reads */
 387 bool lcd_button_support(void)
 388 {
 389     fb_data data = 0xf<<12;
 390     if (lcd_busy)
 391         return false;
 392     lcd_write_reg(R_ENTRY_MODE, R_ENTRY_MODE_HORZ);
 393     /* Set start position and window */
 394
 395     lcd_window_x(-1, 0);
 396     lcd_window_y(-1, 0);
 397     lcd_write_cmd(R_WRITE_DATA_2_GRAM);
 398
 399     lcd_write_data(&data, 1);
 400
 401     return true;
 402 }