restructure

8 files changed, 2004 insertions, 0 deletions

diff --git a/include/gdisp.h b/include/gdisp.h
new file mode 100644
index 00000000..b5a59cf9
--- /dev/null
+++ b/include/gdisp.h
@@ -0,0 +1,266 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

+                 Joel Bodenmann aka Tectu <joel@unormal.org>

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+/**

+ * @file    gdisp.h

+ * @brief   GDISP Graphic Driver subsystem header file.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+#ifndef _GDISP_H

+#define _GDISP_H

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

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

+/* Driver constants.														 */

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

+

+/**

+ * @brief   Some basic colors

+ */

+#define White			HTML2COLOR(0xFFFFFF)

+#define Black			HTML2COLOR(0x000000)

+#define Gray			HTML2COLOR(0x808080)

+#define Grey			Gray

+#define Blue			HTML2COLOR(0x0000FF)

+#define Red				HTML2COLOR(0xFF0000)

+#define Fuchsia			HTML2COLOR(0xFF00FF)

+#define Magenta			Fuchsia

+#define Green			HTML2COLOR(0x008000)

+#define Yellow			HTML2COLOR(0xFFFF00)

+#define Aqua			HTML2COLOR(0x00FFFF)

+#define Cyan			Aqua

+#define Lime			HTML2COLOR(0x00FF00)

+#define Maroon			HTML2COLOR(0x800000)

+#define Navy			HTML2COLOR(0x000080)

+#define Olive			HTML2COLOR(0x808000)

+#define Purple			HTML2COLOR(0x800080)

+#define Silver			HTML2COLOR(0xC0C0C0)

+#define Teal			HTML2COLOR(0x008080)

+#define Orange			HTML2COLOR(0xFFA500)

+#define Pink			HTML2COLOR(0xFFC0CB)

+#define SkyBlue			HTML2COLOR(0x87CEEB)

+

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

+/* Driver pre-compile time settings.                                         */

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

+

+/**

+ * @name    GDISP more complex functionality to be compiled

+ * @{

+ */

+	/**

+	 * @brief   Do the drawing functions need to be thread-safe.

+	 * @details	Defaults to FALSE

+	 * @note	Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make

+	 * 			the gdisp API thread-safe.

+	 * @note	This is more efficient than GDISP_NEED_ASYNC as it only

+	 * 			requires a context switch if something else is already

+	 * 			drawing.

+	 */

+	#ifndef GDISP_NEED_MULTITHREAD

+		#define GDISP_NEED_MULTITHREAD	FALSE

+	#endif

+

+	/**

+	 * @brief   Use asynchronous calls (multi-thread safe).

+	 * @details	Defaults to FALSE

+	 * @note	Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make

+	 * 			the gdisp API thread-safe.

+	 * @note	Turning this on adds two context switches per transaction

+	 *			so it can significantly slow graphics drawing.

+	 */

+	#ifndef GDISP_NEED_ASYNC

+		#define GDISP_NEED_ASYNC	FALSE

+	#endif

+/** @} */

+

+#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC

+	#error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined."

+#endif

+

+#if GDISP_NEED_ASYNC

+	/* Messaging API is required for Async Multi-Thread */

+	#undef GDISP_NEED_MSGAPI

+	#define GDISP_NEED_MSGAPI	TRUE

+#endif

+

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

+/* Low Level Driver details and error checks.                                */

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

+

+/* Include the low level driver information */

+#include "gdisp_lld.h"

+

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

+/* Type definitions                                                          */

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

+

+/**

+ * @brief   Type for the text justification.

+ */

+typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;

+/**

+ * @brief   Type for the font metric.

+ */

+typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;

+

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

+/* External declarations.                                                    */

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

+

+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)

+/**

+ * @brief   Predefined fonts.

+ */

+extern const struct font fontSmall;

+extern const struct font fontSmallDouble;

+extern const struct font fontSmallNarrow;

+extern const struct font fontLarger;

+extern const struct font fontLargerDouble;

+extern const struct font fontLargerNarrow;

+extern const struct font fontUI1;

+extern const struct font fontUI1Double;

+extern const struct font fontUI1Narrow;

+extern const struct font fontUI2;

+extern const struct font fontUI2Double;

+extern const struct font fontUI2Narrow;

+extern const struct font fontLargeNumbers;

+extern const struct font fontLargeNumbersDouble;

+extern const struct font fontLargeNumbersNarrow;

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC

+

+	/* Base Functions */

+	bool_t gdispInit(void);

+	bool_t gdispIsBusy(void);

+

+	/* Drawing Functions */

+	void gdispClear(color_t color);

+	void gdispDrawPixel(coord_t x, coord_t y, color_t color);

+	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);

+	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

+	void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer);

+

+	/* Circle Functions */

+	#if GDISP_NEED_CIRCLE

+	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);

+	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);

+	#endif

+	

+	/* Ellipse Functions */

+	#if GDISP_NEED_ELLIPSE

+	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

+	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

+	#endif

+

+	/* Basic Text Rendering Functions */

+	#if GDISP_NEED_TEXT

+	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);

+	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);

+	#endif

+	

+	/* Read a pixel Function */

+	#if GDISP_NEED_PIXELREAD

+	color_t gdispGetPixelColor(coord_t x, coord_t y);

+	#endif

+

+	/* Scrolling Function - clears the area scrolled out */

+	#if GDISP_NEED_SCROLL

+	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);

+	#endif

+

+	/* Set driver specific control */

+	#if GDISP_NEED_CONTROL

+	void gdispControl(unsigned what, void *value);

+	#endif

+

+	/* Query driver specific data */

+	#if GDISP_NEED_CONTROL

+	void *gdispQuery(unsigned what);

+	#endif

+

+#else

+

+	/* The same as above but use the low level driver directly if no multi-thread support is needed */

+	#define gdispInit(gdisp)									GDISP_LLD(init)()

+	#define gdispIsBusy()										FALSE

+	#define gdispClear(color)									GDISP_LLD(clear)(color)

+	#define gdispDrawPixel(x, y, color)							GDISP_LLD(drawpixel)(x, y, color)

+	#define gdispDrawLine(x0, y0, x1, y1, color)				GDISP_LLD(drawline)(x0, y0, x1, y1, color)

+	#define gdispFillArea(x, y, cx, cy, color)					GDISP_LLD(fillarea)(x, y, cx, cy, color)

+	#define gdispBlitArea(x, y, cx, cy, buffer)					GDISP_LLD(blitarea)(x, y, cx, cy, buffer)

+	#define gdispDrawCircle(x, y, radius, color)				GDISP_LLD(drawcircle)(x, y, radius, color)

+	#define gdispFillCircle(x, y, radius, color)				GDISP_LLD(fillcircle)(x, y, radius, color)

+	#define gdispDrawEllipse(x, y, a, b, color)					GDISP_LLD(drawellipse)(x, y, a, b, color)

+	#define gdispFillEllipse(x, y, a, b, color)					GDISP_LLD(fillellipse)(x, y, a, b, color)

+	#define gdispDrawChar(x, y, c, font, color)					GDISP_LLD(drawchar)(x, y, c, font, color)

+	#define gdispFillChar(x, y, c, font, color, bgcolor)		GDISP_LLD(fillchar)(x, y, c, font, color, bgcolor)

+	#define gdispGetPixelColor(x, y)							GDISP_LLD(getpixelcolor)(x, y)

+	#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor)	GDISP_LLD(verticalscroll)(x, y, cx, cy, lines, bgcolor)

+	#define gdispControl(what, value)							GDISP_LLD(control)(what, value)

+	#define gdispQuery(what)									GDISP_LLD(query)(what)

+

+#endif

+

+void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

+

+/* Extra Text Functions */

+#if GDISP_NEED_TEXT

