path: root/third_party/FreeRTOS/Demo/CORTEX_LM3Sxxxx_Eclipse/RTOSDemo/formike128x128x16.c

//*****************************************************************************
//
// formike128x128x16.c - Display driver for the Formike Electronic
//                       KWH015C04-F01 CSTN panel with an ST7637 controller.
//
// Copyright (c) 2008 Luminary Micro, Inc.  All rights reserved.
// 
// Software License Agreement
// 
// Luminary Micro, Inc. (LMI) is supplying this software for use solely and
// exclusively on LMI's microcontroller products.
// 
// The software is owned by LMI and/or its suppliers, and is protected under
// applicable copyright laws.  All rights are reserved.  You may not combine
// this software with "viral" open-source software in order to form a larger
// program.  Any use in violation of the foregoing restrictions may subject
// the user to criminal sanctions under applicable laws, as well as to civil
// liability for the breach of the terms and conditions of this license.
// 
// THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
// OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
// LMI SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
// CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
// 
// This is part of revision 2523 of the Stellaris Peripheral Driver Library.
//
//*****************************************************************************

//*****************************************************************************
//
//! \addtogroup ek_lm3s3748_api
//! @{
//
//*****************************************************************************

#include "hw_gpio.h"
#include "hw_memmap.h"
#include "hw_types.h"
#include "gpio.h"
#include "sysctl.h"
#include "rom.h"
#include "grlib.h"
#include "formike128x128x16.h"
#include <string.h>

//*****************************************************************************
//
// Defines for the pins that are used to communicate with the ST7637.
//
//*****************************************************************************
#define LCD_A0_BASE            GPIO_PORTB_BASE
#define LCD_A0_PIN             GPIO_PIN_2
#define LCD_WR_BASE            GPIO_PORTC_BASE
#define LCD_WR_PIN             GPIO_PIN_4
#define LCD_RD_BASE            GPIO_PORTC_BASE
#define LCD_RD_PIN             GPIO_PIN_5
#define LCD_BL_BASE            GPIO_PORTF_BASE
#define LCD_BL_PIN             GPIO_PIN_1
#define LCD_DATA_BASE          GPIO_PORTG_BASE

//*****************************************************************************
//
// Translates a 24-bit RGB color to a display driver-specific color.
//
// \param c is the 24-bit RGB color.  The least-significant byte is the blue
// channel, the next byte is the green channel, and the third byte is the red
// channel.
//
// This macro translates a 24-bit RGB color into a value that can be written
// into the display's frame buffer in order to reproduce that color, or the
// closest possible approximation of that color.
//
// \return Returns the display-driver specific color.
//
//*****************************************************************************
#define DPYCOLORTRANSLATE(c)    ((((c) & 0x00ff0000) >> 19) |               \
                                 ((((c) & 0x0000ff00) >> 5) & 0x000007e0) | \
                                 ((((c) & 0x000000ff) << 8) & 0x0000f800))

//*****************************************************************************
//
// Writes a data word to the ST7637.
//
//*****************************************************************************
static void
WriteData(unsigned char ucData)
{
    //
    // Write the data to the data bus.
    //
    HWREG(LCD_DATA_BASE + GPIO_O_DATA + (0xff << 2)) = ucData;

    //
    // Assert the write enable signal.
    //
    HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = 0;

    //
    // Deassert the write enable signal.
    //
    HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = LCD_WR_PIN;
}

//*****************************************************************************
//
// Writes a command to the ST7637.
//
//*****************************************************************************
static void
WriteCommand(unsigned char ucData)
{
    //
    // Write the command to the data bus.
    //
    HWREG(LCD_DATA_BASE + GPIO_O_DATA + (0xff << 2)) = ucData;

    //
    // Set the A0 signal low, indicating a command.
    //
    HWREG(LCD_A0_BASE + GPIO_O_DATA + (LCD_A0_PIN << 2)) = 0;

    //
    // Assert the write enable signal.
    //
    HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = 0;

    //
    // Deassert the write enable signal.
    //
    HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = LCD_WR_PIN;

    //
    // Set the A0 signal high, indicating that following writes are data.
    //
    HWREG(LCD_A0_BASE + GPIO_O_DATA + (LCD_A0_PIN << 2)) = LCD_A0_PIN;
}

