ssd1963.c

Go to the documentation of this file.

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*----- Header-Files -------------------------------------------------------*/
#include <stdint.h>                 /* Standard integer formats             */
#include "ssd1963.h"                /* SSD1963 Graphic-Controller           */
#include "ssd1963_lld.h"            /* SSD1963 Graphic-Controller driver    */
#include "ssd1963_cmd.h"            /* SSD1963 Graphic-Controller commands  */
#include "lcd_conf.h"               /* LCD configuration                    */

/*----- Macros -------------------------------------------------------------*/

/*----- Data types ---------------------------------------------------------*/

/*----- Function prototypes ------------------------------------------------*/

/*----- Data ---------------------------------------------------------------*/
static uint16_t deviceDescriptorBlock[3];

/*----- Implementation -----------------------------------------------------*/
static void SSD1963_Delay(uint32_t nCount) {

    volatile uint32_t index = 0;

    for (index = (100000 * nCount); index != 0; index--)
        ;
}

void SSD1963_Init(void) {

    SSD1963_LLD_Init();

    SSD1963_GetDeviceDescriptorBlock(deviceDescriptorBlock);

    /* Software reset */
    SSD1963_WriteCommand(CMD_SOFT_RESET);
    SSD1963_Delay(10);

    SSD1963_WriteCommand(CMD_SET_PLL_MN);       /* Set PLL with OSC = 8 MHz */
    SSD1963_WriteData(0x002C);  /* Multiplier N = 44,
                                 * VCO (>250MHz) = OSC*(N+1), VCO = 360MHz  */
    SSD1963_WriteData(0x0002);  /* Divider M = 3, PLL = 360/(M+1) = 120MHz  */
    SSD1963_WriteData(0xA5);    /* Validate M and N values                  */

    SSD1963_WriteCommand(CMD_PLL_START);        /* Start PLL command        */
    SSD1963_WriteData(0x01);                    /* Enable PLL               */
    SSD1963_Delay(10);                          /* Wait to stabilize        */

    SSD1963_WriteCommand(CMD_PLL_START);        /* Start PLL command again  */
    SSD1963_WriteData(0x03);                    /* Now, use PLL output as
                                                 * system clock             */
    SSD1963_Delay(10);

    /* Set panel mode, varies from individual manufacturer */
    SSD1963_WriteCommand(CMD_SET_PANEL_MODE);
    SSD1963_WriteData(0x0C);                    /* 18-bit 3.5" TFT Panel    */
    SSD1963_WriteData(0x00);
    SSD1963_WriteData(WR_HIGH_BYTE((TFT_WIDTH-1)));     /* Set horizontal   */
    SSD1963_WriteData(WR_LOW_BYTE((TFT_WIDTH-1)));      /* panel size       */
    SSD1963_WriteData(WR_HIGH_BYTE((TFT_HEIGHT-1)));    /* Set vertical     */
    SSD1963_WriteData(WR_LOW_BYTE((TFT_HEIGHT-1)));     /* panel size       */
    SSD1963_WriteData(0); /* RGB sequence   */

    /* Pixel data interface (host) */
    SSD1963_WriteCommand(CMD_SET_DATA_INTERFACE);
    SSD1963_WriteData(SSD1963_PDI_16BIT565);

    SSD1963_WriteCommand(CMD_SET_PCLK);
    SSD1963_WriteData((LCD_FPR >> 16) & 0xFF);
    SSD1963_WriteData((LCD_FPR >> 8) & 0xFF);
    SSD1963_WriteData(LCD_FPR & 0xFF);

    /* Set horizontal period */
    SSD1963_WriteCommand(CMD_SET_HOR_PERIOD);
    SSD1963_WriteData(WR_HIGH_BYTE(TFT_HSYNC_PERIOD));
    SSD1963_WriteData(WR_LOW_BYTE(TFT_HSYNC_PERIOD));
    SSD1963_WriteData(WR_HIGH_BYTE((TFT_HSYNC_PULSE + TFT_HSYNC_BACK_PORCH)));
    SSD1963_WriteData(WR_LOW_BYTE((TFT_HSYNC_PULSE + TFT_HSYNC_BACK_PORCH)));
    SSD1963_WriteData(TFT_HSYNC_PULSE);
    SSD1963_WriteData(0x00);
    SSD1963_WriteData(0x00);
    SSD1963_WriteData(0x00);

    /* Set vertical period */
    SSD1963_WriteCommand(CMD_SET_VER_PERIOD);
    SSD1963_WriteData(WR_HIGH_BYTE(TFT_VSYNC_PERIOD));
    SSD1963_WriteData(WR_LOW_BYTE(TFT_VSYNC_PERIOD));
    SSD1963_WriteData(WR_HIGH_BYTE((TFT_VSYNC_PULSE + TFT_VSYNC_BACK_PORCH)));
    SSD1963_WriteData(WR_LOW_BYTE((TFT_VSYNC_PULSE + TFT_VSYNC_BACK_PORCH)));
    SSD1963_WriteData(TFT_VSYNC_PULSE);
    SSD1963_WriteData(0x00);
    SSD1963_WriteData(0x00);

    /* Setup GPIOs */
    SSD1963_WriteCommand(CMD_SET_GPIO_CONF);    /* Set all GPIOs to
                                                 * output, controlled by
                                                 * host                     */
    SSD1963_WriteData(0x0F);    /* Set GPIO0 as output                      */
    SSD1963_WriteData(0x01);    /* GPIO[3:0] used as normal GPIOs           */

    /* Clear display to black */
    SSD1963_FillArea(SCRN_LEFT, SCRN_TOP, SCRN_RIGHT, SCRN_BOTTOM, 0x00);
    SSD1963_DisplayOn();        /* Turn on display                          */
}