+	void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);

+	void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);

+	void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);

+	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);

+	coord_t gdispGetCharWidth(char c, font_t font);

+	coord_t gdispGetStringWidth(const char* str, font_t font);

+#endif

+

+/* Support routine for packed pixel formats */

+#ifndef gdispPackPixels

+	void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);

+#endif

+

+/* Macro definitions for common gets and sets */

+#define gdispSetPowerMode(powerMode)			gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode))

+#define gdispSetOrientation(newOrientation)		gdispControl(GDISP_CONTROL_ORITENTATION, (void *)(unsigned)(newOrientation))

+#define gdispSetBacklight(percent)				gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent))

+#define gdispSetContrast(percent)				gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent))

+

+#define gdispGetWidth()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))

+#define gdispGetHeight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))

+#define gdispGetPowerMode()						((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))

+#define gdispGetOrientation()					((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))

+#define gdispGetBacklight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))

+#define gdispGetContrast()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* HAL_USE_GDISP */

+

+#endif /* _GDISP_H */

+/** @} */

diff --git a/include/gdisp_emulation.c b/include/gdisp_emulation.c
new file mode 100644
index 00000000..cb3773a7
--- /dev/null
+++ b/include/gdisp_emulation.c
@@ -0,0 +1,549 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

+                 Joel Bodenmann aka Tectu <joel@unormal.org>

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+

+/*

+	Emulation routines included into gdisp_lld.c

+*/

+

+/*

+	Even though this is a software emulation of a low level driver

+	most validation doesn't need to happen here as eventually

+	we call a real low level driver routine and if validation is

+	required - it will do it.

+*/

+#ifndef GDISP_EMULATION_C

+#define GDISP_EMULATION_C

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

+#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

+

+#ifndef GDISP_LLD_NO_STRUCT

+	static struct GDISPDriver {

+		coord_t				Width;

+		coord_t				Height;

+		gdisp_orientation_t	Orientation;

+		gdisp_powermode_t	Powermode;

+		coord_t				Backlight;

+		coord_t				Contrast;

+		} GDISP;

+#endif

+

+#if !GDISP_HARDWARE_CLEARS 

+	void GDISP_LLD(clear)(color_t color) {

+		GDISP_LLD(fillarea)(0, 0, GDISP.Width, GDISP.Height, color);

+	}

+#endif

+

+#if !GDISP_HARDWARE_LINES 

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

+		int16_t dy, dx;

+		int16_t addx, addy;

+		int16_t P, diff, i;

+

+		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL

+		// speed improvement if vertical or horizontal

+		if (x0 == x1) {

+			if (y1 > y0)

+				GDISP_LLD(fillarea)(x0, y0, 1, y1-y0+1, color);

+			else

+				GDISP_LLD(fillarea)(x0, y1, 1, y0-y1+1, color);

+			return;

+		}

+		if (y0 == y1) {

+			if (x1 > x0)

+				GDISP_LLD(fillarea)(x0, y0, x1-x0+1, 1, color);

+			else

+				GDISP_LLD(fillarea)(x0, y1, x0-x1+1, 1, color);

+			return;

+		}

+		#endif

+

+		if (x1 >= x0) {

+			dx = x1 - x0;

+			addx = 1;

+		} else {

+			dx = x0 - x1;

+			addx = -1;

+		}

+		if (y1 >= y0) {

+			dy = y1 - y0;

+			addy = 1;

+		} else {

+			dy = y0 - y1;

+			addy = -1;

+		}

+

+		if (dx >= dy) {

+			dy *= 2;

+			P = dy - dx;

+			diff = P - dx;

+

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

+				GDISP_LLD(drawpixel)(x0, y0, color);

+				if (P < 0) {

+					P  += dy;

+					x0 += addx;

+				} else {

+					P  += diff;

+					x0 += addx;

+					y0 += addy;

+				}

+			}

+		} else {

+			dx *= 2;

+			P = dx - dy;

+			diff = P - dy;

+

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

+				GDISP_LLD(drawpixel)(x0, y0, color);

+				if (P < 0) {

+					P  += dx;

+					y0 += addy;

+				} else {

+					P  += diff;

+					x0 += addx;

+					y0 += addy;

+				}

+			}

+		}

+	}

+#endif

+

+#if !GDISP_HARDWARE_FILLS

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

+		#if GDISP_HARDWARE_SCROLL

+			GDISP_LLD(verticalscroll)(x, y, cx, cy, cy, color);

+		#elif GDISP_HARDWARE_LINES

+			coord_t x1, y1;

+			

+			x1 = x + cx - 1;

+			y1 = y + cy;

+			for(; y < y1; y++)

+				GDISP_LLD(drawline)(x, y, x1, y, color);

+		#else

+			coord_t x0, x1, y1;

+			

+			x0 = x;

+			x1 = x + cx;

+			y1 = y + cy;

+			for(; y < y1; y++)

+				for(x = x0; x < x1; x++)

+					GDISP_LLD(drawpixel)(x, y, color);

+		#endif

+	}

+#endif

+

+#if !GDISP_HARDWARE_BITFILLS

+	void GDISP_LLD(blitarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer) {

+			coord_t x0, x1, y1;

+			

+			x0 = x;

+			x1 = x + cx;

+			y1 = y + cy;

+			for(; y < y1; y++)

+				for(x = x0; x < x1; x++)

+					GDISP_LLD(drawpixel)(x, y, *buffer++);

+	}

+#endif

+

+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES

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

+		int16_t a, b, P;

+

+		a = 0;

+		b = radius;

+		P = 1 - radius;

+

+		do {

+			GDISP_LLD(drawpixel)(a+x, b+y, color);

+			GDISP_LLD(drawpixel)(b+x, a+y, color);

+			GDISP_LLD(drawpixel)(x-a, b+y, color);

+			GDISP_LLD(drawpixel)(x-b, a+y, color);

+			GDISP_LLD(drawpixel)(b+x, y-a, color);

+			GDISP_LLD(drawpixel)(a+x, y-b, color);

+			GDISP_LLD(drawpixel)(x-a, y-b, color);

+			GDISP_LLD(drawpixel)(x-b, y-a, color);

+			if (P < 0)

+				P += 3 + 2*a++;

+			else

+				P += 5 + 2*(a++ - b--);

+		} while(a <= b);

+	}

+#endif

+

+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS

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

+		int16_t a, b, P;

+		

+		a = 0;

+		b = radius;

+		P = 1 - radius;

+

+		do {

+			GDISP_LLD(drawline)(x-a, y+b, x+a, y+b, color);

+			GDISP_LLD(drawline)(x-a, y-b, x+a, y-b, color);

+			GDISP_LLD(drawline)(x-b, y+a, x+b, y+a, color);

+			GDISP_LLD(drawline)(x-b, y-a, x+b, y-a, color);

+			if (P < 0)

+				P += 3 + 2*a++;

+			else

+				P += 5 + 2*(a++ - b--);

+		} while(a <= b);

+	}

+#endif

+

+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES

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

+		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

+		long a2 = a*a, b2 = b*b;

+		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

+

+		do {

+			GDISP_LLD(drawpixel)(x+dx, y+dy, color); /* I. Quadrant */

+			GDISP_LLD(drawpixel)(x-dx, y+dy, color); /* II. Quadrant */

+			GDISP_LLD(drawpixel)(x-dx, y-dy, color); /* III. Quadrant */

+			GDISP_LLD(drawpixel)(x+dx, y-dy, color); /* IV. Quadrant */

+

+			e2 = 2*err;

+			if(e2 <  (2*dx+1)*b2) {

+				dx++;

+				err += (2*dx+1)*b2;

+			}

+			if(e2 > -(2*dy-1)*a2) {

+				dy--;

+				err -= (2*dy-1)*a2;

+			}

+		} while(dy >= 0); 

