Merge branch 'master' of https://bitbucket.org/Tectu/ugfx

12 files changed, 101 insertions, 995 deletions

diff --git a/drivers/gdisp/SSD1331/gdisp_lld_SSD1331.c b/drivers/gdisp/SSD1331/gdisp_lld_SSD1331.c
index 93a5d0a8..af2a0e06 100644
--- a/drivers/gdisp/SSD1331/gdisp_lld_SSD1331.c
+++ b/drivers/gdisp/SSD1331/gdisp_lld_SSD1331.c
@@ -110,12 +110,12 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 
 	write_cmd(g, SSD1331_DISPLAY_ON);
 
- 	// Release the bus
-	release_bus(g);
-
     // Finish Init
     post_init_board(g);
 
+ 	// Release the bus
+	release_bus(g);
+
 	/* Initialise the GDISP structure */
 	g->g.Width = GDISP_SCREEN_WIDTH;
 	g->g.Height = GDISP_SCREEN_HEIGHT;
diff --git a/drivers/gdisp/SSD1351/gdisp_lld_SSD1351.c b/drivers/gdisp/SSD1351/gdisp_lld_SSD1351.c
index e7fd6cff..87aaf38f 100644
--- a/drivers/gdisp/SSD1351/gdisp_lld_SSD1351.c
+++ b/drivers/gdisp/SSD1351/gdisp_lld_SSD1351.c
@@ -118,8 +118,6 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 	write_cmd(g, 0xAF); // sleep mode OFF (display on)
 	write_cmd(g, 0x5C); // write to RAM
 
-	release_bus(g);
-
     // Finish Init
     post_init_board(g);
 
