rt-thread/bsp/efm32/graphics/dmd/ssd2119/dmd_ssd2119_direct.c

/***************************************************************************//**
* @file
* @brief Dot matrix display Direct Driver for TFT SSD2119 "Generic" mode
* @author Energy Micro AS
* @version 1.2.2
*******************************************************************************
* @section License
* <b>(C) Copyright 2010 Energy Micro AS, http://www.energymicro.com</b>
*******************************************************************************
*
* This source code is the property of Energy Micro AS. The source and compiled
* code may only be used on Energy Micro "EFM32" microcontrollers.
*
* This copyright notice may not be removed from the source code nor changed.
*
* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Energy Micro AS has no
* obligation to support this Software. Energy Micro AS is providing the
* Software "AS IS", with no express or implied warranties of any kind,
* including, but not limited to, any implied warranties of merchantability
* or fitness for any particular purpose or warranties against infringement
* of any proprietary rights of a third party.
*
* Energy Micro AS will not be liable for any consequential, incidental, or
* special damages, or any other relief, or for any claim by any third party,
* arising from your use of this Software.
*
******************************************************************************/
#include <stdint.h>
#include "graphics/em_types.h"
#include "dmd_ssd2119_registers.h"
#include "dmd_ssd2119.h"
#include "efm32.h"
#include "efm32_usart.h"
#include "efm32_cmu.h"
#include "efm32_gpio.h"
#include "tftspi.h"

/** Dimensions of the display */
DMD_DisplayGeometry dimensions =
{
  .xSize = 320,
  .ySize = 240,
  .xClipStart = 0,
  .yClipStart = 0,
  .clipWidth = 320,
  .clipHeight = 240,
};

/** FramePointer base address */
static volatile uint16_t *frameBuffer;

/* Local variables */
static uint32_t initialized = 0;
static uint16_t rcDriverOutputControl = 0;

/* Local function prototypes */
static uint16_t colorTransform24ToRGB565(uint8_t red, uint8_t green, uint8_t blue);

#if 0
static void colorTransformRGB565To24bpp(uint16_t color, uint8_t *red, uint8_t *green, uint8_t *blue);
#endif

/**************************************************************************//**
*  @brief
*  Transforms a 24bpp pixel data into an RGB565 pixel
*
*  @param red
*    8-bit red component of the pixel
*  @param green
*    8-bit green component of the pixel
*  @param blue
*    8-bit blue component of the pixel
*  @return
*    16-bit RGB565 value of pixel
******************************************************************************/
static uint16_t colorTransform24ToRGB565(uint8_t red, uint8_t green, uint8_t blue)
{
  /* Transform each color into 6 bits by dropping the 2 LSB */
  red   = red >> 3;
  green = green >> 2;
  blue  = blue >> 3;

  /* Put it together to one 18bpp color number */
  return (red << 11) | (green << 5) | blue;
}


/**************************************************************************//**
*  @brief
*  Transforms an 16-bit RGB565 pixel into a 24bpp pixel
*
*  @param[in] color
*    RGB565 16-bit color pixel
*  @param red
*    return value for red component of 24bpp pixel
*  @param green
*    return value for green component of 24bpp pixel
*  @param blue
*    return value for blue component of 24bpp pixel
******************************************************************************/
#if 0
static void colorTransformRGB565To24bpp(uint16_t color, uint8_t *red,
                                        uint8_t *green, uint8_t *blue)
{
  /* Get the individual colors out of the 18bpp number */
  uint8_t redValue   = (color & 0x0003F000) >> 12;
  uint8_t greenValue = (color & 0x00000FC0) >> 6;
  uint8_t blueValue  = (color & 0x0000003F);

  /* Convert each color to 8-bit */
  redValue   <<= 2;
  greenValue <<= 2;
  blueValue  <<= 2;

  *red   = redValue;
  *green = greenValue;
  *blue  = blueValue;

  return;
}
#endif