+

+		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

+			GDISP_LLD(drawpixel)(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

+			GDISP_LLD(drawpixel)(x-dx, y, color);

+	   }   

+	}

+#endif

+

+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS

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

+		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

+		long a2 = a*a, b2 = b*b;

+		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

+

+		do {

+			GDISP_LLD(drawline)(x-dx,y+dy,x+dx,y+dy, color);

+			GDISP_LLD(drawline)(x-dx,y-dy,x+dx,y-dy, color);

+

+			e2 = 2*err;

+			if(e2 <  (2*dx+1)*b2) {

+				dx++;

+				err += (2*dx+1)*b2;

+			}

+			if(e2 > -(2*dy-1)*a2) {

+				dy--;

+				err -= (2*dy-1)*a2;

+			}

+		} while(dy >= 0); 

+

+		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

+			GDISP_LLD(drawpixel)(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

+			GDISP_LLD(drawpixel)(x-dx, y, color);

+	   }   

+	}

+#endif

+

+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

+	#include "gdisp_fonts.h"

+#endif

+

+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

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

+		const fontcolumn_t	*ptr;

+		fontcolumn_t		column;

+		coord_t				width, height, xscale, yscale;

+		coord_t				i, j, xs, ys;

+

+		/* Check we actually have something to print */

+		width = _getCharWidth(font, c);

+		if (!width) return;

+		

+		xscale = font->xscale;

+		yscale = font->yscale;

+		height = font->height * yscale;

+		width *= xscale;

+

+		ptr = _getCharData(font, c);

+

+		/* Loop through the data and display. The font data is LSBit first, down the column */

+		for(i=0; i < width; i+=xscale) {

+			/* Get the font bitmap data for the column */

+			column = *ptr++;

+			

+			/* Draw each pixel */

+			for(j=0; j < height; j+=yscale, column >>= 1) {

+				if (column & 0x01) {

+					for(xs=0; xs < xscale; xs++)

+						for(ys=0; ys < yscale; ys++)

+							GDISP_LLD(drawpixel)(x+i+xs, y+j+ys, color);

+				}

+			}

+		}

+	}

+#endif

+

+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS

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

+		coord_t			width, height;

+		coord_t			xscale, yscale;

+		

+		/* Check we actually have something to print */

+		width = _getCharWidth(font, c);

+		if (!width) return;

+

+		xscale = font->xscale;

+		yscale = font->yscale;

+		height = font->height * yscale;

+		width *= xscale;

+

+		/* Method 1: Use background fill and then draw the text */

+		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW

+			

+			/* Fill the area */

+			GDISP_LLD(fillarea)(x, y, width, height, bgcolor);

+			

+			/* Draw the text */

+			GDISP_LLD(drawchar)(x, y, c, font, color);

+

+		/* Method 2: Create a single column bitmap and then blit it */

+		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j, xs, ys;

+

+			/* Working buffer for fast non-transparent text rendering [patch by Badger]

+				This needs to be larger than the largest character we can print.

+				Assume the max is double sized by one column.

+			*/

+			static pixel_t		buf[sizeof(fontcolumn_t)*8*2];

+

+			#if GDISP_NEED_VALIDATION

+				/* Check our buffer is big enough */

+				if (height > sizeof(buf)/sizeof(buf[0]))	return;

+			#endif

+

+			ptr = _getCharData(font, c);

+

+			/* Loop through the data and display. The font data is LSBit first, down the column */

+			for(i = 0; i < width; i+=xscale) {

+				/* Get the font bitmap data for the column */

+				column = *ptr++;

+				

+				/* Draw each pixel */

+				for(j = 0; j < height; j+=yscale, column >>= 1) {

+					if (column & 0x01) {

+						for(ys=0; ys < yscale; ys++)

+							gdispPackPixels(buf, 1, j+ys, 0, color);

+					} else {

+						for(ys=0; ys < yscale; ys++)

+							gdispPackPixels(buf, 1, j+ys, 0, bgcolor);

+					}

+				}

+

+				for(xs=0; xs < xscale; xs++)

+					GDISP_LLD(blitarea)(x+i+xs, y, 1, height, buf);

+			}

+		}

+

+		/* Method 3: Create a character bitmap and then blit it */

+		#elif GDISP_HARDWARE_BITFILLS

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j, xs, ys;

+			

+			/* Working buffer for fast non-transparent text rendering [patch by Badger]

+				This needs to be larger than the largest character we can print.

+				Assume the max is double sized.

+			*/

+			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)*2];

+

+			#if GDISP_NEED_VALIDATION

+				/* Check our buffer is big enough */

+				if ((unsigned)(width * height) > sizeof(buf)/sizeof(buf[0]))	return;

+			#endif

+

+			ptr = _getCharData(font, c);

+

+			/* Loop through the data and display. The font data is LSBit first, down the column */

+			for(i = 0; i < width; i+=xscale) {

+				/* Get the font bitmap data for the column */

+				column = *ptr++;

+				

+				/* Draw each pixel */

+				for(j = 0; j < height; j+=yscale, column >>= 1) {

+					if (column & 0x01) {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								gdispPackPixels(buf, width, i+xs, j+ys, color);

+					} else {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								gdispPackPixels(buf, width, i+xs, j+ys, bgcolor);

+					}

+				}

+			}

+

+			/* [Patch by Badger] Write all in one stroke */

+			GDISP_LLD(blitarea)(x, y, width, height, buf);

+		}

+

+		/* Method 4: Draw pixel by pixel */

+		#else

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j, xs, ys;

+

+			ptr = _getCharData(font, c);

+

+			/* Loop through the data and display. The font data is LSBit first, down the column */

+			for(i = 0; i < width; i+=xscale) {

+				/* Get the font bitmap data for the column */

+				column = *ptr++;

+				

+				/* Draw each pixel */

+				for(j = 0; j < height; j+=yscale, column >>= 1) {

+					if (column & 0x01) {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								GDISP_LLD(drawpixel)(x+i, y+j, color);

+					} else {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								GDISP_LLD(drawpixel)(x+i, y+j, bgcolor);

+					}

+				}

+			}

+		}

+		#endif

+	}

+#endif

+

+

+#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL

+	void GDISP_LLD(control)(unsigned UNUSED(what), void *UNUSED(value)) {

+		/* Ignore everything */

+	}

+#endif

+

+#if GDISP_NEED_QUERY && !GDISP_HARDWARE_QUERY

+void *GDISP_LLD(query)(unsigned what) {

+	switch(what) {

+	case GDISP_QUERY_WIDTH:			return (void *)(unsigned)GDISP.Width;

+	case GDISP_QUERY_HEIGHT:		return (void *)(unsigned)GDISP.Height;

+	case GDISP_QUERY_POWER:			return (void *)(unsigned)GDISP.Powermode;

+	case GDISP_QUERY_ORIENTATION:	return (void *)(unsigned)GDISP.Orientation;

+	case GDISP_QUERY_BACKLIGHT:		return (void *)(unsigned)GDISP.Backlight;

+	case GDISP_QUERY_CONTRAST:		return (void *)(unsigned)GDISP.Contrast;

+	default:						return (void *)-1;

+	}

+}

+#endif

+

+#if GDISP_NEED_MSGAPI