//*****************************************************************************
//
//! Initializes the display driver.
//!
//! This function initializes the ST7637 display controller on the panel,
//! preparing it to display data.
//!
//! \return None.
//
//*****************************************************************************
void
Formike128x128x16Init(void)
{
    unsigned long ulClockMS, ulCount;

    //
    // Get the value to pass to SysCtlDelay() in order to delay for 1 ms.
    //
    ulClockMS = SysCtlClockGet() / (3 * 1000);

    //
    // Enable the GPIO peripherals used to interface to the ST7637.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);

    //
    // Configure the pins that connect to the LCD as GPIO outputs.
    //
    GPIOPinTypeGPIOOutput(LCD_A0_BASE, LCD_A0_PIN);
    GPIOPinTypeGPIOOutput(LCD_WR_BASE, LCD_WR_PIN);
    GPIOPinTypeGPIOOutput(LCD_RD_BASE, LCD_RD_PIN);
    GPIOPinTypeGPIOOutput(LCD_BL_BASE, LCD_BL_PIN);
    GPIOPinTypeGPIOOutput(LCD_DATA_BASE, 0xff);

    //
    // Set the LCD control pins to their default values.
    //
    GPIOPinWrite(LCD_A0_BASE, LCD_A0_PIN, LCD_A0_PIN);
    GPIOPinWrite(LCD_WR_BASE, LCD_WR_PIN | LCD_RD_PIN,
                     LCD_WR_PIN | LCD_RD_PIN);
    GPIOPinWrite(LCD_BL_BASE, LCD_BL_PIN, 0);
    GPIOPinWrite(LCD_DATA_BASE, 0xff, 0x00);

    //
    // Perform a software reset of the ST7637.
    //
    WriteCommand(0x01);

    //
    // Delay for 120ms.
    //
    SysCtlDelay(ulClockMS * 120);

    //
    // Disable auto-load of mask rom data.
    //
    WriteCommand(0xD7);
    WriteData(0xBF);

    //
    // Set the OTP control mode to read.
    //
    WriteCommand(0xE0);
    WriteData(0x00);

    //
    // Delay for 10ms.
    //
    SysCtlDelay(ulClockMS * 10);

    //
    // Start the OTP read.
    //
    WriteCommand(0xE3);

    //
    // Delay for 20ms.
    //
    SysCtlDelay(ulClockMS * 20);

    //
    // Cancel the OTP read (it should have finished by now).
    //
    WriteCommand(0xE1);

    //
    // Turn off the display.
    //
    WriteCommand(0x28);

    //
    // Exit sleep mode.
    //
    WriteCommand(0x11);

    //
    // Delay for 50ms.
    //
    SysCtlDelay(ulClockMS * 50);

    //
    // Program the LCD supply voltage V0 to 14V.
    //
    WriteCommand(0xC0);
    WriteData(0x04);
    WriteData(0x01);

    //
    // Select an LCD bias voltage ratio of 1/12.
    //
    WriteCommand(0xC3);
    WriteData(0x00);

    //
    // Enable the x8 booster circuit.
    //
    WriteCommand(0xC4);
    WriteData(0x07);

    //
    // Invert the column scan direction for the panel.
    //
    WriteCommand(0xB7);
    WriteData(0xC0);

    //
    // Select 16bpp, 5-6-5 data input mode.
    //
    WriteCommand(0x3A);
    WriteData(0x05);

    //
    // Select the memory scanning direction.  The scanning mode does not matter
    // for this driver since the row/column selects will constrain the writes
    // to the desired area of the display.
    //
    WriteCommand(0x36);
    WriteData(0x00);

    //
    // Turn on the display.
    //
    WriteCommand(0x29);

    //
    // Clear the contents of the display buffer.
    //
    WriteCommand(0x2A);
    WriteData(0x00);
    WriteData(0x7F);
    WriteCommand(0x2B);
    WriteData(0x01);
    WriteData(0x80);
    WriteCommand(0x2c);
    for(ulCount = 0; ulCount < (128 * 128); ulCount++)
    {
        WriteData(0x00);
        WriteData(0x00);
    }

    //
    // Enable normal operation of the LCD.
    //
    WriteCommand(0x13);
}

