void main(void) {
int count;
int size;
unsigned int adcValue = 0;
unsigned int adcValueOld = 0;
char buffer[16];
ConfigureOscillator();
InitApp();
lcd_init();
lcd_enable();
lcd_cursor_off();
lcd_test();
lcd_pos(2, 1);
while (1) {
ConvertADC();
while (BusyADC());
adcValue = ReadADC();
if (adcValue != adcValueOld) {
lcd_clear();
//Linha 1
lcd_pos(1, 1);
memset(&buffer[0], 0, sizeof (buffer));
sprintf(&buffer[0], "Step:%.4u %3.1f%%", adcValue, ((float) adcValue / 1023) * 100);
size = (strlen(buffer) > sizeof(buffer)) ? sizeof(buffer) : strlen(buffer);
lcd_write_buffer(buffer, size);
for(count = 0; count < size; count++){
while(BusyUSART());
putcUSART((char)buffer[count]);
}
//Linha 2
lcd_pos(2, 1);
memset(&buffer[0], 0, sizeof (buffer));
sprintf(&buffer[0], "Volts:%1.7fV", (float)adcValue * ((float)5 /1023));
size = (strlen(buffer) > sizeof(buffer)) ? sizeof(buffer) : strlen(buffer);
lcd_write_buffer(buffer, size);
//Variável de controle
adcValueOld = adcValue;
for(count = 0; count < size; count++){
while(BusyUSART());
putcUSART((char)buffer[count]);
}
}
for (count = 0; count < 40; count++) {
__delay_ms(10);
}
}
}
void main(void)
{
ConfigureOscillator();
InitApp();
lcd_init();
lcd_enable();
lcd_cursor_off();
lcd_test();
lcd_pos(2,1);
while(1)
{
}
}
void _backlight_on(void)
{
if (backlight_is_on == 1) {
/* Update pwm ratio in case user changed the brightness */
_pwm_on();
return;
}
#ifdef HAVE_LCD_ENABLE
lcd_enable(true); /* power on lcd + visible display */
#endif
_ll_backlight_on();
_pwm_on();
backlight_is_on = 1;
}
void lcd_init(void)
{
LCD_DDR = LCD_DDR | 0x0F | (1<<LCD_RS) | (1<<LCD_EN); // Port auf Ausgang schalten
// muss 3mal hintereinander gesendet werden zur Initialisierung
_delay_ms(15);
LCD_PORT &= 0xF0;
LCD_PORT |= 0x03;
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0
lcd_enable();
_delay_ms(5);
lcd_enable();
_delay_ms(1);
lcd_enable();
_delay_ms(1);
// 4 Bit Modus aktivieren
LCD_PORT &= 0xF0;
LCD_PORT |= 0x02;
lcd_enable();
_delay_ms(1);
// 4Bit / 2 Zeilen / 5x7
lcd_command(0x28);
// Display ein / Cursor aus / kein Blinken
lcd_command(0x0C);
// inkrement / kein Scrollen
lcd_command(0x06);
lcd_clear();
}
/*!
\brief LCD Configuration
\param[in] none
\param[out] none
\retval none
*/
static void lcd_config(void)
{
/* configure the LCD control line */
lcd_ctrl_line_config();
lcd_disable();
lcd_enable();
/* configure the GPIO of TLI */
tli_gpio_config();
/* configure the LCD_SPI */
lcd_spi_config();
/* power on the LCD */
//lcd_power_on();
lcd_power_on3(); //New Version 3.5" TFT RGB Hardware needs use this initilize funtion ---By xufei 2016.10.21
}
void lcd_invert(uint32_t on)
{
lcd_enable();
if(on == 0)
{
lcd_wrcmd8(LCD_CMD_INV_OFF);
}
else
{
lcd_wrcmd8(LCD_CMD_INV_ON);
}
lcd_disable();
return;
}
void lcd_sendTo(uint8_t data){
uint8_t i;
LCD_PORT |= (1<< LCD_SHIFT_STR);
LCD_PORT &= ~(1<<LCD_SHIFT_OE);
for(i=0;i<8;i++){
LCD_PORT &= ~(1<<LCD_SHIFT_CLOCK);
if(data & (1<<i)){
LCD_PORT |= (1<< LCD_SHIFT_DATA);
}else{
LCD_PORT &= ~(1<< LCD_SHIFT_DATA);
}
LCD_PORT |= (1<< LCD_SHIFT_CLOCK);
}
LCD_PORT &= ~(1<< LCD_SHIFT_STR);
LCD_PORT |= (1<< LCD_SHIFT_OE);
lcd_enable();
}
// Initialize LCD in 4-bit mode.
void
lcd_reset(
void
)
{
// Output pins low and as output (except last pin).
// If R/W is configured, this sets R/W to 0, i.e. write mode.
lcd_enable(0);
xtl_lcd_hd44780_set_rw(0);
xtl_lcd_hd44780_set_rs(0);
// Wait at least 15ms for the LCD to initialise.
lcd_delay_ms(15);
// Reset as per p. 211 of HD44780 user guide.
// Function set (8-bit data, two line mode, 5x7 dots).
lcd_data_write(0x30);
xtl_lcd_hd44780_strobe();
lcd_delay_ms(10); // Need at least 4.1ms according to the guide.
xtl_lcd_hd44780_strobe();
lcd_delay_ms(2); // Need at least 100us according to the guide.
xtl_lcd_hd44780_strobe();
lcd_delay_ms(2); // Don't use BF here either.
// Function set (8-bit data, two line mode, 5x7 dots).
xtl_lcd_hd44780_send_cmd(0x38);
lcd_delay_ms(6);
// Display off
xtl_lcd_hd44780_send_cmd(DISP_OFF);
lcd_delay_ms(5);
// Display clear
xtl_lcd_hd44780_send_cmd(CLR_DISP);
lcd_delay_ms(10);
// Entry mode, increasing cursor position.
xtl_lcd_hd44780_send_cmd(ENTRY_INC);
// Display on.
xtl_lcd_hd44780_wait_ready();
xtl_lcd_hd44780_send_cmd(DISP_ON);
}
/** Initialize the display */
void lcd_init()
{
// configure pins as output
as_output(LCD_E);
as_output(LCD_RW);
as_output(LCD_RS);
_lcd_mode = 1; // force data pins to output
_lcd_mode_w();
// Magic sequence to invoke Cthulhu (or enter 4-bit mode)
_delay_ms(16);
_lcd_write_nibble(0b0011);
_lcd_clk();
_delay_ms(5);
_lcd_clk();
_delay_ms(5);
_lcd_clk();
_delay_ms(5);
_lcd_write_nibble(0b0010);
_lcd_clk();
_delay_us(100);
// Configure the display
lcd_command(LCD_IFACE_4BIT_2LINE);
lcd_command(LCD_DISABLE);
lcd_command(LCD_CLEAR);
lcd_command(LCD_MODE_INC);
// mark as enabled
lcd_enable();
_lcd_singleton.tx = &lcd_write;
_lcd_singleton.rx = &lcd_read;
// Stream
lcd = &_lcd_singleton;
_pos.x = 0;
_pos.y = 0;
_addrtype = TEXT;
}
static void display_image(enum image_t image, uint16_t soc)
{
uint16_t *image_start;
uint16_t *image_end;
if (soc < SOC_THRESH_DISPLAY_MIN) {
lcd_disable();
lcd_is_on = 0;
return;
}
switch(image) {
case IMAGE_CHARGE_NEEDED:
image_start = (uint16_t *) _binary_connect_charge_rle_start;
image_end = (uint16_t *) _binary_connect_charge_rle_end;
break;
case IMAGE_CHARGING:
image_start = (uint16_t *) _binary_lowbatt_charge_rle_start;
image_end = (uint16_t *) _binary_lowbatt_charge_rle_end;
break;
case IMAGE_BOOT:
default:
image_start = (uint16_t *) _binary_o_nookcolor_logo_large_rle_start;
image_end = (uint16_t *) _binary_o_nookcolor_logo_large_rle_end;
break;
}
if (!lcd_is_on) {
spi_init();
lcd_enable();
lcd_is_on = 1;
}
if (image == IMAGE_BOOT) {
lcd_bl_set_brightness(255);
}
lcd_display_image(image_start, image_end);
}
void lcd_power(uint32_t on)
{
lcd_enable();
if(on == 0)
{
lcd_wrcmd8(LCD_CMD_DISPLAY_OFF);
delay_ms(20);
lcd_wrcmd8(LCD_CMD_SLEEPIN);
delay_ms(120);
}
else
{
lcd_wrcmd8(LCD_CMD_SLEEPOUT);
delay_ms(120);
lcd_wrcmd8(LCD_CMD_DISPLAY_ON);
delay_ms(20);
}
lcd_disable();
return;
}
static int s6e3hf2_displayon(struct dsim_device *dsim)
{
lcd_init(dsim->id, &dsim->lcd_info);
lcd_enable(dsim->id);
return 1;
}
void backlight_hw_off(void)
{
and_l(~0x00020000, &GPIO1_OUT);
lcd_enable(false);
}
static void lcd_resume(struct disp_process_dev *pdev)
{
PM_DBGOUT("%s\n", __func__);
lcd_enable(pdev, 1);
}
void lcd_init()
{
const uint8_t MEM_BGR = 3;
const uint8_t MEM_X = 6;
const uint8_t MEM_Y = 7;
uint8_t init_sequence[] = {
VCMD_COMMAND | 1, LCD_CMD_RESET,
VCMD_SLEEP |20,
VCMD_COMMAND | 1, LCD_CMD_DISPLAY_OFF,
VCMD_SLEEP |20,
VCMD_COMMAND | 1, LCD_CMD_POWER_CTRLB,
VCMD_DATA | 3, 0x00, 0x83, 0x30, //0x83 0x81 0xAA
VCMD_COMMAND | 1, LCD_CMD_POWERON_SEQ_CTRL,
VCMD_DATA | 4, 0x64, 0x03, 0x12, 0x81, //0x64 0x67
VCMD_COMMAND | 1, LCD_CMD_DRV_TIMING_CTRLA,
VCMD_DATA | 3, 0x85, 0x01, 0x79, //0x79 0x78
VCMD_COMMAND | 1, LCD_CMD_POWER_CTRLA,
VCMD_DATA | 5, 0x39, 0X2C, 0x00, 0x34, 0x02,
VCMD_COMMAND | 1, LCD_CMD_PUMP_RATIO_CTRL,
VCMD_DATA | 1, 0x20,
VCMD_COMMAND | 1, LCD_CMD_DRV_TIMING_CTRLB,
VCMD_DATA | 2, 0x00, 0x00,
VCMD_COMMAND | 1, LCD_CMD_POWER_CTRL1,
VCMD_DATA | 1, 0x26, //0x26 0x25
VCMD_COMMAND | 1, LCD_CMD_POWER_CTRL2,
VCMD_DATA | 1, 0x11,
VCMD_COMMAND | 1, LCD_CMD_VCOM_CTRL1,
VCMD_DATA | 2, 0x35, 0x3E,
VCMD_COMMAND | 1, LCD_CMD_VCOM_CTRL2,
VCMD_DATA | 1, 0xBE, //0xBE 0x94
VCMD_COMMAND | 1, LCD_CMD_FRAME_CTRL,
VCMD_DATA | 2, 0x00, 0x1B, //0x1B 0x70
VCMD_COMMAND | 1, LCD_CMD_ENABLE_3G,
VCMD_DATA | 1, 0x08, //0x08 0x00
VCMD_COMMAND | 1, LCD_CMD_GAMMA,
VCMD_DATA | 1, 0x01, //G2.2
VCMD_COMMAND | 1, LCD_CMD_POS_GAMMA,
VCMD_DATA |15, 0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0x87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00,
VCMD_COMMAND | 1, LCD_CMD_NEG_GAMMA,
VCMD_DATA |15, 0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F,
VCMD_COMMAND | 1, LCD_CMD_DISPLAY_CTRL,
VCMD_DATA | 4, 0x0A, 0x82, 0x27, 0x00,
VCMD_COMMAND | 1, LCD_CMD_ENTRY_MODE,
VCMD_DATA | 1, 0x07,
VCMD_COMMAND | 1, LCD_CMD_PIXEL_FORMAT,
VCMD_DATA | 1, 0x55, //16bit
VCMD_COMMAND | 1, LCD_CMD_MEMACCESS_CTRL,
VCMD_DATA | 1, (1<<MEM_BGR) | (1<<MEM_X) | (1<<MEM_Y),
VCMD_COMMAND | 1, LCD_CMD_COLUMN,
VCMD_DATA | 2, 0x00, 0x00,
VCMD_DATA | 2, ((LCD_HEIGHT-1)>>8)&0xFF, (LCD_HEIGHT-1)&0xFF,
VCMD_COMMAND | 1, LCD_CMD_PAGE,
VCMD_DATA | 2, 0x00, 0x00,
VCMD_DATA | 2, ((LCD_WIDTH-1)>>8)&0xFF, (LCD_WIDTH-1)&0xFF,
VCMD_COMMAND | 1, LCD_CMD_SLEEPOUT,
VCMD_SLEEP |60,
VCMD_SLEEP |60,
VCMD_COMMAND | 1, LCD_CMD_DISPLAY_ON,
VCMD_SLEEP |20,
};
DISABLE_IRQ();
// initialize pins
IOCON_PIO2_0 &= ~IOCON_PIO2_0_FUNC_MASK;
IOCON_PIO2_1 &= ~IOCON_PIO2_1_FUNC_MASK;
IOCON_PIO2_2 &= ~IOCON_PIO2_2_FUNC_MASK;
IOCON_PIO2_3 &= ~IOCON_PIO2_3_FUNC_MASK;
IOCON_PIO2_4 &= ~IOCON_PIO2_4_FUNC_MASK;
IOCON_PIO2_5 &= ~IOCON_PIO2_5_FUNC_MASK;
IOCON_PIO2_6 &= ~IOCON_PIO2_6_FUNC_MASK;
IOCON_PIO2_7 &= ~IOCON_PIO2_7_FUNC_MASK;
IOCON_PIO2_8 &= ~IOCON_PIO2_8_FUNC_MASK;
IOCON_PIO2_9 &= ~IOCON_PIO2_9_FUNC_MASK;
IOCON_PIO2_10 &= ~IOCON_PIO2_10_FUNC_MASK;
IOCON_PIO2_11 &= ~IOCON_PIO2_11_FUNC_MASK;
IOCON_PIO3_5 &= ~IOCON_PIO3_5_FUNC_MASK;
// set all 12 pins to output mode
GPIO_GPIO2DIR |= 0xFFF;
// set all pins high
LCD_GPIO |= 0xFFF;
// set pin 5 of gpio 3 to output mode
GPIO_GPIO3DIR |= LCD_RD_MASK;
GPIO_GPIO3DATA |= LCD_RD_MASK;
ENABLE_IRQ();
// trigger hard-reset
LCD_MASKED_GPIO(LCD_RST_MASK, 0);
delay_ms(20);
LCD_MASKED_GPIO(LCD_RST_MASK, LCD_RST_MASK);
delay_ms(120);
lcd_enable();
delay_ms(1);
for (unsigned int i = 0; i < sizeof(init_sequence);) {
uint8_t instruction = init_sequence[i++];
switch (instruction & 0xC0) {
case VCMD_COMMAND:
{
//~ printf("cmd 0x%02x", instruction & 0x3f);
for (int j = (instruction & 0x3f); j > 0; j--) {
uint8_t data = init_sequence[i++];
//~ printf(" 0x%02x", data);
lcd_wrcmd8(data);
}
//~ printf("\n");
break;
}
case VCMD_DATA:
{
//~ printf("data 0x%02x\n", instruction & 0x3f);
for (int j = (instruction & 0x3f); j > 0; j--) {
uint8_t data = init_sequence[i++];
//~ printf(" 0x%02x", data);
lcd_wrdata8(data);
}
//~ printf("\n");
break;
}
case VCMD_SLEEP:
{
//~ printf("sleep %d\n", instruction & 0x3f);
delay_ms(instruction & 0x3f);
break;
}
default:
// cannot happen :)
continue;
};
}
lcd_drawstart();
for (int i = (LCD_WIDTH*LCD_HEIGHT/8); i > 0; i--) {
lcd_draw(0);
lcd_draw(0);
lcd_draw(0);
lcd_draw(0);
lcd_draw(0);
lcd_draw(0);
lcd_draw(0);
lcd_draw(0);
}
lcd_drawstop();
lcd_disable();
}
void lcd_init(char cursor_onoff, char cursor_blinking) {
#if (LCD_USED_CONTROLLER==LCD_CONTROLLER_KS0066) || (LCD_USED_CONTROLLER==LCD_CONTROLLER_HD44780)
#warning " LCD library uses KS0066 or HD44780 controller"
LCDPORTS_OUT();
LCD_RS_DDR |= (1<<LCD_RS);
#if LCD_RW_CONNECTED!=0
LCD_RW_DDR |= (1<<LCD_RW);
#endif
LCD_EN_DDR |= (1<<LCD_EN);
_delay_ms(40);
// muss 3mal hintereinander gesendet werden zur Initialisierung
RW0(); // set RW=0
RS0(); // RS auf 0 setzen
EN0(); // RS auf 0 setzen
_delay_ms(40);
if (LCD_DATASTART==0) {
LCD_PORT &= 0xF0;
LCD_PORT |= 0x03; // setzen
} else {
LCD_PORT &= 0x0F;
LCD_PORT |= (0x03<<4); // setzen
}
LCD_RS_PORT &= ~(1<<LCD_RS); // RS auf 0
lcd_enable();
_delay_ms(1);
lcd_enable();
_delay_ms(5);
lcd_enable();
_delay_ms(5);
// 4 Bit Modus aktivieren
if (LCD_DATASTART==0) {
LCD_PORT &= 0xF0;
LCD_PORT |= 0x02; // setzen
} else {
LCD_PORT &= 0x0F;
LCD_PORT |= (0x02<<4); // setzen
}
lcd_enable();
_delay_ms(5);
// 4Bit / 2 Zeilen / 5x7
lcd_command(0x28);
// Display ein / Cursor aus / kein Blinken
lcd_command(0x0C);
// inkrement / kein Scrollen
lcd_command(0x06);
lcd_clear();
#elif (LCD_USED_CONTROLLER==LCD_CONTROLLER_ST7036)
#warning " LCD library uses ST7036 controller"
// set 4 data ports as outputs and all control signals as outputs
LCDPORTS_OUT();
LCD_RS_DDR |= (1<<LCD_RS);
LCD_RW_DDR |= (1<<LCD_RW);
LCD_EN_DDR |= (1<<LCD_EN);
_delay_ms(20);
RW0();
RS0();
EN0();
_delay_ms(100);
#if (LCD_INTERFACE == LCD_INTERFACE_4BIT)
#warning " 4 Bit Interface"
// init 4-bit by sending 0b0011XXXX three times to the display
lcd_data_out(0x03);
_delay_ms(10);
//lcd_enable();
lcd_data_out(0x03);
_delay_ms(10);
lcd_data_out(0x03);
_delay_ms(10);
lcd_data_out(0x02); // function set 0b0010XXXX
_delay_ms(10);
#elif (LCD_INTERFACE == LCD_INTERFACE_8BIT || LCD_INTERFACE == LCD_INTERFACE_8BIT_SHIFTREG)
#warning " 8 Bit Interface"
lcd_data_out(0x39);
_delay_us(LCD_SHORTDELAY);
lcd_data_out(0x39);
_delay_us(LCD_SHORTDELAY);
#endif
uint8_t c=0x31;
#if (LCD_VOLTAGE == LCD_VOLTAGE_5V)
#warning " 5V supply voltage"
#if (LCD_LINECOUNT>1)
c=c + 0x08;
#endif
lcd_command(c); // function set 0b0011<N><DH><IS2><IS1>
// 0b0011 N 0 0 1 =0x31 & (N*0x08)
lcd_command(0x1D); // intern. osc freq. 0b0001<BS><F2><F1><F0>
// 0b0001 1 1 0 1 =0x1D
lcd_command(0x50); // power/ICON/contrast 0b0101<Ion><Bon><C5><C4>
// 0b0101 0 0 0 0 =0x50
lcd_command(0x6C); // follower control 0b0110<Fon><Rab2><Rab1><Rab0>
// 0b0110 1 1 0 0 =0x6C
lcd_command(0x7C); // contrast set 0b0111<C3><C2><C1><C0>
// 0b0111 1 1 0 0 =0x7C
#elif (LCD_VOLTAGE == LCD_VOLTAGE_3V)
#warning " 3V supply voltage"
#if (LCD_LINECOUNT>1)
c=c + 0x08;
#endif
lcd_command(c); // function set 0b0011<N><DH><IS2><IS1>
// 0b0011 N 0 0 1 =0x31 & (N*0x08)
lcd_command(0x15); // intern. osc freq. 0b0001<BS><F2><F1><F0>
// 0b0001 0 1 0 1 =0x15
lcd_command(0x55); // power/ICON/contrast 0b0101<Ion><Bon><C5><C4>
// 0b0101 0 1 0 1 =0x55
lcd_command(0x6E); // follower control 0b0110<Fon><Rab2><Rab1><Rab0>
// 0b0110 1 1 1 0 =0x6E
lcd_command(0x72); // contrast set 0b0111<C3><C2><C1><C0>
// 0b0111 0 0 1 0 =0x72
#endif
lcd_command(c & 0b11111100); // switch back to instruction table 0 0b0011<N>000 =0x38
#endif
lcd_setcursor(1, cursor_onoff, cursor_blinking);
lcd_setcontrast(LCD_DEFAULTCONTRAST);
lcd_clear();
lcd_home();
}
static int lcd_suspend(struct disp_process_dev *pdev)
{
PM_DBGOUT("%s\n", __func__);
return lcd_enable(pdev, 0);
}
////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void )
{
// verwendete Pins auf Ausgang schalten
uint8_t pins = (0x0F << LCD_DB) | // 4 Datenleitungen
(1<<LCD_RS) | // R/S Leitung
(1<<LCD_EN); // Enable Leitung
LCD_DDR |= pins;
// initial alle Ausgänge auf Null
LCD_PORT &= ~pins;
//Initialisiere LCD Backlight Pin
LCD_BL_DDR |= (1<<LCD_BL);
LCD_BL_PORT |= (1<<LCD_BL);
// warten auf die Bereitschaft des LCD
_delay_ms( LCD_BOOTUP_MS );
// Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
lcd_out( LCD_SOFT_RESET );
_delay_ms( LCD_SOFT_RESET_MS1 );
lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS2 );
lcd_enable();
_delay_ms( LCD_SOFT_RESET_MS3 );
// 4-bit Modus aktivieren
lcd_out( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT );
_delay_ms( LCD_SET_4BITMODE_MS );
// 4-bit Modus / 2 Zeilen / 5x7
lcd_command( LCD_SET_FUNCTION |
LCD_FUNCTION_4BIT |
LCD_FUNCTION_2LINE |
LCD_FUNCTION_5X7 );
// Display ein / Cursor aus / Blinken aus
lcd_command( LCD_SET_DISPLAY |
LCD_DISPLAY_ON |
LCD_CURSOR_OFF |
LCD_BLINKING_OFF);
// Cursor inkrement / kein Scrollen
lcd_command( LCD_SET_ENTRY |
LCD_ENTRY_INCREASE |
LCD_ENTRY_NOSHIFT );
//Gradzeichen
uint8_t chrdata0[8] = {
0b00000100,
0b00001010,
0b00000100, // X X
0b00000000, // XXXXX
0b00000000, // XXX
0b00000000, // X
0b00000000,
0b00000000
};
//µ
uint8_t chrdata1[8] = {
0b00000000,
0b00001001,
0b00001001, // X X
0b00001001, // XXXXX
0b00001111, // XXX
0b00001000, // X
0b00010000,
0b00000000
};
//Rechtecksignal
uint8_t chrdata2[8] = {
0b00000000,
0b00011101,
0b00010101, // X X
0b00010101, // XXXXX
0b00010101, // XXX
0b00010101, // X
0b00010111,
0b00000000
};
lcd_generatechar(LCD_GC_CHAR0, chrdata0);
lcd_generatechar(LCD_GC_CHAR1, chrdata1);
lcd_generatechar(LCD_GC_CHAR2, chrdata2);
lcd_clear();
}
void cmd_lcd_drawimage(uint_least16_t fgcolor, uint_least16_t bgcolor)
{
uint_least8_t b, c, e, n;
uint_least16_t a, x0, y0, x1, y1, w, h;
uint_least32_t i, ms;
x0 = if_read(); //x0
y0 = if_read(); //y0
w = if_read(); //w
h = if_read(); //h
x1 = x0+w-1;
y1 = y0+h-1;
c = if_read8(); //color mode + encoding
e = c & COLOR_RLE;
c = c & ~COLOR_RLE;
lcd_enable();
lcd_setarea(x0, y0, x1, y1);
lcd_drawstart();
switch(c)
{
case COLOR_BW: //black/white
fgcolor = RGB(0,0,0);
bgcolor = RGB(255,255,255);
break;
case COLOR_WB: //white/black
fgcolor = RGB(255,255,255);
bgcolor = RGB(0,0,0);
break;
case COLOR_FG: //fg/bg
fgcolor = fgcolor;
bgcolor = bgcolor;
break;
case COLOR_BG: //bg/fg
fgcolor ^= bgcolor;
bgcolor ^= fgcolor;
fgcolor ^= bgcolor;
break;
}
ms = get_ms();
if(e == 0) //no encoding
{
switch(c)
{
case COLOR_BW: //black/white
case COLOR_WB: //white/black
case COLOR_FG: //fg/bg
case COLOR_BG: //bg/fg
for(i=w*h; i!=0;)
{
if(if_available())
{
a = if_read8();
for(b=0x80; (b!=0) && (i!=0); b>>=1)
{
if(a & b) { lcd_draw(fgcolor); }
else { lcd_draw(bgcolor); }
i--;
}
}
else if((get_ms()-ms) > 2000) //2s
{
break;
}
}
break;
case COLOR_RGB323:
case COLOR_RGB332:
case COLOR_RGB233:
case COLOR_GRAY:
for(i=w*h; i!=0;)
{
if(if_available())
{
a = if_read8();
if(c == COLOR_RGB323){ a = RGB323toRGB565(a); }
else if(c == COLOR_RGB332){ a = RGB332toRGB565(a); }
else if(c == COLOR_RGB233){ a = RGB233toRGB565(a); }
else { a = GRAYtoRGB565(a); }
lcd_draw(a);
i--;
}
else if((get_ms()-ms) > 2000) //2s
{
break;
}
}
break;
default:
case COLOR_RGB565:
for(i=w*h; i!=0;)
{
if(if_available())
{
a = if_read16();
lcd_draw(a);
i--;
}
else if((get_ms()-ms) > 2000) //2s
{
break;
}
}
break;
case COLOR_RGB888:
for(i=w*h; i!=0;)
{
if(if_available())
{
a = (if_read8()&0xF8)<<8; //R (5 bits)
a |= (if_read8()&0xFC)<<3; //G (6 bits)
a |= (if_read8()&0xF8)>>3; //B (5 bits)
lcd_draw(a);
i--;
}
else if((get_ms()-ms) > 2000) //2s
{
break;
}
}
break;
}
/**********************************************************************************************************
** Function name: lcd_ctrl_init
** Descriptions: initial lcd controller's register. Called by common/lcd.c lcd_init
** input parameters: NONE
** output parameters: NONE
** Returned value: NONE
** Created by: WangDongfang
** Created Date: 2011-04-14
**---------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
**---------------------------------------------------------------------------------------------------------
**********************************************************************************************************/
void lcd_init()
{
/*
* 配置端口为LCD控制器
*/
rMIFPCON &= ~(1 << 3); /* bypass 模式禁能 */
rSPCON = (rSPCON & ~(3UL)) | 1UL; /* 选择LCD控制器为RGB模式 */
rGPICON = 0xaaaaaaaa; /* 使能引脚功能是LCD控制器 */
rGPIPUD = 0; /* 禁止引脚上拉功能 */
rGPJCON = 0xaaaaaa; /* 设置GPJ引脚功能为LCD控制器 */
rGPJPUD = 0; /* 禁止引脚上拉功能 */
rVIDCON0 = (0 << 29) /* 0 - 渐进模式------------*/
/* 1 - 交错模式 */
| (0 << 26) /* 00 - RGB 模式------------*/
/* 01 - TV模式 */
/* 02 - LDI0 180 IF */
/* 03 - LDI1 180 IF */
| (0 << 23) /* XXX - LDI1 180 IF数据方式-*/
| (0 << 20) /* XXX - LDI1 180 IF数据方式-*/
| (0 << 17) /* 00 - RGB并行 RGB---------*/
/* 01 - RGB并行 BGR */
/* 10 - 串行RGB R-G-B */
/* 10 - 串行RGB B-G-R */
| (0 << 16) /* 0 - CLKVAL_F一直有效----*/
/* 1- - 帧开始时一帧只有一次*/
| (CLK_VAL << 6) /* 0-255 LCD时钟分频器-------*/
/* VCLK = clk/本数据+1)*/
/* VCLK最大不能超过66M */
| (0 << 5) /* 0 - 常规模式/由ENVID控制*/
/* 1 - 自由运行 */
| (1 << 4) /* 0 - 直接使用选择时钟----*/
/* 1 - 使用分频后的时钟 */
| (0 << 2) /* 00 - clk 时钟源 =HCLK-- */
/* 01 - clk 时钟源 =视频时钟*/
/* 10 - RESV */
/* 11 - clk 时钟源=27M EXCLK*/
| (0 << 1) /* 0 - 不输出视频信号------*/
/* 1 - 输出视频信号 */
| (0 << 0); /* 0 - 帧尾视频信号被使能--*/
/* 1 - 帧尾视频信号被禁止 */
rVIDCON1 = (0 << 7) /* 0 - VCLK下降沿有效------*/
/* 1 - VCLK上升沿有效 */
| (HS_POL << 6) /* 0 - Hsync正常有效-------*/
/* 1 - Hsync反向 */
| (VS_POL << 5) /* 0 - Vsync正常有效-------*/
/* 1 - Vsync反向 */
| (0 << 4) /* 0 - VDEN正常有效--------*/
/* 1 - VDEN反向有效 */
| (0 << 0); /* 保留 */
rVIDCON2 = (0 << 23) /* 0 - ITU601无输出--------*/
/* 1 - ITU601被使能 */
| (0 << 14) /* 0 - YUV数据格式硬件选择-*/
/* 1 - YUV数据格式软件选择 */
| (0 << 12) /* 00 - YUV输出RGB格式------*/
/* 01 - YUV 422输出格式 */
/* 1x - YUV 444输出格式 */
| (0 << 8) /* 0 - Y-cb-cr数据格式-----*/
/* 1 - cb-cr-Y数据格式 */
| (0 << 7) /* 0 - cb-cr数据格式-------*/
/* 1 - cr-cb数据格式 */
| (0 << 0); /* 保留 */
/*
* |VFPD |VSPW |VBPD |-------------有效行-----------------------------|
* |VFPDE | |VBPDE| |
* 帧起始 | | | 帧结束
* V V V V V
* |------| |------------------------------------------------------|
* | | | ^ ^
* | ------ | |
* | -------------------------------------------------|
* | ^ ^
* | line0 line?
*/
rVIDTCON0 = (0 << 24) /* VBPDE-----------------------*/
/* 0-255 帧起始经过同步脉冲后 */
/* 有多少无效行,(只针对YUV端口)*/
| (VBP << 16) /* VBPD------------------------*/
/* 0-255 帧起始经过同步脉冲后 */
/* 有多少无效行 */
| (VFP << 8) /* VFPD------------------------*/
/* 0-255 - 帧结束后,在同步脉*/
/* 冲前有多少个无效行 */
| (VSW << 0); /* VSPW------------------------*/
/* 0-255 帧同步脉冲有多少无效行*/
/*
* |HFPD |HSPW |HBPD |-------------有效像素---------------------------|
* 行起始 | | | 行结束
* V V V V V
* |------| |------------------------------------------------------|
* | | | ^ ^
* | ------ | |
* | -------------------------------------------------|
* | ^ ^
* | pixel0 pixel?
*/
rVIDTCON1 = (0 << 24) /* VFPDE-----------------------*/
/* 0-255 帧在经过同步脉冲前,有 */
/* 多少无效行,(只针对YUV端口) */
| (HBP << 16) /* HBPD------------------------*/
/* 0-255 经过行同步脉冲下降沿 */
/* 后,在首个有效数据前,有多少 */
/* 无效像素 */
| (HFP << 8) /* HFPD------------------------*/
/* 0-255行结束后,在行同步时钟上*/
/* 升沿前有多少个无效像素 */
| (HSW << 0); /* HSPW------------------------*/
/* 0-255 行同步有多少无效时钟 */
rVIDTCON2 = ((U_LCD_YSIZE - 1) << 11) /* 0~2048 有效行数 */
| ((U_LCD_XSIZE - 1) << 0); /* 0~2048 有效列数 */
rWINCON0 = (0 << 22) /* 0 - 专用DMA进行数据访问 */
/* 1 * 程序控制 */
| (0 << 20) /* 0~1 采用哪个缓冲区 */
| (0 << 19) /* 0 - 双缓冲固定----------*/
/* 0 - 通过H/W信号自动改变 */
| (0 << 18) /* 0 - 位交换禁止----------*/
/* 0 - 位交换使能 */
| (0 << 17) /* 0 - 字节交换禁止--------*/
/* 1 - 字节交换使能 */
| (1 << 16) /* 0 - 半字交换禁止--------*/
/* 1 - 半字交换使能 */
| (0 << 13) /* 0 - RGB颜色空间---------*/
/* 1 - YCbCr颜色空间 */
| (0 << 9) /* 0 - 猝发传输16字--------*/
/* 1 - 猝发传输8字 */
/* 2 - 猝发传输4字 */
| (5 << 2) /* 0000- 1BPP----------------*/
/* 0001- 2BPP */
/* 0010- 4BPP */
/* 0011- 8BPP 调色板 */
/* 0101- 16BPP 565 */
/* 0111- 16BPP 555 */
/* 1000- 16BPP 无填充 */
/* 1011- 24BPP 无填充 */
| (0 << 0); /* 0 - 禁止窗口0输出 */
/* 1 - 使能窗口0输出-------*/
rVIDOSD0A = (0 << 11) /* 窗口左上角X坐标 */
| (0 << 0); /* 窗口左上角Y坐标 */
rVIDOSD0B = ((U_LCD_XSIZE - 1) << 11) /* 窗口右下角X坐标 */
| ((U_LCD_YSIZE - 1) << 0); /* 窗口右下角Y坐标 */
rVIDOSD0C = (U_LCD_XSIZE * U_LCD_YSIZE);
rDITHMODE = (0 << 5) /* 红色抖动位控制--------------*/
/* 00 - 8位抖动 */
/* 01 - 6位抖动 */
/* 10 - 5位抖动 */
| (0 << 5) /* 绿色抖动位控制--------------*/
/* 00 - 8位抖动 */
/* 01 - 6位抖动 */
/* 10 - 5位抖动 */
| (0 << 5) /* 蓝色抖动位控制--------------*/
/* 00 - 8位抖动 */
/* 01 - 6位抖动 */
/* 10 - 5位抖动 */
| (0 << 0); /* 0 - 抖动禁止 */
/* 1 - 抖动使能------------*/
/*
* Setup Frame buffer address in s3c6410 LCD controller
*/
rVIDW00ADD0B0 = (FIRST_FB_ADDR); /* Frame buffer start address */
rVIDW00ADD1B0 = (FIRST_FB_ADDR & 0xffffff) + (V_SCR_XSIZE * U_LCD_YSIZE * BYTE_PER_PIXEL);
/* Frame buffer end address */
rVIDW00ADD0B1 = (0); /* Frame buffer start address */
rVIDW00ADD1B1 = (V_SCR_XSIZE * U_LCD_YSIZE * BYTE_PER_PIXEL); /* Frame buffer end address */
rVIDW00ADD2 = (((V_SCR_XSIZE - U_LCD_XSIZE) * BYTE_PER_PIXEL) << 13) |
(U_LCD_XSIZE * BYTE_PER_PIXEL) << 0; /* Virtual screen controls */
rVIDINTCON0 = (0 << 0); /* 0 - 禁止LCD控制器所有中断*/
rVIDINTCON1 = (0 << 0); /* 0 - 禁止LCD控制器所有中断*/
/*
* 打开窗口0输出、LCD控制器输出
*/
rWINCON0 |= (1 << 0); /* 0 - 禁止窗口0输出 */
/* 1 - 使能窗口0输出----- -*/
rVIDCON0 |= (1 << 1) /* 0 - 不输出视频信号------*/
/* 1 - 输出视频信号 */
| (1 << 0); /* 0 - 帧尾视频信号被使能--*/
/* 1 - 帧尾视频信号被禁止 */
lcd_clear (0x001f); /* set lcd screen as blue */
lcd_enable();
_G_show_addr = (uint16 *)FIRST_FB_ADDR;
}
/*
* this is called from board_init() after the hardware has been set up
* and is usable. That seems like a good time to do this.
* Right now the return value is ignored.
*/
int do_auto_update(void)
{
block_dev_desc_t *stor_dev;
long sz;
int i, res = 0, cnt, old_ctrlc;
char *env;
long start, end;
#if 0 /* disable key-press detection to speed up boot-up time */
uchar keypad_status1[2] = {0,0}, keypad_status2[2] = {0,0};
/*
* Read keypad status
*/
i2c_read(I2C_PSOC_KEYPAD_ADDR, 0, 0, keypad_status1, 2);
mdelay(500);
i2c_read(I2C_PSOC_KEYPAD_ADDR, 0, 0, keypad_status2, 2);
/*
* Check keypad
*/
if ( !(keypad_status1[1] & KEYPAD_MASK_LO) ||
(keypad_status1[1] != keypad_status2[1])) {
return 0;
}
#endif
au_usb_stor_curr_dev = -1;
/* start USB */
if (usb_stop() < 0) {
debug ("usb_stop failed\n");
return -1;
}
if (usb_init() < 0) {
debug ("usb_init failed\n");
return -1;
}
/*
* check whether a storage device is attached (assume that it's
* a USB memory stick, since nothing else should be attached).
*/
au_usb_stor_curr_dev = usb_stor_scan(0);
if (au_usb_stor_curr_dev == -1) {
debug ("No device found. Not initialized?\n");
res = -1;
goto xit;
}
/* check whether it has a partition table */
stor_dev = get_dev("usb", 0);
if (stor_dev == NULL) {
debug ("uknown device type\n");
res = -1;
goto xit;
}
if (fat_register_device(stor_dev, 1) != 0) {
debug ("Unable to use USB %d:%d for fatls\n",
au_usb_stor_curr_dev, 1);
res = -1;
goto xit;
}
if (file_fat_detectfs() != 0) {
debug ("file_fat_detectfs failed\n");
}
/*
* now check whether start and end are defined using environment
* variables.
*/
start = -1;
end = 0;
env = getenv("firmware_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("firmware_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_FIRMWARE] = (end + 1) - start;
aufl_layout[IDX_FIRMWARE].start = start;
aufl_layout[IDX_FIRMWARE].end = end;
}
start = -1;
end = 0;
env = getenv("kernel_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("kernel_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_KERNEL] = (end + 1) - start;
aufl_layout[IDX_KERNEL].start = start;
aufl_layout[IDX_KERNEL].end = end;
}
start = -1;
end = 0;
env = getenv("rootfs_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("rootfs_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_ROOTFS] = (end + 1) - start;
aufl_layout[IDX_ROOTFS].start = start;
aufl_layout[IDX_ROOTFS].end = end;
}
/* make certain that HUSH is runnable */
u_boot_hush_start();
/* make sure that we see CTRL-C and save the old state */
old_ctrlc = disable_ctrlc(0);
/* validate the images first */
for (i = 0; i < AU_MAXFILES; i++) {
ulong imsize;
/* just read the header */
sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ());
debug ("read %s sz %ld hdr %d\n",
aufile[i], sz, image_get_header_size ());
if (sz <= 0 || sz < image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
ausize[i] = 0;
continue;
}
/* au_check_header_valid() updates ausize[] */
if ((imsize = au_check_header_valid(i, sz)) < 0) {
debug ("%s header not valid\n", aufile[i]);
continue;
}
/* totsize accounts for image size and flash erase size */
totsize += (imsize + (aufl_layout[i].end - aufl_layout[i].start));
}
#ifdef CONFIG_PROGRESSBAR
if (totsize) {
lcd_puts(" Update in progress\n");
lcd_enable();
}
#endif
/* just loop thru all the possible files */
for (i = 0; i < AU_MAXFILES && totsize; i++) {
if (!ausize[i]) {
continue;
}
sz = file_fat_read(aufile[i], LOAD_ADDR, ausize[i]);
debug ("read %s sz %ld hdr %d\n",
aufile[i], sz, image_get_header_size ());
if (sz != ausize[i]) {
printf ("%s: size %ld read %ld?\n", aufile[i], ausize[i], sz);
continue;
}
if (sz <= 0 || sz <= image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
if (au_check_cksum_valid(i, sz) < 0) {
debug ("%s checksum not valid\n", aufile[i]);
continue;
}
/* this is really not a good idea, but it's what the */
/* customer wants. */
cnt = 0;
do {
res = au_do_update(i, sz);
/* let the user break out of the loop */
if (ctrlc() || had_ctrlc()) {
clear_ctrlc();
break;
}
cnt++;
#ifdef AU_TEST_ONLY
} while (res < 0 && cnt < (AU_MAXFILES + 1));
if (cnt < (AU_MAXFILES + 1))
#else
} while (res < 0);
#endif
}
void lcd_reset(void)
{
uint32_t c, i, j;
uint8_t initdata[] =
{
//0x40| 1, LCD_CMD_RESET,
//0xC0|60,
//0xC0|60,
0x40| 1, LCD_CMD_DISPLAY_OFF,
0xC0|20,
0x40| 1, LCD_CMD_POWER_CTRLB,
0x80| 3, 0x00, 0x83, 0x30, //0x83 0x81 0xAA
0x40| 1, LCD_CMD_POWERON_SEQ_CTRL,
0x80| 4, 0x64, 0x03, 0x12, 0x81, //0x64 0x67
0x40| 1, LCD_CMD_DRV_TIMING_CTRLA,
0x80| 3, 0x85, 0x01, 0x79, //0x79 0x78
0x40| 1, LCD_CMD_POWER_CTRLA,
0x80| 5, 0x39, 0X2C, 0x00, 0x34, 0x02,
0x40| 1, LCD_CMD_PUMP_RATIO_CTRL,
0x80| 1, 0x20,
0x40| 1, LCD_CMD_DRV_TIMING_CTRLB,
0x80| 2, 0x00, 0x00,
0x40| 1, LCD_CMD_POWER_CTRL1,
0x80| 1, 0x26, //0x26 0x25
0x40| 1, LCD_CMD_POWER_CTRL2,
0x80| 1, 0x11,
0x40| 1, LCD_CMD_VCOM_CTRL1,
0x80| 2, 0x35, 0x3E,
0x40| 1, LCD_CMD_VCOM_CTRL2,
0x80| 1, 0xBE, //0xBE 0x94
0x40| 1, LCD_CMD_FRAME_CTRL,
0x80| 2, 0x00, 0x1B, //0x1B 0x70
0x40| 1, LCD_CMD_ENABLE_3G,
0x80| 1, 0x08, //0x08 0x00
0x40| 1, LCD_CMD_GAMMA,
0x80| 1, 0x01, //G2.2
0x40| 1, LCD_CMD_POS_GAMMA,
0x80|15, 0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0x87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00,
//0x80|15, 0x0F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0x87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00,
0x40| 1, LCD_CMD_NEG_GAMMA,
0x80|15, 0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F,
//0x80|15, 0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x0F,
0x40| 1, LCD_CMD_DISPLAY_CTRL,
0x80| 4, 0x0A, 0x82, 0x27, 0x00,
0x40| 1, LCD_CMD_ENTRY_MODE,
0x80| 1, 0x07,
0x40| 1, LCD_CMD_PIXEL_FORMAT,
0x80| 1, 0x55, //16bit
0x40| 1, LCD_CMD_MEMACCESS_CTRL,
0x80| 1, (1<<MEM_BGR) | (1<<MEM_X) | (1<<MEM_Y),
0x40| 1, LCD_CMD_COLUMN,
0x80| 2, 0x00, 0x00,
0x80| 2, ((LCD_HEIGHT-1)>>8)&0xFF, (LCD_HEIGHT-1)&0xFF,
0x40| 1, LCD_CMD_PAGE,
0x80| 2, 0x00, 0x00,
0x80| 2, ((LCD_WIDTH-1)>>8)&0xFF, (LCD_WIDTH-1)&0xFF,
0x40| 1, LCD_CMD_SLEEPOUT,
0xC0|60,
0xC0|60,
0x40| 1, LCD_CMD_DISPLAY_ON,
0xC0|20,
};
//init pins
INIT_PINS();
//hardware reset
GPIO_CLRPIN(LCD_PORT, RST_PIN);
delay_ms(20);
GPIO_SETPIN(LCD_PORT, RST_PIN);
delay_ms(120);
lcd_enable();
//send init commands and data
for(i=0; i<sizeof(initdata);)
{
c = initdata[i++];
switch(c&0xC0)
{
case 0x40: //command
for(j=c&0x3F; j!=0; j--)
{
c = initdata[i++];
lcd_wrcmd8(c);
}
break;
case 0x80: //data
for(j=c&0x3F; j!=0; j--)
{
c = initdata[i++];
lcd_wrdata8(c);
}
break;
case 0xC0: //delay
delay_ms(c&0x3F);
break;
}
}
//clear display buffer
lcd_drawstart();
for(i=(LCD_WIDTH*LCD_HEIGHT); i!=0; i--)
{
lcd_draw(0);
}
lcd_drawstop();
lcd_disable();
return;
}
void backlight_hw_on(void)
{
lcd_enable(true);
}
void lcd_ctrl_init_70(void *lcdbase)
{
ulong freq_lcdclk;
ulong freq_Hclk;
ulong fb_size;
unsigned char nn;
unsigned short *pp;
int i;
GPICON_REG = 0xaaaaaaaa;
GPIPUD_REG = 0xaaaaaaaa;
GPJCON_REG = 0xaaaaaaaa;
GPJPUD_REG = 0xaaaaaaaa;
lcd_disable();
S3C_WINCON0 &= (~(S3C_WINCONx_ENWIN_F_ENABLE));
MIFPCON_REG &= (~SEL_BYPASS_MASK);
SPCON_REG &= (~LCD_SEL_MASK);
SPCON_REG |= (RGB_IF_STYLE_MASK);
freq_lcdclk = S3CFB_PIXEL_CLOCK;
freq_Hclk = get_HCLK();
nn = (unsigned char)(freq_Hclk / freq_lcdclk) - 1;
if(freq_lcdclk < freq_Hclk/2)
{
S3C_VIDCON0 = S3C_VIDCON0_INTERLACE_F_PROGRESSIVE + S3C_VIDCON0_VIDOUT_RGB_IF + \
S3C_VIDCON0_PNRMODE_RGB_P + S3C_VIDCON0_CLKVALUP_ST_FRM + S3C_VIDCON0_CLKVAL_F(nn) + \
S3C_VIDCON0_CLKDIR_DIVIDED + S3C_VIDCON0_CLKSEL_F_HCLK;
}else
{
S3C_VIDCON0 = S3C_VIDCON0_INTERLACE_F_PROGRESSIVE + S3C_VIDCON0_VIDOUT_RGB_IF + \
S3C_VIDCON0_PNRMODE_RGB_P + S3C_VIDCON0_CLKVALUP_ST_FRM + S3C_VIDCON0_CLKVAL_F(0) + \
S3C_VIDCON0_CLKDIR_DIRECTED + S3C_VIDCON0_CLKSEL_F_HCLK;
}
nn = 0;
if(S3CFB_IVCLK)
{
nn += S3C_VIDCON1_IVCLK_RISE_EDGE;
}
if(S3CFB_IHSYNC)
{
nn += S3C_VIDCON1_IHSYNC_INVERT;
}
if(S3CFB_IVSYNC)
{
nn += S3C_VIDCON1_IVSYNC_INVERT;
}
if(S3CFB_IVDEN)
{
nn += S3C_VIDCON1_IVDEN_INVERT;
}
S3C_VIDCON1 = (unsigned int)nn;
S3C_VIDCON2 = 0;
S3C_VIDTCON0 = S3C_VIDTCON0_VBPD(S3CFB_VBP - 1) | S3C_VIDTCON0_VFPD(S3CFB_VFP - 1) | S3C_VIDTCON0_VSPW(S3CFB_VSW - 1);
S3C_VIDTCON1 = S3C_VIDTCON1_HBPD(S3CFB_HBP - 1) | S3C_VIDTCON1_HFPD(S3CFB_HFP -1) | S3C_VIDTCON1_HSPW(S3CFB_HSW - 1);
S3C_VIDTCON2 = S3C_VIDTCON2_LINEVAL(S3CFB_VRES - 1) | S3C_VIDTCON2_HOZVAL(S3CFB_HRES - 1);
#if LCD_BPP == LCD_COLOR32
S3C_WINCON0 = S3C_WINCONx_BPPMODE_F_24BPP_888;
S3C_WINCON1 = S3C_WINCONx_BPPMODE_F_24BPP_888 | S3C_WINCONx_BLD_PIX_PIXEL;
#else
S3C_WINCON0 = S3C_WINCONx_BPPMODE_F_16BPP_565 | S3C_WINCONx_HAWSWP_ENABLE;
S3C_WINCON1 = S3C_WINCONx_BPPMODE_F_16BPP_565 | S3C_WINCONx_HAWSWP_ENABLE | S3C_WINCONx_BLD_PIX_PIXEL;
#endif
S3C_WINCON2 = 0;
S3C_WINCON3 = 0;
S3C_WINCON4 = 0;
S3C_VIDOSD0A = S3C_VIDOSDxA_OSD_LTX_F(0) + S3C_VIDOSDxA_OSD_LTY_F(0);
S3C_VIDOSD0B = S3C_VIDOSDxB_OSD_RBX_F(S3CFB_HRES - 1) | S3C_VIDOSDxB_OSD_RBY_F(S3CFB_VRES - 1);
S3C_VIDOSD0C = S3C_VIDOSD0C_OSDSIZE(S3CFB_HRES*S3CFB_VRES);
S3C_VIDOSD1A = S3C_VIDOSDxA_OSD_LTX_F(0) + S3C_VIDOSDxA_OSD_LTY_F(0);
S3C_VIDOSD1B = S3C_VIDOSDxB_OSD_RBX_F(S3CFB_HRES - 1) | S3C_VIDOSDxB_OSD_RBY_F(S3CFB_VRES - 1);
S3C_VIDOSD1C = 0xDDD000;/*alpha blending*/
S3C_VIDOSD1D = S3C_VIDOSD0C_OSDSIZE(S3CFB_HRES*S3CFB_VRES);
S3C_VIDOSD2A = 0;
S3C_VIDOSD2B = 0;
S3C_VIDOSD2C = 0;
S3C_VIDOSD2D = 0;
S3C_VIDOSD3A = 0;
S3C_VIDOSD3B = 0;
S3C_VIDOSD3C = 0;
S3C_VIDOSD4A = 0;
S3C_VIDOSD4B = 0;
S3C_VIDOSD4C = 0;
fb_size = calc_fbsize();
S3C_VIDW00ADD0B0 = virt_to_phys(lcdbase);
S3C_VIDW00ADD0B1 = 0;
S3C_VIDW01ADD0B0 = virt_to_phys(osd_frame_buffer);
S3C_VIDW01ADD0B1 = 0;
S3C_VIDW02ADD0 = 0;
S3C_VIDW03ADD0 = 0;
S3C_VIDW04ADD0 = 0;
S3C_VIDW00ADD1B0 = virt_to_phys((unsigned int)(lcdbase) + fb_size);
S3C_VIDW00ADD1B1 = 0;
S3C_VIDW01ADD1B0 = virt_to_phys(osd_frame_buffer) + fb_size;
S3C_VIDW01ADD1B1 = 0;
S3C_VIDW02ADD1 = 0;
S3C_VIDW03ADD1 = 0;
S3C_VIDW04ADD1 = 0;
S3C_VIDW00ADD2 = 0;//S3C_VIDWxxADD2_OFFSIZE_F(0) | (S3C_VIDWxxADD2_PAGEWIDTH_F(panel_info.vl_col*panel_info.vl_bpix/8));
S3C_VIDW01ADD2 = 0;//S3C_VIDWxxADD2_OFFSIZE_F(0) | (S3C_VIDWxxADD2_PAGEWIDTH_F(panel_info.vl_col*panel_info.vl_bpix/8));
S3C_VIDW02ADD2 = 0;
S3C_VIDW03ADD2 = 0;
S3C_VIDW04ADD2 = 0;
S3C_W1KEYCON0 = S3C_WxKEYCON0_KEYBLEN_ENABLE | S3C_WxKEYCON0_KEYEN_F_ENABLE | S3C_WxKEYCON0_COMPKEY(0xFFFF);
S3C_W1KEYCON1 = 0x00000000;/*color key*/
#if 1
memset(lcdbase,0x00,fb_size*2);
#else
pp = lcdbase;
for(i=0;i< S3CFB_HRES * S3CFB_VRES;i++)
{
*pp = 0xf100;
pp++;
}
#endif
lcd_enable();
S3C_WINCON0 |= S3C_WINCONx_ENWIN_F_ENABLE;
S3C_WINCON1 |= S3C_WINCONx_ENWIN_F_ENABLE;
return (0);
}
void _backlight_off(void)
{
lcd_enable(false);
ascodec_write(0x25, ascodec_read(0x25) & ~2); /* lcd power */
ascodec_write_pmu(AS3543_BACKLIGHT, 1, 0x0);
}
void _backlight_on(void)
{
ascodec_write(0x25, ascodec_read(0x25) | 2); /* lcd power */
ascodec_write_pmu(AS3543_BACKLIGHT, 1, 0x90);
lcd_enable(true);
}
int enter_boot_power_down()
{
int key;
int ac;
power_gate_init();
lcd_disable();
video_dac_disable();
camera_power_off() ;
vcc2_power_off();
//turn_off_audio_DAC();
if (!early_suspend_flag) {
printf("\n boot_suspend \n");
// if (pdata->set_exgpio_early_suspend) {
// pdata->set_exgpio_early_suspend(OFF);
// }
early_power_gate_switch(OFF);
early_clk_switch(OFF);
early_pll_switch(OFF);
early_suspend_flag = 1;
}
printf("enter boot_pm_suspend!\n");
analog_switch(OFF);
usb_switch(OFF, 0);
usb_switch(OFF, 1);
// if (pdata->set_vccx2) {
// pdata->set_vccx2(OFF);
// }
power_gate_switch(OFF);
clk_switch(OFF);
pll_switch(OFF);
clrbits_le32(P_HHI_SYS_CPU_CLK_CNTL,1<<7); //change A9-->24M
printf("boot sleep ...\n");
// WRITE_MPEG_REG_BITS(HHI_MALI_CLK_CNTL, 0, 9, 3); // mali use xtal
// CLEAR_CBUS_REG_MASK(HHI_SYS_CPU_CLK_CNTL, 1<<7); // a9 use xtal
// SET_CBUS_REG_MASK(HHI_SYS_PLL_CNTL, (1 << 15)); // turn off sys pll
//
// meson_power_suspend();
key = powerkey_scan();
ac = axp_charger_is_ac_online();
while((!key)&&ac)
{
key = powerkey_scan();
ac = axp_charger_is_ac_online();
}
setbits_le32(P_HHI_SYS_CPU_CLK_CNTL,1<<7); //change A9-->normal
printf("boot... wake up\n");
// if (pdata->set_vccx2) {
// pdata->set_vccx2(ON);
// }
SET_CBUS_REG_MASK(HHI_SYS_CPU_CLK_CNTL, (1 << 7)); // a9 use pll
WRITE_MPEG_REG_BITS(HHI_MALI_CLK_CNTL, 3, 9, 3); // mali use pll
pll_switch(ON);
clk_switch(ON);
power_gate_switch(ON);
usb_switch(ON, 0);
usb_switch(ON, 1);
analog_switch(ON);
if (early_suspend_flag) {
early_pll_switch(ON);
early_clk_switch(ON);
early_power_gate_switch(ON);
early_suspend_flag = 0;
printf("boot sys_resume\n");
}
printf("mlvds init\n");
lcd_enable();
printf("mlvds init finish\n");
return ac;
}
int main()
{
char c;
init_uart();
lcd_init();
lcd_enable();
ts_init();
ts_calibrate();
printf("can update program with serial port\n\r");
while (1)
{
printf("[w] write the nand flash\n\r");
printf("[r] read the nand flash\n\r");
printf("[e] erase the nand flash\n\r");
printf("[g] get file, and write to nand flash 0 block\n\r");
printf("[x] get file to ddr(0x52000000), run it\n\r");
printf("[t] test lcd\n\r");
printf("[s] test touch screem\n\r");
do {
c = getc();
if (c == '\n' || c == '\r')
{
printf("\n\r");
}
else
{
putc(c);
}
} while (c == '\n' || c == '\r');
switch (c)
{
case 'w':
case 'W':
{
nand_write_test();
break;
}
case 'r':
case 'R':
{
nand_read_test();
break;
}
case 'e':
case 'E':
{
nand_erase_test();
break;
}
case 'g':
case 'G':
{
update_program();
break;
}
case 'x':
case 'X':
{
run_program();
break;
}
case 't':
case 'T':
{
lcd_test();
break;
}
case 's':
case 'S':
{
ts_test();
break;
}
}
}
return 0;
}
void backlight_hw_off(void)
{
lcd_enable(false);
}
void backlight_hw_on(void)
{
lcd_enable(true);
sleep(HZ/100); /* lcd needs time - avoid flashing for dark screens */
or_l(0x00020000, &GPIO1_OUT);
}