+	void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg) {

+		switch(msg->action) {

+		case GDISP_LLD_MSG_NOP:

+			break;

+		case GDISP_LLD_MSG_INIT:

+			GDISP_LLD(init)();

+			break;

+		case GDISP_LLD_MSG_CLEAR:

+			GDISP_LLD(clear)(msg->clear.color);

+			break;

+		case GDISP_LLD_MSG_DRAWPIXEL:

+			GDISP_LLD(drawpixel)(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);

+			break;

+		case GDISP_LLD_MSG_FILLAREA:

+			GDISP_LLD(fillarea)(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);

+			break;

+		case GDISP_LLD_MSG_BLITAREA:

+			GDISP_LLD(blitarea)(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.buffer);

+			break;

+		case GDISP_LLD_MSG_DRAWLINE:

+			GDISP_LLD(drawline)(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);

+			break;

+		#if GDISP_NEED_CIRCLE

+			case GDISP_LLD_MSG_DRAWCIRCLE:

+				GDISP_LLD(drawcircle)(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);

+				break;

+			case GDISP_LLD_MSG_FILLCIRCLE:

+				GDISP_LLD(fillcircle)(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);

+				break;

+		#endif

+		#if GDISP_NEED_ELLIPSE

+			case GDISP_LLD_MSG_DRAWELLIPSE:

+				GDISP_LLD(drawellipse)(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);

+				break;

+			case GDISP_LLD_MSG_FILLELLIPSE:

+				GDISP_LLD(fillellipse)(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);

+				break;

+		#endif

+		#if GDISP_NEED_TEXT

+			case GDISP_LLD_MSG_DRAWCHAR:

+				GDISP_LLD(drawchar)(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);

+				break;

+			case GDISP_LLD_MSG_FILLCHAR:

+				GDISP_LLD(fillchar)(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);

+				break;

+		#endif

+		#if GDISP_NEED_PIXELREAD

+			case GDISP_LLD_MSG_GETPIXELCOLOR:

+				msg->getpixelcolor.result = GDISP_LLD(getpixelcolor)(msg->getpixelcolor.x, msg->getpixelcolor.y);

+				break;

+		#endif

+		#if GDISP_NEED_SCROLL

+			case GDISP_LLD_MSG_VERTICALSCROLL:

+				GDISP_LLD(verticalscroll)(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);

+				break;

+		#endif

+		#if GDISP_NEED_CONTROL

+			case GDISP_LLD_MSG_CONTROL:

+				GDISP_LLD(control)(msg->control.what, msg->control.value);

+				break;

+		#endif

+		#if GDISP_NEED_QUERY

+			case GDISP_LLD_MSG_QUERY:

+				msg->query.result = GDISP_LLD(query)(msg->query.what);

+				break;

+		#endif

+		}

+	}

+#endif

+

+#endif  /* HAL_USE_GDISP */

+#endif	/* GDISP_EMULATION_C */

diff --git a/include/gdisp_fonts.h b/include/gdisp_fonts.h
new file mode 100644
index 00000000..a1a4c3cb
--- /dev/null
+++ b/include/gdisp_fonts.h
@@ -0,0 +1,90 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

+                 Joel Bodenmann aka Tectu <joel@unormal.org>

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+/**

+ * @file    gdisp_fonts.h

+ * @brief   GDISP internal font definitions.

+ * @details	This is not generally needed by an application. It is used

+ * 			by the low level drivers that need to understand a font.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+

+#ifndef _GDISP_FONTS_H

+#define _GDISP_FONTS_H

+

+/* Don't test against HAL_USE_GDISP as we may want to use this in other non-GDISP utilities. */

+

+/**

+ * @brief   The maximum height of a font.

+ * @details	Either 16 or 32. Defaults to 16

+ * @note	Setting this to 32 causes the font tables to take

+ *			twice the internal program memory.

+ */

+#ifndef GDISP_MAX_FONT_HEIGHT

+	#define GDISP_MAX_FONT_HEIGHT	16

+#endif

+

+/**

+ * @brief   The type of a font column.

+ * @note	Set by defining @p GDISP_MAX_FNT_HEIGHT appropriately.

+ */

+#if GDISP_MAX_FONT_HEIGHT == 16

+	typedef uint16_t	fontcolumn_t;

+#elif GDISP_MAX_FONT_HEIGHT == 32

+	typedef uint32_t	fontcolumn_t;

+#else

+	#error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32"

+#endif

+

+/**

+ * @brief   Internal font structure.

+ * @note	This structure is followed by:

+ *				1. An array of character widths (uint8_t)

+ *				2. An array of column data offsets (relative to the font structure)

+ *				3. Each characters array of column data (fontcolumn_t)

+ *			Each sub-structure must be padded to a multiple of 8 bytes

+ *			to allow the tables to work across many different compilers.

+ */

+struct font {

+	uint8_t				height;

+	uint8_t				charPadding;

+	uint8_t				lineSpacing;

+	uint8_t				descenderHeight;

+	uint8_t				minWidth;

+	uint8_t				maxWidth;

+	char				minChar;

+	char				maxChar;

+	uint8_t				xscale;

+	uint8_t				yscale;

+	const uint8_t		*widthTable;

+	const uint16_t      *offsetTable;

+	const fontcolumn_t  *dataTable;

+	};

+

+/**

+ * @brief   Macros to get to the complex parts of the font structure.

+ */

+#define _getCharWidth(f,c)		(((c) < (f)->minChar || (c) > (f)->maxChar) ? 0 : (f)->widthTable[(c) - (f)->minChar])

+#define _getCharOffset(f,c)		((f)->offsetTable[(c) - (f)->minChar])

+#define _getCharData(f,c)		(&(f)->dataTable[_getCharOffset(f, c)])

+

+#endif /* _GDISP_FONTS_H */

+/** @} */

diff --git a/include/gdisp_lld.h b/include/gdisp_lld.h
new file mode 100644
index 00000000..99865a9f
--- /dev/null
+++ b/include/gdisp_lld.h
@@ -0,0 +1,599 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

+                 Joel Bodenmann aka Tectu <joel@unormal.org>

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+/**

+ * @file    gdisp_lld.h

+ * @brief   GDISP Graphic Driver subsystem low level driver header.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+

+#ifndef _GDISP_LLD_H

+#define _GDISP_LLD_H

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

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

+/* Low level driver configuration needs					                     */

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

+

+/**

+ * @name    GDISP low level driver more complex functionality to be compiled

+ * @{

+ */

+	/**

+	 * @brief   Should all operations be clipped to the screen and colors validated.

+	 * @details	Defaults to TRUE.

+	 * @note    If this is FALSE, any operations that extend beyond the

+	 *          edge of the screen will have undefined results. Any

+	 *			out-of-range colors will produce undefined results.

+	 * @note	If defined then all low level and high level driver routines

+	 *			must check the validity of inputs and do something sensible

+	 *			if they are out of range. It doesn't have to be efficient,

+	 *			just valid.

+	 */

+	#ifndef GDISP_NEED_VALIDATION

+		#define GDISP_NEED_VALIDATION	TRUE

+	#endif

+

+	/**

+	 * @brief   Are circle functions needed.

+	 * @details	Defaults to TRUE

+	 */

+	#ifndef GDISP_NEED_CIRCLE

+		#define GDISP_NEED_CIRCLE		TRUE

+	#endif

+

+	/**

+	 * @brief   Are ellipse functions needed.

+	 * @details	Defaults to TRUE

+	 */

+	#ifndef GDISP_NEED_ELLIPSE

+		#define GDISP_NEED_ELLIPSE		TRUE

+	#endif

+

+	/**

+	 * @brief   Are text functions needed.

+	 * @details	Defaults to TRUE

+	 */

+	#ifndef GDISP_NEED_TEXT

+		#define GDISP_NEED_TEXT			TRUE

+	#endif

+

+	/**

+	 * @brief   Is scrolling needed.

+	 * @details	Defaults to FALSE

+	 */

+	#ifndef GDISP_NEED_SCROLL

+		#define GDISP_NEED_SCROLL		FALSE

+	#endif

+

+	/**

+	 * @brief   Is the capability to read pixels back needed.

+	 * @details	Defaults to FALSE

+	 */