diff --git a/drivers/gdisp/STM32F429iDiscovery/board_STM32F429iDiscovery_template.h b/drivers/gdisp/STM32F429iDiscovery/board_STM32F429iDiscovery_template.h
deleted file mode 100644
index e13af4b3..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/board_STM32F429iDiscovery_template.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef _GDISP_LLD_BOARD_H
-#define _GDISP_LLD_BOARD_H
-
-static const ltdcConfig driverCfg = {
-	240, 320,
-	10, 2,
-	20, 2,
-	10, 4,
-	0,
-	0x000000,
-	{
-		(LLDCOLOR_TYPE *)SDRAM_BANK_ADDR,	// frame
-		240, 320,							// width, height
-		240 * LTDC_PIXELBYTES,				// pitch
-		LTDC_PIXELFORMAT,					// fmt
-		0, 0,								// x, y
-		240, 320,							// cx, cy
-		LTDC_COLOR_FUCHSIA,					// defcolor
-		0x980088,							// keycolor
-		LTDC_BLEND_FIX1_FIX2,				// blending
-		0,									// palette
-		0,									// palettelen
-		0xFF,								// alpha
-		LTDC_LEF_ENABLE						// flags
-	},
-	LTDC_UNUSED_LAYER_CONFIG
-};
-
-static GFXINLINE void init_board(GDisplay *g) {
-
-	// As we are not using multiple displays we set g->board to NULL as we don't use it.
-	g->board = 0;
-
-	switch(g->controllerdisplay) {
-	case 0:											// Set up for Display 0
-		// Your init here
-		break;
-	}
-}
-
-static GFXINLINE void post_init_board(GDisplay *g) {
-}
-
-static GFXINLINE void set_backlight(GDisplay *g, uint8_t percent) {
-}
-
-static GFXINLINE void acquire_bus(GDisplay *g) {
-}
-
-static GFXINLINE void release_bus(GDisplay *g) {
-}
-
-static GFXINLINE void write_index(GDisplay *g, uint8_t index) {
-}
-
-static GFXINLINE void write_data(GDisplay *g, uint8_t data) {
-}
-
-#endif /* _GDISP_LLD_BOARD_H */
diff --git a/drivers/gdisp/STM32F429iDiscovery/driver.mk b/drivers/gdisp/STM32F429iDiscovery/driver.mk
deleted file mode 100644
index afad5b85..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/driver.mk
+++ /dev/null
@@ -1,2 +0,0 @@
-GFXINC +=	$(GFXLIB)/drivers/gdisp/STM32F429iDiscovery
-GFXSRC +=	$(GFXLIB)/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_STM32F429iDiscovery.c
diff --git a/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_STM32F429iDiscovery.c b/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_STM32F429iDiscovery.c
deleted file mode 100644
index 91e914d3..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_STM32F429iDiscovery.c
+++ /dev/null
@@ -1,520 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#include "gfx.h"
-
-#if GFX_USE_GDISP
-
-#if defined(GDISP_SCREEN_HEIGHT)
-	#warning "GDISP: This low level driver does not support setting a screen size. It is being ignored."
-	#undef GISP_SCREEN_HEIGHT
-#endif
-#if defined(GDISP_SCREEN_WIDTH)
-	#warning "GDISP: This low level driver does not support setting a screen size. It is being ignored."
-	#undef GDISP_SCREEN_WIDTH
-#endif
-
-#ifndef LTDC_USE_DMA2D
- 	#define LTDC_USE_DMA2D FALSE
-#endif
-
-#define GDISP_DRIVER_VMT			GDISPVMT_STM32F429iDiscovery
-#include "gdisp_lld_config.h"
-#include "../../../src/gdisp/gdisp_driver.h"
-
-#include "stm32_ltdc.h"
-
-#if LTDC_USE_DMA2D
- 	#include "stm32_dma2d.h"
-#endif
-
-typedef struct ltdcLayerConfig {
-	// frame
-	LLDCOLOR_TYPE	*frame;			// Frame buffer address
-	coord_t			width, height;	// Frame size in pixels
-	coord_t			pitch;			// Line pitch, in bytes
-	uint16_t		fmt;			// Pixel format in LTDC format
-
-	// window
-	coord_t			x, y;			// Start pixel position of the virtual layer
-	coord_t			cx, cy;			// Size of the virtual layer
-
-	uint32_t		defcolor;		// Default color, ARGB8888
-	uint32_t		keycolor;		// Color key, RGB888
-	uint32_t		blending;		// Blending factors
-	const uint32_t *palette;		// The palette, RGB888 (can be NULL)
-	uint16_t		palettelen;		// Palette length
-	uint8_t			alpha;			// Constant alpha factor
-	uint8_t			layerflags;		// Layer configuration
-} ltdcLayerConfig;
-
-#define LTDC_UNUSED_LAYER_CONFIG	{ 0, 1, 1, 1, LTDC_FMT_L8, 0, 0, 1, 1, 0x000000, 0x000000, LTDC_BLEND_FIX1_FIX2, 0, 0, 0, 0 }
-
-typedef struct ltdcConfig {
-	coord_t		width, height;				// Screen size
-	coord_t		hsync, vsync;				// Horizontal and Vertical sync pixels
-	coord_t		hbackporch, vbackporch;		// Horizontal and Vertical back porch pixels
-	coord_t		hfrontporch, vfrontporch;	// Horizontal and Vertical front porch pixels
-	uint8_t		syncflags;					// Sync flags
-	uint32_t	bgcolor;					// Clear screen color RGB888
-
-	ltdcLayerConfig	bglayer;				// Background layer config
-	ltdcLayerConfig	fglayer;				// Foreground layer config
-} ltdcConfig;
-
-#if GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565
-	#define LTDC_PIXELFORMAT	LTDC_FMT_RGB565
-	#define LTDC_PIXELBYTES		2
-	#define LTDC_PIXELBITS		16
-#elif GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
-	#define LTDC_PIXELFORMAT	LTDC_FMT_RGB888
-	#define LTDC_PIXELBYTES		3
-	#define LTDC_PIXELBITS		24
-#else
-	#error "GDISP: STM32F4iDiscovery - unsupported pixel format"
-#endif
-
-#include "board_STM32F429iDiscovery.h"
-
-#include "ili9341.h"
-
-/*===========================================================================*/
-/* Driver local definitions.                                                 */
-/*===========================================================================*/
-
-#ifndef GDISP_INITIAL_CONTRAST
-	#define GDISP_INITIAL_CONTRAST	50
-#endif
-#ifndef GDISP_INITIAL_BACKLIGHT
-	#define GDISP_INITIAL_BACKLIGHT	100
-#endif
-
-/*===========================================================================*/
-/* Driver local routines    .                                                */
-/*===========================================================================*/
-
-#define PIXIL_POS(g, x, y)		((y) * driverCfg.bglayer.pitch + (x) * LTDC_PIXELBYTES)
-#define PIXEL_ADDR(g, pos)		((LLDCOLOR_TYPE *)((uint8_t *)driverCfg.bglayer.frame+pos))
-
-/*===========================================================================*/
-/* Driver exported functions.                                                */
-/*===========================================================================*/
-
-static void InitController(GDisplay *g) {
-	#define REG_TYPEMASK	0xFF00
-	#define REG_DATAMASK	0x00FF
-
-	#define REG_DATA		0x0000
-	#define REG_COMMAND		0x0100
-	#define REG_DELAY		0x0200
-
-	static const uint16_t initdata[] = {
-			REG_COMMAND | ILI9341_CMD_RESET,
-			REG_DELAY   | 5,
-			REG_COMMAND | ILI9341_CMD_DISPLAY_OFF,
-			REG_COMMAND | ILI9341_SET_FRAME_CTL_NORMAL, 0x00, 0x1B,
-			REG_COMMAND | ILI9341_SET_FUNCTION_CTL, 0x0A, 0xA2,
-			REG_COMMAND | ILI9341_SET_POWER_CTL_1, 0x10,
-			REG_COMMAND | ILI9341_SET_POWER_CTL_2, 0x10,
-			#if 1
-				REG_COMMAND | ILI9341_SET_VCOM_CTL_1, 0x45, 0x15,
-				REG_COMMAND | ILI9341_SET_VCOM_CTL_2, 0x90,
-			#else
-				REG_COMMAND | ILI9341_SET_VCOM_CTL_1, 0x35, 0x3E,
-				REG_COMMAND | ILI9341_SET_VCOM_CTL_2, 0xBE,
-			#endif
-			REG_COMMAND | ILI9341_SET_MEM_ACS_CTL, 0xC8,
-			REG_COMMAND | ILI9341_SET_RGB_IF_SIG_CTL, 0xC2,
-			REG_COMMAND | ILI9341_SET_FUNCTION_CTL, 0x0A, 0xA7, 0x27, 0x04,
-			REG_COMMAND | ILI9341_SET_COL_ADDR, 0x00, 0x00, 0x00, 0xEF,
-			REG_COMMAND | ILI9341_SET_PAGE_ADDR, 0x00, 0x00, 0x01, 0x3F,
-			REG_COMMAND | ILI9341_SET_IF_CTL, 0x01, 0x00, 0x06,
-			REG_COMMAND | ILI9341_SET_GAMMA, 0x01,
-			REG_COMMAND | ILI9341_SET_PGAMMA,
-				#if 1
-					0x0F, 0x29, 0x24, 0x0C, 0x0E, 0x09, 0x4E, 0x78,
-					0x3C, 0x09, 0x13, 0x05, 0x17, 0x11, 0x00,
-				#else
-					0x1F, 0x1a, 0x18, 0x0a, 0x0f, 0x06, 0x45, 0x87,
-					0x32, 0x0a, 0x07, 0x02, 0x07, 0x05, 0x00,
-				#endif
-			REG_COMMAND | ILI9341_SET_NGAMMA,
-				#if 1
-					0x00, 0x16, 0x1B, 0x04, 0x11, 0x07, 0x31, 0x33,
-					0x42, 0x05, 0x0C, 0x0A, 0x28, 0x2F, 0x0F,
-				#else
-					0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3a, 0x78,
-					0x4d, 0x05, 0x18, 0x0d, 0x38, 0x3a, 0x1f,
-				#endif
-			REG_COMMAND | ILI9341_CMD_SLEEP_OFF,
-			REG_DELAY   | 10,
-			REG_COMMAND | ILI9341_CMD_DISPLAY_ON,
-			REG_COMMAND | ILI9341_SET_MEM
-	};
-
-	const uint16_t	*p;
-
-	acquire_bus(g);
-	for(p = initdata; p < &initdata[sizeof(initdata)/sizeof(initdata[0])]; p++) {
-		switch(*p & REG_TYPEMASK) {
-		case REG_DATA:		write_data(g, *p);					break;
-		case REG_COMMAND:	write_index(g, *p);					break;
-		case REG_DELAY:		gfxSleepMilliseconds(*p & 0xFF);	break;
-		}
-	}
-	release_bus(g);
-}
-
-static void LTDC_Reload(void) {
-	LTDC->SRCR |= LTDC_SRCR_IMR;
-	while (LTDC->SRCR & (LTDC_SRCR_IMR | LTDC_SRCR_VBR))
-		gfxYield();
-}
-
-static void LTDC_LayerInit(LTDC_Layer_TypeDef *pLayReg, const ltdcLayerConfig * pCfg) {
-	static const uint8_t fmt2Bpp[] = {
-		4, /* LTDC_FMT_ARGB8888 */
-		3, /* LTDC_FMT_RGB888 */
-		2, /* LTDC_FMT_RGB565 */
-		2, /* LTDC_FMT_ARGB1555 */
-		2, /* LTDC_FMT_ARGB4444 */
-		1, /* LTDC_FMT_L8 */
-		1, /* LTDC_FMT_AL44 */
-		2  /* LTDC_FMT_AL88 */
-	};
-	uint32_t start, stop;
-
-	// Set the framebuffer dimensions and format
-	pLayReg->PFCR = (pLayReg->PFCR & ~LTDC_LxPFCR_PF) | ((uint32_t)pCfg->fmt & LTDC_LxPFCR_PF);
-	pLayReg->CFBAR = (uint32_t)pCfg->frame & LTDC_LxCFBAR_CFBADD;
-	pLayReg->CFBLR = ((((uint32_t)pCfg->pitch << 16) & LTDC_LxCFBLR_CFBP) | (((uint32_t)fmt2Bpp[pCfg->fmt] * pCfg->width + 3) & LTDC_LxCFBLR_CFBLL));
-	pLayReg->CFBLNR = (uint32_t)pCfg->height & LTDC_LxCFBLNR_CFBLNBR;
-
-	// Set the display window boundaries
-	start = (uint32_t)pCfg->x + driverCfg.hsync + driverCfg.hbackporch;
-	stop  = start + pCfg->cx - 1;
-	pLayReg->WHPCR = ((start <<  0) & LTDC_LxWHPCR_WHSTPOS) | ((stop  << 16) & LTDC_LxWHPCR_WHSPPOS);
-	start = (uint32_t)pCfg->y + driverCfg.vsync + driverCfg.vbackporch;
-	stop  = start + pCfg->cy - 1;
-	pLayReg->WVPCR = ((start <<  0) & LTDC_LxWVPCR_WVSTPOS) | ((stop  << 16) & LTDC_LxWVPCR_WVSPPOS);
-
-	// Set colors
-	pLayReg->DCCR = pCfg->defcolor;
-	pLayReg->CKCR = (pLayReg->CKCR & ~0x00FFFFFF) | (pCfg->keycolor & 0x00FFFFFF);
-	pLayReg->CACR = (pLayReg->CACR & ~LTDC_LxCACR_CONSTA) | ((uint32_t)pCfg->alpha & LTDC_LxCACR_CONSTA);
-	pLayReg->BFCR = (pLayReg->BFCR & ~(LTDC_LxBFCR_BF1 | LTDC_LxBFCR_BF2)) | ((uint32_t)pCfg->blending & (LTDC_LxBFCR_BF1 | LTDC_LxBFCR_BF2));
-	for (start = 0; start < pCfg->palettelen; start++)
-		pLayReg->CLUTWR = ((uint32_t)start << 24) | (pCfg->palette[start] & 0x00FFFFFF);
-
-	// Final flags
-	pLayReg->CR = (pLayReg->CR & ~LTDC_LEF_MASK) | ((uint32_t)pCfg->layerflags & LTDC_LEF_MASK);
-}
-
-static void LTDC_Init(void) {
-	// Set up the display scanning
-	uint32_t hacc, vacc;
-
-	/* Reset the LTDC hardware module.*/
-	RCC->APB2RSTR |= RCC_APB2RSTR_LTDCRST;
-	RCC->APB2RSTR = 0;
-
-	/* Enable the LTDC clock.*/
-	RCC->DCKCFGR = (RCC->DCKCFGR & ~RCC_DCKCFGR_PLLSAIDIVR) | (1 << 16); /* /4 */
-
-	// Enable the module
-	RCC->APB2ENR |= RCC_APB2ENR_LTDCEN;
-
-	// Turn off the controller and its interrupts.
-	LTDC->GCR = 0;
-	LTDC->IER = 0;
-	LTDC_Reload();
-
-	// Set synchronization params
-	hacc = driverCfg.hsync - 1;
-	vacc = driverCfg.vsync - 1;
-	LTDC->SSCR = ((hacc << 16) & LTDC_SSCR_HSW) | ((vacc <<  0) & LTDC_SSCR_VSH);
-
-	// Set accumulated back porch params
-	hacc += driverCfg.hbackporch;
-	vacc += driverCfg.vbackporch;
-	LTDC->BPCR = ((hacc << 16) & LTDC_BPCR_AHBP) | ((vacc <<  0) & LTDC_BPCR_AVBP);
-
-	// Set accumulated active params
-	hacc += driverCfg.width;
-	vacc += driverCfg.height;
-	LTDC->AWCR = ((hacc << 16) & LTDC_AWCR_AAW) | ((vacc <<  0) & LTDC_AWCR_AAH);
-
-	// Set accumulated total params
-	hacc += driverCfg.hfrontporch;
-	vacc += driverCfg.vfrontporch;
-	LTDC->TWCR = ((hacc << 16) & LTDC_TWCR_TOTALW) | ((vacc <<  0) & LTDC_TWCR_TOTALH);
-
-	// Set signal polarities and other flags
-	LTDC->GCR = driverCfg.syncflags & (LTDC_EF_MASK & ~LTDC_EF_ENABLE);
-
-	// Set background color
-	LTDC->BCCR = (LTDC->BCCR & ~0x00FFFFFF) | (driverCfg.bgcolor & 0x00FFFFFF);
-
-	// Load the background layer
-	LTDC_LayerInit(LTDC_Layer1, &driverCfg.bglayer);
-
-	// Load the foreground layer
-	LTDC_LayerInit(LTDC_Layer2, &driverCfg.fglayer);
-
-	// Interrupt handling
-	//nvicEnableVector(STM32_LTDC_EV_NUMBER, CORTEX_PRIORITY_MASK(STM32_LTDC_EV_IRQ_PRIORITY));
-	//nvicEnableVector(STM32_LTDC_ER_NUMBER, CORTEX_PRIORITY_MASK(STM32_LTDC_ER_IRQ_PRIORITY));
-	// Possible flags - LTDC_IER_RRIE, LTDC_IER_LIE, LTDC_IER_FUIE, LTDC_IER_TERRIE etc
-	LTDC->IER = 0;
-
-	// Set everything going
-	LTDC_Reload();
-	LTDC->GCR |= LTDC_GCR_LTDCEN;
-	LTDC_Reload();
-}
-
-LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
-
-	// Initialize the private structure
-	g->priv = 0;
-	g->board = 0;
-	//if (!(g->priv = gfxAlloc(sizeof(fbPriv))))
-	//	gfxHalt("GDISP Framebuffer: Failed to allocate private memory");
-
-	// Init the board
-	init_board(g);
-	//((fbPriv *)g->priv)->fbi.cfg = init_board(g);
-
-	// Initialise the ILI9341 controller
-	InitController(g);
-
-	// Initialise the LTDC controller
-	LTDC_Init();
-
-	// Initialise DMA2D
-	#if LTDC_USE_DMA2D
-		dma2d_init();
-	#endif
-
-	// Initialise DMA2D
-	//dma2dStart(&DMA2DD1, &dma2d_cfg);
-	//dma2d_test();
-
-    // Finish Init the board
-    post_init_board(g);
-
-	/* Turn on the back-light */
-	set_backlight(g, GDISP_INITIAL_BACKLIGHT);
-
-	/* Initialise the GDISP structure */
-	g->g.Width = driverCfg.bglayer.width;
-	g->g.Height = driverCfg.bglayer.height;
-	g->g.Orientation = GDISP_ROTATE_0;
-	g->g.Powermode = powerOn;
-	g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
-	g->g.Contrast = GDISP_INITIAL_CONTRAST;
-	return TRUE;
-}
-
-LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
-	unsigned	pos;
-
-	#if GDISP_NEED_CONTROL
-		switch(g->g.Orientation) {
-		case GDISP_ROTATE_0:
-		default:
-			pos = PIXIL_POS(g, g->p.x, g->p.y);
-			break;
-		case GDISP_ROTATE_90:
-			pos = PIXIL_POS(g, g->p.y, g->g.Width-g->p.x-1);
-			break;
-		case GDISP_ROTATE_180:
-			pos = PIXIL_POS(g, g->g.Width-g->p.x-1, g->g.Height-g->p.y-1);
-			break;
-		case GDISP_ROTATE_270:
-			pos = PIXIL_POS(g, g->g.Height-g->p.y-1, g->p.x);
-			break;
-		}
-	#else
-		pos = PIXIL_POS(g, g->p.x, g->p.y);
-	#endif
-
-		PIXEL_ADDR(g, pos)[0] = gdispColor2Native(g->p.color);
-}
-
-LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay *g) {
-	unsigned		pos;
-	LLDCOLOR_TYPE	color;
-
-	#if GDISP_NEED_CONTROL
-		switch(g->g.Orientation) {
-		case GDISP_ROTATE_0:
-		default:
-			pos = PIXIL_POS(g, g->p.x, g->p.y);
-			break;
-		case GDISP_ROTATE_90:
-			pos = PIXIL_POS(g, g->p.y, g->g.Width-g->p.x-1);
-			break;
-		case GDISP_ROTATE_180:
-			pos = PIXIL_POS(g, g->g.Width-g->p.x-1, g->g.Height-g->p.y-1);
-			break;
-		case GDISP_ROTATE_270:
-			pos = PIXIL_POS(g, g->g.Height-g->p.y-1, g->p.x);
-			break;
-		}
-	#else
-		pos = PIXIL_POS(g, g->p.x, g->p.y);
-	#endif
-
-	color = PIXEL_ADDR(g, pos)[0];
-	return gdispNative2Color(color);
-}
-
-#if GDISP_NEED_CONTROL
-	LLDSPEC void gdisp_lld_control(GDisplay *g) {
-		switch(g->p.x) {
-		case GDISP_CONTROL_POWER:
-			if (g->g.Powermode == (powermode_t)g->p.ptr)
-				return;
-			switch((powermode_t)g->p.ptr) {
-			case powerOff: case powerOn: case powerSleep: case powerDeepSleep:
-				// TODO
-				break;
-			default:
-				return;
-			}
-			g->g.Powermode = (powermode_t)g->p.ptr;
-			return;
-
-		case GDISP_CONTROL_ORIENTATION:
-			if (g->g.Orientation == (orientation_t)g->p.ptr)
-				return;
-			switch((orientation_t)g->p.ptr) {
-				case GDISP_ROTATE_0:
-				case GDISP_ROTATE_180:
-					if (g->g.Orientation == GDISP_ROTATE_90 || g->g.Orientation == GDISP_ROTATE_270) {
-						coord_t		tmp;
-
-						tmp = g->g.Width;
-						g->g.Width = g->g.Height;
-						g->g.Height = tmp;
-					}
-					break;
-				case GDISP_ROTATE_90:
-				case GDISP_ROTATE_270:
-					if (g->g.Orientation == GDISP_ROTATE_0 || g->g.Orientation == GDISP_ROTATE_180) {
-						coord_t		tmp;
-
-						tmp = g->g.Width;
-						g->g.Width = g->g.Height;
-						g->g.Height = tmp;
-					}
-					break;
-				default:
-					return;
-			}
-			g->g.Orientation = (orientation_t)g->p.ptr;
-			return;
-
-		case GDISP_CONTROL_BACKLIGHT:
-			if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
-			set_backlight(g, (unsigned)g->p.ptr);
-			g->g.Backlight = (unsigned)g->p.ptr;
-			return;
-
-		case GDISP_CONTROL_CONTRAST:
-			if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
-			// TODO
-			g->g.Contrast = (unsigned)g->p.ptr;
-			return;
-		}
-	}
-#endif
-
-#if LTDC_USE_DMA2D
-	static void dma2d_init(void)
-	{
-		// Enable DMA2D clock (DMA2DEN = 1)
-		RCC->AHB1ENR |= RCC_AHB1ENR_DMA2DEN;
-	
-		// Output color format
-		#if GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565
-			DMA2D->OPFCCR = OPFCCR_RGB565;
-		#elif GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
-			DMA2D->OPFCCR = OPFCCR_OPFCCR_RGB888;
-		#endif
-	
-		// Foreground color format
-		#if GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565
-			DMA2D->FGPFCCR = FGPFCCR_CM_RGB565;
-		#elif GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
-			DMA2D->FGPFCCR = FGPFCCR_CM_RGB888;
-		#endif
-	}
-
-	// Uses p.x,p.y  p.cx,p.cy  p.color
-	LLDSPEC void gdisp_lld_fill_area(GDisplay* g)
-	{
-		LLDCOLOR_TYPE c;
-	
-		// Wait until DMA2D is ready
-		while (1) {
-			if (!(DMA2D->CR & DMA2D_CR_START)) {
-				break;
-			}
-		}
-	
-		c = gdispColor2Native(g->p.color);
-	
-		// Output color register
-		DMA2D->OCOLR = (uint32_t)c;
-	
-		// Output memory address register
-		DMA2D->OMAR = g->p.y * g->g.Width * LTDC_PIXELBYTES + g->p.x * LTDC_PIXELBYTES + (uint32_t)driverCfg.bglayer.frame;
-
-		// Output offset register (in pixels)
-		DMA2D->OOR = g->g.Width - g->p.cx;
-	
-		// PL (pixel per lines to be transferred); NL (number of lines)
-		DMA2D->NLR = (g->p.cx << 16) | (g->p.cy);
-
-		// Set MODE to R2M and Start the process
-		DMA2D->CR = DMA2D_CR_MODE_R2M | DMA2D_CR_START;
-	}
-
-	// Uses p.x,p.y  p.cx,p.cy  p.x1,p.y1 (=srcx,srcy)  p.x2 (=srccx), p.ptr (=buffer)
-	LLDSPEC void gdisp_lld_blit_area(GDisplay* g)
-	{
-		// Wait until DMA2D is ready
-		while (1) {
-			if (!(DMA2D->CR & DMA2D_CR_START)) {
-				break;
-			}
-		}
-
-		// Foreground memory address register
-		DMA2D->FGMAR = g->p.y1 * g->p.x2 * LTDC_PIXELBYTES + g->p.x1 * LTDC_PIXELBYTES + (uint32_t)g->p.ptr;
-
-		// Foreground offset register (expressed in pixels)
-		DMA2D->FGOR = g->p.x2 - g->p.cx;
-	
-		// Output memory address register
-		DMA2D->OMAR = g->p.y * g->g.Width * LTDC_PIXELBYTES + g->p.x * LTDC_PIXELBYTES + (uint32_t)driverCfg.bglayer.frame;
-
-		// Output offset register (expressed in pixels)
-		DMA2D->OOR = g->g.Width - g->p.cx;
-	
-		// PL (pixel per lines to be transferred); NL (number of lines)
-		DMA2D->NLR = (g->p.cx << 16) | (g->p.cy);
-
-		// Set MODE to M2M and Start the process
-		DMA2D->CR = DMA2D_CR_MODE_M2M | DMA2D_CR_START;
-	}
-
-#endif /* LTDC_USE_DMA2D */
-
-#endif /* GFX_USE_GDISP */
diff --git a/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_config.h b/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_config.h
deleted file mode 100644
index c661f67c..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/gdisp_lld_config.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef _GDISP_LLD_CONFIG_H
-#define _GDISP_LLD_CONFIG_H
-
-#if GFX_USE_GDISP
-
-/*===========================================================================*/
-/* Driver hardware support.                                                  */
-/*===========================================================================*/
-
-#define	LTDC_USE_DMA2D					TRUE
-#define GDISP_HARDWARE_DRAWPIXEL		TRUE
-#define GDISP_HARDWARE_PIXELREAD		TRUE
-#define GDISP_HARDWARE_CONTROL			TRUE
-#define GDISP_LLD_PIXELFORMAT			GDISP_PIXELFORMAT_RGB565
-
-
-/*===========================================================================*/
-/* Don't change stuff below this line. Please.                               */
-/*===========================================================================*/
-
-#if LTDC_USE_DMA2D
- 	#define GDISP_HARDWARE_FILLS		TRUE
- 	#define GDISP_HARDWARE_BITFILLS		TRUE
-#else
- 	#define GDISP_HARDWARE_FILLS		FALSE
- 	#define GDISP_HARDWARE_BITFILLS		FALSE
-#endif /* GDISP_USE_DMA2D */
-
-#endif	/* GFX_USE_GDISP */
-
-#endif	/* _GDISP_LLD_CONFIG_H */
diff --git a/drivers/gdisp/STM32F429iDiscovery/ili9341.h b/drivers/gdisp/STM32F429iDiscovery/ili9341.h
deleted file mode 100644
index ae1620c0..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/ili9341.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef ILI9341_H
-#define ILI9341_H
-
-// ILI9341 commands
-#define ILI9341_CMD_NOP                 0x00    /**< No operation.*/
-#define ILI9341_CMD_RESET               0x01    /**< Software reset.*/
-#define ILI9341_GET_ID_INFO             0x04    /**< Get ID information.*/
-#define ILI9341_GET_STATUS              0x09    /**< Get status.*/
-#define ILI9341_GET_PWR_MODE            0x0A    /**< Get power mode.*/
-#define ILI9341_GET_MADCTL              0x0B    /**< Get MADCTL.*/
-#define ILI9341_GET_PIX_FMT             0x0C    /**< Get pixel format.*/
-#define ILI9341_GET_IMG_FMT             0x0D    /**< Get image format.*/
-#define ILI9341_GET_SIG_MODE            0x0E    /**< Get signal mode.*/
-#define ILI9341_GET_SELF_DIAG           0x0F    /**< Get self-diagnostics.*/
-#define ILI9341_CMD_SLEEP_ON            0x10    /**< Enter sleep mode.*/
-#define ILI9341_CMD_SLEEP_OFF           0x11    /**< Exist sleep mode.*/
-#define ILI9341_CMD_PARTIAL_ON          0x12    /**< Enter partial mode.*/
-#define ILI9341_CMD_PARTIAL_OFF         0x13    /**< Exit partial mode.*/
-#define ILI9341_CMD_INVERT_ON           0x20    /**< Enter inverted mode.*/
-#define ILI9341_CMD_INVERT_OFF          0x21    /**< Exit inverted mode.*/
-#define ILI9341_SET_GAMMA               0x26    /**< Set gamma params.*/
-#define ILI9341_CMD_DISPLAY_OFF         0x28    /**< Disable display.*/
-#define ILI9341_CMD_DISPLAY_ON          0x29    /**< Enable display.*/
-#define ILI9341_SET_COL_ADDR            0x2A    /**< Set column address.*/
-#define ILI9341_SET_PAGE_ADDR           0x2B    /**< Set page address.*/
-#define ILI9341_SET_MEM                 0x2C    /**< Set memory.*/
-#define ILI9341_SET_COLOR               0x2D    /**< Set color.*/
-#define ILI9341_GET_MEM                 0x2E    /**< Get memory.*/
-#define ILI9341_SET_PARTIAL_AREA        0x30    /**< Set partial area.*/
-#define ILI9341_SET_VSCROLL             0x33    /**< Set vertical scroll def.*/
-#define ILI9341_CMD_TEARING_ON          0x34    /**< Tearing line enabled.*/
-#define ILI9341_CMD_TEARING_OFF         0x35    /**< Tearing line disabled.*/
-#define ILI9341_SET_MEM_ACS_CTL         0x36    /**< Set mem access ctl.*/
-#define ILI9341_SET_VSCROLL_ADDR        0x37    /**< Set vscroll start addr.*/
-#define ILI9341_CMD_IDLE_OFF            0x38    /**< Exit idle mode.*/
-#define ILI9341_CMD_IDLE_ON             0x39    /**< Enter idle mode.*/
-#define ILI9341_SET_PIX_FMT             0x3A    /**< Set pixel format.*/
-#define ILI9341_SET_MEM_CONT            0x3C    /**< Set memory continue.*/
-#define ILI9341_GET_MEM_CONT            0x3E    /**< Get memory continue.*/
-#define ILI9341_SET_TEAR_SCANLINE       0x44    /**< Set tearing scanline.*/
-#define ILI9341_GET_TEAR_SCANLINE       0x45    /**< Get tearing scanline.*/
-#define ILI9341_SET_BRIGHTNESS          0x51    /**< Set brightness.*/
-#define ILI9341_GET_BRIGHTNESS          0x52    /**< Get brightness.*/
-#define ILI9341_SET_DISPLAY_CTL         0x53    /**< Set display ctl.*/
-#define ILI9341_GET_DISPLAY_CTL         0x54    /**< Get display ctl.*/
-#define ILI9341_SET_CABC                0x55    /**< Set CABC.*/
-#define ILI9341_GET_CABC                0x56    /**< Get CABC.*/
-#define ILI9341_SET_CABC_MIN            0x5E    /**< Set CABC min.*/
-#define ILI9341_GET_CABC_MIN            0x5F    /**< Set CABC max.*/
-#define ILI9341_GET_ID1                 0xDA    /**< Get ID1.*/
-#define ILI9341_GET_ID2                 0xDB    /**< Get ID2.*/
-#define ILI9341_GET_ID3                 0xDC    /**< Get ID3.*/
-
-// ILI9341 extended commands
-#define ILI9341_SET_RGB_IF_SIG_CTL      0xB0    /**< RGB IF signal ctl.*/
-#define ILI9341_SET_FRAME_CTL_NORMAL    0xB1    /**< Set frame ctl (normal).*/
-#define ILI9341_SET_FRAME_CTL_IDLE      0xB2    /**< Set frame ctl (idle).*/
-#define ILI9341_SET_FRAME_CTL_PARTIAL   0xB3    /**< Set frame ctl (partial).*/
-#define ILI9341_SET_INVERSION_CTL       0xB4    /**< Set inversion ctl.*/
-#define ILI9341_SET_BLANKING_PORCH_CTL  0xB5    /**< Set blanking porch ctl.*/
-#define ILI9341_SET_FUNCTION_CTL        0xB6    /**< Set function ctl.*/
-#define ILI9341_SET_ENTRY_MODE          0xB7    /**< Set entry mode.*/
-#define ILI9341_SET_LIGHT_CTL_1         0xB8    /**< Set backlight ctl 1.*/
-#define ILI9341_SET_LIGHT_CTL_2         0xB9    /**< Set backlight ctl 2.*/
-#define ILI9341_SET_LIGHT_CTL_3         0xBA    /**< Set backlight ctl 3.*/
-#define ILI9341_SET_LIGHT_CTL_4         0xBB    /**< Set backlight ctl 4.*/
-#define ILI9341_SET_LIGHT_CTL_5         0xBC    /**< Set backlight ctl 5.*/
-#define ILI9341_SET_LIGHT_CTL_7         0xBE    /**< Set backlight ctl 7.*/
-#define ILI9341_SET_LIGHT_CTL_8         0xBF    /**< Set backlight ctl 8.*/
-#define ILI9341_SET_POWER_CTL_1         0xC0    /**< Set power ctl 1.*/
-#define ILI9341_SET_POWER_CTL_2         0xC1    /**< Set power ctl 2.*/
-#define ILI9341_SET_VCOM_CTL_1          0xC5    /**< Set VCOM ctl 1.*/
-#define ILI9341_SET_VCOM_CTL_2          0xC6    /**< Set VCOM ctl 2.*/
-#define ILI9341_SET_NVMEM               0xD0    /**< Set NVMEM data.*/
-#define ILI9341_GET_NVMEM_KEY           0xD1    /**< Get NVMEM protect key.*/
-#define ILI9341_GET_NVMEM_STATUS        0xD2    /**< Get NVMEM status.*/
-#define ILI9341_GET_ID4                 0xD3    /**< Get ID4.*/
-#define ILI9341_SET_PGAMMA              0xE0    /**< Set positive gamma.*/
-#define ILI9341_SET_NGAMMA              0xE1    /**< Set negative gamma.*/
-#define ILI9341_SET_DGAMMA_CTL_1        0xE2    /**< Set digital gamma ctl 1.*/
-#define ILI9341_SET_DGAMMA_CTL_2        0xE3    /**< Set digital gamma ctl 2.*/
-#define ILI9341_SET_IF_CTL              0xF6    /**< Set interface control.*/
-
-// ILI9341 interface modes
-#define ILI9341_IM_3LSI_1               0x5     /**< 3-line serial, mode 1.*/
-#define ILI9341_IM_3LSI_2               0xD     /**< 3-line serial, mode 2.*/
-#define ILI9341_IM_4LSI_1               0x6     /**< 4-line serial, mode 1.*/
-#define ILI9341_IM_4LSI_2               0xE     /**< 4-line serial, mode 2.*/
-
-#endif /* ILI9341_H */
diff --git a/drivers/gdisp/STM32F429iDiscovery/readme.txt b/drivers/gdisp/STM32F429iDiscovery/readme.txt
deleted file mode 100644
index ce2dd03b..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/readme.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-To use this driver:
-
-1. Add in your gfxconf.h:
-	a) #define GFX_USE_GDISP		TRUE
-
-2. To your makefile add the following lines:
-	include $(GFXLIB)/gfx.mk
-	include $(GFXLIB)/drivers/gdisp/STM32F429iDiscovery/driver.mk
-
-3. Add a board_STM32F429iDiscovery.h to you project directory (or board directory)
-	base on one of the templates.
diff --git a/drivers/gdisp/STM32F429iDiscovery/stm32_dma2d.h b/drivers/gdisp/STM32F429iDiscovery/stm32_dma2d.h
deleted file mode 100644
index d3374d05..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/stm32_dma2d.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef _STM32_DMA2D_H
-#define _STM32_DMA2D_H
-
-#define OPFCCR_ARGB8888		0x00
-#define OPFCCR_RGB888		0x01
-#define OPFCCR_RGB565		0x02
-#define OPFCCR_ARGB1555		0x03
-#define OPFCCR_ARGB4444		0x04
-
-#define FGPFCCR_CM_RGB888	0x01
-#define FGPFCCR_CM_RGB565	0x02
-
-#define DMA2D_CR_MODE_R2M	((uint32_t)0x00030000)	/* Register-to-memory mode */
-#define DMA2D_CR_MODE_M2M	((uint32_t)0x00000000)	/* Register-to-memory mode */
-
-static void dma2d_init(void);
-
-#endif /* _STM32_DMA2D_H */
diff --git a/drivers/gdisp/STM32F429iDiscovery/stm32_ltdc.h b/drivers/gdisp/STM32F429iDiscovery/stm32_ltdc.h
deleted file mode 100644
index 866b9d89..00000000
--- a/drivers/gdisp/STM32F429iDiscovery/stm32_ltdc.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef STM32_LTDC_H
-#define STM32_LTDC_H
-
-// LTDC enable flags
-#define LTDC_EF_ENABLE          (1 <<  0)   /**< LTDC enabled.*/
-#define LTDC_EF_DITHER          (1 << 16)   /**< Dithering enabled.*/
-#define LTDC_EF_PIXCLK_INVERT   (1 << 28)   /**< Inverted pixel clock.*/
-#define LTDC_EF_DATAEN_HIGH     (1 << 29)   /**< Active-high data enable.*/
-#define LTDC_EF_VSYNC_HIGH      (1 << 30)   /**< Active-high vsync.*/
-#define LTDC_EF_HSYNC_HIGH      (1 << 31)   /**< Active-high hsync.*/
-
-#define LTDC_EF_MASK			(LTDC_EF_ENABLE | LTDC_EF_DITHER | LTDC_EF_PIXCLK_INVERT | LTDC_EF_DATAEN_HIGH | LTDC_EF_VSYNC_HIGH | LTDC_EF_HSYNC_HIGH)
-
-// LTDC layer enable flags
-#define LTDC_LEF_ENABLE         (1 << 0)    /**< Layer enabled*/
-#define LTDC_LEF_KEYING         (1 << 1)    /**< Color keying enabled.*/
-#define LTDC_LEF_PALETTE        (1 << 4)    /**< Palette enabled.*/
-
-#define LTDC_LEF_MASK			(LTDC_LEF_ENABLE | LTDC_LEF_KEYING | LTDC_LEF_PALETTE)
-
-// LTDC pixel formats
-#define LTDC_FMT_ARGB8888       0           /**< ARGB-8888 format.*/
-#define LTDC_FMT_RGB888         1           /**< RGB-888 format.*/
-#define LTDC_FMT_RGB565         2           /**< RGB-565 format.*/
-#define LTDC_FMT_ARGB1555       3           /**< ARGB-1555 format.*/
-#define LTDC_FMT_ARGB4444       4           /**< ARGB-4444 format.*/
-#define LTDC_FMT_L8             5           /**< L-8 format.*/
-#define LTDC_FMT_AL44           6           /**< AL-44 format.*/
-#define LTDC_FMT_AL88           7           /**< AL-88 format.*/
-
-// LTDC pixel format aliased raw masks
-#define LTDC_XMASK_ARGB8888     0xFFFFFFFF  /**< ARGB-8888 aliased mask.*/
-#define LTDC_XMASK_RGB888       0x00FFFFFF  /**< RGB-888 aliased mask.*/
-#define LTDC_XMASK_RGB565       0x00F8FCF8  /**< RGB-565 aliased mask.*/
-#define LTDC_XMASK_ARGB1555     0x80F8F8F8  /**< ARGB-1555 aliased mask.*/
-#define LTDC_XMASK_ARGB4444     0xF0F0F0F0  /**< ARGB-4444 aliased mask.*/
-#define LTDC_XMASK_L8           0x000000FF  /**< L-8 aliased mask.*/
-#define LTDC_XMASK_AL44         0xF00000F0  /**< AL-44 aliased mask.*/
-#define LTDC_XMASK_AL88         0xFF0000FF  /**< AL-88 aliased mask.*/
-
-// LTDC blending factors
-#define LTDC_BLEND_FIX1_FIX2    0x0405      /**<      cnst1; 1 -      cnst2 */
-#define LTDC_BLEND_FIX1_MOD2    0x0407      /**<      cnst1; 1 - a2 * cnst2 */
-#define LTDC_BLEND_MOD1_FIX2    0x0605      /**< a1 * cnst1; 1 -      cnst2 */
-#define LTDC_BLEND_MOD1_MOD2    0x0607      /**< a1 * cnst1; 1 - a2 * cnst2 */
-
-// LTDC parameter bounds
-#define LTDC_MIN_SCREEN_WIDTH           1
-#define LTDC_MIN_SCREEN_HEIGHT          1
-#define LTDC_MAX_SCREEN_WIDTH           800
-#define LTDC_MAX_SCREEN_HEIGHT          600
-
-#define LTDC_MIN_HSYNC_WIDTH            1
-#define LTDC_MIN_VSYNC_HEIGHT           1
-#define LTDC_MAX_HSYNC_WIDTH            (1 << 12)
-#define LTDC_MAX_VSYNC_HEIGHT           (1 << 11)
-
-#define LTDC_MIN_HBP_WIDTH              0
-#define LTDC_MIN_VBP_HEIGHT             0
-#define LTDC_MAX_HBP_WIDTH              (1 << 12)
-#define LTDC_MAX_VBP_HEIGHT             (1 << 11)
-
-#define LTDC_MIN_ACC_HBP_WIDTH          1
-#define LTDC_MIN_ACC_VBP_HEIGHT         1
-#define LTDC_MAX_ACC_HBP_WIDTH          (1 << 12)
-#define LTDC_MAX_ACC_VBP_HEIGHT         (1 << 11)
-
-#define LTDC_MIN_HFP_WIDTH              0
-#define LTDC_MIN_VFP_HEIGHT             0
-#define LTDC_MAX_HFP_WIDTH              (1 << 12)
-#define LTDC_MAX_VFP_HEIGHT             (1 << 11)
-
-#define LTDC_MIN_ACTIVE_WIDTH           0
-#define LTDC_MIN_ACTIVE_HEIGHT          0
-#define LTDC_MAX_ACTIVE_WIDTH           (1 << 12)
-#define LTDC_MAX_ACTIVE_HEIGHT          (1 << 11)
-
-#define LTDC_MIN_ACC_ACTIVE_WIDTH       1
-#define LTDC_MIN_ACC_ACTIVE_HEIGHT      1
-#define LTDC_MAX_ACC_ACTIVE_WIDTH       (1 << 12)
-#define LTDC_MAX_ACC_ACTIVE_HEIGHT      (1 << 11)
-
-#define LTDC_MIN_ACC_TOTAL_WIDTH        1
-#define LTDC_MIN_ACC_TOTAL_HEIGHT       1
-#define LTDC_MAX_ACC_TOTAL_WIDTH        (1 << 12)
-#define LTDC_MAX_ACC_TOTAL_HEIGHT       (1 << 11)
-
-#define LTDC_MIN_LINE_INTERRUPT_POS     0
-#define LTDC_MAX_LINE_INTERRUPT_POS     ((1 << 11) - 1)
-
-#define LTDC_MIN_WINDOW_HSTART          0
-#define LTDC_MIN_WINDOW_HSTART          0
-#define LTDC_MAX_WINDOW_HSTOP           ((1 << 12) - 1)
-#define LTDC_MAX_WINDOW_HSTOP           ((1 << 12) - 1)
-
-#define LTDC_MIN_WINDOW_VSTART          0
-#define LTDC_MIN_WINDOW_VSTART          0
-#define LTDC_MAX_WINDOW_VSTOP           ((1 << 11) - 1)
-#define LTDC_MAX_WINDOW_VSTOP           ((1 << 11) - 1)
-
-#define LTDC_MIN_FRAME_WIDTH_BYTES      0
-#define LTDC_MIN_FRAME_HEIGHT_LINES     0
-#define LTDC_MIN_FRAME_PITCH_BYTES      0
-#define LTDC_MAX_FRAME_WIDTH_BYTES      ((1 << 13) - 1 - 3)
-#define LTDC_MAX_FRAME_HEIGHT_LINES     ((1 << 11) - 1)
-#define LTDC_MAX_FRAME_PITCH_BYTES      ((1 << 13) - 1)
-
-#define LTDC_MIN_PIXFMT_ID              0
-#define LTDC_MAX_PIXFMT_ID              7
-
-#define LTDC_MAX_PALETTE_LENGTH         256
-
-// LTDC basic ARGB-8888 colors.
-#define LTDC_COLOR_BLACK        0xFF000000
-#define LTDC_COLOR_MAROON       0xFF800000
-#define LTDC_COLOR_GREEN        0xFF008000
-#define LTDC_COLOR_OLIVE        0xFF808000
-#define LTDC_COLOR_NAVY         0xFF000080
-#define LTDC_COLOR_PURPLE       0xFF800080
-#define LTDC_COLOR_TEAL         0xFF008080
-#define LTDC_COLOR_SILVER       0xFFC0C0C0
-#define LTDC_COLOR_GRAY         0xFF808080
-#define LTDC_COLOR_RED          0xFFFF0000
-#define LTDC_COLOR_LIME         0xFF00FF00
-#define LTDC_COLOR_YELLOW       0xFFFFFF00
-#define LTDC_COLOR_BLUE         0xFF0000FF
-#define LTDC_COLOR_FUCHSIA      0xFFFF00FF
-#define LTDC_COLOR_AQUA         0xFF00FFFF
-#define LTDC_COLOR_WHITE        0xFFFFFFFF
-
-#ifndef STM32F429_439xx
-#error "Currently only STM32F429xx and STM32F439xx are supported"
-#endif
-
-#endif /* STM32_LTDC_H */
diff --git a/drivers/gdisp/STM32LTDC/gdisp_lld_STM32LTDC.c b/drivers/gdisp/STM32LTDC/gdisp_lld_STM32LTDC.c
index 949088b5..9d1aafa0 100644
--- a/drivers/gdisp/STM32LTDC/gdisp_lld_STM32LTDC.c
+++ b/drivers/gdisp/STM32LTDC/gdisp_lld_STM32LTDC.c
@@ -102,17 +102,13 @@ typedef struct ltdcConfig {
 /* Driver exported functions.                                                */
 /*===========================================================================*/
 
-static void _ltdc_reload(void)
-{
+static void _ltdc_reload(void) {
 	LTDC->SRCR |= LTDC_SRCR_IMR;
-	
-	while (LTDC->SRCR & (LTDC_SRCR_IMR | LTDC_SRCR_VBR)) {
+	while (LTDC->SRCR & (LTDC_SRCR_IMR | LTDC_SRCR_VBR))
 		gfxYield();
-	}
 }
 
-static void _ltdc_layer_init(LTDC_Layer_TypeDef* pLayReg, const ltdcLayerConfig* pCfg)
-{
+static void _ltdc_layer_init(LTDC_Layer_TypeDef* pLayReg, const ltdcLayerConfig* pCfg) {
 	static const uint8_t fmt2Bpp[] = {
 		4, /* LTDC_FMT_ARGB8888 */
 		3, /* LTDC_FMT_RGB888 */
@@ -151,8 +147,7 @@ static void _ltdc_layer_init(LTDC_Layer_TypeDef* pLayReg, const ltdcLayerConfig*
 	pLayReg->CR = (pLayReg->CR & ~LTDC_LEF_MASK) | ((uint32_t)pCfg->layerflags & LTDC_LEF_MASK);
 }
 
-static void _ltdc_init(void)
-{
+static void _ltdc_init(void) {
 	// Set up the display scanning
 	uint32_t hacc, vacc;
 
@@ -161,9 +156,9 @@ static void _ltdc_init(void)
 	RCC->APB2RSTR = 0;
 
 	// Enable the LTDC clock
-	#if defined(STM32F4)
+	#if defined(STM32F4) || defined(STM32F429_439xx) || defined(STM32F429xx)
 		RCC->DCKCFGR = (RCC->DCKCFGR & ~RCC_DCKCFGR_PLLSAIDIVR) | (1 << 16);
-	#elif defined(STM32F7)
+	#elif defined(STM32F7) || defined(STM32F746xx)
 		RCC->DCKCFGR1 = (RCC->DCKCFGR1 & ~RCC_DCKCFGR1_PLLSAIDIVR) | (1 << 16);
 	#else
 		#error STM32LTDC driver not implemented for your platform
@@ -219,8 +214,7 @@ static void _ltdc_init(void)
 	_ltdc_reload();
 }
 
-LLDSPEC bool_t gdisp_lld_init(GDisplay* g)
-{
+LLDSPEC bool_t gdisp_lld_init(GDisplay* g) {
 	// Initialize the private structure
 	g->priv = 0;
 	g->board = 0;
@@ -253,8 +247,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay* g)
 	return TRUE;
 }
 
-LLDSPEC void gdisp_lld_draw_pixel(GDisplay* g)
-{
+LLDSPEC void gdisp_lld_draw_pixel(GDisplay* g) {
 	unsigned	pos;
 
 	#if GDISP_NEED_CONTROL
@@ -277,11 +270,14 @@ LLDSPEC void gdisp_lld_draw_pixel(GDisplay* g)
 		pos = PIXIL_POS(g, g->p.x, g->p.y);
 	#endif
 
-		PIXEL_ADDR(g, pos)[0] = gdispColor2Native(g->p.color);
+	#if LTDC_USE_DMA2D
+		while(DMA2D->CR & DMA2D_CR_START);
+	#endif
+
+	PIXEL_ADDR(g, pos)[0] = gdispColor2Native(g->p.color);
 }
 
-LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay* g)
-{
+LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay* g) {
 	unsigned		pos;
 	LLDCOLOR_TYPE	color;
 
@@ -305,24 +301,28 @@ LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay* g)
 		pos = PIXIL_POS(g, g->p.x, g->p.y);
 	#endif
 
+	#if LTDC_USE_DMA2D
+		while(DMA2D->CR & DMA2D_CR_START);
+	#endif
+
 	color = PIXEL_ADDR(g, pos)[0];
 	
 	return gdispNative2Color(color);
 }
 
 #if GDISP_NEED_CONTROL
-	LLDSPEC void gdisp_lld_control(GDisplay* g)
-	{
+	LLDSPEC void gdisp_lld_control(GDisplay* g) {
 		switch(g->p.x) {
 		case GDISP_CONTROL_POWER:
-			// Don't do anything if it is the same power mode
 			if (g->g.Powermode == (powermode_t)g->p.ptr)
 				return;
 			switch((powermode_t)g->p.ptr) {
+			case powerOff: case powerOn: case powerSleep: case powerDeepSleep:
+				// TODO
+				break;
 			default:
 				return;
 			}
-
 			g->g.Powermode = (powermode_t)g->p.ptr;
 			return;
 
@@ -353,7 +353,6 @@ LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay* g)
 				default:
 					return;
 			}
-
 			g->g.Orientation = (orientation_t)g->p.ptr;
 			return;
 
@@ -373,8 +372,7 @@ LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay* g)
 #endif
 
 #if LTDC_USE_DMA2D
-	static void dma2d_init(void)
-	{
+	static void dma2d_init(void) {
 		// Enable DMA2D clock
 		RCC->AHB1ENR |= RCC_AHB1ENR_DMA2DEN;
 	
@@ -396,91 +394,88 @@ LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay* g)
 	// Uses p.x,p.y  p.cx,p.cy  p.color
 	LLDSPEC void gdisp_lld_fill_area(GDisplay* g)
 	{	
-		uint32_t reg_omar = 0;
-		uint32_t reg_oor = 0;
-		uint32_t reg_nlr = 0;
+		uint32_t pos;
+		uint32_t lineadd;
+		uint32_t shape;
 
 		// Wait until DMA2D is ready
-		while (1) {
-			if (!(DMA2D->CR & DMA2D_CR_START)) {
-				break;
-			}
-		}
+		while(DMA2D->CR & DMA2D_CR_START);
 
-		// Calculate pixel positions and stuff like that
 		#if GDISP_NEED_CONTROL
 			switch(g->g.Orientation) {
 			case GDISP_ROTATE_0:
 			default:
-				reg_omar = g->p.y * g->g.Width * LTDC_PIXELBYTES + g->p.x * LTDC_PIXELBYTES + (uint32_t)driverCfg.bglayer.frame;
-				reg_oor = g->g.Width - g->p.cx;
-				reg_nlr = (g->p.cx << 16) | (g->p.cy);
+				pos = PIXIL_POS(g, g->p.x, g->p.y);
+				lineadd = g->g.Width - g->p.cx;
+				shape = (g->p.cx << 16) | (g->p.cy);
 				break;
-
 			case GDISP_ROTATE_90:
+				pos = PIXIL_POS(g, g->p.y, g->g.Width-g->p.x-g->p.cx);
+				lineadd = g->g.Height - g->p.cy;
+				shape = (g->p.cy << 16) | (g->p.cx);
 				break;
-
 			case GDISP_ROTATE_180:
-				reg_omar = g->g.Width * (g->g.Height - g->p.y - g->p.cy) * LTDC_PIXELBYTES + (g->g.Width - g->p.x - g->p.cx) * LTDC_PIXELBYTES + (uint32_t)driverCfg.bglayer.frame;
-				reg_oor = g->g.Width - g->p.cx;
-				reg_nlr = (g->p.cy << 16) | (g->p.cx);
+				pos = PIXIL_POS(g, g->g.Width-g->p.x-g->p.cx, g->g.Height-g->p.y-g->p.cy);
+				lineadd = g->g.Width - g->p.cx;
+				shape = (g->p.cx << 16) | (g->p.cy);
 				break;
-
 			case GDISP_ROTATE_270:
+				pos = PIXIL_POS(g, g->g.Height-g->p.y-g->p.cy, g->p.x);
+				lineadd = g->g.Height - g->p.cy;
+				shape = (g->p.cy << 16) | (g->p.cx);
 				break;
 			}
 		#else
-			reg_omar = g->p.y * g->g.Width * LTDC_PIXELBYTES + g->p.x * LTDC_PIXELBYTES + (uint32_t)driverCfg.bglayer.frame;
-			reg_oor = g->g.Width - g->p.cx;
-			reg_nlr = (g->p.cx << 16) | (g->p.cy);
+			pos = PIXIL_POS(g, g->p.x, g->p.y);
+			lineadd = g->g.Width - g->p.cx;
+			shape = (g->p.cx << 16) | (g->p.cy);
 		#endif
-
-		// Output memory address register
-		DMA2D->OMAR = reg_omar;
-
-		// Output offset register (in pixels)
-		DMA2D->OOR = reg_oor;
-
-		// PL (pixel per lines to be transferred); NL (number of lines)
-		DMA2D->NLR = reg_nlr;
-
-		// Output color register
+		
+		// Start the DMA2D
+		DMA2D->OMAR = (uint32_t)PIXEL_ADDR(g, pos);
+		DMA2D->OOR = lineadd;
+		DMA2D->NLR = shape;
 		DMA2D->OCOLR = (uint32_t)(gdispColor2Native(g->p.color));
-
-		// Set MODE to R2M and Start the process
 		DMA2D->CR = DMA2D_CR_MODE_R2M | DMA2D_CR_START;	
 	}
 
-	// Uses p.x,p.y  p.cx,p.cy  p.x1,p.y1 (=srcx,srcy)  p.x2 (=srccx), p.ptr (=buffer)
-	LLDSPEC void gdisp_lld_blit_area(GDisplay* g)
-	{
-		// Wait until DMA2D is ready
-		while (1) {
-			if (!(DMA2D->CR & DMA2D_CR_START)) {
-				break;
-			}
+	/* Oops - the DMA2D only supports GDISP_ROTATE_0.
+	 *
+	 * Where the width is 1 we can trick it for other orientations.
+	 * That is worthwhile as a width of 1 is common. For other
+	 * situations we need to fall back to pixel pushing.
+	 *
+	 * Additionally, although DMA2D can translate color formats
+	 * it can only do it for a small range of formats. For any
+	 * other formats we also need to fall back to pixel pushing.
+	 *
+	 * As the code to actually do all that for other than the
+	 * simplest case (orientation == GDISP_ROTATE_0 and
+	 * GDISP_PIXELFORMAT == GDISP_LLD_PIXELFORMAT) is very complex
+	 * we will always pixel push for now. In practice that is OK as
+	 * access to the framebuffer is fast - probably faster than DMA2D.
+	 * It just uses more CPU.
+	 */
+	#if GDISP_HARDWARE_BITFILLS 
+		// Uses p.x,p.y  p.cx,p.cy  p.x1,p.y1 (=srcx,srcy)  p.x2 (=srccx), p.ptr (=buffer)
+		LLDSPEC void gdisp_lld_blit_area(GDisplay* g) {
+			// Wait until DMA2D is ready
+			while(DMA2D->CR & DMA2D_CR_START);
+
+			// Source setup
+			DMA2D->FGMAR = LTDC_PIXELBYTES * (g->p.y1 * g->p.x2 + g->p.x1) + (uint32_t)g->p.ptr;
+			DMA2D->FGOR = g->p.x2 - g->p.cx;
+		
+			// Output setup
+			DMA2D->OMAR = (uint32_t)PIXEL_ADDR(g, PIXIL_POS(g, g->p.x, g->p.y));
+			DMA2D->OOR = g->g.Width - g->p.cx;
+			DMA2D->NLR = (g->p.cx << 16) | (g->p.cy);
+
+			// Set MODE to M2M and Start the process
+			DMA2D->CR = DMA2D_CR_MODE_M2M | DMA2D_CR_START;
 		}
-
-		// Foreground memory address register
-		DMA2D->FGMAR = g->p.y1 * g->p.x2 * LTDC_PIXELBYTES + g->p.x1 * LTDC_PIXELBYTES + (uint32_t)g->p.ptr;
-
-		// Foreground offset register (expressed in pixels)
-		DMA2D->FGOR = g->p.x2 - g->p.cx;
-	
-		// Output memory address register
-		DMA2D->OMAR = g->p.y * g->g.Width * LTDC_PIXELBYTES + g->p.x * LTDC_PIXELBYTES + (uint32_t)driverCfg.bglayer.frame;
-
-		// Output offset register (expressed in pixels)
-		DMA2D->OOR = g->g.Width - g->p.cx;
-	
-		// PL (pixel per lines to be transferred); NL (number of lines)
-		DMA2D->NLR = (g->p.cx << 16) | (g->p.cy);
-
-		// Set MODE to M2M and Start the process
-		DMA2D->CR = DMA2D_CR_MODE_M2M | DMA2D_CR_START;
-	}
+	#endif
 
 #endif /* LTDC_USE_DMA2D */
 
-
 #endif /* GFX_USE_GDISP */
diff --git a/drivers/gdisp/STM32LTDC/gdisp_lld_config.h b/drivers/gdisp/STM32LTDC/gdisp_lld_config.h
index 846fc1f0..5c3b1883 100644
--- a/drivers/gdisp/STM32LTDC/gdisp_lld_config.h
+++ b/drivers/gdisp/STM32LTDC/gdisp_lld_config.h
@@ -14,11 +14,15 @@
 /* Driver hardware support.                                                  */
 /*===========================================================================*/
 
-#define	LTDC_USE_DMA2D					FALSE	// Currently has display artifacts
-#define GDISP_HARDWARE_DRAWPIXEL		TRUE
-#define GDISP_HARDWARE_PIXELREAD		TRUE
-#define GDISP_HARDWARE_CONTROL			TRUE
-#define GDISP_LLD_PIXELFORMAT			GDISP_PIXELFORMAT_RGB565
+#define	LTDC_USE_DMA2D						TRUE
+#define GDISP_HARDWARE_DRAWPIXEL			TRUE
+#define GDISP_HARDWARE_PIXELREAD			TRUE
+#define GDISP_HARDWARE_CONTROL				TRUE
+
+// Both these pixel formats are supported - pick one.
+// RGB565 obviously is faster and uses less RAM but with lower color resolution than RGB888
+#define GDISP_LLD_PIXELFORMAT				GDISP_PIXELFORMAT_RGB565
+//#define GDISP_LLD_PIXELFORMAT				GDISP_PIXELFORMAT_RGB888
 
 
 /*===========================================================================*/
@@ -26,11 +30,14 @@
 /*===========================================================================*/
 
 #if LTDC_USE_DMA2D
+	// DMA2D supports accelerated fills
  	#define GDISP_HARDWARE_FILLS		TRUE
- 	#define GDISP_HARDWARE_BITFILLS		TRUE
-#else
- 	#define GDISP_HARDWARE_FILLS		FALSE
- 	#define GDISP_HARDWARE_BITFILLS		FALSE
+
+	// Accelerated bitfills are also possible but only for GDISP_ROTATE_0
+	//	and if no color translation is required (for now)
+	#if !GDISP_NEED_CONTROL && GDISP_PIXELFORMAT == GDISP_LLD_PIXELFORMAT
+ 		#define GDISP_HARDWARE_BITFILLS	TRUE
+	#endif
 #endif /* GDISP_USE_DMA2D */
 
 #endif	/* GFX_USE_GDISP */