Extracted font structure definitions, re-organised some files, added gdispS6d1121 driver

Created gdisp_fonts.h to describe the internal structure of a font.
Moved template directory to templates and created a sub-folder for each
low level driver type.
Moved the pre-defined font data and emulation code into better
locations.
Changed the emulation code to be included in the low level driver (where
it should be) instead of the high level driver.
Added new low level driver gdispS6d1121 (someone please test)
Updated and added new readme's.

6 files changed, 1330 insertions, 0 deletions

diff --git a/halext/drivers/gdispS6d1121/gdisp_lld.c b/halext/drivers/gdispS6d1121/gdisp_lld.c
new file mode 100644
index 00000000..fdf7dce9
--- /dev/null
+++ b/halext/drivers/gdispS6d1121/gdisp_lld.c
@@ -0,0 +1,695 @@
+/*

+    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,

+                 2011,2012 Giovanni Di Sirio.

+

+    This file is part of ChibiOS/RT.

+

+    ChibiOS/RT is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 3 of the License, or

+    (at your option) any later version.

+

+    ChibiOS/RT is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License

+    along with this program.  If not, see <http://www.gnu.org/licenses/>.

+

+                                      ---

+

+    A special exception to the GPL can be applied should you wish to distribute

+    a combined work that includes ChibiOS/RT, without being obliged to provide

+    the source code for any proprietary components. See the file exception.txt

+    for full details of how and when the exception can be applied.

+*/

+/*

+   Concepts and parts of this file have been contributed by:

+		Joel Bodenmann aka Tectu	-> Maintainer

+		Andrew Hannam aka inmarket	-> framework

+		Badger						-> console implementation and FSMC

+		Abhishek 					-> font rendering

+		Ben William					-> fastMath and lcdDrawEllipse()

+		Dongxu Li aka dxli			-> lcdDrawEllipse() filled option

+*/

+

+/**

+ * @file    gdispS6d1121/gdisp_lld.c

+ * @brief   GDISP Graphics Driver subsystem low level driver source for the S6d1121 display.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+

+#include "ch.h"

+#include "hal.h"

+#include "gdisp.h"

+#include "gdisp_fonts.h"

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

+/*===========================================================================*/

+/* Driver local definitions.                                                 */

+/*===========================================================================*/

+

+#ifdef UNUSED

+#elif defined(__GNUC__)

+# define UNUSED(x) UNUSED_ ## x __attribute__((unused))

+#elif defined(__LCLINT__)

+# define UNUSED(x) /*@unused@*/ x

+#else

+# define UNUSED(x) x

+#endif

+

+/*===========================================================================*/

+/* Driver exported variables.                                                */

+/*===========================================================================*/

+

+#if !defined(__DOXYGEN__)

+	GDISPDriver GDISP;

+#endif

+

+/*===========================================================================*/

+/* Driver local variables.                                                   */

+/*===========================================================================*/

+

+/*===========================================================================*/

+/* Driver local functions.                                                   */

+/*===========================================================================*/

+

+#include "s6d1121_lld.c.h"

+

+/*===========================================================================*/

+/* Driver interrupt handlers.                                                */

+/*===========================================================================*/

+

+/*===========================================================================*/

+/* Driver exported functions.                                                */

+/*===========================================================================*/

+

+/* Include the software emulation routines */

+#include "gdisp_lld_inc_emulation.c.h"

+

+/* ---- Required Routines ---- */

+/*

+	The following 2 routines are required.

+	All other routines are optional.

+*/

+

+/**

+ * @brief   Low level GDISP driver initialization.

+ *

+ * @notapi

+ */