//*****************************************************************************
//
//! Turns on the backlight.
//!
//! This function turns on the backlight on the display.
//!
//! \return None.
//
//*****************************************************************************
void
Formike128x128x16BacklightOn(void)
{
    //
    // Assert the signal that turns on the backlight.
    //
    HWREG(LCD_BL_BASE + GPIO_O_DATA + (LCD_BL_PIN << 2)) = LCD_BL_PIN;
}

//*****************************************************************************
//
//! Turns off the backlight.
//!
//! This function turns off the backlight on the display.
//!
//! \return None.
//
//*****************************************************************************
void
Formike128x128x16BacklightOff(void)
{
    //
    // Deassert the signal that turns on the backlight.
    //
    HWREG(LCD_BL_BASE + GPIO_O_DATA + (LCD_BL_PIN << 2)) = 0;
}

//*****************************************************************************
//
//! Draws a pixel on the screen.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//! \param lX is the X coordinate of the pixel.
//! \param lY is the Y coordinate of the pixel.
//! \param ulValue is the color of the pixel.
//!
//! This function sets the given pixel to a particular color.  The coordinates
//! of the pixel are assumed to be within the extents of the display.
//!
//! \return None.
//
//*****************************************************************************
static void
Formike128x128x16PixelDraw(void *pvDisplayData, long lX, long lY,
                           unsigned long ulValue)
{
    //
    // Set the X address of the display cursor.
    //
    WriteCommand(0x2a);
    WriteData(lX);
    WriteData(lX);

    //
    // Set the Y address of the display cursor.
    //
    WriteCommand(0x2b);
    WriteData(lY + 1);
    WriteData(lY + 1);

    //
    // Write the pixel value.
    //
    WriteCommand(0x2c);
    WriteData(ulValue >> 8);
    WriteData(ulValue);
}