/**************************************************************************//**
*  @brief
*  Writes a value to a control register in the LCD controller
*
*  @param reg
*  The register that will be written to
*  @param data
*  The value to write to the register
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMDIF_writeReg(uint8_t reg, uint16_t data)
{
  SPI_TFT_WriteRegister(reg, data);

  return DMD_OK;
}


/**************************************************************************//**
*  @brief
*  Initializes the LCD display
*
*  @param cmdRegAddr
*     If set to 0, initialize SSD2119 for direct drive, if set to 1 update
*     frame buffer base pointer (offset to EBI bank) only
*  @param dataRegAddr
*     Address in memory for frame buffer base pointer
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_init(uint32_t cmdRegAddr, uint32_t dataRegAddr)
{
  uint16_t data;
  volatile uint32_t i;
  (void) cmdRegAddr;
  (void) dataRegAddr;

  /* Use data reg addr as pointer to frame buffer */
  frameBuffer = (uint16_t *) dataRegAddr;

  if(cmdRegAddr==1) return DMD_OK;

  SPI_TFT_Init();

  DMDIF_writeReg(DMD_SSD2119_VCOM_OTP_1, 0x0006);

  /* Oscillation driven DCLK */
#if 0
  data = DMD_SSD2119_OSCILLATION_START_OSCEN;
  DMDIF_writeReg(DMD_SSD2119_OSCILLATION_START, data);
#endif

  /* Display control */
  data = 0;
  // data |= DMD_SSD2119_DISPLAY_CONTROL_DTE;
  data |= DMD_SSD2119_DISPLAY_CONTROL_GON;
  data |= DMD_SSD2119_DISPLAY_CONTROL_D1;
  data |= DMD_SSD2119_DISPLAY_CONTROL_D0;
  DMDIF_writeReg(DMD_SSD2119_DISPLAY_CONTROL, data);

  /* Exit sleep mode */
  data = 0;
  DMDIF_writeReg(DMD_SSD2119_SLEEP_MODE_1, data);

  /* Wait */
  for (i = 0; i < 100000; i++);

  /* Display control */
  DMDIF_writeReg(DMD_SSD2119_DISPLAY_CONTROL, 0x33);

  /* Entry mode */

  data  = DMD_SSD2119_ENTRY_MODE_DFM_65K << DMD_SSD2119_ENTRY_MODE_DFM_SHIFT;
  data |= DMD_SSD2119_ENTRY_MODE_WMODE;
  data |= DMD_SSD2119_ENTRY_MODE_NOSYNC;
  data |= DMD_SSD2119_ENTRY_MODE_DMODE;
  data |= DMD_SSD2119_ENTRY_MODE_ID1;
  data |= DMD_SSD2119_ENTRY_MODE_ID0;

  DMDIF_writeReg(DMD_SSD2119_ENTRY_MODE, data);

  // DMDIF_writeReg(DMD_SSD2119_DRIVER_OUTPUT_CONTROL, 0x3aef);

  /* Generic Interface Control */
  // data  = DMD_SSD2119_GENERIC_INTERFACE_CONTROL_INVDEN;
  // DMDIF_writeReg(DMD_SSD2119_GENERIC_INTERFACE_CONTROL, data);

  /* Driver output control */
  data = 0;
  data                 |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_REV;
  data                 |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_GD;
  // data                 |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_TB;
  // data                 |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_SM;
  // data                 |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_RL;
  data                 |= ((DMD_VERTICAL_SIZE - 1) << DMD_SSD2119_DRIVER_OUTPUT_CONTROL_MUX_SHIFT);
  DMDIF_writeReg(DMD_SSD2119_DRIVER_OUTPUT_CONTROL, data);

  /* LCD AC control */
  data  = DMD_SSD2119_LCD_AC_CONTROL_BC;
  data |= DMD_SSD2119_LCD_AC_CONTROL_EOR;
  /* data |= DMD_SSD2119_LCD_AC_CONTROL_FLC; */
  DMDIF_writeReg(DMD_SSD2119_LCD_AC_CONTROL, data);

  /* RAM data write */
  data  = 0xff;
  DMDIF_writeReg(DMD_SSD2119_ACCESS_DATA, data);

  /* Mark graphics as initialized */
  initialized = 1;

  return DMD_OK;
}