+	#ifndef GDISP_NEED_PIXELREAD

+		#define GDISP_NEED_PIXELREAD	FALSE

+	#endif

+

+	/**

+	 * @brief   Control some aspect of the drivers operation.

+	 * @details	Defaults to FALSE

+	 */

+	#ifndef GDISP_NEED_CONTROL

+		#define GDISP_NEED_CONTROL		FALSE

+	#endif

+

+	/**

+	 * @brief   Query some aspect of the drivers operation.

+	 * @details	Defaults to TRUE

+	 */

+	#ifndef GDISP_NEED_QUERY

+		#define GDISP_NEED_QUERY		TRUE

+	#endif

+

+	/**

+	 * @brief   Is the messaging api interface required.

+	 * @details	Defaults to FALSE

+	 */

+	#ifndef GDISP_NEED_MSGAPI

+		#define GDISP_NEED_MSGAPI	FALSE

+	#endif

+/** @} */

+

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

+/* Include the low level driver configuration information                    */

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

+

+#include "gdisp_lld_config.h"

+

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

+/* Constants.                                                                */

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

+

+/**

+ * @brief   Driver Control Constants

+ * @detail	Unsupported control codes are ignored.

+ * @note	The value parameter should always be typecast to (void *).

+ * @note	There are some predefined and some specific to the low level driver.

+ * @note	GDISP_CONTROL_POWER			- Takes a gdisp_powermode_t

+ * 			GDISP_CONTROL_ORIENTATION	- Takes a gdisp_orientation_t

+ * 			GDISP_CONTROL_BACKLIGHT -	 Takes an int from 0 to 100. For a driver

+ * 											that only supports off/on anything other

+ * 											than zero is on.

+ * 			GDISP_CONTROL_CONTRAST		- Takes an int from 0 to 100.

+ * 			GDISP_CONTROL_LLD			- Low level driver control constants start at

+ * 											this value.

+ */

+#define GDISP_CONTROL_POWER			0

+#define GDISP_CONTROL_ORIENTATION	1

+#define GDISP_CONTROL_BACKLIGHT		2

+#define GDISP_CONTROL_CONTRAST		3

+#define GDISP_CONTROL_LLD			1000

+

+/**

+ * @brief   Driver Query Constants

+ * @detail	Unsupported query codes return (void *)-1.

+ * @note	There are some predefined and some specific to the low level driver.

+ * @note	The result should be typecast the required type.

+ * @note	GDISP_QUERY_WIDTH			- Gets the width of the screen

+ * 			GDISP_QUERY_HEIGHT			- Gets the height of the screen

+ * 			GDISP_QUERY_POWER			- Get the current powermode

+ * 			GDISP_QUERY_ORIENTATION		- Get the current orientation

+ * 			GDISP_QUERY_BACKLIGHT		- Get the backlight state (0 to 100)

+ * 			GDISP_QUERY_CONTRAST		- Get the contrast.

+ * 			GDISP_QUERY_LLD				- Low level driver control constants start at

+ * 											this value.

+ */

+#define GDISP_QUERY_WIDTH			0

+#define GDISP_QUERY_HEIGHT			1

+#define GDISP_QUERY_POWER			2

+#define GDISP_QUERY_ORIENTATION		3

+#define GDISP_QUERY_BACKLIGHT		4

+#define GDISP_QUERY_CONTRAST		5

+#define GDISP_QUERY_LLD				1000

+

+/**

+ * @brief   Driver Pixel Format Constants

+ */

+#define GDISP_PIXELFORMAT_RGB565	565

+#define GDISP_PIXELFORMAT_RGB888	888

+#define GDISP_PIXELFORMAT_RGB444	444

+#define GDISP_PIXELFORMAT_RGB332	332

+#define GDISP_PIXELFORMAT_RGB666	666

+#define GDISP_PIXELFORMAT_CUSTOM	99999

+#define GDISP_PIXELFORMAT_ERROR		88888

+

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

+/* Error checks.                                                             */

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

+

+/**

+ * @name    GDISP hardware accelerated support

+ * @{

+ */

+	/**

+	 * @brief   Hardware accelerated line drawing.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_LINES

+		#define GDISP_HARDWARE_LINES			FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated screen clears.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_CLEARS

+		#define GDISP_HARDWARE_CLEARS			FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated rectangular fills.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_FILLS

+		#define GDISP_HARDWARE_FILLS			FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated fills from an image.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_BITFILLS

+		#define GDISP_HARDWARE_BITFILLS			FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated circles.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_CIRCLES

+		#define GDISP_HARDWARE_CIRCLES			FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated filled circles.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_CIRCLEFILLS

+		#define GDISP_HARDWARE_CIRCLEFILLS		FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated ellipses.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_ELLIPSES

+		#define GDISP_HARDWARE_ELLIPSES			FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated filled ellipses.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_ELLIPSEFILLS

+		#define GDISP_HARDWARE_ELLIPSEFILLS		FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated text drawing.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_TEXT

+		#define GDISP_HARDWARE_TEXT				FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated text drawing with a filled background.

+	 * @details If set to @p FALSE software emulation is used.

+	 */

+	#ifndef GDISP_HARDWARE_TEXTFILLS

+		#define GDISP_HARDWARE_TEXTFILLS		FALSE

+	#endif

+

+	/**

+	 * @brief   Hardware accelerated scrolling.

+	 * @details If set to @p FALSE there is no support for scrolling.

+	 */

+	#ifndef GDISP_HARDWARE_SCROLL

+		#define GDISP_HARDWARE_SCROLL			FALSE

+	#endif

+

+	/**

+	 * @brief   Reading back of pixel values.

+	 * @details If set to @p FALSE there is no support for pixel read-back.

+	 */

+	#ifndef GDISP_HARDWARE_PIXELREAD

+		#define GDISP_HARDWARE_PIXELREAD		FALSE

+	#endif

+

+	/**

+	 * @brief   The driver supports one or more control commands.

+	 * @details If set to @p FALSE there is no support for control commands.

+	 */

+	#ifndef GDISP_HARDWARE_CONTROL

+		#define GDISP_HARDWARE_CONTROL			FALSE

+	#endif

+

+	/**

+	 * @brief   The driver supports a non-standard query.

+	 * @details If set to @p FALSE there is no support for non-standard queries.

+	 */

+	#ifndef GDISP_HARDWARE_QUERY

+		#define GDISP_HARDWARE_QUERY			FALSE

+	#endif

+/** @} */

+

+/**

+ * @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.

+	 */

+	#ifndef GDISP_SOFTWARE_TEXTFILLDRAW

+		#define GDISP_SOFTWARE_TEXTFILLDRAW		FALSE

+	#endif

+

+	/**

+	 * @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.

+	 */

+	#ifndef GDISP_SOFTWARE_TEXTBLITCOLUMN

+		#define GDISP_SOFTWARE_TEXTBLITCOLUMN	FALSE

+	#endif

+/** @} */

+

+/**

+ * @name    GDISP pixel format choices

+ * @{

+ */

+	/**

+	 * @brief   The native pixel format for this device

+	 * @note	Should be set to one of the following:

+	 *				GDISP_PIXELFORMAT_RGB565

+	 *				GDISP_PIXELFORMAT_RGB888

+	 *				GDISP_PIXELFORMAT_RGB444

+	 *				GDISP_PIXELFORMAT_RGB332

+	 *				GDISP_PIXELFORMAT_RGB666

+	 *				GDISP_PIXELFORMAT_CUSTOM

+	 * @note	If you set 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.

+	 */

+	#ifndef GDISP_PIXELFORMAT

+		#define GDISP_PIXELFORMAT	GDISP_PIXELFORMAT_ERROR

+	#endif

+