//*****************************************************************************
//
//! Draws a horizontal sequence of pixels on the screen.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//! \param lX is the X coordinate of the first pixel.
//! \param lY is the Y coordinate of the first pixel.
//! \param lX0 is sub-pixel offset within the pixel data, which is valid for 1
//! or 4 bit per pixel formats.
//! \param lCount is the number of pixels to draw.
//! \param lBPP is the number of bits per pixel; must be 1, 4, or 8.
//! \param pucData is a pointer to the pixel data.  For 1 and 4 bit per pixel
//! formats, the most significant bit(s) represent the left-most pixel.
//! \param pucPalette is a pointer to the palette used to draw the pixels.
//!
//! This function draws a horizontal sequence of pixels on the screen, using
//! the supplied palette.  For 1 bit per pixel format, the palette contains
//! pre-translated colors; for 4 and 8 bit per pixel formats, the palette
//! contains 24-bit RGB values that must be translated before being written to
//! the display.
//!
//! \return None.
//
//*****************************************************************************
static void
Formike128x128x16PixelDrawMultiple(void *pvDisplayData, long lX, long lY,
                                   long lX0, long lCount, long lBPP,
                                   const unsigned char *pucData,
                                   const unsigned char *pucPalette)
{
    unsigned long ulByte;

    //
    // Set the extent of the line along the X axis.
    //
    WriteCommand(0x2a);
    WriteData(lX);
    WriteData(lX + lCount - 1);

    //
    // Set the Y address of the display cursor.
    //
    WriteCommand(0x2b);
    WriteData(lY + 1);
    WriteData(lY + 1);

    //
    // Write the data RAM write command.
    //
    WriteCommand(0x2c);

    //
    // Determine how to interpret the pixel data based on the number of bits
    // per pixel.
    //
    switch(lBPP)
    {
        //
        // The pixel data is in 1 bit per pixel format.
        //
        case 1:
        {
            //
            // Loop while there are more pixels to draw.
            //
            while(lCount)
            {
                //
                // Get the next byte of image data.
                //
                ulByte = *pucData++;

                //
                // Loop through the pixels in this byte of image data.
                //
                for(; (lX0 < 8) && lCount; lX0++, lCount--)
                {
                    //
                    // Draw this pixel in the appropriate color.
                    //
                    lBPP = ((unsigned long *)pucPalette)[(ulByte >>
                                                          (7 - lX0)) & 1];
                    WriteData(lBPP >> 8);
                    WriteData(lBPP);
                }

                //
                // Start at the beginning of the next byte of image data.
                //
                lX0 = 0;
            }

            //
            // The image data has been drawn.
            //
            break;
        }

        //
        // The pixel data is in 4 bit per pixel format.
        //
        case 4:
        {
            //
            // Loop while there are more pixels to draw.  "Duff's device" is
            // used to jump into the middle of the loop if the first nibble of
            // the pixel data should not be used.  Duff's device makes use of
            // the fact that a case statement is legal anywhere within a
            // sub-block of a switch statement.  See
            // http://en.wikipedia.org/wiki/Duff's_device for detailed
            // information about Duff's device.
            //
            switch(lX0 & 1)
            {
                case 0:
                    while(lCount)
                    {
                        //
                        // Get the upper nibble of the next byte of pixel data
                        // and extract the corresponding entry from the
                        // palette.
                        //
                        ulByte = (*pucData >> 4) * 3;
                        ulByte = (*(unsigned long *)(pucPalette + ulByte) &
                                  0x00ffffff);

                        //
                        // Translate this palette entry and write it to the
                        // screen.
                        //
                        ulByte = DPYCOLORTRANSLATE(ulByte);
                        WriteData(ulByte >> 8);
                        WriteData(ulByte);

                        //
                        // Decrement the count of pixels to draw.
                        //
                        lCount--;

                        //
                        // See if there is another pixel to draw.
                        //
                        if(lCount)
                        {
                case 1:
                            //
                            // Get the lower nibble of the next byte of pixel
                            // data and extract the corresponding entry from
                            // the palette.
                            //
                            ulByte = (*pucData++ & 15) * 3;
                            ulByte = (*(unsigned long *)(pucPalette + ulByte) &
                                      0x00ffffff);

                            //
                            // Translate this palette entry and write it to the
                            // screen.
                            //
                            ulByte = DPYCOLORTRANSLATE(ulByte);
                            WriteData(ulByte >> 8);
                            WriteData(ulByte);

                            //
                            // Decrement the count of pixels to draw.
                            //
                            lCount--;
                        }
                    }
            }

            //
            // The image data has been drawn.
            //
            break;
        }

        //
        // The pixel data is in 8 bit per pixel format.
        //
        case 8:
        {
            //
            // Loop while there are more pixels to draw.
            //
            while(lCount--)
            {
                //
                // Get the next byte of pixel data and extract the
                // corresponding entry from the palette.
                //
                ulByte = *pucData++ * 3;
                ulByte = *(unsigned long *)(pucPalette + ulByte) & 0x00ffffff;

                //
                // Translate this palette entry and write it to the screen.
                //
                ulByte = DPYCOLORTRANSLATE(ulByte);
                WriteData(ulByte >> 8);
                WriteData(ulByte);
            }

            //
            // The image data has been drawn.
            //
            break;
        }
    }
}