/**************************************************************************//**
*  @brief
*  Get the dimensions of the display and of the current clipping area
*
*  @return
*  DMD_Dimensions structure containing the size of the display and the
*  clipping area
******************************************************************************/
EMSTATUS DMD_getDisplayGeometry(DMD_DisplayGeometry **geometry)
{
  if (!initialized)
  {
    return DMD_ERROR_DRIVER_NOT_INITIALIZED;
  }
  *geometry = &dimensions;

  return DMD_OK;
}

/**************************************************************************//**
*  @brief
*  Sets the clipping area. All coordinates given to writeData/writeColor/readData
*  are relative to this clipping area.
*
*  @param xStart
*  X coordinate of the upper left corner of the clipping area
*  @param yStart
*  Y coordinate of the upper left corner of the clipping area
*  @param width
*  Width of the clipping area
*  @param height
*  Height of the clipping area
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_setClippingArea(uint16_t xStart, uint16_t yStart,
uint16_t width, uint16_t height)
{
  if (!initialized)
  {
    return DMD_ERROR_DRIVER_NOT_INITIALIZED;
  }

  /* Check parameters */
  if (xStart + width > dimensions.xSize ||
      yStart + height > dimensions.ySize)
  {
    return DMD_ERROR_PIXEL_OUT_OF_BOUNDS;
  }

  if (width == 0 || height == 0)
  {
    return DMD_ERROR_EMPTY_CLIPPING_AREA;
  }

  /* Update the dimensions structure */
  dimensions.xClipStart = xStart;
  dimensions.yClipStart = yStart;
  dimensions.clipWidth  = width;
  dimensions.clipHeight = height;

  return DMD_OK;
}

/**************************************************************************//**
*  @brief
*  Draws pixels to the display
*
*  @param x
*  X coordinate of the first pixel to be written, relative to the clipping area
*  @param y
*  Y coordinate of the first pixel to be written, relative to the clipping area
*  @param data
*  Array containing the pixel data. Each 8-bit element in the array are one color
*  component of the pixel, so that 3 bytes represent one pixel. The pixels are
*  ordered by increasing x coordinate, after the last pixel of a row, the next
*  pixel will be the first pixel on the next row.
*  @param numPixels
*  Number of pixels to be written
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_writeData(uint16_t x, uint16_t y, const uint8_t data[],
                       uint32_t numPixels)
{
  uint8_t *dest = (uint8_t *)((uint32_t) frameBuffer +
                              (uint32_t) (y*dimensions.xSize*sizeof(uint16_t)) +
                              (uint32_t) (x*sizeof(uint16_t)));

  while(numPixels--)
  {
    *dest++ = *data++;
  }


  return DMD_OK;
}


/**************************************************************************//**
*  @brief
*  Reads data from display memory
*  DOESN'T WORK yet - TIMING ISSUE?
*
*  @param x
*  X coordinate of the first pixel to be read, relative to the clipping area
*  @param y
*  Y coordinate of the first pixel to be read, relative to the clipping area
*  @param data
*  Pointer to where the pixel data will be stored
*  @param numPixels
*  Number of pixels to be read
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_readData(uint16_t x, uint16_t y,
                      uint8_t data[], uint32_t numPixels)
{
  uint8_t *source = (uint8_t *)((uint32_t) frameBuffer +
                                (uint32_t) (y*dimensions.xSize*sizeof(uint16_t)) +
                                (uint32_t) (x*sizeof(uint16_t)));
  if (y > dimensions.ySize) return DMD_ERROR_PIXEL_OUT_OF_BOUNDS;

  while(numPixels--)
  {
    *data++ = *source++;
  }

  return DMD_OK;
}


/**************************************************************************//**
*  \brief
*  Draws a number of pixels of the same color to the display
*
*  @param x
*  X coordinate of the first pixel to be written, relative to the clipping area
*  @param y
*  Y coordinate of the first pixel to be written, relative to the clipping area
*  @param red
*  Red component of the color
*  @param green
*  Green component of the color
*  @param blue
*  Blue component of the color
*  @param numPixels
*  Number of pixels to be written
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_writeColor(uint16_t x, uint16_t y,
                        uint8_t red, uint8_t green, uint8_t blue, uint32_t numPixels)
{
  uint16_t color;
  uint16_t xStart = x;
  uint16_t *pixelPointer = (uint16_t *)
    ((uint32_t) frameBuffer +
     (uint32_t) ((y+dimensions.yClipStart)*dimensions.xSize*sizeof(uint16_t)) +
     (uint32_t) ((x+dimensions.xClipStart)*sizeof(uint16_t)));
  color = colorTransform24ToRGB565(red,green,blue);

  /* Draw the requied number of pixels */
  while(numPixels--)
  {
    x++;
    *pixelPointer++ = color;
    /* Increment line, start at the right x position inside clipping region */
    if (x>=dimensions.clipWidth)
    {
      x = xStart;
      pixelPointer = (uint16_t *)
        ((uint32_t) frameBuffer +
         (uint32_t) (((++y)+dimensions.yClipStart)*dimensions.xSize*sizeof(uint16_t)) +
         (uint32_t) ((xStart+dimensions.xClipStart)*sizeof(uint16_t)));
    }
  }

  return DMD_OK;
}