+	/**

+	 * @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.

+	 */

+	#ifndef GDISP_PACKED_PIXELS

+		#define GDISP_PACKED_PIXELS			FALSE

+	#endif

+

+	/**

+	 * @brief   Do lines of pixels require packing for a blit

+	 * @note	Ignored if GDISP_PACKED_PIXELS is FALSE

+	 */

+	#ifndef GDISP_PACKED_LINES

+		#define GDISP_PACKED_LINES			FALSE

+	#endif

+/** @} */

+

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

+/* Define the macro's for the various pixel formats */

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

+

+#if defined(__DOXYGEN__)

+	/**

+	 * @brief   The color of a pixel.

+	 */

+	typedef uint16_t color_t;

+	/**

+	 * @brief   Convert a number (of any type) to a color_t.

+	 * @details Masks any invalid bits in the color

+	 */

+	#define COLOR(c)			((color_t)(c))

+	/**

+	 * @brief   Does the color_t type contain invalid bits that need masking.

+	 */

+	#define MASKCOLOR			FALSE

+	/**

+	 * @brief   Convert red, green, blue (each 0 to 255) into a color value.

+	 */

+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))

+	/**

+	 * @brief   Convert a 6 digit HTML code (hex) into a color value.

+	 */

+	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))

+	/**

+	 * @brief   Extract the red component (0 to 255) of a color value.

+	 */

+	#define RED_OF(c)			(((c) & 0xF800)>>8)

+	/**

+	 * @brief   Extract the green component (0 to 255) of a color value.

+	 */

+	#define GREEN_OF(c)			(((c)&0x007E)>>3)

+	/**

+	 * @brief   Extract the blue component (0 to 255) of a color value.

+	 */

+	#define BLUE_OF(c)			(((c)&0x001F)<<3)

+

+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565

+	typedef uint16_t color_t;

+	#define COLOR(c)			((color_t)(c))

+	#define MASKCOLOR			FALSE

+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))

+	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))

+	#define RED_OF(c)			(((c) & 0xF800)>>8)

+	#define GREEN_OF(c)			(((c)&0x007E)>>3)

+	#define BLUE_OF(c)			(((c)&0x001F)<<3)

+	#define RGB565CONVERT(red, green, blue) (uint16_t)( (( red   >> 3 ) << 11 ) | (( green >> 2 ) << 5  ) | ( blue  >> 3 ))

+

+

+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888

+	typedef uint32_t color_t;

+	#define COLOR(c)			((color_t)(((c) & 0xFFFFFF)))

+	#define MASKCOLOR			TRUE

+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))

+	#define HTML2COLOR(h)		((color_t)(h))

+	#define RED_OF(c)			(((c) & 0xFF0000)>>16)

+	#define GREEN_OF(c)			(((c)&0x00FF00)>>8)

+	#define BLUE_OF(c)			((c)&0x0000FF)

+

+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444

+	typedef uint16_t color_t;

+	#define COLOR(c)			((color_t)(((c) & 0x0FFF)))

+	#define MASKCOLOR			TRUE

+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))

+	#define HTML2COLOR(h)		((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))

+	#define RED_OF(c)			(((c) & 0x0F00)>>4)

+	#define GREEN_OF(c)			((c)&0x00F0)

+	#define BLUE_OF(c)			(((c)&0x000F)<<4)

+

+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332

+	typedef uint8_t color_t;

+	#define COLOR(c)			((color_t)(c))

+	#define MASKCOLOR			FALSE

+	#define RGB2COLOR(r,g,b)	((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))

+	#define HTML2COLOR(h)		((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))

+	#define RED_OF(c)			((c) & 0xE0)

+	#define GREEN_OF(c)			(((c)&0x1C)<<3)

+	#define BLUE_OF(c)			(((c)&0x03)<<6)

+

+#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666

+	typedef uint32_t color_t;

+	#define COLOR(c)			((color_t)(((c) & 0x03FFFF)))

+	#define MASKCOLOR			TRUE

+	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))

+	#define HTML2COLOR(h)		((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))

+	#define RED_OF(c)			(((c) & 0x03F000)>>12)

+	#define GREEN_OF(c)			(((c)&0x00FC00)>>8)

+	#define BLUE_OF(c)			(((c)&0x00003F)<<2)

+

+#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM

+	#error "GDISP: No supported pixel format has been specified."

+#endif

+

+/* Verify information for packed pixels and define a non-packed pixel macro */

+#if !GDISP_PACKED_PIXELS

+	#define gdispPackPixels(buf,cx,x,y,c)	{ ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }

+#elif !GDISP_HARDWARE_BITFILLS

+	#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."

+#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \

+		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \

+		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \

+		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM

+	#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."

+#endif

+

+#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL

+	#error "GDISP: Hardware scrolling is wanted but not supported."

+#endif

+

+#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD

+	#error "GDISP: Pixel read-back is wanted but not supported."

+#endif

+

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

+/* Driver types.                                                             */

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

+

+/**

+ * @brief   The type for a coordinate or length on the screen.

+ */

+typedef uint16_t	coord_t;

+/**

+ * @brief   The type of a pixel.

+ */

+typedef color_t		pixel_t;

+/**

+ * @brief   The type of a font.

+ */

+typedef const struct font *font_t;

+/**

+ * @brief   Type for the screen orientation.

+ */

+typedef enum orientation {portrait, landscape, portraitInv, landscapeInv} gdisp_orientation_t;

+/**

+ * @brief   Type for the available power modes for the screen.

+ */

+typedef enum powermode {powerOff, powerSleep, powerOn} gdisp_powermode_t;

+

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

+/* External declarations.                                                    */

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

+

+#ifndef GDISP_LLD_VMT

+	/* Special magic stuff for the VMT driver */

+	#define GDISP_LLD_VMT(x) GDISP_LLD(x)

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+	/* Core functions */

+	extern bool_t GDISP_LLD(init)(void);

+

+	/* 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 */

+	extern void GDISP_LLD_VMT(clear)(color_t color);

+	extern void GDISP_LLD_VMT(drawpixel)(coord_t x, coord_t y, color_t color);

