Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/firmware/target/arm/tcc780x/cowond2/lcd-cowond2.c

419 lines
12 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2008 by Rob Purchase
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "hwcompat.h"
#include "kernel.h"
#include "lcd.h"
#include "system.h"
#include "cpu.h"
/* GPIO A pins for LCD panel SDI interface */
#define LTV250QV_CS (1<<24)
#define LTV250QV_SCL (1<<25)
#define LTV250QV_SDI (1<<26)
/* LCD Controller registers */
#define LCDC_CTRL (*(volatile unsigned long *)0xF0000000)
#define LCDC_CLKDIV (*(volatile unsigned long *)0xF0000008)
#define LCDC_HTIME1 (*(volatile unsigned long *)0xF000000C)
#define LCDC_HTIME2 (*(volatile unsigned long *)0xF0000010)
#define LCDC_VTIME1 (*(volatile unsigned long *)0xF0000014)
#define LCDC_VTIME2 (*(volatile unsigned long *)0xF0000018)
#define LCDC_VTIME3 (*(volatile unsigned long *)0xF000001C)
#define LCDC_VTIME4 (*(volatile unsigned long *)0xF0000020)
#define LCDC_DS (*(volatile unsigned long *)0xF000005C)
#define LCDC_I1CTRL (*(volatile unsigned long *)0xF000008C)
#define LCDC_I1POS (*(volatile unsigned long *)0xF0000090)
#define LCDC_I1SIZE (*(volatile unsigned long *)0xF0000094)
#define LCDC_I1BASE (*(volatile unsigned long *)0xF0000098)
#define LCDC_I1OFF (*(volatile unsigned long *)0xF00000A8)
#define LCDC_I1SCALE (*(volatile unsigned long *)0xF00000AC)
/* Power and display status */
static bool display_on = false; /* Is the display turned on? */
static unsigned lcd_yuv_options = 0;
/* Framebuffer copy as seen by the hardware */
fb_data lcd_driver_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH];
int lcd_default_contrast(void)
{
return 0x1f;
}
void lcd_set_contrast(int val)
{
/* TODO: This won't be implemented until the S6F2002 controller
is better understood (nb: registers 16-23 control gamma). */
(void)val;
}
/* LTV250QV panel functions */
static void ltv250qv_write(unsigned int command)
{
int i;
GPIOA_CLEAR = LTV250QV_CS;
for (i = 23; i >= 0; i--)
{
GPIOA_CLEAR = LTV250QV_SCL;
if ((command>>i) & 1)
GPIOA_SET = LTV250QV_SDI;
else
GPIOA_CLEAR = LTV250QV_SDI;
GPIOA_SET = LTV250QV_SCL;
}
GPIOA_SET = LTV250QV_CS;
}
static void lcd_write_reg(unsigned char reg, unsigned short val)
{
ltv250qv_write(0x740000 | reg);
ltv250qv_write(0x760000 | val);
}
/*
TEMP: Rough millisecond delay routine used by the LCD panel init sequence.
PCK_TCT must first have been initialised to 2Mhz by calling clock_init().
*/
static void sleep_ms(unsigned int ms)
{
/* disable timer */
TCFG1 = 0;
/* set Timer1 reference value based on 125kHz tick */
TREF1 = ms * 125;
/* single count, zero the counter, divider = 16 [2^(3+1)], enable */
TCFG1 = (1<<9) | (1<<8) | (3<<4) | 1;
/* wait until Timer1 ref reached */
while (!(TIREQ & TF1)) {};
}
static void lcd_display_on(void)
{
/* power on sequence as per the D2 firmware */
GPIOA_SET = (1<<16);
sleep_ms(10);
lcd_write_reg(1, 0x1D);
lcd_write_reg(2, 0x0);
lcd_write_reg(3, 0x0);
lcd_write_reg(4, 0x0);
lcd_write_reg(5, 0x40A3);
lcd_write_reg(6, 0x0);
lcd_write_reg(7, 0x0);
lcd_write_reg(8, 0x0);
lcd_write_reg(9, 0x0);
lcd_write_reg(10, 0x0);
lcd_write_reg(16, 0x0);
lcd_write_reg(17, 0x0);
lcd_write_reg(18, 0x0);
lcd_write_reg(19, 0x0);
lcd_write_reg(20, 0x0);
lcd_write_reg(21, 0x0);
lcd_write_reg(22, 0x0);
lcd_write_reg(23, 0x0);
lcd_write_reg(24, 0x0);
lcd_write_reg(25, 0x0);
sleep_ms(10);
lcd_write_reg(9, 0x4055);
lcd_write_reg(10, 0x0);
sleep_ms(40);
lcd_write_reg(10, 0x2000);
sleep_ms(40);
lcd_write_reg(1, 0xC01D);
lcd_write_reg(2, 0x204);
lcd_write_reg(3, 0xE100);
lcd_write_reg(4, 0x1000);
lcd_write_reg(5, 0x5033);
lcd_write_reg(6, 0x4);
lcd_write_reg(7, 0x30);
lcd_write_reg(8, 0x41C);
lcd_write_reg(16, 0x207);
lcd_write_reg(17, 0x702);
lcd_write_reg(18, 0xB05);
lcd_write_reg(19, 0xB05);
lcd_write_reg(20, 0x707);
lcd_write_reg(21, 0x507);
lcd_write_reg(22, 0x103);
lcd_write_reg(23, 0x406);
lcd_write_reg(24, 0x2);
lcd_write_reg(25, 0x0);
sleep_ms(60);
lcd_write_reg(9, 0xA55);
lcd_write_reg(10, 0x111F);
sleep_ms(10);
/* tell that we're on now */
display_on = true;
}
static void lcd_display_off(void)
{
/* block drawing operations and changing of first */
display_on = false;
/* LQV shutdown sequence */
lcd_write_reg(9, 0x55);
lcd_write_reg(10, 0x1417);
lcd_write_reg(5, 0x4003);
sleep_ms(10);
lcd_write_reg(9, 0x0);
sleep_ms(10);
/* kill power to LCD panel (unconfirmed) */
GPIOA_CLEAR = (1<<16);
}
void lcd_enable(bool on)
{
if (on == display_on)
return;
if (on)
{
lcd_display_on();
LCDC_CTRL |= 1; /* controller enable */
lcd_update(); /* Resync display */
lcd_call_enable_hook();
}
else
{
LCDC_CTRL &= ~1; /* controller disable */
lcd_display_off();
}
}
bool lcd_enabled(void)
{
return display_on;
}
/* TODO: implement lcd_sleep() and separate out the power on/off functions */
void lcd_init_device(void)
{
BCLKCTR |= 4; /* enable LCD bus clock */
/* set PCK_LCD to 108Mhz */
PCLK_LCD &= ~PCK_EN;
PCLK_LCD = PCK_EN | (CKSEL_PLL1<<24) | 1; /* source = PLL1, divided by 2 */
/* reset the LCD controller */
SWRESET |= 4;
SWRESET &= ~4;
/* set port configuration */
PORTCFG1 &= ~0xC0000000;
PORTCFG1 &= ~0x3FC0;
PORTCFG2 &= ~0x100;
/* set physical display size */
LCDC_DS = (LCD_HEIGHT<<16) | LCD_WIDTH;
LCDC_HTIME1 = (0x2d<<16) | 0x3bf;
LCDC_HTIME2 = (1<<16) | 1;
LCDC_VTIME1 = LCDC_VTIME3 = (0<<16) | 239;
LCDC_VTIME2 = LCDC_VTIME4 = (1<<16) | 3;
LCDC_I1BASE = (unsigned int)lcd_driver_framebuffer;
LCDC_I1SIZE = (LCD_HEIGHT<<16) | LCD_WIDTH; /* image 1 size */
LCDC_I1POS = (0<<16) | 0; /* position */
LCDC_I1OFF = 0; /* address offset */
LCDC_I1SCALE = 0; /* scaling */
LCDC_I1CTRL = 5; /* 565bpp (7 = 888bpp) */
LCDC_CTRL &= ~(1<<28);
LCDC_CLKDIV = (LCDC_CLKDIV &~ 0xFF00FF) | (1<<16) | 2; /* and this means? */
/* set and clear various flags - not investigated yet */
LCDC_CTRL &~ 0x090006AA; /* clear bits 1,3,5,7,9,10,24,27 */
LCDC_CTRL |= 0x02800144; /* set bits 2,6,8,25,23 */
LCDC_CTRL = (LCDC_CTRL &~ 0xF0000) | 0x20000;
LCDC_CTRL = (LCDC_CTRL &~ 0x700000) | 0x700000;
/* enable LCD controller */
LCDC_CTRL |= 1;
/* enable LTV250QV panel */
lcd_display_on();
}
/*** Update functions ***/
/* Copies a rectangle from one framebuffer to another. Can be used in
single transfer mode with width = num pixels, and height = 1 which
allows a full-width rectangle to be copied more efficiently. */
extern void lcd_copy_buffer_rect(fb_data *dst, const fb_data *src,
int width, int height);
/* Update the display.
This must be called after all other LCD functions that change the display. */
void lcd_update(void) ICODE_ATTR;
void lcd_update(void)
{
if (!display_on)
return;
lcd_copy_buffer_rect(&lcd_driver_framebuffer[0][0],
&lcd_framebuffer[0][0], LCD_WIDTH*LCD_HEIGHT, 1);
}
/* Update a fraction of the display. */
void lcd_update_rect(int, int, int, int) ICODE_ATTR;
void lcd_update_rect(int x, int y, int width, int height)
{
fb_data *dst, *src;
if (!display_on)
return;
if (x + width > LCD_WIDTH)
width = LCD_WIDTH - x; /* Clip right */
if (x < 0)
width += x, x = 0; /* Clip left */
if (width <= 0)
return; /* nothing left to do */
if (y + height > LCD_HEIGHT)
height = LCD_HEIGHT - y; /* Clip bottom */
if (y < 0)
height += y, y = 0; /* Clip top */
if (height <= 0)
return; /* nothing left to do */
/* TODO: It may be faster to swap the addresses of lcd_driver_framebuffer
* and lcd_framebuffer */
dst = &lcd_driver_framebuffer[y][x];
src = &lcd_framebuffer[y][x];
/* Copy part of the Rockbox framebuffer to the second framebuffer */
if (width < LCD_WIDTH)
{
/* Not full width - do line-by-line */
lcd_copy_buffer_rect(dst, src, width, height);
}
else
{
/* Full width - copy as one line */
lcd_copy_buffer_rect(dst, src, LCD_WIDTH*height, 1);
}
}
void lcd_set_flip(bool yesno)
{
// TODO
(void)yesno;
}
void lcd_set_invert_display(bool yesno)
{
// TODO
(void)yesno;
}
void lcd_yuv_set_options(unsigned options)
{
lcd_yuv_options = options;
}
/* Line write helper function for lcd_yuv_blit. Write two lines of yuv420. */
extern void lcd_write_yuv420_lines(fb_data *dst,
unsigned char const * const src[3],
int width,
int stride);
extern void lcd_write_yuv420_lines_odither(fb_data *dst,
unsigned char const * const src[3],
int width,
int stride,
int x_screen, /* To align dither pattern */
int y_screen);
/* Performance function to blit a YUV bitmap directly to the LCD */
void lcd_blit_yuv(unsigned char * const src[3],
int src_x, int src_y, int stride,
int x, int y, int width, int height)
{
unsigned char const * yuv_src[3];
off_t z;
if (!display_on)
return;
/* Sorry, but width and height must be >= 2 or else */
width &= ~1;
height >>= 1;
y = LCD_WIDTH - 1 - y;
fb_data *dst = &lcd_driver_framebuffer[x][y];
z = stride*src_y;
yuv_src[0] = src[0] + z + src_x;
yuv_src[1] = src[1] + (z >> 2) + (src_x >> 1);
yuv_src[2] = src[2] + (yuv_src[1] - src[1]);
if (lcd_yuv_options & LCD_YUV_DITHER)
{
do
{
lcd_write_yuv420_lines_odither(dst, yuv_src, width, stride, y, x);
yuv_src[0] += stride << 1; /* Skip down two luma lines */
yuv_src[1] += stride >> 1; /* Skip down one chroma line */
yuv_src[2] += stride >> 1;
dst -= 2;
y -= 2;
}
while (--height > 0);
}
else
{
do
{
lcd_write_yuv420_lines(dst, yuv_src, width, stride);
yuv_src[0] += stride << 1; /* Skip down two luma lines */
yuv_src[1] += stride >> 1; /* Skip down one chroma line */
yuv_src[2] += stride >> 1;
dst -= 2;
}
while (--height > 0);
}
}
Reference in a new issue View git blame Copy permalink