Esempio n. 1
0
static void lcd_display_off(void)
{
    /* LQV shutdown sequence */
    lcd_write_reg(LTV_PWRCTL1,  (LTV_VCOMOUT_ENABLE | LTV_DRIVE_CURRENT(5) | LTV_SUPPLY_CURRENT(5)));
    sleep_ms(20);
    
    lcd_write_reg(LTV_PWRCTL1,  (LTV_DRIVE_CURRENT(5) | LTV_SUPPLY_CURRENT(5)));
    lcd_write_reg(LTV_GATECTL2, (LTV_NW_INV_1LINE | LTV_FTI(3) | LTV_FWI(3)));
    lcd_write_reg(LTV_PWRCTL2,  0);
    sleep_ms(20);
    
    lcd_write_reg(LTV_PWRCTL1,  0);
    sleep_ms(10);
    unsigned char temp[1];
    temp[0] = 0;
    spi_block_transfer(SPI_target_LTV250QV, temp, sizeof(temp), NULL, 0);
    
    IO_GIO_BITCLR2 = (1 << 4);
    sleep_ms(5);
    IO_GIO_BITCLR2 = (1 << 7);
    sleep_ms(5);
    IO_GIO_BITCLR2 = (1 << 0);
    sleep_ms(2);
    IO_GIO_BITCLR2 = (1 << 8);
    IO_GIO_BITCLR2 = (1 << 5);
    
    /* Disable main power */
    IO_GIO_BITCLR2 |= (1 << 3);
    
    enable_venc(false);
    
    lcd_on = false;
}
Esempio n. 2
0
/* void lcd_update_rect(int, int, int, int) ICODE_ATTR; */
void lcd_update_rect(int x, int y, int width, int height)
{
    const fb_data *addr;
    int ymax;

    /* The Y coordinates have to work on even 8 pixel rows */
    ymax = (y + height-1) >> 2;
    y >>= 2;

    if(x + width > LCD_WIDTH)
        width = LCD_WIDTH - x;
    if (width <= 0)
        return; /* nothing left to do, 0 is harmful to lcd_write_data() */
    if(ymax >= LCD_FBHEIGHT)
        ymax = LCD_FBHEIGHT-1;

    /* Copy specified rectange bitmap to hardware */
    for (; y <= ymax; y++)
    {
        lcd_write_reg(LCD_CNTL_PAGE, y);
        lcd_write_reg(LCD_CNTL_COLUMN, x);

        addr = &lcd_framebuffer[y][x];

        lcd_send_cmd(LCD_CNTL_DATA_WRITE);
        lcd_write_data(addr, width);
    }
}
Esempio n. 3
0
void unknown02(void)
{
    /* BOOT: 0x6308
       OF: 0x88D0C */

    lcd_write_reg(0x7, 0x160);
    lcd_write_reg(0x10, 0x17B1);
}
Esempio n. 4
0
/* unknown 01 and 02 - sleep or enable on and off funcs? */
void unknown01(void)
{
    /* BOOT: 0x62C4
       OF: 0x88CA0 */

    lcd_write_reg(0x10, 0x17B0);
    udelay(100);
    lcd_write_reg(0x7, 0x173);
}
Esempio n. 5
0
static void lcd_set_cursor(uint16_t x, uint16_t y){
	
	uint16_t temp;
	temp = y;
	y = x;
	x = MAX_Y - 1 - temp;
	
	lcd_write_reg(0x0020, x);
	lcd_write_reg(0x0021, y);
	lcd_write_index(0x0022);
}
static void lcd_sync_settings(void)
{
#ifdef HAVE_LCD_CONTRAST
    lcd_write_reg(0x0b, reg0x0b);
#endif
#ifdef HAVE_LCD_INVERT
    lcd_write_reg(0x27, reg0x27);
#endif
#ifdef HAVE_LCD_FLIP
    lcd_write_reg(0x06, reg0x06);
#endif
}
Esempio n. 7
0
static void lcd_enable_seq(bool enable)
{
    if(enable)
    {
        lcd_write_reg(0x11, NULL, 0);
        lcd_write_reg(0x29, NULL, 0);
    }
    else
    {
        lcd_write_reg(0x28, NULL, 0);
        lcd_write_reg(0x10, NULL, 0);
    }
}
Esempio n. 8
0
static void lcd_v1_set_gram_area(int x, int y, int width, int height)
{
    lcdctrl_bypass(1);
    LCDC_CTRL |= RGB24B;
    
    lcd_write_reg(0x03, x);
    lcd_write_reg(0x05, width-1);
    lcd_write_reg(0x07, y);
    lcd_write_reg(0x09, height-1);
    
    lcd_cmd(0x22);
    LCDC_CTRL &= ~RGB24B;
}
Esempio n. 9
0
void lcd_update_rect(int x, int y, int w, int h)
{
    #ifdef HAVE_LCD_ENABLE
    if(!lcd_on)
        return;
    #endif

    imx233_lcdif_wait_ready();
    lcd_write_reg(0x16, x | (x + w - 1) << 8);
    lcd_write_reg(0x17, y | (y + h - 1) << 8);
    lcd_write_reg(0x21, y * LCD_WIDTH + x);
    lcd_write_reg(0x22, 0);
    for(int yy = y; yy < y + h; yy++)
        imx233_lcdif_pio_send(true, 2 * w, FBADDR(x, yy));
}
void lcd_set_contrast(int val)
{
    reg0x0b = val & 0x3f;

    if (!lcd_on)
        return;

    lcd_write_reg(0x0b, reg0x0b);
}
void lcd_set_invert_display(bool yesno)
{
    reg0x27 = yesno ? 0x10 : 0x00;

    if (!lcd_on)
        return;

    lcd_write_reg(0x27, reg0x27);
}
Esempio n. 12
0
void lcd_set_point(uint16_t x, uint16_t y, uint16_t color){
	
	if( (x >= MAX_X) || (y >= MAX_Y)){
		return;
	}
	
	lcd_set_cursor(x, y);
	lcd_write_reg(0x0022,color);
}
void lcd_set_flip(bool yesno)
{
    reg0x06 = yesno ? 0x02 : 0x04;

    if (!lcd_on)
        return;

    lcd_write_reg(0x06, reg0x06);
}
Esempio n. 14
0
void lcd_update(void)
{
    const fb_data *addr;

    addr = FBADDR(LCD_WIDTH,LCD_HEIGHT);

    lcd_write_reg(0x20, 0x0);
    lcd_write_reg(0x21, 0x0);

    int i,j;
    for(i=0; i < LCD_HEIGHT; i++)
    {
        for(j=0; j < LCD_WIDTH; j++)
        {
            lcd_write_reg(0x22, *addr);
            addr++;
        }
    }
}
static void lcd_set_power(bool powered)
{
    if (powered)
    {
        lcd_powered = false;
        lcd_write_reg(0x04, 0x00);
        lcd_enable_interface(false);
        bitclr32(&GPIO3_DR, (1 << 12));
        mc13783_clear(MC13783_REGULATOR_MODE1, MC13783_VCAMEN);
    }
    else
    {
        mc13783_set(MC13783_REGULATOR_MODE1, MC13783_VCAMEN);
        bitset32(&GPIO3_DR, (1 << 12));
        lcd_enable_interface(true);
        lcd_write_reg(0x04, 0x01);
        lcd_powered = true;
    }
}
Esempio n. 16
0
void lcd_update(void)
{
    const fb_data *addr;

    addr = &lcd_framebuffer[LCD_HEIGHT][LCD_WIDTH];

    lcd_write_reg(0x20, 0x0);
    lcd_write_reg(0x21, 0x0);

    int i,j;
    for(i=0; i < LCD_HEIGHT; i++)
    {
        for(j=0; j < LCD_WIDTH; j++)
        {
            lcd_write_reg(0x22, *addr);
            addr++;
        }
    }
}
Esempio n. 17
0
static void lcd_init_seq(void)
{
    // seems compatible with ILI9163
    lcd_write_reg(1, NULL, 0); // software reset
    lcd_write_reg(0x11, NULL, 0); // sleep out
    mdelay(150);
    /* format: (<cmd> <data size> <data0> <dataN>)+ */
    static uint8_t init_seq[] =
    {
    /*  cmd  sz  data... */
        0x26, 1, 4, /* Gamma Set */
        0xb1, 2, 9, 0xd, /* Frame Rate */
        0xc0, 2, 8, 0, /* Power Control 1 */
        0xc1, 1, 5, /* Power Control 2 */
        0xc5, 2, 0x31, 0x40, /* VCOM Control 1 */
        0xc7, 1, 0xc8, /* VCOM Offset Control */
        0xec, 1, 0xc, /* Unknown */
        0x3a, 1, 5, /* Interface Pixel Format */
        0x2a, 4, 0, 0, 0, 0x7f, /* Column Address */
        0x2b, 4, 0, 0, 0, 0x9f, /* Page Address Set */
        0x35, 1, 0, /* Tear Effect Line On */
        0x36, 1, 0xc8, /* Memory access Control */
        0xb4, 1, 0, /* Display Inversion */
        0xb7, 1, 0, /* Source Driver Direction Control */
        0xb8, 1, 0, /* Gate Driver Direction Control */
        0xf2, 1, 1, /* Gamma Adjustment */
        0xe0, 15, 0x3f, 0x20, 0x1d, 0x2d, 0x26, 0x0c, 0x4b, 0xb7,
                  0x39, 0x17, 0x1d, 0x16, 0x16, 0x10, 0x00, /* Positive Gamma */
        0xe1, 15, 0x00, 0x1f, 0x21, 0x12, 0x18, 0x13, 0x34, 0x48,
                  0x46, 0x08, 0x21, 0x29, 0x28, 0x2f, 0x3f, /* Negative Gamma */
        0x29, 0, /* Display On */
    };

    for(unsigned i = 0; i < sizeof(init_seq); )
    {
        lcd_write_reg(init_seq[i], &init_seq[i + 2], init_seq[i + 1]);
        i += 2 + init_seq[i + 1];
    }
}
Esempio n. 18
0
static void lcd_v1_enable (bool on)
{
    if (on == display_on)
        return;

    lcdctrl_bypass(1);
    LCDC_CTRL |= RGB24B;

    if (on)
    {
        lcd_write_reg(0x18, 0x44);
        lcd_write_reg(0x21, 0x01);
        lcd_write_reg(0x01, 0x00);
        lcd_write_reg(0x1C, 0x03);
        lcd_write_reg(0x19, 0x06);
        udelay(5);
        lcd_write_reg(0x26, 0x84);
        udelay(40);
        lcd_write_reg(0x26, 0xB8);
        udelay(40);
        lcd_write_reg(0x26, 0xBC);
    }
    else
    {
        lcd_write_reg(0x26, 0xB8);
        udelay(40);
        lcd_write_reg(0x19, 0x01);
        udelay(40);
        lcd_write_reg(0x26, 0xA4);
        udelay(40);
        lcd_write_reg(0x26, 0x84);
        udelay(40);
        lcd_write_reg(0x1C, 0x00);
        lcd_write_reg(0x01, 0x02);
        lcd_write_reg(0x21, 0x00);
    }
    display_on = on;

    LCDC_CTRL &= ~RGB24B;
}
Esempio n. 19
0
void lcd_init_device(void)
{
#if 0
    /* This is the init sequence from the yh820 OF bootloader */
    unsigned long tmp;

    DEV_INIT2 |= 0x400;

    DEV_INIT1 &= ~0x3000;
    tmp = DEV_INIT1;
    DEV_INIT1 = tmp;
    DEV_INIT2 &= ~0x400;

    LCD1_CONTROL &= ~0x4;
    udelay(15);
    LCD1_CONTROL |= 0x4;

    LCD1_CONTROL = 0x680;
    LCD1_CONTROL = 0x684;

    LCD1_CONTROL |= 0x1;

    lcd_send_cmd(LCD_CNTL_RESET);
    lcd_send_cmd(LCD_CNTL_DISCHARGE_ON_OFF | 0);
    lcd_send_cmd(LCD_CNTL_ON_OFF | 0); /* LCD OFF */
    lcd_send_cmd(LCD_CNTL_COLUMN_ADDRESS_DIR | 0);   /* Normal */
    lcd_send_cmd(LCD_CNTL_COMMON_OUTPUT_STATUS | 0); /* Normal */
    lcd_send_cmd(LCD_CNTL_REVERSE | 0); /* Reverse OFF */
    lcd_send_cmd(LCD_CNTL_ALL_LIGHTING | 0); /* Normal */
    lcd_write_reg_ex(LCD_CNTL_DUTY_SET, 0x1f, 0x00);
    lcd_send_cmd(LCD_CNTL_OFF_MODE | 1); /* OFF -> VCC on drivers */
    lcd_write_reg(LCD_CNTL_VOLTAGE_SELECT, 0x03);
    lcd_write_reg(LCD_CNTL_ELECTRONIC_VOLUME, 0x40);
    lcd_write_reg(LCD_CNTL_TEMP_GRADIENT_SELECT, 0x00);
    lcd_write_reg(LCD_CNTL_LINE_INVERT_DRIVE, 0x1f);
    lcd_send_cmd(LCD_CNTL_NLINE_ON_OFF | 1); /* N-line ON */
    lcd_write_reg(LCD_CNTL_OSC_FREQUENCY, 0x00);
    lcd_send_cmd(LCD_CNTL_OSC_ON_OFF | 1); /* Oscillator ON */
    lcd_write_reg(LCD_CNTL_STEPUP_CK_FREQ, 0x03);
    lcd_write_reg(LCD_CNTL_POWER_CONTROL, 0x1c);
    lcd_write_reg(LCD_CNTL_POWER_CONTROL, 0x1e);
    lcd_write_reg(LCD_CNTL_DISPLAY_START_LINE, 0x00);
    lcd_send_cmd(LCD_CNTL_DATA_INPUT_DIR | 0); /* Column mode */
    lcd_send_cmd(LCD_CNTL_DISPLAY_MODE, 0); /* Greyscale mode */
    lcd_write_reg(LCD_CNTL_GRAY_SCALE_PATTERN, 0x52);
    lcd_send_cmd(LCD_CNTL_PARTIAL_DISPLAY_ON_OFF | 0);
    lcd_write_reg(LCD_CNTL_POWER_CONTROL, 0x1f);
    lcd_send_cmd(LCD_CNTL_ON_OFF | 1); /* LCD ON */
#endif
}
Esempio n. 20
0
static void lcd_v2_display_init(void)
{
    unsigned int x, y;

    lcd_write_reg(0xD0, 0x0003);
    lcd_write_reg(0xEB, 0x0B00);
    lcd_write_reg(0xEC, 0x00CF);
    lcd_write_reg(0xC7, 0x030F);

    lcd_write_reg(0x01, 0x001C);
    lcd_write_reg(0x02, 0x0100);
    lcd_write_reg(0x03, 0x1038);
    lcd_write_reg(0x07, 0x0000);
    lcd_write_reg(0x08, 0x0808);
    lcd_write_reg(0x0F, 0x0901);
    lcd_write_reg(0x10, 0x0000);
    lcd_write_reg(0x11, 0x1B41);
    lcd_write_reg(0x12, 0x2010);
    lcd_write_reg(0x13, 0x0009);
    lcd_write_reg(0x14, 0x4C65);

    lcd_write_reg(0x30, 0x0000);
    lcd_write_reg(0x31, 0x00DB);
    lcd_write_reg(0x32, 0x0000);
    lcd_write_reg(0x33, 0x0000);
    lcd_write_reg(0x34, 0x00DB);
    lcd_write_reg(0x35, 0x0000);
    lcd_write_reg(0x36, 0x00AF);
    lcd_write_reg(0x37, 0x0000);
    lcd_write_reg(0x38, 0x00DB);
    lcd_write_reg(0x39, 0x0000);

    lcd_write_reg(0x50, 0x0000);
    lcd_write_reg(0x51, 0x0705);
    lcd_write_reg(0x52, 0x0C0A);
    lcd_write_reg(0x53, 0x0401);
    lcd_write_reg(0x54, 0x040C);
    lcd_write_reg(0x55, 0x0608);
    lcd_write_reg(0x56, 0x0000);
    lcd_write_reg(0x57, 0x0104);
    lcd_write_reg(0x58, 0x0E06);
    lcd_write_reg(0x59, 0x060E);

    lcd_write_reg(0x20, 0x0000);
    lcd_write_reg(0x21, 0x0000);

    lcd_write_reg(0x07, 0x1017);

    lcd_write_reg(0x20, 0x00AF);
    lcd_write_reg(0x21, 0x0000);

    lcd_cmd(0x22);

    for (x=0; x<LCD_WIDTH; x++)
        for(y=0; y<LCD_HEIGHT; y++)
            lcd_data(0x00);

    display_on = true;
}
Esempio n. 21
0
void lcd_v1_display_init(void)
{
    unsigned int x, y;

    /* Driving ability setting */
    lcd_write_reg(0x60, 0x00);
    lcd_write_reg(0x61, 0x06);
    lcd_write_reg(0x62, 0x00);
    lcd_write_reg(0x63, 0xC8);

    /* Gamma 2.2 Setting */
    lcd_write_reg(0x40, 0x00);
    lcd_write_reg(0x41, 0x40);
    lcd_write_reg(0x42, 0x45);
    lcd_write_reg(0x43, 0x01);
    lcd_write_reg(0x44, 0x60);
    lcd_write_reg(0x45, 0x05);
    lcd_write_reg(0x46, 0x0C);
    lcd_write_reg(0x47, 0xD1);
    lcd_write_reg(0x48, 0x05);

    lcd_write_reg(0x50, 0x75);
    lcd_write_reg(0x51, 0x01);
    lcd_write_reg(0x52, 0x67);
    lcd_write_reg(0x53, 0x14);
    lcd_write_reg(0x54, 0xF2);
    lcd_write_reg(0x55, 0x07);
    lcd_write_reg(0x56, 0x03);
    lcd_write_reg(0x57, 0x49);

    /* Power voltage setting */
    lcd_write_reg(0x1F, 0x03);
    lcd_write_reg(0x20, 0x00);
    lcd_write_reg(0x24, 0x28);
    lcd_write_reg(0x25, 0x45);

    lcd_write_reg(0x23, 0x2F);

    /* Power on setting */
    lcd_write_reg(0x18, 0x44);
    lcd_write_reg(0x21, 0x01);
    lcd_write_reg(0x01, 0x00);
    lcd_write_reg(0x1C, 0x03);
    lcd_write_reg(0x19, 0x06);
    udelay(5);

    /* Display on setting */
    lcd_write_reg(0x26, 0x84);
    udelay(40);
    lcd_write_reg(0x26, 0xB8);
    udelay(40);
    lcd_write_reg(0x26, 0xBC);
    udelay(40);

    /* Memmory access setting */
    lcd_write_reg(0x16, 0x68);
    /* Setup 16bit mode */
    lcd_write_reg(0x17, 0x05);

    /* Set GRAM area */
    lcd_write_reg(0x02, 0x00);
    lcd_write_reg(0x03, 0x00);
    lcd_write_reg(0x04, 0x00);
    lcd_write_reg(0x05, LCD_WIDTH - 1);
    lcd_write_reg(0x06, 0x00);
    lcd_write_reg(0x07, 0x00);
    lcd_write_reg(0x08, 0x00);
    lcd_write_reg(0x09, LCD_HEIGHT - 1);

    /* Start GRAM write */
    lcd_cmd(0x22);

    for (x=0; x<LCD_WIDTH; x++)
        for(y=0; y<LCD_HEIGHT; y++)
            lcd_data(0x00);

    display_on = true;
}
Esempio n. 22
0
/* Run the powerup sequence for the driver IC */
static void lcd_power_on(void)
{
    lcd_reset();
    /* OF: 0x5DC0 *
    * r2: cmd    *
    * r3: data   */
    lcd_write_reg(0xE5, 0x8000);
    lcd_write_reg(0x0, 0x1);
    lcd_write_reg(0x1, 0x100);
    lcd_write_reg(0x2, 0x700);
    lcd_write_reg(0x3, 0x1230);
    lcd_write_reg(0x4, 0x0);
    lcd_write_reg(0x8, 0x408);
    lcd_write_reg(0x9, 0x0);
    lcd_write_reg(0xa, 0x0);
    lcd_write_reg(0xd, 0x0);
    lcd_write_reg(0xf, 0x2);
    lcd_write_reg(0x10, 0x0);
    lcd_write_reg(0x11, 0x0);
    lcd_write_reg(0x12, 0x0);
    lcd_write_reg(0x13, 0x0);
    sleep(HZ/5);
    lcd_write_reg(0x10, 0x17B0);
    lcd_write_reg(0x11, 0x7);
    sleep(HZ/20);
    lcd_write_reg(0x12, 0x13c);
    sleep(HZ/20);

    /* BOOT: BNE 0x5fb2 */

    if (lcd_type == 0)
    {
        lcd_write_reg(0x13, 0x1700);
        lcd_write_reg(0x29, 0x10);
        sleep(HZ/10);
        lcd_write_reg(0x20, 0x0);
        lcd_write_reg(0x21, 0x0);

        lcd_write_reg(0x30, 0x7);
        lcd_write_reg(0x31, 0x403);
        lcd_write_reg(0x32, 0x400);
        lcd_write_reg(0x35, 0x3);
        lcd_write_reg(0x36, 0xF07);
        lcd_write_reg(0x37, 0x606);
        lcd_write_reg(0x38, 0x106);
        lcd_write_reg(0x39, 0x7);
    }
    else
    {
        lcd_write_reg(0x13, 0x1800);
        lcd_write_reg(0x29, 0x13);
        sleep(HZ/10);
        lcd_write_reg(0x20, 0x0);
        lcd_write_reg(0x21, 0x0);

        lcd_write_reg(0x30, 0x2);
        lcd_write_reg(0x31, 0x606);
        lcd_write_reg(0x32, 0x501);
        lcd_write_reg(0x35, 0x206);
        lcd_write_reg(0x36, 0x504);
        lcd_write_reg(0x37, 0x707);
        lcd_write_reg(0x38, 0x306);
        lcd_write_reg(0x39, 0x9);
    }

    /* BOOT: 0x6066 */
    lcd_write_reg(0x3c, 0x700);
    lcd_write_reg(0x3d, 0x700);

    lcd_write_reg(0x50, 0x0);
    lcd_write_reg(0x51, 0xef);  /* 239 - LCD_WIDTH */
    lcd_write_reg(0x52, 0x0);
    lcd_write_reg(0x53, 0x13f); /* 319 - LCD_HEIGHT */

    /* BOOT: b 0x6114 */
    lcd_write_reg(0x60, 0x2700);
    lcd_write_reg(0x61, 0x1);
    lcd_write_reg(0x6a, 0x0);

    lcd_write_reg(0x80, 0x0);
    lcd_write_reg(0x81, 0x0);
    lcd_write_reg(0x82, 0x0);
    lcd_write_reg(0x83, 0x0);
    lcd_write_reg(0x84, 0x0);
    lcd_write_reg(0x85, 0x0);

    /* BOOT: 0x61A8 */
    lcd_write_reg(0x90, 0x10);
    lcd_write_reg(0x92, 0x0);
    lcd_write_reg(0x93, 0x3);
    lcd_write_reg(0x95, 0x110);
    lcd_write_reg(0x97, 0x0);
    lcd_write_reg(0x98, 0x0);

    lcd_write_reg(0xc, 0x110);
    lcd_write_reg(0x7, 0x173);
    sleep(HZ/10);

    power_on = true;
}
Esempio n. 23
0
void lcd_update_rect(int x, int y, int w, int h)
{
#ifdef HAVE_LCD_ENABLE
    if(!lcd_on)
        return;
#endif
    /* make sure the rectangle is included in the screen */
    x = MIN(x, LCD_WIDTH);
    y = MIN(y, LCD_HEIGHT);
    w = MIN(w, LCD_WIDTH - x);
    h = MIN(h, LCD_HEIGHT - y);

    imx233_lcdif_wait_ready();
    uint32_t window = x << 8 | (x + w - 1) << 24;
    lcd_write_reg(0x2a, &window, sizeof(window));
    window = y << 8 | (y + h - 1) << 24;
    lcd_write_reg(0x2b, &window, sizeof(window));
    lcd_write_reg(0x2c, NULL, 0);

    imx233_lcdif_wait_ready();
    imx233_lcdif_set_data_swizzle(3);
    imx233_lcdif_set_word_length(8);
    /* there are two cases here:
     * - either width = LCD_WIDTH and we can directly memcopy a part of lcd_framebuffer to FRAME
     *   and send it
     * - either width != LCD_WIDTH and we have to build a contiguous copy of the rectangular area
     *   into FRAME before sending it (which is slower and doesn't use the hardware)
     * In all cases, FRAME just acts as a temporary buffer.
     * NOTE It's more interesting to do a copy to FRAME in all cases since in system mode
     * the clock runs at 24MHz which provides barely 10MB/s bandwidth compared to >100MB/s
     * for memcopy operations
     */
    if(w == LCD_WIDTH)
    {
        memcpy((void *)FRAME, FBADDR(x,y), w * h * sizeof(fb_data));
    }
    else
    {
        for(int i = 0; i < h; i++)
            memcpy((fb_data *)FRAME + i * w, FBADDR(x,y + i), w * sizeof(fb_data));
    }
    /* WARNING The LCDIF has a limitation on the vertical count ! In 16-bit packed mode
     * (which we used, ie 16-bit per pixel, 2 pixels per 32-bit words), the v_count
     * field must be a multiple of 2. Furthermore, it seems the lcd controller doesn't
     * really like when both w and h are even, probably because the writes to the GRAM
     * are done on several words and the controller requires dummy writes.
     * The workaround is to always make sure that we send a number of pixels which is
     * a multiple of 4 so that both the lcdif and the controller are happy. If any
     * of w or h is odd, we will send a copy of the first pixels as dummy writes. We will
     * send at most 3 bytes. We then send (w * h + 3) / 4 x 4 bytes.
     */
    if(w % 2 == 1 || h % 2 == 1)
    {
        /* copy three pixel after the last one */
        for(int i = 0; i < 3; i++)
            *((fb_data *)FRAME + w * h + i) = *((fb_data *)FRAME + i);
        /* WARNING we need to update w and h to reflect the pixel count BUT it
         * has no relation to w * h (it can even be 2 * prime). Hopefully, w <= 240 and
         * h <= 320 so w * h <= 76800 and (w * h + 3) / 4 <= 38400 which fits into
         * a 16-bit integer (horizontal count). */
        h = (w * h + 3) / 4;
        w = 4;
    }
    imx233_lcdif_dma_send((void *)FRAME_PHYS_ADDR, w * 2, h);
}
Esempio n. 24
0
void lcd_init_device(void)
{
    /* clock at 24MHZ */
    imx233_clkctrl_enable(CLK_PIX, false);
    imx233_clkctrl_set_div(CLK_PIX, 3);
    imx233_clkctrl_set_bypass(CLK_PIX, true); /* use XTAL */
    imx233_clkctrl_enable(CLK_PIX, true);
    imx233_lcdif_init();
    imx233_lcdif_setup_system_pins(8);
    imx233_lcdif_set_timings(2, 2, 2, 2);
    imx233_lcdif_set_word_length(8);

    lcd_write_reg(0, 1);
    lcd_write_reg(3, 0);

    lcd_write_reg(3, 0x510);
    lcd_write_reg(9, 8);
    lcd_write_reg(0xc, 0);
    lcd_write_reg(0xd, 0);
    lcd_write_reg(0xe, 0);
    lcd_write_reg(0x5b, 4);
    lcd_write_reg(0xd, 0x10);
    lcd_write_reg(9, 0);
    lcd_write_reg(3, 0x10);
    lcd_write_reg(0xd, 0x14);
    lcd_write_reg(0xe, 0x2b12);
    lcd_write_reg(1, 0x21f);
    lcd_write_reg(2, 0x700);
    lcd_write_reg(5, 0x30);
    lcd_write_reg(6, 0);
    lcd_write_reg(8, 0x202);
    lcd_write_reg(0xa, 0x3); // OF uses 0xc0003 with 3 transfers/pixels
    lcd_write_reg(0xb, 0);
    lcd_write_reg(0xf, 0);
    lcd_write_reg(0x10, 0);
    lcd_write_reg(0x11, 0);
    lcd_write_reg(0x14, 0x9f00);
    lcd_write_reg(0x15, 0x9f00);
    lcd_write_reg(0x16, 0x7f00);
    lcd_write_reg(0x17, 0x9f00);
    lcd_write_reg(0x20, 0);
    lcd_write_reg(0x21, 0);
    lcd_write_reg(0x23, 0);
    lcd_write_reg(0x24, 0);
    lcd_write_reg(0x25, 0);
    lcd_write_reg(0x26, 0);
    lcd_write_reg(0x30, 0x707);
    lcd_write_reg(0x31, 0x504);
    lcd_write_reg(0x32, 7);
    lcd_write_reg(0x33, 0x307);
    lcd_write_reg(0x34, 7);
    lcd_write_reg(0x35, 0x400);
    lcd_write_reg(0x36, 0x607);
    lcd_write_reg(0x37, 0x703);
    lcd_write_reg(0x3a, 0x1a0d);
    lcd_write_reg(0x3b, 0x1309);

    lcd_write_reg(9, 4);
    lcd_write_reg(7, 5);
    lcd_write_reg(7, 0x25);
    lcd_write_reg(7, 0x27);
    lcd_write_reg(0x5b, 0);
    lcd_write_reg(7, 0x37);
#ifdef HAVE_LCD_ENABLE
    lcd_on = true;
#endif
}
Esempio n. 25
0
void lcd_initialize(void){
	
	uint32_t i = 0x1fffff;
	
	lcd_line_init();
	
	lcd_fsmc_initialize();
	
	while(i--);
	
	lcd_write_reg(0x00e7,0x0010);
	lcd_write_reg(0x0000,0x0001);
	
	lcd_write_reg(0x0001,(0<<10)|(1<<8));
	
	lcd_write_reg(0x0002,0x0700);
	lcd_write_reg(0x0003,(1<<12)|(1<<5)|(0<<4)|(1<<3));
	lcd_write_reg(0x0004,0x0000);
	lcd_write_reg(0x0008,0x0207);
	lcd_write_reg(0x0009,0x0000);
	lcd_write_reg(0x000a,0x0000);
	lcd_write_reg(0x000c,0x0001);
	lcd_write_reg(0x000d,0x0000);
	lcd_write_reg(0x000f,0x0000);
	lcd_write_reg(0x0010,0x0000);
	lcd_write_reg(0x0011,0x0007);
	lcd_write_reg(0x0012,0x0000);
	lcd_write_reg(0x0013,0x0000);
	lcd_delay(50);
	lcd_write_reg(0x0010,0x1590);
	lcd_write_reg(0x0011,0x0227);
	lcd_delay(50);
	lcd_write_reg(0x0012,0x009c);
	lcd_delay(50);
	lcd_write_reg(0x0013,0x1900);
	lcd_write_reg(0x0029,0x0023);
	lcd_write_reg(0x002b,0x000e);
	lcd_delay(50);
	lcd_delay(50);
	lcd_write_reg(0x0030,0x0007);
	lcd_write_reg(0x0031,0x0707);
	lcd_write_reg(0x0032,0x0006);
	lcd_write_reg(0x0035,0x0704);
	lcd_write_reg(0x0036,0x1f04);
	lcd_write_reg(0x0037,0x0004);
	lcd_write_reg(0x0038,0x0000);
	lcd_write_reg(0x0039,0x0706);
	lcd_write_reg(0x003c,0x0701);
	lcd_write_reg(0x003d,0x000f);
	lcd_delay(50);
	lcd_write_reg(0x0050,0x0000);
	lcd_write_reg(0x0051,0x00ef);
	lcd_write_reg(0x0052,0x0000);
	lcd_write_reg(0x0053,0x013f);
	lcd_write_reg(0x0060,0xa700);
	lcd_write_reg(0x0061,0x0001);
	lcd_write_reg(0x006a,0x0000);
	lcd_write_reg(0x0080,0x0000);
	lcd_write_reg(0x0081,0x0000);
	lcd_write_reg(0x0082,0x0000);
	lcd_write_reg(0x0083,0x0000);
	lcd_write_reg(0x0084,0x0000);
	lcd_write_reg(0x0085,0x0000);
	lcd_write_reg(0x0090,0x0010);
	lcd_write_reg(0x0092,0x0600);
	lcd_write_reg(0x0093,0x0003);
	lcd_write_reg(0x0095,0x0110);
	lcd_write_reg(0x0097,0x0000);
	lcd_write_reg(0x0098,0x0000);
	lcd_write_reg(0x0007,0x0133);
}
Esempio n. 26
0
void lcd_set_cursor(u16 x, u16 y) {
    lcd_write_reg(0x20, x);
    lcd_write_reg(0x21, y);
}
Esempio n. 27
0
void lcd_set_window(u16 left, u16 top, u16 right, u16 bottom) {
    lcd_write_reg(0x50, sat(left, 0, LCD_WIDTH-1));
    lcd_write_reg(0x51, sat(right-1, 0, LCD_WIDTH-1));
    lcd_write_reg(0x52, sat(top, 0, LCD_HEIGHT-1));
    lcd_write_reg(0x53, sat(bottom-1, 0, LCD_HEIGHT-1));
}
Esempio n. 28
0
static void lcd_display_on(bool reset)
{  
    /* Enable main power */
    IO_GIO_BITSET2 |= (1 << 3);
    
    /* power on sequence as per the ZVM firmware */
    sleep_ms(250);
    IO_GIO_BITSET1 = (1 << 13);
    sleep_ms(5);
    IO_GIO_BITSET2 = (1 << 5);
    IO_GIO_BITSET2 = (1 << 8);
    sleep_ms(1);
    
    /*Init SPI here... */
    sleep_ms(32);
    
    IO_GIO_BITSET2 = (1 << 0);
    sleep_ms(5);
    IO_GIO_BITSET2 = (1 << 7);
    sleep_ms(5);
    IO_GIO_BITSET2 = (1 << 4);
    sleep_ms(5);
    IO_GIO_BITCLR2 = (1 << 8);
    /*TODO: figure out what OF does after this... */
    IO_GIO_BITSET2 = (1 << 8);
    sleep_ms(1);
    
    lcd_write_reg(LTV_IFCTL,     LTV_NL(29));
    lcd_write_reg(LTV_DATACTL,   0);
    lcd_write_reg(LTV_ENTRY_MODE,0);
    lcd_write_reg(LTV_GATECTL1,  0);
    lcd_write_reg(LTV_GATECTL2,  (LTV_NW_INV_1LINE | LTV_FHN | LTV_FTI(2) | LTV_FWI(3)));
    lcd_write_reg(LTV_VBP,       0);
    lcd_write_reg(LTV_HBP,       0);
    lcd_write_reg(LTV_SOTCTL,    0);
    lcd_write_reg(LTV_PWRCTL1,   0);
    lcd_write_reg(LTV_PWRCTL2,   0);
    lcd_write_reg(LTV_GAMMA(0),  0);
    lcd_write_reg(LTV_GAMMA(1),  0);
    lcd_write_reg(LTV_GAMMA(2),  0);
    lcd_write_reg(LTV_GAMMA(3),  0);
    lcd_write_reg(LTV_GAMMA(4),  0);
    lcd_write_reg(LTV_GAMMA(5),  0);
    lcd_write_reg(LTV_GAMMA(6),  0);
    lcd_write_reg(LTV_GAMMA(7),  0);
    lcd_write_reg(LTV_GAMMA(8),  0);
    lcd_write_reg(LTV_GAMMA(9),  0);
    sleep_ms(10);
    
    lcd_write_reg(LTV_PWRCTL1,   (LTV_VCOM_DISABLE | LTV_DRIVE_CURRENT(5) | LTV_SUPPLY_CURRENT(5)));
    lcd_write_reg(LTV_PWRCTL2,   0);
    sleep_ms(40);
    
    lcd_write_reg(LTV_PWRCTL2,   LTV_VCOML_ENABLE);
    sleep_ms(40);
    
    lcd_write_reg(LTV_IFCTL,     (LTV_NMD | LTV_NL(29)));
    lcd_write_reg(LTV_DATACTL,   (LTV_DS_SAME | LTV_CHS_480 | LTV_DF_RGB | LTV_RGB_BGR));
    lcd_write_reg(LTV_ENTRY_MODE,(LTV_VSPL_ACTIVE_LOW | LTV_HSPL_ACTIVE_LOW | LTV_DPL_SAMPLE_RISING | LTV_EPL_ACTIVE_LOW | LTV_SS_RIGHT_TO_LEFT));
    lcd_write_reg(LTV_GATECTL1,  LTV_CLW(1));
    lcd_write_reg(LTV_GATECTL2,  (LTV_NW_INV_1LINE | LTV_DSC | LTV_FTI(3) | LTV_FWI(3)));
    lcd_write_reg(LTV_VBP,       0x5);
    lcd_write_reg(LTV_HBP,       0x1B);
    lcd_write_reg(LTV_SOTCTL,    LTV_SDT(2));
    lcd_write_reg(LTV_GAMMA(0),  0x203);
    lcd_write_reg(LTV_GAMMA(1),  0x302);
    lcd_write_reg(LTV_GAMMA(2),  0xC08);
    lcd_write_reg(LTV_GAMMA(3),  0xC08);
    lcd_write_reg(LTV_GAMMA(4),  0x707);
    lcd_write_reg(LTV_GAMMA(5),  0x707);
    lcd_write_reg(LTV_GAMMA(6),  0x104);
    lcd_write_reg(LTV_GAMMA(7),  0x306);
    lcd_write_reg(LTV_GAMMA(8),  0);
    lcd_write_reg(LTV_GAMMA(9),  0);
    sleep_ms(60);
    
    lcd_write_reg(LTV_PWRCTL1,   (LTV_VCOMOUT_ENABLE | LTV_POWER_ON | LTV_DRIVE_CURRENT(5) | LTV_SUPPLY_CURRENT(5)));
    lcd_write_reg(LTV_PWRCTL2,   (LTV_VCOML_VOLTAGE(17) | LTV_VCOMH_VOLTAGE(26))); /* VCOML=0,0625V VCOMH=1,21875V */
    sleep_ms(10);

    if(!reset)
    {
        enable_venc(true);
        /* Re-enable video encoder */
        IO_VID_ENC_VMOD |= VENC_VMOD_VENC;
    }
    /* tell that we're on now */
    lcd_on = true;
}