+	extern void GDISP_LLD_VMT(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

+	extern void GDISP_LLD_VMT(blitarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer);

+	extern void GDISP_LLD_VMT(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);

+

+	/* Circular Drawing Functions */

+	#if GDISP_NEED_CIRCLE

+	extern void GDISP_LLD_VMT(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color);

+	extern void GDISP_LLD_VMT(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color);

+	#endif

+

+	#if GDISP_NEED_ELLIPSE

+	extern void GDISP_LLD_VMT(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

+	extern void GDISP_LLD_VMT(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

+	#endif

+

+	/* Text Rendering Functions */

+	#if GDISP_NEED_TEXT

+	extern void GDISP_LLD_VMT(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color);

+	extern void GDISP_LLD_VMT(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

+	extern color_t GDISP_LLD_VMT(getpixelcolor)(coord_t x, coord_t y);

+	#endif

+

+	/* Scrolling Function - clears the area scrolled out */

+	#if GDISP_NEED_SCROLL

+	extern void GDISP_LLD_VMT(verticalscroll)(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);

+	#endif

+

+	/* Set driver specific control */

+	#if GDISP_NEED_CONTROL

+	extern void GDISP_LLD_VMT(control)(unsigned what, void *value);

+	#endif

+

+	/* Query driver specific data */

+	#if GDISP_NEED_QUERY

+	extern void *GDISP_LLD_VMT(query)(unsigned what);

+	#endif

+

+	/* Messaging API */

+	#if GDISP_NEED_MSGAPI

+	#include "gdisp_lld_msgs.h"

+	extern void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg);

+	#endif

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif	/* HAL_USE_GDISP */

+

+#endif	/* _GDISP_LLD_H */

+/** @} */

diff --git a/include/gdisp_lld_msgs.h b/include/gdisp_lld_msgs.h
new file mode 100644
index 00000000..28a6707e
--- /dev/null
+++ b/include/gdisp_lld_msgs.h
@@ -0,0 +1,165 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

+                 Joel Bodenmann aka Tectu <joel@unormal.org>

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+/**

+ * @file    gdisp_lld_msgs.h

+ * @brief   GDISP Graphic Driver subsystem low level driver message structures.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+

+#ifndef _GDISP_LLD_MSGS_H

+#define _GDISP_LLD_MSGS_H

+

+/* This file describes the message API for gdisp_lld */

+#if HAL_USE_GDISP && GDISP_NEED_MSGAPI

+

+typedef enum gdisp_msgaction {

+	GDISP_LLD_MSG_NOP,

+	GDISP_LLD_MSG_INIT,

+	GDISP_LLD_MSG_CLEAR,

+	GDISP_LLD_MSG_DRAWPIXEL,

+	GDISP_LLD_MSG_FILLAREA,

+	GDISP_LLD_MSG_BLITAREA,

+	GDISP_LLD_MSG_DRAWLINE,

+	#if GDISP_NEED_CIRCLE

+		GDISP_LLD_MSG_DRAWCIRCLE,

+		GDISP_LLD_MSG_FILLCIRCLE,

+	#endif

+	#if GDISP_NEED_ELLIPSE

+		GDISP_LLD_MSG_DRAWELLIPSE,

+		GDISP_LLD_MSG_FILLELLIPSE,

+	#endif

+	#if GDISP_NEED_TEXT

+		GDISP_LLD_MSG_DRAWCHAR,

+		GDISP_LLD_MSG_FILLCHAR,

+	#endif

+	#if GDISP_NEED_PIXELREAD

+		GDISP_LLD_MSG_GETPIXELCOLOR,

+	#endif

+	#if GDISP_NEED_SCROLL

+		GDISP_LLD_MSG_VERTICALSCROLL,

+	#endif

+	#if GDISP_NEED_CONTROL

+		GDISP_LLD_MSG_CONTROL,

+	#endif

+	#if GDISP_NEED_QUERY

+		GDISP_LLD_MSG_QUERY,

+	#endif

+} gdisp_msgaction_t;

+

+typedef union gdisp_lld_msg {

+	gdisp_msgaction_t	action;

+	struct gdisp_lld_msg_init {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_INIT

+	} init;

+	struct gdisp_lld_msg_clear {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CLEAR

+		color_t				color;

+	} clear;

+	struct gdisp_lld_msg_drawpixel {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWPIXEL

+		coord_t				x, y;

+		color_t				color;

+	} drawpixel;

+	struct gdisp_lld_msg_fillarea {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLAREA

+		coord_t				x, y;

+		coord_t				cx, cy;

+		color_t				color;

+	} fillarea;

+	struct gdisp_lld_msg_blitarea {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_BLITAREA

+		coord_t				x, y;

+		coord_t				cx, cy;

+		const pixel_t		*buffer;

+	} blitarea;

+	struct gdisp_lld_msg_drawline {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWLINE

+		coord_t				x0, y0;

+		coord_t				x1, y1;

+		color_t				color;

+	} drawline;

+	struct gdisp_lld_msg_drawcircle {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCIRCLE

+		coord_t				x, y;

+		coord_t				radius;

+		color_t				color;

+	} drawcircle;

+	struct gdisp_lld_msg_fillcircle {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCIRCLE

+		coord_t				x, y;

+		coord_t				radius;

+		color_t				color;

+	} fillcircle;

+	struct gdisp_lld_msg_drawellipse {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWELLIPSE

+		coord_t				x, y;

+		coord_t				a, b;

+		color_t				color;

+	} drawellipse;

+	struct gdisp_lld_msg_fillellipse {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLELLIPSE

+		coord_t				x, y;

+		coord_t				a, b;

+		color_t				color;

+	} fillellipse;

+	struct gdisp_lld_msg_drawchar {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCHAR

+		coord_t				x, y;

+		char				c;

+		font_t				font;

+		color_t				color;

+	} drawchar;

+	struct gdisp_lld_msg_fillchar {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCHAR

+		coord_t				x, y;

+		char				c;

+		font_t				font;

+		color_t				color;

+		color_t				bgcolor;

+	} fillchar;

+	struct gdisp_lld_msg_getpixelcolor {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_GETPIXELCOLOR

+		coord_t				x, y;

+		color_t				result;

+	} getpixelcolor;

+	struct gdisp_lld_msg_verticalscroll {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_VERTICALSCROLL

+		coord_t				x, y;

+		coord_t				cx, cy;

+		int					lines;

+		color_t				bgcolor;

+	} verticalscroll;

+	struct gdisp_lld_msg_control {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CONTROL

+		int					what;

+		void *				value;

+	} control;

+	struct gdisp_lld_msg_query {

+		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_QUERY

+		int					what;

+		void *				result;

+	} query;

+} gdisp_lld_msg_t;

+

+#endif	/* HAL_USE_GDISP */

+#endif	/* _GDISP_LLD_MSGS_H */

+/** @} */

diff --git a/include/glcd.h b/include/glcd.h
new file mode 100644
index 00000000..ab2f6be2
--- /dev/null
+++ b/include/glcd.h
@@ -0,0 +1,136 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

+                 Joel Bodenmann aka Tectu <joel@unormal.org>

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+

+/*

+	This file is an emulation of the GLCD interface using the

+	new GDISP interface. It is probably not a perfect replica,

+	some code changes may be necessary.

+	Note it does not replicate the GLCD low level driver, just

+	the high level interface.

+	You may also need to define the various GDISP_NEED_XXX in your

+	halconf.h in order to turn on the functionality you need.

+*/

+

+#ifndef GLCD_H

+#define GLCD_H

+

+#include "ch.h"

+#include "hal.h"

+#include "gdisp.h"

+

+#define PORTRAIT	(lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv)

+#define LANDSCAPE	(lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)

+

+#define RGB565CONVERT(r, g, b)	RGB2COLOR(r,g,b)

+

+enum filled {frame, filled};

+enum transparency {solid, transparent};

+#define sleepOn		powerSleep

+#define sleepOff	powerOn

+

+#define font_Small						(&fontSmall)

+#define font_SmallDouble				(&fontSmallDouble)

+#define font_SmallNarrow				(&fontSmall)

+#define font_Larger						(&fontLarger)

+#define font_LargerDouble				(&fontLargerDouble)

+#define font_LargerNarrow				(&fontLargerNarrow)

+#define font_MediumBold					(&fontUI1)

+#define font_MediumBoldDouble			(&fontUI1Double)

+#define font_MediumBoldNarrow			(&fontUI1Narrow)

+#define font_LargeNumbers				(&fontLargeNumbers)

+#define font_LargeNumbersDouble			(&fontLargeNumbersDouble)

+#define font_LargeNumbersNarrow			(&fontLargeNumbersNarrow)

+

+enum glcd_result {	GLCD_DONE,

+					GLCD_FAILED,

+					GLCD_PROGRESS,

+				};

+

+typedef enum glcd_result glcd_result_t;

+

+/* Core functions */

+#define lcdInit(dvr)							gdispInit(dvr)

+static __inline glcd_result_t lcdClear(color_t color) {

+	gdispClear(color);

+	return GLCD_DONE;

+}

+static __inline glcd_result_t lcdSetOrientation(enum orientation newO) {

+	gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(int)newO);

+	return ((enum orientation)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) == (newO) ? GLCD_DONE : GLCD_FAILED;

+}

+static __inline glcd_result_t lcdFillArea(coord_t x0, coord_t y0, coord_t x1, coord_t y1,color_t c) {

+	gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c));

+	return GLCD_DONE;

+}