+void gdisp_lld_init(void) {

+	palSetPadMode(LCD_RST_GPIO, LCD_RST_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+	// A Good idea to reset the module before using

+	LCD_RST_LOW;

+	s6d1121_delay(2);

+	LCD_RST_HIGH;         // Hardware Reset

+	s6d1121_delay(2);

+

+	#ifdef LCD_USE_GPIO

+		// IO Default Configurations

+		palSetPadMode(LCD_CS_GPIO, LCD_CS_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+		palSetPadMode(LCD_WR_GPIO, LCD_WR_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+		palSetPadMode(LCD_RD_GPIO, LCD_RD_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+		palSetPadMode(LCD_RS_GPIO, LCD_RS_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+		palSetPadMode(LCD_BL_GPIO, LCD_BL_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+

+		palSetGroupMode(LCD_D0_GPIO, 0x0000000F, 0, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+		palSetGroupMode(LCD_D4_GPIO, 0x0000FFF0, 0, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);

+

+		LCD_CS_HIGH;

+		LCD_RD_HIGH;

+		LCD_WR_HIGH;

+		LCD_BL_LOW;

+

+	#elif defined(LCD_USE_FSMC)

+		#if defined(STM32F1XX)

+			/* FSMC setup. TODO: this only works for STM32F1 */

+			rccEnableAHB(RCC_AHBENR_FSMCEN, 0);

+

+			/* TODO: pin setup */

+		#elif defined(STM32F4XX)

+			/* STM32F4 FSMC init */

+			rccEnableAHB3(RCC_AHB3ENR_FSMCEN, 0);

+

+			/* set pins to FSMC mode */

+			IOBus busD = {GPIOD, (1 << 0) | (1 << 1) | (1 << 4) | (1 << 5) | (1 << 7) | (1 << 8) |

+									(1 << 9) | (1 << 10) | (1 << 11) | (1 << 14) | (1 << 15), 0};

+

+			IOBus busE = {GPIOE, (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 12) |

+								(1 << 13) | (1 << 14) | (1 << 15), 0};

+

+			palSetBusMode(&busD, PAL_MODE_ALTERNATE(12));

+			palSetBusMode(&busE, PAL_MODE_ALTERNATE(12));

+		#else

+			#error "FSMC not implemented for this device"

+		#endif

+

+		int FSMC_Bank = 0;

+		/* FSMC timing */

+		FSMC_Bank1->BTCR[FSMC_Bank+1] = (10) | (10 << 8) | (10 << 16);

+

+		/* Bank1 NOR/SRAM control register configuration */

+		FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN;

+	#endif

+

+	lld_lcdWriteReg(0x11,0x2004);

+	lld_lcdWriteReg(0x13,0xCC00);

+	lld_lcdWriteReg(0x15,0x2600);

+	lld_lcdWriteReg(0x14,0x252A);

+	lld_lcdWriteReg(0x12,0x0033);

+	lld_lcdWriteReg(0x13,0xCC04);

+

+	s6d1121_delay(1);

+

+	lld_lcdWriteReg(0x13,0xCC06);

+

+	s6d1121_delay(1);

+

+	lld_lcdWriteReg(0x13,0xCC4F);

+

+	s6d1121_delay(1);

+

+	lld_lcdWriteReg(0x13,0x674F);

+	lld_lcdWriteReg(0x11,0x2003);

+

+	s6d1121_delay(1);

+

+	// Gamma Setting

+	lld_lcdWriteReg(0x30,0x2609);

+	lld_lcdWriteReg(0x31,0x242C);

+	lld_lcdWriteReg(0x32,0x1F23);

+	lld_lcdWriteReg(0x33,0x2425);

+	lld_lcdWriteReg(0x34,0x2226);

+	lld_lcdWriteReg(0x35,0x2523);

+	lld_lcdWriteReg(0x36,0x1C1A);

+	lld_lcdWriteReg(0x37,0x131D);

+	lld_lcdWriteReg(0x38,0x0B11);

+	lld_lcdWriteReg(0x39,0x1210);

+	lld_lcdWriteReg(0x3A,0x1315);

+	lld_lcdWriteReg(0x3B,0x3619);

+	lld_lcdWriteReg(0x3C,0x0D00);

+	lld_lcdWriteReg(0x3D,0x000D);

+

+	lld_lcdWriteReg(0x16,0x0007);

+	lld_lcdWriteReg(0x02,0x0013);

+	lld_lcdWriteReg(0x03,0x0003);

+	lld_lcdWriteReg(0x01,0x0127);

+

+	s6d1121_delay(1);

+

+	lld_lcdWriteReg(0x08,0x0303);

+	lld_lcdWriteReg(0x0A,0x000B);

+	lld_lcdWriteReg(0x0B,0x0003);

+	lld_lcdWriteReg(0x0C,0x0000);

+	lld_lcdWriteReg(0x41,0x0000);

+	lld_lcdWriteReg(0x50,0x0000);

+	lld_lcdWriteReg(0x60,0x0005);

+	lld_lcdWriteReg(0x70,0x000B);

+	lld_lcdWriteReg(0x71,0x0000);

+	lld_lcdWriteReg(0x78,0x0000);

+	lld_lcdWriteReg(0x7A,0x0000);

+	lld_lcdWriteReg(0x79,0x0007);

+	lld_lcdWriteReg(0x07,0x0051);

+

+	s6d1121_delay(1);

+

+	lld_lcdWriteReg(0x07,0x0053);

+	lld_lcdWriteReg(0x79,0x0000);

+

+	lld_lcdResetViewPort();

+

+	/* Now initialise the GDISP structure */

+	GDISP.Width = SCREEN_WIDTH;

+	GDISP.Height = SCREEN_HEIGHT;

+	GDISP.Orientation = portrait;

+	GDISP.Powermode = powerOn;

+}

+

+/**

+ * @brief   Draws a pixel on the display.

+ *

+ * @param[in] x        X location of the pixel

+ * @param[in] y        Y location of the pixel

+ * @param[in] color    The color of the pixel

+ *

+ * @notapi

+ */

+void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) {

+	#if GDISP_NEED_VALIDATION

+		if (x >= GDISP.Width || y >= GDISP.Height) return;

+	#endif

+	lld_lcdSetCursor(x, y);

+	lld_lcdWriteReg(0x0022, color);

+}

+

+/* ---- Optional Routines ---- */

+/*

+	All the below routines are optional.

+	Defining them will increase speed but everything

+	will work if they are not defined.

+	If you are not using a routine - turn it off using

+	the appropriate GDISP_HARDWARE_XXXX macro.

+	Don't bother coding for obvious similar routines if

+	there is no performance penalty as the emulation software

+	makes a good job of using similar routines.

+		eg. If gdisp_lld_fillarea() is defined there is little

+			point in defining gdisp_lld_clear() unless the

+			performance bonus is significant.

+	For good performance it is suggested to implement

+		gdisp_lld_fillarea() and gdisp_lld_blitarea().

+*/

+

+#if GDISP_HARDWARE_POWERCONTROL || defined(__DOXYGEN__)

+/**

+ * @brief   Sets the power mode for the graphic device.

+ * @note    The power modes are powerOn, powerSleep and powerOff.

+ *          If powerSleep is not supported it is equivalent to powerOn.

+ *

+ * @param[in] powerMode    The new power mode

+ *

+ * @notapi

+ */

+	void gdisp_lld_setpowermode(gdisp_powermode_t powerMode) {

+		if (GDISP.Powermode == powerMode)

+			return;

+

+		switch(powerMode) {

+			case powerOff:

+				/* 	Code here */

+				break;

+			case powerOn:

+				/* 	Code here */

+				/* You may need this ---

+					if (GDISP.Powermode != powerSleep)

+						gdisp_lld_init();

+				*/

+				break;

+			case powerSleep:

+				/* 	Code here */

+				break;

+			default:

+				return;

+		}

+

+		GDISP.Powermode = powerMode;

+	}

+#endif

+

+#if GDISP_HARDWARE_ORIENTATION || defined(__DOXYGEN__)

+	/**

+	 * @brief   Sets the orientation of the display.

+	 * @note    This may be ignored if not supported by the device.

+	 *

+	 * @param[in] newOrientation    The new orientation

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_setorientation(gdisp_orientation_t newOrientation) {

+		if (GDISP.Orientation == newOrientation)

+			return;

+

+		switch(newOrientation) {

+			case portrait:

+				lld_lcdWriteReg(0x0001,0x0127);

+				lld_lcdWriteReg(0x03, 0b0011);

+				GDISP.Height = SCREEN_HEIGHT;

+				GDISP.Width = SCREEN_WIDTH;

+				break;

+			case landscape:

+				lld_lcdWriteReg(0x0001,0x0027);

+				lld_lcdWriteReg(0x0003, 0b1011);

+				GDISP.Height = SCREEN_WIDTH;

+				GDISP.Width = SCREEN_HEIGHT;

+				break;

+			case portraitInv:

+				lld_lcdWriteReg(0x0001,0x0127);

+				lld_lcdWriteReg(0x0003, 0b0000);

+				GDISP.Height = SCREEN_HEIGHT;

+				GDISP.Width = SCREEN_WIDTH;

+				break;

+			case landscapeInv:

+				lld_lcdWriteReg(0x0001,0x0027);

+				lld_lcdWriteReg(0x0003, 0b1000);

+				GDISP.Height = SCREEN_WIDTH;

+				GDISP.Width = SCREEN_HEIGHT;

+				break;

+			default:

+				return;

+		}

+		GDISP.Orientation = newOrientation;

+	}

+#endif

+

+#if GDISP_HARDWARE_CLEARS || defined(__DOXYGEN__)

+	/**

+	 * @brief   Clear the display.

+	 * @note    Optional - The high level driver can emulate using software.

+	 *

+	 * @param[in] color    The color of the pixel

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_clear(color_t color) {

+	    unsigned i;

+

+	    lld_lcdSetCursor(0, 0);

+	    lld_lcdWriteStreamStart();

+

+	    for(i = 0; i < SCREEN_WIDTH * SCREEN_HEIGHT; i++)

+	    	lld_lcdWriteData(color);

+

+	    lld_lcdWriteStreamStop();

+	}

+#endif

+

+#if GDISP_HARDWARE_LINES || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a line.

+	 * @note    Optional - The high level driver can emulate using software.

+	 *

+	 * @param[in] x0, y0   The start of the line

+	 * @param[in] x1, y1   The end of the line

+	 * @param[in] color    The color of the line

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Need to clip to screen */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if GDISP_HARDWARE_BOX || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a box.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   The start position

+	 * @param[in] cx,cy   The size of the box (outside dimensions)

+	 * @param[in] color   The color to use

+	 * @param[in] filled  Should the box should be filled

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_drawbox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Need to clip to screen */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)

+	/**

+	 * @brief   Fill an area with a color.

+	 * @note    Optional - The high level driver can emulate using software.

+	 *

+	 * @param[in] x, y     The start filled area

+	 * @param[in] cx, cy   The width and height to be filled

+	 * @param[in] color    The color of the fill

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			if (cx < 1 || cy < 1 || x >= GDISP.Width || y >= GDISP.Height) return;

+			if (x+cx > GDISP.Width)	cx = GDISP.Width - x;

+			if (y+cy > GDISP.Height)	cy = GDISP.Height - y;

+		#endif

+

+		unsigned i, area;

+

+		area = cx*cy;

+		lld_lcdSetViewPort(x, y, cx, cy);

+		lld_lcdWriteStreamStart();

+		for(i = 0; i < area; i++)

+			lld_lcdWriteData(color);

+		lld_lcdWriteStreamStop();

+		lld_lcdResetViewPort();

+	}

+#endif

+

+#if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)

+	/**

+	 * @brief   Fill an area with a bitmap.

+	 * @note    Optional - The high level driver can emulate using software.

+	 *

+	 * @param[in] x, y     The start filled area

+	 * @param[in] cx, cy   The width and height to be filled

+	 * @param[in] buffer   The pixels to use to fill the area.

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {

+		unsigned i, area;

+

+		#if GDISP_NEED_VALIDATION

+			if (cx < 1 || cy < 1 || x >= GDISP.Width || y >= GDISP.Height) return;

+			if (x+cx > GDISP.Width) return;

+			if (y+cy > GDISP.Height)	cy = GDISP.Height - y;

+		#endif

+

+		area = cx*cy;

+		lld_lcdSetViewPort(x, y, cx, cy);

+		lld_lcdWriteStreamStart();

+		for(i = 0; i < area; i++)

+			lld_lcdWriteData(*buffer++);

+		lld_lcdWriteStreamStop();

+		lld_lcdResetViewPort();

+	}

+#endif

+

+/* Circular Drawing Functions */

+#if (GDISP_NEED_CIRCLE && GDISP_HARDWARE_CIRCLES) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a circle.

+	 * @note    Optional - The high level driver can emulate using software.

+	 * @note    If GDISP_NEED_CLIPPING is defined this routine MUST behave

+	 *          correctly if the circle is over the edges of the screen.

+	 *

+	 * @param[in] x, y     The centre of the circle

+	 * @param[in] radius   The radius of the circle

+	 * @param[in] color    The color of the circle

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Code here */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if (GDISP_NEED_CIRCLE && GDISP_HARDWARE_CIRCLEFILLS) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Create a filled circle.

+	 * @note    Optional - The high level driver can emulate using software.

+	 * @note    If GDISP_NEED_CLIPPING is defined this routine MUST behave

+	 *          correctly if the circle is over the edges of the screen.

+	 *

+	 * @param[in] x, y     The centre of the circle

+	 * @param[in] radius   The radius of the circle

+	 * @param[in] color    The color of the circle

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Code here */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if (GDISP_NEED_ELLIPSE && GDISP_HARDWARE_ELLIPSES) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw an ellipse.

+	 * @note    Optional - The high level driver can emulate using software.

+	 * @note    If GDISP_NEED_CLIPPING is defined this routine MUST behave

+	 *          correctly if the ellipse is over the edges of the screen.

+	 *

+	 * @param[in] x, y     The centre of the ellipse

+	 * @param[in] a, b     The dimensions of the ellipse

+	 * @param[in] color    The color of the ellipse

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Code here */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if (GDISP_NEED_ELLIPSE && GDISP_HARDWARE_ELLIPSEFILLS) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Create a filled ellipse.

+	 * @note    Optional - The high level driver can emulate using software.

+	 * @note    If GDISP_NEED_CLIPPING is defined this routine MUST behave

+	 *          correctly if the ellipse is over the edges of the screen.

+	 *

+	 * @param[in] x, y     The centre of the ellipse

+	 * @param[in] a, b     The dimensions of the ellipse

+	 * @param[in] color    The color of the ellipse

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Code here */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a character using a transparent background.

+	 * @note    Optional - The high level driver can emulate using software.

+	 *

+	 * @param[in] x, y     The top-left corner of the text

+	 * @param[in] c        The character to print

+	 * @param[in] color    The color of the character

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color) {

+		#if GDISP_NEED_VALIDATION

+			/* Code here */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXTFILLS) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a character using a filled background.

+	 * @note    Optional - The high level driver can emulate using software.

+	 *

+	 * @param[in] x, y     The top-left corner of the text

+	 * @param[in] c        The character to print

+	 * @param[in] color    The color of the character

+	 * @param[in] bgcolor  The background color

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {

+		#if GDISP_NEED_VALIDATION

+			/* Code here */

+		#endif

+		/* Code here */

+	}

+#endif

+

+#if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Get the color of a particular pixel.

+	 * @note    Optional.

+	 * @note    If x,y is off the screen, the result is undefined.

+	 *

+	 * @param[in] x, y     The start of the text

+	 *

+	 * @notapi

+	 */

+	color_t gdisp_lld_getpixelcolor(coord_t x, coord_t y) {

+		/* This routine is marked "DO NOT USE" in the original

+		 *  GLCD driver. We just keep our GDISP_HARDWARE_READPIXEL

+		 *  turned off for now.

+		 */

+		color_t color;

+

+		#if GDISP_NEED_VALIDATION

+			if (x >= GDISP.Width || y >= GDISP.Height) return 0;

+		#endif

+

+		lld_lcdSetCursor(x, y);

+		lld_lcdWriteStreamStart();

+

+		color = lld_lcdReadData();

+		color = lld_lcdReadData();

+

+		lld_lcdWriteStreamStop();

+

+		return color;

+	}

+#endif

+

+#if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Scroll vertically a section of the screen.

+	 * @note    Optional.

+	 * @note    If x,y + cx,cy is off the screen, the result is undefined.

+	 * @note    If lines is >= cy, it is equivelent to a area fill with bgcolor.

+	 *

+	 * @param[in] x, y     The start of the area to be scrolled

+	 * @param[in] cx, cy   The size of the area to be scrolled

+	 * @param[in] lines    The number of lines to scroll (Can be positive or negative)

+	 * @param[in] bgcolor  The color to fill the newly exposed area.

+	 *

+	 * @notapi

+	 */

+	void gdisp_lld_verticalscroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {

+		/* This is marked as "TODO: Test this" in the original GLCD driver.

+		 * For now we just leave the GDISP_HARDWARE_SCROLL off.

+		 */

+		static color_t buf[((SCREEN_HEIGHT > SCREEN_WIDTH ) ? SCREEN_HEIGHT : SCREEN_WIDTH)];

+		coord_t row0, row1;

+		unsigned i, gap, abslines;

+

+		abslines = lines < 0 ? -lines : lines;

+

+		#if GDISP_NEED_VALIDATION

+			if (cx < 1 || cy < 1 || x >= GDISP.Width || y >= GDISP.Height) return;

+			if (x+cx > GDISP.Width)	cx = GDISP.Width - x;

+			if (y+cy > GDISP.Height)	cy = GDISP.Height - y;

+		#endif

+

+		if (!abslines) return;

+		if (abslines >= cy) {

+			abslines = cy;

+			gap = 0;

+		} else {

+			gap = cy - abslines;

+			for(i = 0; i < gap; i++) {

+				if(lines > 0) {

+					row0 = y + i + lines;

+					row1 = y + i;

+				} else {

+					row0 = (y - i - 1) + lines;

+					row1 = (y - i - 1);

+				}

+

+				/* read row0 into the buffer and then write at row1*/

+				lld_lcdSetViewPort(x, row0, cx, 1);

+				lld_lcdReadStreamStart();

+				lld_lcdReadStream(buf, cx);

+				lld_lcdReadStreamStop();

+

+				lld_lcdSetViewPort(x, row1, cx, 1);

+				lld_lcdWriteStreamStart();

+				lld_lcdWriteStream(buf, cx);

+				lld_lcdWriteStreamStop();

+			}

+		}

+

+		/* fill the remaining gap */

+		lld_lcdSetViewPort(x, lines > 0 ? (y+gap) : y, cx, abslines);

+		lld_lcdWriteStreamStart();

+		gap = cx*abslines;

+		for(i = 0; i < gap; i++) lld_lcdWriteData(color);

+		lld_lcdWriteStreamStop();

+		lld_lcdResetViewPort();

+	}

+#endif

+

+#endif /* HAL_USE_GDISP */

+/** @} */

diff --git a/halext/drivers/gdispS6d1121/gdisp_lld.h b/halext/drivers/gdispS6d1121/gdisp_lld.h
new file mode 100644
index 00000000..55241715
--- /dev/null
+++ b/halext/drivers/gdispS6d1121/gdisp_lld.h
@@ -0,0 +1,166 @@
+/*
+    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+                 2011,2012 Giovanni Di Sirio.
+
+    This file is part of ChibiOS/RT.
+
+    ChibiOS/RT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/RT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+                                      ---
+
+    A special exception to the GPL can be applied should you wish to distribute
+    a combined work that includes ChibiOS/RT, without being obliged to provide
+    the source code for any proprietary components. See the file exception.txt
+    for full details of how and when the exception can be applied.
+*/
+/*
+   Concepts and parts of this file have been contributed by:
+		Joel Bodenmann aka Tectu	-> Maintainer
+		Andrew Hannam aka inmarket	-> framework
+		Badger						-> console implementation and FSMC
+		Abhishek 					-> font rendering
+		Ben William					-> fastMath and lcdDrawEllipse()
+		Dongxu Li aka dxli			-> lcdDrawEllipse() filled option
+*/
+
+/**
+ * @file    templates/gdisp_lld.h
+ * @brief   GDISP Graphic Driver subsystem low level driver header template.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_LLD_H
+#define _GDISP_LLD_H
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver constants.                                                         */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver pre-compile time settings.                                         */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Derived constants and error checks.                                       */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver data structures and types.                                         */
+/*===========================================================================*/
+
+/**
+ * @brief   Structure representing a GDISP driver.
+ * @note    Implementations may extend this structure to contain more,
+ *          architecture dependent, fields.
+ */
+struct GDISPDriver {
+	/**
+	 * @brief   Width of the screen.
+	 * @note    Read-only.
+	 */
+	coord_t				Width;
+	/**
+	 * @brief   Height of the screen.
+	 * @note    Read-only.
+	 */
+	coord_t				Height;
+	/**
+	 * @brief   Current orientation of the screen.
+	 * @note    Read-only.
+	 */
+	gdisp_orientation_t	Orientation;
+	/**
+	 * @brief   Current power mode of the screen.
+	 * @note    Read-only.
+	 */
+	gdisp_powermode_t	Powermode;
+	
+	#if defined(GDISP_DRIVER_EXT_FIELDS)
+	GDISP_DRIVER_EXT_FIELDS
+	#endif
+	/* End of mandatory fields */
+};
+
+/*===========================================================================*/
+/* Driver macros.                                                            */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#if !defined(__DOXYGEN__)
+	extern GDISPDriver GDISP;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	/* Core functions */
+	void gdisp_lld_init(void);
+	void gdisp_lld_setpowermode(gdisp_powermode_t powerMode);
+	void gdisp_lld_setorientation(gdisp_orientation_t newOrientation);
+
+	/* Some of these functions will be implemented in software by the high level driver
+	   depending on the GDISP_HARDWARE_XXX macros defined in gdisp_lld_config.h.
+	 */
+
+	/* Drawing functions */
+	void gdisp_lld_clear(color_t color);
+	void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color);
+	void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
+	void gdisp_lld_drawbox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+	void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+	void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer);
+
+	/* Circular Drawing Functions */
+	#if GDISP_NEED_CIRCLE
+	void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color);
+	void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color);
+	#endif
+
+	#if GDISP_NEED_ELLIPSE
+	void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	#endif
+
+	/* Text Rendering Functions */
+	#if GDISP_NEED_TEXT
+	void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color);
+	void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
+	#endif
+
+	/* Pixel readback */
+	#if GDISP_NEED_PIXELREAD
+	color_t gdisp_lld_getpixelcolor(coord_t x, coord_t y);
+	#endif
+
+	/* Scrolling Function - clears the area scrolled out */
+	#if GDISP_NEED_SCROLL
+	void gdisp_lld_verticalscroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
+	#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* HAL_USE_GDISP */
+
+#endif	/* _GDISP_LLD_H */
+/** @} */
diff --git a/halext/drivers/gdispS6d1121/gdisp_lld.mk b/halext/drivers/gdispS6d1121/gdisp_lld.mk
new file mode 100644
index 00000000..632655ea
--- /dev/null
+++ b/halext/drivers/gdispS6d1121/gdisp_lld.mk
@@ -0,0 +1,5 @@
+# List the required driver.