void SSD1963_WritePixel(uint16_t x, uint16_t y, uint16_t color) {

    SSD1963_SetArea(x, y, x + 1, y + 1);
    SSD1963_WriteCommand(CMD_WR_MEMSTART);
    SSD1963_WriteData(color);
}

uint16_t SSD1963_ReadPixel(uint16_t x, uint16_t y) {

    SSD1963_SetArea(x, y, x + 1, y + 1);
    SSD1963_WriteCommand(CMD_RD_MEMSTART);
    return SSD1963_ReadData();
}

void SSD1963_SetArea(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {

    SSD1963_WriteCommand(CMD_SET_COLUMN);
    SSD1963_WriteData((x1 >> 8) & 0x0FF);
    SSD1963_WriteData((x1) & 0xFF);
    SSD1963_WriteData((x2 >> 8) & 0xFF);
    SSD1963_WriteData((x2) & 0xFF);
    SSD1963_WriteCommand(CMD_SET_PAGE);
    SSD1963_WriteData((y1 >> 8) & 0x0FF);
    SSD1963_WriteData((y1) & 0x0FF);
    SSD1963_WriteData((y2 >> 8) & 0x0FF);
    SSD1963_WriteData((y2) & 0x0FF);
}

void SSD1963_FillArea(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,
                      uint16_t color) {

    uint32_t i;

    SSD1963_SetArea(x1, y1, x2, y2);
    SSD1963_WriteCommand(CMD_WR_MEMSTART);
    for (i = 0; i < ((x2 - x1 + 1) * (y2 - y1 + 1)); i++) {
        SSD1963_WriteData(color);
    }
}

void SSD1963_WriteArea(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,
                       uint16_t *pData) {

    uint32_t i;

    SSD1963_SetArea(x1, y1, x2, y2);
    SSD1963_WriteCommand(CMD_WR_MEMSTART);
    for (i = 0; i < ((x2 - x1 + 1) * (y2 - y1 + 1)); i++) {
        SSD1963_WriteData(*pData++);
    }
}

void SSD1963_SetTearingCfg(uint8_t state, uint8_t mode) {

    if (state == 1) {
        SSD1963_WriteCommand(CMD_SET_TEAR_SCANLINE);
        SSD1963_WriteData(mode & 0x01);
    }
    else {
        SSD1963_WriteCommand(0x34);
    }
}

void SSD1963_GetDeviceDescriptorBlock(uint16_t *ddb) {

    SSD1963_WriteCommand(CMD_RD_DDB_START);
    ddb[0] = SSD1963_ReadData();
    ddb[1] = SSD1963_ReadData();
    ddb[2] = SSD1963_ReadData();
}

#ifdef __cplusplus
}
#endif /* __cplusplus */