+static __inline glcd_result_t lcdWriteArea(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const pixel_t *b, coord_t n) {

+		(void)n;

+		gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b));

+		return GLCD_DONE;

+}

+static __inline glcd_result_t lcdSetPowerMode(enum powermode pm) {

+	gdispControl(GDISP_CONTROL_POWER, (void *)(int)pm);

+	return ((enum powermode)(unsigned)gdispQuery(GDISP_QUERY_POWER)) == (pm) ? GLCD_DONE : GLCD_FAILED;

+}

+

+/* Drawing functions */

+static __inline glcd_result_t lcdDrawPixel(coord_t x, coord_t y, color_t c) {

+	gdispDrawPixel((x),(y),(c));

+	return GLCD_DONE;

+}

+#define lcdDrawLine(x0,y0,x1,y1,c)				gdispDrawLine((x0),(y0),(x1),(y1),(c))

+#define lcdDrawRect(x0,y0,x1,y1,f,c)			{if(f) gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)); else gdispDrawBox((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c));}

+#define lcdDrawRectString(x0,y0,x1,y1,s,f,c,b)	gdispFillStringBox((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(s),(f),(c),(b),justifyLeft)

+#define lcdDrawCircle(x,y,r,f,c)				{if(f) gdispFillCircle((x),(y),(r),(c)); else gdispDrawCircle((x),(y),(r),(c));}

+#define lcdDrawEllipse(x,y,a,b,f,c)				{if(f) gdispFillEllipse((x),(y),(a),(b),(c)); else gdispDrawEllipse((x),(y),(a),(b),(c));}

+

+/* Text Rendering Functions */

+static __inline coord_t lcdDrawChar(coord_t x, coord_t y, char h, font_t f, color_t c, color_t b, bool_t t) {

+	if (t)

+		gdispDrawChar((x),(y),(h),(f),(c));

+	else

+		gdispFillChar((x),(y),(h),(f),(c),(b));

+	return gdispGetCharWidth((h),(f))+gdispGetFontMetric((f), fontCharPadding);

+}

+static __inline coord_t lcdDrawString(coord_t x, coord_t y, const char *s, font_t f, color_t c, color_t b, bool_t t) {

+	if (t)

+		gdispDrawString((x),(y),(s),(f),(c));

+	else

+		gdispFillString((x),(y),(s),(f),(c),(b));

+	return gdispGetStringWidth((s),(f))+gdispGetFontMetric((f), fontCharPadding);

+}

+

+/* Character measuring functions */

+#define lcdMeasureChar(h,f)						(gdispGetCharWidth((h),(f))+gdispGetFontMetric((f), fontCharPadding))

+#define lcdMeasureString(s,f)					(gdispGetStringWidth((s),(f))+gdispGetFontMetric((f), fontCharPadding))

+#define lcdGetFontHeight(f)						gdispGetFontMetric((f), fontHeight)

+

+/* Size and orientation related */

+#define lcdGetHeight()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))

+#define lcdGetWidth()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))

+#define lcdGetOrientation()						((enum orientation)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))

+

+/* BGR->RGB and pixel readback */

+#define lcdBGR2RGB(c)							RGB2COLOR(BLUE_OF(c),GREEN_OF(c),RED_OF(c))

+#define lcdGetPixelColor(x,y)					gdispGetPixelColor((x),(y))

+

+/* Scrolling function */

+#define lcdVerticalScroll(x0,y0,x1,y1,l)		gdispVerticalScroll((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,l,Black)

+

+#endif

diff --git a/include/touchpad.h b/include/touchpad.h
new file mode 100644
index 00000000..445d3202
--- /dev/null
+++ b/include/touchpad.h
@@ -0,0 +1,93 @@
+/*
+    ChibiOS-LCD-Driver/RT - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS-LCD-Driver.
+
+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.
+*/
+
+/**
+ * @file	touchpad.h
+ * @brief	TOUCHPAD Touchpad Driver subsystem header file.
+ *
+ * @addgroup TOUCHPAD
+ * @{
+ */
+#ifndef _TOUCHPAD_H
+#define _TOUCHPAD_H
+
+#if HAL_USE_TOUCHPAD || defined(__DOXYGEN__)
+
+/**
+ * @brief	specifies how many conversions are made for a readout.
+ *
+ * @note	higher is more accurate, but takes more time
+ */
+#define	CONVERSIONS 3
+
+/*===========================================================================*/
+/* Driver constants.                                                         */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Low Level Driver details and error checks.                                */
+/*===========================================================================*/
+
+/* Include the low level driver information */
+#include "touchpad_lld.h"
+
+/*===========================================================================*/
+/* Type definitions                                                          */
+/*===========================================================================*/
+
+/**
+ * @brief	Struct used for calibration
+ */
+struct cal {
+    float xm; 
+    float ym; 
+    float xn; 
+    float yn; 
+};
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void tpInit(TOUCHPADDriver *tp);
+uint16_t tpReadX(void);
+uint16_t tpReadY(void);
+
+#if TOUCHPAD_HAS_IRQ
+	uint8_t tpIRQ(void);
+#endif
+
+#if TOUCHPAD_HAS_PRESSURE
+	uint16_t tpReadZ(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_USE_TOUCHPAD */
+
+#endif /* _TOUCHPAD_H */
+/** @} */
+
diff --git a/include/touchpad_lld.h b/include/touchpad_lld.h
new file mode 100644
index 00000000..45a561d3
--- /dev/null
+++ b/include/touchpad_lld.h
@@ -0,0 +1,106 @@
+/*
+    ChibiOS-LCD-Driver/RT - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS-LCD-Driver.
+
+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.
+*/
+
+/**
+ * @file	touchpad_lld.h
+ * @brief	TOUCHPAD Driver subsystem low level driver header.
+ *
+ * @addgroup TOUCHPAD
+ * @{
+ */
+
+#ifndef _TOUCHPAD_LLD_H
+#define _TOUCHPAD_LLD_H
+
+#if HAL_USE_TOUCHPAD || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Include the low level driver configuration information                    */
+/*===========================================================================*/
+
+#include "touchpad_lld_config.h"
+
+/*===========================================================================*/
+/* Error checks.                                                             */
+/*===========================================================================*/
+
+#ifndef TOUCHPAD_HAS_IRQ
+	#define TOUCHPAD_HAS_IRQ	FALSE
+#endif
+
+#ifndef TOUCHPAD_HAS_PRESSURE
+	#define TOUCHPAD_HAS_PRESSURE	FALSE
+#endif
+
+/*===========================================================================*/
+/* Driver types.                                                             */
+/*===========================================================================*/
+
+typedef struct TOUCHPADDriver TOUCHPADDriver;
+
+/**
+ * @brief	Structure representing a Touchpad driver.
+ */
+struct TOUCHPADDriver {
+	/*
+	 * @brief	Pointer to SPI driver.
+	 */
+	SPIDriver *spid;
+
+	/*
+	 * @brief	SPI configuration.
+	 */
+	SPIConfig *spicfg;	
+};
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#if !defined(__DOXYGEN__)
+    extern TOUCHPADDriver Touchpad;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	/* Core functions */
+	void tp_lld_init(TOUCHPADDriver *tp);
+	uint16_t tp_lld_read_x(void);
+	uint16_t tp_lld_read_y(void);
+
+	#if TOUCHPAD_HAS_IRQ
+	uint8_t tp_lld_irq(void);
+	#endif
+
+	#if TOUCHPAD_HAS_PRESSURE
+	uint16_t tp_lld_read_z(void);
+	#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_USE_TOUCHPAD */
+
+#endif /* _TOUCHPAD_LLD_H */
+/** @} */
+