//*****************************************************************************
//
//! Flushes any cached drawing operations.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//!
//! This functions flushes any cached drawing operations to the display.  This
//! is useful when a local frame buffer is used for drawing operations, and the
//! flush would copy the local frame buffer to the display.  For the ST7637
//! driver, the flush is a no operation.
//!
//! \return None.
//
//*****************************************************************************
static void
Formike128x128x16Flush(void *pvDisplayData)
{
    //
    // There is nothing to be done.
    //
}

//*****************************************************************************
//
//! Draws a horizontal line.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//! \param lX1 is the X coordinate of the start of the line.
//! \param lX2 is the X coordinate of the end of the line.
//! \param lY is the Y coordinate of the line.
//! \param ulValue is the color of the line.
//!
//! This function draws a horizontal line on the display.  The coordinates of
//! the line are assumed to be within the extents of the display.
//!
//! \return None.
//
//*****************************************************************************
static void
Formike128x128x16LineDrawH(void *pvDisplayData, long lX1, long lX2, long lY,
                           unsigned long ulValue)
{
    //
    // Set the extent of the line along the X axis.
    //
    WriteCommand(0x2a);
    WriteData(lX1);
    WriteData(lX2);

    //
    // Set the Y address of the display cursor.
    //
    WriteCommand(0x2b);
    WriteData(lY + 1);
    WriteData(lY + 1);

    //
    // Write the data RAM write command.
    //
    WriteCommand(0x2c);

    //
    // Loop through the pixels of this horizontal line.
    //
    while(lX1++ <= lX2)
    {
        //
        // Write the pixel value.
        //
        WriteData(ulValue >> 8);
        WriteData(ulValue);
    }
}

//*****************************************************************************
//
//! Draws a vertical line.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//! \param lX is the X coordinate of the line.
//! \param lY1 is the Y coordinate of the start of the line.
//! \param lY2 is the Y coordinate of the end of the line.
//! \param ulValue is the color of the line.
//!
//! This function draws a vertical line on the display.  The coordinates of the
//! line are assumed to be within the extents of the display.
//!
//! \return None.
//
//*****************************************************************************
static void
Formike128x128x16LineDrawV(void *pvDisplayData, long lX, long lY1, long lY2,
                           unsigned long ulValue)
{
    //
    // Set the X address of the display cursor.
    //
    WriteCommand(0x2a);
    WriteData(lX);
    WriteData(lX);

    //
    // Set the extent of the line along the Y axis.
    //
    WriteCommand(0x2b);
    WriteData(lY1 + 1);
    WriteData(lY2 + 1);

    //
    // Write the data RAM write command.
    //
    WriteCommand(0x2c);

    //
    // Loop through the pixels of this vertical line.
    //
    while(lY1++ <= lY2)
    {
        //
        // Write the pixel value.
        //
        WriteData(ulValue >> 8);
        WriteData(ulValue);
    }
}

//*****************************************************************************
//
//! Fills a rectangle.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//! \param pRect is a pointer to the structure describing the rectangle.
//! \param ulValue is the color of the rectangle.
//!
//! This function fills a rectangle on the display.  The coordinates of the
//! rectangle are assumed to be within the extents of the display, and the
//! rectangle specification is fully inclusive (i.e. both sXMin and sXMax are
//! drawn, along with sYMin and sYMax).
//!
//! \return None.
//
//*****************************************************************************
static void
Formike128x128x16RectFill(void *pvDisplayData, const tRectangle *pRect,
                          unsigned long ulValue)
{
    long lCount;

    //
    // Set the extent of the rectangle along the X axis.
    //
    WriteCommand(0x2a);
    WriteData(pRect->sXMin);
    WriteData(pRect->sXMax);

    //
    // Set the extent of the rectangle along the Y axis.
    //
    WriteCommand(0x2b);
    WriteData(pRect->sYMin + 1);
    WriteData(pRect->sYMax + 1);

    //
    // Write the data RAM write command.
    //
    WriteCommand(0x2c);

    //
    // Loop through the pixels in this rectangle.
    //
    for(lCount = ((pRect->sXMax - pRect->sXMin + 1) *
                  (pRect->sYMax - pRect->sYMin + 1)); lCount > 0; lCount--)
    {
        //
        // Write the pixel value.
        //
        WriteData(ulValue >> 8);
        WriteData(ulValue);
    }
}

