marvell/uboot/drivers/video/st7735.c

/*
 * st7335 LCD panel driver.
 *
 * Copyright (C) 2015 Marvell
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <malloc.h>
#include <spi.h>
#include <asm/gpio.h>

#define ST7735_NOP      (0x0)
#define ST7735_SWRESET  (0x01)
#define ST7735_SLPIN    (0x10)
#define ST7735_SLPOUT   (0x11)
#define ST7735_PTLON    (0x12)
#define ST7735_NORON    (0x13)
#define ST7735_INVOFF   (0x20)
#define ST7735_INVON    (0x21)
#define ST7735_DISPON   (0x29)
#define ST7735_CASET    (0x2A)
#define ST7735_RASET    (0x2B)
#define ST7735_RAMWR    (0x2C)
#define ST7735_COLMOD   (0x3A)
#define ST7735_MADCTL   (0x36)
#define ST7735_FRMCTR1  (0xB1)
#define ST7735_FRMCTR2  (0xB2)
#define ST7735_FRMCTR3  (0xB3)
#define ST7735_INVCTR   (0xB4)
#define ST7735_DISSET5  (0xB6)
#define ST7735_PWCTR1   (0xC0)
#define ST7735_PWCTR2   (0xC1)
#define ST7735_PWCTR3   (0xC2)
#define ST7735_PWCTR4   (0xC3)
#define ST7735_PWCTR5   (0xC4)
#define ST7735_VMCTR1   (0xC5)
#define ST7735_PWCTR6   (0xFC)
#define ST7735_GMCTRP1  (0xE0)
#define ST7735_GMCTRN1  (0xE1)

#define LCD_177_SIZE

uint16_t cmd01[3] = {0x102,0x135,0x136};
uint16_t cmd02[3] = {0x102,0x135,0x136};
uint16_t cmd03[6] = {0x102,0x135,0x136,0x102,0x135,0x136};
uint16_t cmd04[1] = {0x100};
uint16_t cmd05[3] = {0x1a2,0x102,0x184};
uint16_t cmd06[1] = {0x1c5};
uint16_t cmd07[2] = {0x10d,0x100};
uint16_t cmd08[2] = {0x18a,0x12a};
uint16_t cmd09[2] = {0x18d,0x1ee};
uint16_t cmd10[1] = {0x112};

#if REVERSE_LEFT_90_DEGREE
uint16_t cmd11[1] = {0x108};
#elif REVERSE_RIGHT_90_DEGREE
uint16_t cmd11[1] = {0x1c8};
#else
uint16_t cmd11[1] = {0x168};
#endif
uint16_t cmd12[16] = {0x112,0x11c,0x110,0x118,0x133,0x12c,0x125,0x128,
			0x128,0x127,0x12f,0x13c,0x100,0x103,0x103,0x110};
uint16_t cmd13[16] = {0x112,0x11c,0x110,0x118,0x12d,0x128,0x123,0x128,
			0x128,0x126,0x12f,0x13b,0x100,0x103,0x103,0x110};
uint16_t cmd14[1] = {0x105};
uint16_t cmd15[4] = {0x100,0x102,0x100,0x181};
uint16_t cmd16[4] = {0x100,0x103,0x100,0x1a2};

#define data_size(x)		sizeof(x)/sizeof(uint16_t)

#define LCD_PWR_GPIO		13
#define LCD_RST_GPIO35		35
#define SPI_9BIT_MODE		9

#ifdef LCD_177_SIZE
#define DEFAULT_FB_XRES    160
#else
#define DEFAULT_FB_XRES    128
#endif

#define DEFAULT_FB_YRES    128
#define DEFAULT_FB_SIZE    (DEFAULT_FB_XRES * DEFAULT_FB_YRES * 4)

#define DATA_HR		0x100
#define DataH(x)	DATA_HR | (x)

static uint16_t *lcd_buff;
struct spi_slave *spi;
void lcdFillRGB(uint16_t color);
static void st7735fb_draw_logo(void);

const u8 marvell_logo[1][64][4] =
{
	{ // marvell
		{0x01, 0x00, 0x00, 0x00}, {0x03, 0x00, 0x00, 0x00}, {0x07, 0x00, 0x00, 0x00}, {0x0f, 0x00, 0x00, 0x00},
		{0x1f, 0x00, 0x00, 0x00}, {0x3f, 0x00, 0x00, 0x00}, {0x7f, 0x00, 0x00, 0x00}, {0xff, 0x00, 0x00, 0x00},
		{0xff, 0x01, 0x00, 0x00}, {0xff, 0x03, 0x00, 0x00}, {0xff, 0x07, 0x00, 0x00}, {0xff, 0x0f, 0x00, 0x00}, // 11
		{0xff, 0x1f, 0x00, 0x00}, {0xff, 0x3f, 0x00, 0x00}, {0xfe, 0x7f, 0x00, 0x00}, {0xfc, 0xff, 0x00, 0x00},
		{0xf8, 0xff, 0x01, 0x00}, {0xf0, 0xff, 0x03, 0x00}, {0xe0, 0xff, 0x07, 0x00}, {0xc0, 0xff, 0x0f, 0x00},
		{0x80, 0xff, 0x1f, 0x00}, {0x00, 0xff, 0x3f, 0x00}, {0x00, 0xfe, 0x7f, 0x00}, {0x01, 0xfc, 0xff, 0x00},
		{0x03, 0xf8, 0xff, 0x01}, {0x77, 0xf7, 0xff, 0x03}, {0x5d, 0x15, 0x00, 0x02}, {0x5d, 0x15, 0x00, 0x02},
		{0x5d, 0x15, 0x00, 0x02}, {0x5d, 0x15, 0x00, 0x02}, {0xdd, 0x15, 0x00, 0x02}, {0xdd, 0x15, 0x00, 0x02},
		{0xdd, 0x15, 0x00, 0x02}, {0xdd, 0x15, 0x00, 0x02}, {0xdd, 0x15, 0x00, 0x02}, {0xdd, 0x1d, 0x00, 0x02},
		{0xdd, 0x1d, 0x00, 0x02}, {0xdd, 0x1d, 0x00, 0x02}, {0xff, 0xff, 0xff, 0x03}, {0xfc, 0xff, 0x00, 0x00}, // 39
		{0xf8, 0xff, 0x01, 0x00}, {0xf0, 0xff, 0x03, 0x00}, {0xe0, 0xff, 0x07, 0x00}, {0xc0, 0xff, 0x0f, 0x00},
		{0x80, 0xff, 0x1f, 0x00}, {0x00, 0xff, 0x3f, 0x00}, {0x00, 0xfe, 0x7f, 0x00}, {0x00, 0xfc, 0xff, 0x00},
		{0x00, 0xf8, 0xff, 0x01}, {0x77, 0xf7, 0xff, 0x03}, {0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02},
		{0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02},
		{0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02},
		{0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02}, {0x55, 0x15, 0x00, 0x02}, {0x77, 0xf7, 0xff, 0x03}
	}
};

void write_command_data(uint16_t cmd, uint16_t *data_addr, uint32_t data_size)
{
	int ret;

	ret = spi_xfer(spi, SPI_9BIT_MODE, &cmd, NULL,
				SPI_XFER_BEGIN | SPI_XFER_END);
	if (ret)
		debug("SPILCD: Failed to send command %d\n", cmd);

	if (data_addr && data_size > 0) {
		ret = spi_xfer(spi, SPI_9BIT_MODE * data_size, data_addr, NULL,
					SPI_XFER_BEGIN | SPI_XFER_END);
		if (ret)
			debug("SPILCD: Failed to send data.\n");
	}
}

void st7735InitDisplay(void)
{
	write_command_data(ST7735_SLPOUT, NULL, 0);
	mdelay(300);

	write_command_data(ST7735_FRMCTR1, cmd01, data_size(cmd01));
	write_command_data(ST7735_FRMCTR2, cmd02, data_size(cmd02));
	write_command_data(ST7735_FRMCTR3, cmd03, data_size(cmd03));
	write_command_data(ST7735_INVCTR, cmd04, data_size(cmd04));
	write_command_data(ST7735_PWCTR1, cmd05, data_size(cmd05));
	write_command_data(ST7735_PWCTR2, cmd06, data_size(cmd06));
	write_command_data(ST7735_PWCTR3, cmd07, data_size(cmd07));
	write_command_data(ST7735_PWCTR4, cmd08, data_size(cmd08));
	write_command_data(ST7735_PWCTR5, cmd09, data_size(cmd09));
	write_command_data(ST7735_PWCTR6, cmd10, data_size(cmd10));
	write_command_data(ST7735_MADCTL, cmd11, data_size(cmd11));
	write_command_data(ST7735_GMCTRP1, cmd12, data_size(cmd12));
	write_command_data(ST7735_GMCTRN1, cmd13, data_size(cmd13));
	write_command_data(ST7735_COLMOD, cmd14, data_size(cmd14));
	write_command_data(ST7735_CASET, cmd15, data_size(cmd15));
	write_command_data(ST7735_RASET, cmd16, data_size(cmd16));

	write_command_data(ST7735_DISPON, NULL, 0);
	write_command_data(ST7735_RAMWR, NULL, 0);
}

void lcdBacklight(bool state)
{
	gpio_direction_output(LCD_PWR_GPIO, state);
}

int ST7735_lcdInit(void)
{
	int ret;
	int bus = 0;

	lcd_buff = malloc(DEFAULT_FB_SIZE);

	spi_init();
	spi = spi_setup_slave(bus, 25, 0, SPI_MODE_3);
	if (!spi) {
		printf("SF: Failed to set up slave\n");
		return -1;
	}

	ret = spi_claim_bus(spi);
	if (ret) {
		debug("SF: Failed to claim SPI bus: %d\n", ret);
		return -1;
	}
	spi_set_wordlen(spi, 9);

	gpio_direction_output(LCD_RST_GPIO35, 1);
	mdelay(50);
	gpio_direction_output(LCD_RST_GPIO35, 0);
	mdelay(50);
	gpio_direction_output(LCD_RST_GPIO35, 1);
	mdelay(150);

	// Run LCD init sequence
	st7735InitDisplay();

	//lcdFillRGB(0x0);
	st7735fb_draw_logo();
	lcdBacklight(1);
	return 0;
}

void st7735SetAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1)
{
	uint16_t buf[4];
	buf[0] = DataH(0);
#ifdef LCD_177_SIZE
	buf[1] = DataH(x0);
#else
	buf[1] = DataH(x0+2);
#endif
	buf[2] = DataH(0);
#ifdef LCD_177_SIZE
	buf[3] = DataH(x1);
#else
	buf[3] = DataH(x1+2);
#endif
	write_command_data(ST7735_CASET, buf, 4);	// column addr set

	buf[0] = DataH(0);
#ifdef LCD_177_SIZE
	buf[1] = DataH(y0);
#else
	buf[1] = DataH(y0+3);
#endif
	buf[2] = DataH(0);
#ifdef LCD_177_SIZE
	buf[3] = DataH(y1);
#else
	buf[3] = DataH(y1+3);
#endif
	write_command_data(ST7735_RASET, buf, 4);   // row addr set
}

void lcdFillRGB(uint16_t color)
{
	uint8_t x, y;
	uint16_t *buff;

	buff = lcd_buff;
	memset(buff, 0x00, DEFAULT_FB_SIZE);

	st7735SetAddrWindow(0, 0, DEFAULT_FB_XRES - 1, DEFAULT_FB_YRES - 1);

	for (x=0; x < DEFAULT_FB_XRES; x++)
	{
		for (y=0; y < DEFAULT_FB_YRES; y++)
		{
			*(uint16_t *)(buff++) = DataH(color >> 8);
			*(uint16_t *)(buff++) = DataH(color);
		}
	}

	flush_cache((unsigned long)lcd_buff, DEFAULT_FB_SIZE);
	write_command_data(ST7735_RAMWR, lcd_buff, DEFAULT_FB_SIZE / 2);
}

void lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color)
{
	uint16_t buf[2];
	st7735SetAddrWindow(x, y, x+1, y+1);
	buf[0] = DataH(color >> 8);
	buf[1] = DataH(color);
	write_command_data(ST7735_RAMWR, buf, 2);
}

void lcdDrawHLine(uint16_t x0, uint16_t x1, uint16_t y, uint16_t color)
{
	// Allows for slightly better performance than setting individual pixels
	uint16_t x, pixels;
	uint16_t *buff = lcd_buff;

	if (x1 < x0)	// Switch x1 and x0
	{
		x = x1;
		x1 = x0;
		x0 = x;
	}

	// Check limits
	if (x1 >= DEFAULT_FB_XRES)
		x1 = DEFAULT_FB_XRES - 1;
	if (x0 >= DEFAULT_FB_XRES)
		x0 = DEFAULT_FB_XRES - 1;

	st7735SetAddrWindow(x0, y, DEFAULT_FB_XRES, y + 1);
	for (pixels = 0; pixels < x1 - x0 + 1; pixels++)
	{
		*(uint16_t *)buff = DataH(color >> 8);
		buff++;
	}
	write_command_data(ST7735_RAMWR, lcd_buff, (x1 - x0));
	write_command_data(ST7735_NOP, NULL, 0);
}

/*************************************************/
void lcdDrawVLine(uint16_t x, uint16_t y0, uint16_t y1, uint16_t color)
{
	// Allows for slightly better performance than setting individual pixels
	uint16_t y, pixels;

	if (y1 < y0)
	{
		y = y1;
		y1 = y0;
		y0 = y;
	}

	// Check limits
	if (y1 >= DEFAULT_FB_YRES)
		y1 = DEFAULT_FB_YRES - 1;
	if (y0 >= DEFAULT_FB_YRES)
		y0 = DEFAULT_FB_YRES - 1;

	st7735SetAddrWindow(x, y0, x, DEFAULT_FB_YRES);
	for (pixels = 0; pixels < y1 - y0 + 1; pixels++)
	{
		*(uint16_t *)lcd_buff = DataH(color >> 8);
		lcd_buff++;
	}
	write_command_data(ST7735_RAMWR, lcd_buff, (y1 - y0));
}

