firmware/target/arm/imx31/gigabeat-s/lcd-gigabeat-s.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 by Will Robertson
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <sys/types.h>
  22 #include "inttypes.h"
  23
  24 #include "config.h"
  25 #include "cpu.h"
  26 #include "string.h"
  27 #include "lcd.h"
  28 #include "kernel.h"
  29 #include "lcd-target.h"
  30 #include "backlight-target.h"
  31
  32 #define MAIN_LCD_IDMAC_CHANNEL 14
  33 #define LCDADDR(x, y) (&lcd_framebuffer[(y)][(x)])
  34
  35 static bool lcd_on = true;
  36 static bool lcd_powered = true;
  37 static unsigned lcd_yuv_options = 0;
  38
  39 /* Copies a rectangle from one framebuffer to another. Can be used in
  40    single transfer mode with width = num pixels, and height = 1 which
  41    allows a full-width rectangle to be copied more efficiently. */
  42 extern void lcd_copy_buffer_rect(fb_data *dst, const fb_data *src,
  43                                  int width, int height);
  44
  45 /* LCD init */
  46 void lcd_init_device(void)
  47 {
  48     /* Move the framebuffer */
  49 #ifdef BOOTLOADER
  50     /* Only do this once to avoid flicker */
  51     memset(FRAME, 0x00, FRAME_SIZE);
  52 #endif
  53     IPU_IMA_ADDR = ((0x1 << 16) | (MAIN_LCD_IDMAC_CHANNEL << 4)) + (1 << 3);
  54     IPU_IMA_DATA = FRAME_PHYS_ADDR;
  55 }
  56
  57 /* Update a fraction of the display. */
  58 void lcd_update_rect(int x, int y, int width, int height)
  59 {
  60     fb_data *dst, *src;
  61
  62     if (!lcd_on)
  63         return;
  64
  65     if (x + width > LCD_WIDTH)
  66         width = LCD_WIDTH - x; /* Clip right */
  67     if (x < 0)
  68         width += x, x = 0; /* Clip left */
  69     if (width <= 0)
  70         return; /* nothing left to do */
  71
  72     if (y + height > LCD_HEIGHT)
  73         height = LCD_HEIGHT - y; /* Clip bottom */
  74     if (y < 0)
  75         height += y, y = 0; /* Clip top */
  76     if (height <= 0)
  77         return; /* nothing left to do */
  78
  79     /* TODO: It may be faster to swap the addresses of lcd_driver_framebuffer
  80      * and lcd_framebuffer */
  81     dst = (fb_data *)FRAME + LCD_WIDTH*y + x;
  82     src = &lcd_framebuffer[y][x];
  83
  84     /* Copy part of the Rockbox framebuffer to the second framebuffer */
  85     if (width < LCD_WIDTH)
  86     {
  87         /* Not full width - do line-by-line */
  88         lcd_copy_buffer_rect(dst, src, width, height);
  89     }
  90     else
  91     {
  92         /* Full width - copy as one line */
  93         lcd_copy_buffer_rect(dst, src, LCD_WIDTH*height, 1);
  94     }
  95 }
  96
  97 void lcd_sleep(void)
  98 {
  99     if (lcd_powered)
 100     {
 101         lcd_enable(false);
 102         lcd_powered = false;
 103         IPU_IDMAC_CHA_EN &= ~(1ul << MAIN_LCD_IDMAC_CHANNEL);
 104         _backlight_lcd_sleep();
 105     }
 106 }
 107
 108 void lcd_enable(bool state)
 109 {
 110     if (state == lcd_on)
 111         return;
 112
 113     if (state)
 114     {
 115         IPU_IDMAC_CHA_EN |= 1ul << MAIN_LCD_IDMAC_CHANNEL;
 116         sleep(HZ/50);
 117         lcd_powered = true;
 118         lcd_on = true;
 119         lcd_update();
 120         send_event(LCD_EVENT_ACTIVATION, NULL);
 121     }
 122     else
 123     {
 124         lcd_on = false;
 125     }
 126 }
 127
 128 bool lcd_active(void)
 129 {
 130     return lcd_on;
 131 }
 132
 133 /* Update the display.
 134    This must be called after all other LCD functions that change the display. */
 135 void lcd_update(void)
 136 {
 137     if (!lcd_on)
 138         return;
 139
 140     lcd_copy_buffer_rect((fb_data *)FRAME, &lcd_framebuffer[0][0],
 141                          LCD_WIDTH*LCD_HEIGHT, 1);
 142 }
 143
 144 void lcd_yuv_set_options(unsigned options)
 145 {
 146     lcd_yuv_options = options;
 147 }
 148
 149 /* Line write helper function for lcd_yuv_blit. Write two lines of yuv420. */
 150 extern void lcd_write_yuv420_lines(fb_data *dst,
 151                                    unsigned char const * const src[3],
 152                                    int width,
 153                                    int stride);
 154 extern void lcd_write_yuv420_lines_odither(fb_data *dst,
 155                                            unsigned char const * const src[3],
 156                                            int width,
 157                                            int stride,
 158                                            int x_screen, /* To align dither pattern */
 159                                            int y_screen);
 160 /* Performance function to blit a YUV bitmap directly to the LCD */
 161 /* For the Gigabeat - show it rotated */
 162 /* So the LCD_WIDTH is now the height */
 163 void lcd_blit_yuv(unsigned char * const src[3],
 164                   int src_x, int src_y, int stride,
 165                   int x, int y, int width, int height)
 166 {
 167     /* Caches for chroma data so it only need be recaculated every other
 168        line */
 169     unsigned char const * yuv_src[3];
 170     off_t z;
 171
 172     if (!lcd_on)
 173         return;
 174
 175     /* Sorry, but width and height must be >= 2 or else */
 176     width &= ~1;
 177     height >>= 1;
 178
 179     y = LCD_WIDTH - 1 - y;
 180     fb_data *dst = (fb_data*)FRAME + x * LCD_WIDTH + y;
 181
 182     z = stride*src_y;
 183     yuv_src[0] = src[0] + z + src_x;
 184     yuv_src[1] = src[1] + (z >> 2) + (src_x >> 1);
 185     yuv_src[2] = src[2] + (yuv_src[1] - src[1]);
 186
 187     if (lcd_yuv_options & LCD_YUV_DITHER)
 188     {
 189         do
 190         {
 191             lcd_write_yuv420_lines_odither(dst, yuv_src, width, stride, y, x);
 192             yuv_src[0] += stride << 1; /* Skip down two luma lines */
 193             yuv_src[1] += stride >> 1; /* Skip down one chroma line */
 194             yuv_src[2] += stride >> 1;
 195             dst -= 2;
 196             y -= 2;
 197         }
 198         while (--height > 0);
 199     }
 200     else
 201     {
 202         do
 203         {
 204             lcd_write_yuv420_lines(dst, yuv_src, width, stride);
 205             yuv_src[0] += stride << 1; /* Skip down two luma lines */
 206             yuv_src[1] += stride >> 1; /* Skip down one chroma line */
 207             yuv_src[2] += stride >> 1;
 208             dst -= 2;
 209         }
 210         while (--height > 0);
 211     }
 212 }
 213
 214 void lcd_set_contrast(int val) {
 215   (void) val;
 216   // TODO:
 217 }
 218
 219 void lcd_set_invert_display(bool yesno) {
 220   (void) yesno;
 221   // TODO:
 222 }
 223
 224 void lcd_set_flip(bool yesno) {
 225   (void) yesno;
 226   // TODO:
 227 }
 228