+HALSRC += ${CHIBIOS}/os/halext/drivers/gdispS6d1121/gdisp_lld.c

+

+# Required include directories

+HALINC += ${CHIBIOS}/os/halext/drivers/gdispS6d1121

diff --git a/halext/drivers/gdispS6d1121/gdisp_lld_config.h b/halext/drivers/gdispS6d1121/gdisp_lld_config.h
new file mode 100644
index 00000000..be9f81d8
--- /dev/null
+++ b/halext/drivers/gdispS6d1121/gdisp_lld_config.h
@@ -0,0 +1,224 @@
+/*
+    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+                 2011,2012 Giovanni Di Sirio.
+
+    This file is part of ChibiOS/RT.
+
+    ChibiOS/RT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/RT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+                                      ---
+
+    A special exception to the GPL can be applied should you wish to distribute
+    a combined work that includes ChibiOS/RT, without being obliged to provide
+    the source code for any proprietary components. See the file exception.txt
+    for full details of how and when the exception can be applied.
+*/
+/*
+   Concepts and parts of this file have been contributed by:
+		Joel Bodenmann aka Tectu	-> Maintainer
+		Andrew Hannam aka inmarket	-> framework
+		Badger						-> console implementation and FSMC
+		Abhishek 					-> font rendering
+		Ben William					-> fastMath and lcdDrawEllipse()
+		Dongxu Li aka dxli			-> lcdDrawEllipse() filled option
+*/
+
+/**
+ * @file    gdispS6d1121/gdisp_lld_config.h
+ * @brief   GDISP Graphic Driver subsystem low level driver header for the S6d1121 display.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_LLD_CONFIG_H
+#define _GDISP_LLD_CONFIG_H
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver pre-compile time settings.                                         */
+/*===========================================================================*/
+
+/**
+ * @name    GDISP hardware accelerated support
+ * @{
+ */
+	/**
+	 * @brief   Hardware supports changing the orientation.
+	 * @details If set to @p FALSE a software stubb is provided.
+	 */
+	#define GDISP_HARDWARE_ORIENTATION		TRUE
+
+	/**
+	 * @brief   Hardware supports power control.
+	 * @details If set to @p FALSE a software stubb is provided.
+	 */
+	#define GDISP_HARDWARE_POWERCONTROL		FALSE
+
+	/**
+	 * @brief   Hardware accelerated line drawing.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_LINES			FALSE
+
+	/**
+	 * @brief   Hardware accelerated box drawing.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_BOX				FALSE
+
+	/**
+	 * @brief   Hardware accelerated screen clears.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_CLEARS			TRUE
+
+	/**
+	 * @brief   Hardware accelerated rectangular fills.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_FILLS			TRUE
+
+	/**
+	 * @brief   Hardware accelerated fills from an image.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_BITFILLS			TRUE
+
+	/**
+	 * @brief   Hardware accelerated circles.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_CIRCLES			FALSE
+
+	/**
+	 * @brief   Hardware accelerated filled circles.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_CIRCLEFILLS		FALSE
+
+	/**
+	 * @brief   Hardware accelerated ellipses.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_ELLIPSES			FALSE
+
+	/**
+	 * @brief   Hardware accelerated filled ellipses.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_ELLIPSEFILLS		FALSE
+
+	/**
+	 * @brief   Hardware accelerated text drawing.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_TEXT				FALSE
+
+	/**
+	 * @brief   Hardware accelerated text drawing with a filled background.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_TEXTFILLS		FALSE
+
+	/**
+	 * @brief   Hardware accelerated scrolling.
+	 * @details If set to @p FALSE there is no support for scrolling.
+	 */
+	#define GDISP_HARDWARE_SCROLL			FALSE
+
+	/**
+	 * @brief   Reading back of pixel values.
+	 * @details If set to @p FALSE there is no support for pixel read-back.
+	 */
+	#define GDISP_HARDWARE_PIXELREAD		FALSE
+/** @} */
+
+/**
+ * @name    GDISP software algorithm choices
+ * @{
+ */
+	/**
+	 * @brief   For filled text drawing, use a background fill and then draw
+	 *			the text instead of using a blit or direct pixel drawing.
+	 * @details If set to @p TRUE background fill and then text draw is used.
+	 * @note    This is ignored if hardware accelerated text is supported.
+	 */
+	#define GDISP_SOFTWARE_TEXTFILLDRAW		FALSE
+	/**
+	 * @brief   For filled text drawing, when using a bitmap blit
+	 *			use a column by column buffer rather than a full character
+	 *			buffer to save memory at a small performance cost.
+	 * @details If set to @p TRUE background fill one character column at a time.
+	 * @note    This is ignored if software text using blit is not being used.
+	 */
+	#define GDISP_SOFTWARE_TEXTBLITCOLUMN	FALSE
+/** @} */
+
+/**
+ * @name    GDISP pixel format choices
+ * @{
+ */
+	/**
+	 * @brief   The native pixel format for this device
+	 * @note	One of the following should be defined:
+	 *				GDISP_PIXELFORMAT_RGB565
+	 *				GDISP_PIXELFORMAT_RGB888
+	 *				GDISP_PIXELFORMAT_RGB444
+	 *				GDISP_PIXELFORMAT_RGB332
+	 *				GDISP_PIXELFORMAT_RGB666
+	 *				GDISP_PIXELFORMAT_CUSTOM
+	 * @note	If you define GDISP_PIXELFORMAT_CUSTOM you need to also define
+	 *				color_t, RGB2COLOR(r,g,b), HTML2COLOR(h),
+	 *              RED_OF(c), GREEN_OF(c), BLUE_OF(c),
+	 *              COLOR(c) and MASKCOLOR.
+	 */
+	#define GDISP_PIXELFORMAT_RGB565
+
+	/**
+	 * @brief   Do pixels require packing for a blit
+	 * @note	Is only valid for a pixel format that doesn't fill it's datatype. ie formats:
+	 *				GDISP_PIXELFORMAT_RGB888
+	 *				GDISP_PIXELFORMAT_RGB444
+	 *				GDISP_PIXELFORMAT_RGB666
+	 *				GDISP_PIXELFORMAT_CUSTOM
+	 * @note	If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills
+	 *				you need to also define @P gdispPackPixels(buf,cx,x,y,c)
+	 * @note	If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel
+	 *				format must not be a packed format as the software blit does
+	 *				not support packed pixels
+	 * @note	Very few cases should actually require packed pixels as the low
+	 *				level driver can also pack on the fly as it is sending it
+	 *				to the graphics device.
+	 */
+	#define GDISP_PACKED_PIXELS			FALSE
+
+	/**
+	 * @brief   Do lines of pixels require packing for a blit
+	 * @note	Ignored if GDISP_PACKED_PIXELS is FALSE
+	 */
+	#define GDISP_PACKED_LINES			FALSE
+
+	/**
+	 * @brief   Do lines of pixels require packing for a blit
+	 * @note	Ignored if GDISP_PACKED_PIXELS is FALSE
+	 */
+	#define GDISP_PACKED_LINES			FALSE
+/** @} */
+
+#endif	/* HAL_USE_GDISP */
+
+#endif	/* _GDISP_LLD_CONFIG_H */
+/** @} */
diff --git a/halext/drivers/gdispS6d1121/readme.txt b/halext/drivers/gdispS6d1121/readme.txt
new file mode 100644
index 00000000..fc24d4a2
--- /dev/null
+++ b/halext/drivers/gdispS6d1121/readme.txt
@@ -0,0 +1,16 @@
+To use this driver:

+

+1. Add in your halconf.h:

+	a) #define HAL_USE_GDISP	TRUE

+	b) Any optional high level driver defines (see gdisp.h) eg: GDISP_NEED_MULTITHREAD

+	c) One (only) of:

+		#define LCD_USE_GPIO

+		#define LCD_USE_SPI

+		#define LCD_USE_FSMC

+	d) All of the following (with appropriate values):

+		#define SCREEN_WIDTH	320

+		#define SCREEN_HEIGHT	240

+

+2. To your makefile add the following lines:

+	include $(CHIBIOS)/os/halext/halext.mk

+	include $(CHIBIOS)/os/halext/drivers/gdispS6d1121/gdisp_lld.mk

diff --git a/halext/drivers/gdispS6d1121/s6d1121_lld.c.h b/halext/drivers/gdispS6d1121/s6d1121_lld.c.h
new file mode 100644
index 00000000..8e4fdd07
--- /dev/null
+++ b/halext/drivers/gdispS6d1121/s6d1121_lld.c.h
@@ -0,0 +1,224 @@
+#ifndef S6D1121_H
+#define S6D1121_H
+
+// I/O assignments
+#define LCD_BL_GPIO			GPIOB
+#define LCD_BL_PIN			8
+
+#define LCD_CS_GPIO			GPIOD
+#define LCD_CS_PIN			7
+
+#define LCD_RS_GPIO			GPIOD
+#define LCD_RS_PIN			11
+
+#define LCD_RST_GPIO		GPIOD
+#define LCD_RST_PIN			10
+
+#define LCD_RD_GPIO			GPIOD
+#define LCD_RD_PIN			9
+
+#define LCD_WR_GPIO			GPIOD
+#define LCD_WR_PIN			8
+
+#define LCD_D0_GPIO			GPIOD
+#define LCD_D4_GPIO			GPIOE
+
+/* all interfaces use RST via GPIO */
+/* TODO: option to disable RST; assumes RST is tied high */
+#define LCD_RST_LOW		palClearPad(LCD_RST_GPIO, LCD_RST_PIN)
+#define LCD_RST_HIGH	palSetPad(LCD_RST_GPIO, LCD_RST_PIN)
+
+#define s6d1121_delay(n) 	halPolledDelay(MS2RTT(n));
+
+#if defined(LCD_USE_GPIO)
+
+	#define LCD_CS_LOW		palClearPad(LCD_CS_GPIO, LCD_CS_PIN)
+	#define LCD_CS_HIGH		palSetPad(LCD_CS_GPIO, LCD_CS_PIN)
+
+	#define LCD_RS_LOW		palClearPad(LCD_RS_GPIO, LCD_RS_PIN)
+	#define LCD_RS_HIGH		palSetPad(LCD_RS_GPIO, LCD_RS_PIN)
+
+	#define LCD_RD_LOW		palClearPad(LCD_RD_GPIO, LCD_RD_PIN)
+	#define LCD_RD_HIGH		palSetPad(LCD_RD_GPIO, LCD_RD_PIN)
+
+	#define LCD_WR_LOW		palClearPad(LCD_WR_GPIO, LCD_WR_PIN)
+	#define LCD_WR_HIGH		palSetPad(LCD_WR_GPIO, LCD_WR_PIN)
+
+	#define LCD_BL_LOW		palClearPad(LCD_BL_GPIO, LCD_BL_PIN)
+	#define LCD_BL_HIGH		palSetPad(LCD_BL_GPIO, LCD_BL_PIN)
+
+
+	static inline void lld_lcddelay(void)				{ asm volatile ("nop"); asm volatile ("nop"); }
+	static inline void lld_lcdwrite(uint16_t db) {
+		LCD_D4_GPIO->BSRR.W=((~db&0xFFF0)<<16)|(db&0xFFF0);
+		LCD_D0_GPIO->BSRR.W=((~db&0x000F)<<16)|(db&0x000F);
+		LCD_WR_LOW;
+		lld_lcddelay();
+		LCD_WR_HIGH;
+	}
+	static __inline uint16_t lld_lcdReadData(void) {
+		uint16_t value=0;
+
+		LCD_RS_HIGH; LCD_WR_HIGH; LCD_RD_LOW;
+		#ifndef STM32F4XX
+			// change pin mode to digital input
+			LCD_DATA_PORT->CRH = 0x47444444;
+			LCD_DATA_PORT->CRL = 0x47444444;
+		#endif
+		#ifndef STM32F4XX
+			// change pin mode back to digital output
+			LCD_DATA_PORT->CRH = 0x33333333;
+			LCD_DATA_PORT->CRL = 0x33333333;
+		#endif
+	    LCD_RD_HIGH;
+		return value;
+	}
+	static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
+	    uint16_t value;
+
+	    LCD_CS_LOW; LCD_RS_LOW;
+	    lld_lcdwrite(lcdReg);
+	    LCD_RS_HIGH;
+	    lcdRAM = lld_lcdReadData();
+	    LCD_CS_HIGH;
+	    return lcdRAM;
+	}
+	static void lld_lcdWriteIndex(uint16_t lcdReg) {
+		LCD_RS_LOW;
+		lld_lcdwrite(lcdReg);
+		LCD_RS_HIGH;
+	}
+	static void lld_lcdWriteData(uint16_t lcdData) {
+		lld_lcdwrite(lcdData);
+	}
+	static void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
+		LCD_CS_LOW;
+		lld_lcdWriteIndex(lcdReg);
+		lld_lcdWriteData(lcdRegValue);
+		LCD_CS_HIGH;
+	}
+	static __inline void lld_lcdWriteStreamStart(void) {
+		LCD_CS_LOW;
+		lld_lcdWriteIndex(0x0022);
+	}
+	static __inline void lld_lcdWriteStreamStop(void) {
+		LCD_CS_HIGH;
+	}
+	static __inline void lld_lcdWriteStream(uint16_t *buffer, uint16_t size) {
+		uint16_t i;
+
+		for(i = 0; i < size; i++) { lld_lcdwrite(buffer[i]); }
+	}
+	static __inline void lld_lcdReadStreamStart(void) {	/* TODO */ }
+	static __inline void lld_lcdReadStreamStop(void) { /* TODO */ }
+	static __inline void lld_lcdReadStream(uint16_t *UNUSED(buffer), size_t UNUSED(size)) { /* TODO */ }
+
+#elif defined(LCD_USE_FSMC)
+	#define LCD_REG              (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
+	#define LCD_RAM              (*((volatile uint16_t *) 0x60020000)) /* RS = 1 */
+
+	static __inline void lld_lcdWriteIndex(uint16_t index)			{ LCD_REG = index; }
+	static __inline void lld_lcdWriteData(uint16_t data)			{ LCD_RAM = data; }
+	static __inline void lld_lcdWriteReg(uint16_t lcdReg,uint16_t lcdRegValue) {
+		LCD_REG = lcdReg;
+		LCD_RAM = lcdRegValue;
+	}
+	static __inline uint16_t lld_lcdReadData(void)					{ return (LCD_RAM); }
+	static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
+		LCD_REG = lcdReg;
+		return LCD_RAM;
+	}
+	static __inline void lld_lcdWriteStreamStart(void)				{ LCD_REG = 0x0022; }
+	static __inline void lld_lcdWriteStreamStop(void)				{}
+	static __inline void lld_lcdWriteStream(uint16_t *buffer, uint16_t size) {
+		uint16_t i;
+		for(i = 0; i < size; i++) LCD_RAM = buffer[i];
+	}
+	static __inline void lld_lcdReadStreamStart(void)				{ LCD_REG = 0x0022; }
+	static __inline void lld_lcdReadStreamStop(void)				{}
+	static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
+		uint16_t i;
+		volatile uint16_t dummy;
+
+		/* throw away first value read */
+		dummy = LCD_RAM;
+		for(i = 0; i < size; i++) buffer[i] = LCD_RAM;
+	}
+
+#elif defined(LCD_USE_SPI)
+	#error "gdispS6d1121: LCD_USE_SPI not implemented yet"
+
+#else
+	#error "gdispS6d1121: No known LCD_USE_XXX has been defined"
+#endif
+
+static void lld_lcdSetCursor(coord_t x, coord_t y) {
+	/* R20h - 8 bit
+	 * R21h - 9 bit
+	 */
+	switch(GDISP.Orientation) {
+		case portraitInv:
+			lld_lcdWriteReg(0x0020, (SCREEN_WIDTH-1-x) & 0x00FF);
+			lld_lcdWriteReg(0x0021, (SCREEN_HEIGHT-1-y) & 0x01FF);
+			break;
+		case portrait:
+			lld_lcdWriteReg(0x0020, x & 0x00FF);
+			lld_lcdWriteReg(0x0021, y & 0x01FF);
+			break;
+		case landscape:
+			lld_lcdWriteReg(0x0020, y & 0x00FF);
+			lld_lcdWriteReg(0x0021, x & 0x01FF);
+			break;
+		case landscapeInv:
+			lld_lcdWriteReg(0x0020, (SCREEN_WIDTH - y - 1) & 0x00FF);
+			lld_lcdWriteReg(0x0021, (SCREEN_HEIGHT - x - 1) & 0x01FF);
+			break;
+	}
+}
+
+static void lld_lcdSetViewPort(uint16_t x, uint16_t y, uint16_t cx, uint16_t cy) {
+	/* HSA / HEA are 8 bit
+	 * VSA / VEA are 9 bit
+	 * use masks 0x00FF and 0x01FF to enforce this
+	 */
+
+	switch(GDISP.Orientation) {
+		case portrait:
+			lld_lcdWriteReg(0x46, (((x+cx-1) << 8) & 0xFF00 ) | (x & 0x00FF));
+			lld_lcdWriteReg(0x48, y & 0x01FF);
+			lld_lcdWriteReg(0x47, (y+cy-1) & 0x01FF);
+			break;
+		case landscape:
+			lld_lcdWriteReg(0x46, (((x+cx-1) << 8) & 0xFF00) | ((y+cy) & 0x00FF));
+			lld_lcdWriteReg(0x48, x & 0x01FF);
+			lld_lcdWriteReg(0x47, (x+cx-1) & 0x01FF);
+			break;
+		case portraitInv:
+			lld_lcdWriteReg(0x46, (((SCREEN_WIDTH-x-1) & 0x00FF) << 8) | ((SCREEN_WIDTH - (x+cx)) & 0x00FF));
+			lld_lcdWriteReg(0x48, (SCREEN_HEIGHT-(y+cy)) & 0x01FF);
+			lld_lcdWriteReg(0x47, (SCREEN_HEIGHT-y-1) & 0x01FF);
+			break;
+		case landscapeInv:
+			lld_lcdWriteReg(0x46, (((SCREEN_WIDTH - y - 1) & 0x00FF) << 8) | ((SCREEN_WIDTH - (y+cy)) & 0x00FF));
+			lld_lcdWriteReg(0x48, (SCREEN_HEIGHT - (x+cx)) & 0x01FF);
+			lld_lcdWriteReg(0x47, (SCREEN_HEIGHT - x - 1) & 0x01FF);
+			break;
+	}
+
+	lld_lcdSetCursor(x, y);
+}
+
+static void lld_lcdResetViewPort(void) {
+	switch(GDISP.Orientation) {
+		case portrait:
+		case portraitInv:
+			lld_lcdSetViewPort(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+			break;
+		case landscape:
+		case landscapeInv:
+			lld_lcdSetViewPort(0, 0, SCREEN_HEIGHT, SCREEN_WIDTH);
+			break;
+	}
+}
+
+#endif /* S6D1121_H */