static void st7735fb_display_picture(u8 p_x, u8 line, u8 W, u8 H,
	u8 *buf,u16 txt_color, u16 bg_color){
	int i,j,k;
	u8 c;
	int index,size;
	uint16_t *buff = lcd_buff;

	st7735SetAddrWindow(line, p_x, (line+H-1), (p_x+W-1));

	index = 0;
	for(i=0;i<W;i++){
		for(k=(H/8 -1);k>=0;k--){
			c = *buf++;
			for(j=(8-1);j>=0;j--){
				if((1<<(7-j)) & c){
					*(uint16_t *)(buff++) = DataH((txt_color >> 8)&0xff);
					*(uint16_t *)(buff++) = DataH(txt_color&0xff);
				}else{
					*(uint16_t *)(buff++) = DataH((bg_color >> 8)&0xff);
					*(uint16_t *)(buff++) = DataH(bg_color&0xff);
				}
				index++;
			}
	   }
	}
	size = index;
	write_command_data(ST7735_RAMWR, lcd_buff, size*8);
}

static void st7735fb_draw_logo(void)
{
	st7735fb_display_picture(0x20, 0x40, 0x40, 0x20,
			(u8 *)marvell_logo, 0xffff, 0x0000);
}

void lcdTest(void)
{
	uint8_t i = 0;
	for (i = 0; i < 100; i++)
	{
		lcdDrawPixel(i, i, 0xFFFF);
	}
}