/**************************************************************************//**
*  @brief
*  Turns off the display and puts it into sleep mode
*  Does not turn off backlight
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_sleep(void)
{
  uint16_t data;

  if (!initialized)
  {
    return DMD_ERROR_DRIVER_NOT_INITIALIZED;
  }

  /* Put into sleep mode */
  data = DMD_SSD2119_SLEEP_MODE_1_SLP;
  DMDIF_writeReg(DMD_SSD2119_SLEEP_MODE_1, data);

  /* Turn off display */
  data = 0;
  DMDIF_writeReg(DMD_SSD2119_DISPLAY_CONTROL, 0x0000);

  /* Delay 1.5 frame */
  /*DMDIF_delay((1000 / DMD_FRAME_FREQUENCY) * 3 / 2);*/

  return DMD_OK;
}


/**************************************************************************//**
*  @brief
*  Wakes up the display from sleep mode
*
*  @return
*  DMD_OK on success, otherwise error code
******************************************************************************/
EMSTATUS DMD_wakeUp(void)
{
  uint16_t data;

  if (!initialized)
  {
    return DMD_ERROR_DRIVER_NOT_INITIALIZED;
  }

  /* Get out of sleep mode */
  data = 0;
  DMDIF_writeReg(DMD_SSD2119_SLEEP_MODE_1, data);

  /* Turn on display */
  data  = DMD_SSD2119_DISPLAY_CONTROL_DTE;
  data |= DMD_SSD2119_DISPLAY_CONTROL_GON;
  data |= DMD_SSD2119_DISPLAY_CONTROL_D1;
  data |= DMD_SSD2119_DISPLAY_CONTROL_D0;
  DMDIF_writeReg(DMD_SSD2119_DISPLAY_CONTROL, data);

  /* Delay 10 frames */
  /*DMDIF_delay((1000 / DMD_FRAME_FREQUENCY) * 10);*/

  return DMD_OK;
}


/**************************************************************************//**
*  @brief
*  Set horizontal and vertical flip mode of display controller
*
*  @param hor
*  Set to flip display horizontally
*
*  @param ver
*  Set to flip display vertically
*
*  @return
*  Returns DMD_OK is successful, error otherwise.
******************************************************************************/
EMSTATUS DMD_flipDisplay(int horizontal, int vertical)
{
  uint16_t reg;

  reg = rcDriverOutputControl;

  if (horizontal) reg &= ~DMD_SSD2119_DRIVER_OUTPUT_CONTROL_RL;
  else reg |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_RL;

  if (vertical) reg &= ~DMD_SSD2119_DRIVER_OUTPUT_CONTROL_TB;
  else reg |= DMD_SSD2119_DRIVER_OUTPUT_CONTROL_TB;

  rcDriverOutputControl = reg;
  DMDIF_writeReg(DMD_SSD2119_DRIVER_OUTPUT_CONTROL, rcDriverOutputControl);

  return DMD_OK;
}