//*****************************************************************************
//
//! Translates a 24-bit RGB color to a display driver-specific color.
//!
//! \param pvDisplayData is a pointer to the driver-specific data for this
//! display driver.
//! \param ulValue is the 24-bit RGB color.  The least-significant byte is the
//! blue channel, the next byte is the green channel, and the third byte is the
//! red channel.
//!
//! This function translates a 24-bit RGB color into a value that can be
//! written into the display's frame buffer in order to reproduce that color,
//! or the closest possible approximation of that color.
//!
//! \return Returns the display-driver specific color.
//
//*****************************************************************************
static unsigned long
Formike128x128x16ColorTranslate(void *pvDisplayData, unsigned long ulValue)
{
    //
    // Translate from a 24-bit RGB color to a 5-6-5 RGB color.
    //
    return(DPYCOLORTRANSLATE(ulValue));
}

//*****************************************************************************
//
//! The display structure that describes the driver for the Formike Electronic
//! KWH015C04-F01 CSTN panel with an ST7637 controller.
//
//*****************************************************************************
const tDisplay g_sFormike128x128x16 =
{
    sizeof(tDisplay),
    0,
    128,
    128,
    Formike128x128x16PixelDraw,
    Formike128x128x16PixelDrawMultiple,
    Formike128x128x16LineDrawH,
    Formike128x128x16LineDrawV,
    Formike128x128x16RectFill,
    Formike128x128x16ColorTranslate,
    Formike128x128x16Flush
};

//*****************************************************************************
//
// Close the Doxygen group.
//! @}
//
//*****************************************************************************
















/* FreeRTOS.org demo wrappers.  These are required so the prototypes for the
functions are the same as for the display drivers used by other evaluation
kits. */

static tContext sContext;

void vFormike128x128x16Clear( void )
{
const tRectangle xRectangle = { 0, 0, 127, 127 };

    GrContextForegroundSet( &sContext, ClrBlack );
    GrRectFill( &sContext, &xRectangle );
	GrContextForegroundSet(&sContext, ClrWhite);
}
/*-----------------------------------------------------------*/

void vFormike128x128x16StringDraw( const char *pcString, unsigned long lX, unsigned long lY, unsigned char ucColor )
{
	GrContextForegroundSet(&sContext, ClrWhite);
	GrStringDraw( &sContext, pcString, strlen( pcString ), lX, lY, false );
}
/*-----------------------------------------------------------*/

void vFormike128x128x16Init( unsigned long ul )
{
tRectangle rectScreen;
const unsigned char *pcAppName = "www.FreeRTOS.org";

	( void ) ul;
	
    Formike128x128x16Init();
    Formike128x128x16BacklightOn();
    GrContextInit(&sContext, &g_sFormike128x128x16);
    GrContextFontSet(&sContext, &g_sFontCmss12);
    rectScreen.sXMin = 0;

	/* Fill the screen with a black rectangle. */
    rectScreen.sYMin = 0;
    rectScreen.sXMax = g_sFormike128x128x16.usWidth - 1;
    rectScreen.sYMax = g_sFormike128x128x16.usHeight - 1;
    GrContextForegroundSet(&sContext, ClrBlack);
    GrRectFill(&sContext, &rectScreen);
}
/*-----------------------------------------------------------*/

void vFormike128x128x16ImageDraw( const unsigned char *pucImage, unsigned long ulX, unsigned long ulY, unsigned long ulWidth, unsigned long ulHeight )
{
	GrImageDraw( &sContext, pucImage, ( long ) ulX, ( long ) ulY);
}