Many changes

Fixed compile errors Moved to halext directory (with readme instructions) Started gdispNokia6100 low level driver
author: Andrew Hannam <andrewh@inmarket.com.au> 2012-07-31 14:34:10 +1000
committer: Andrew Hannam <andrewh@inmarket.com.au> 2012-07-31 14:34:10 +1000
commit: 256062859a1b60dd93c73939b8d9a697e569f252 (patch)
tree: 8dab6d09b8860878de07f9dc6aeef2fab2e47652 /halext
parent: d1bfbf2b339192a76306f37150c30cdcf690266f (diff)
download: uGFX-256062859a1b60dd93c73939b8d9a697e569f252.tar.gz
uGFX-256062859a1b60dd93c73939b8d9a697e569f252.tar.bz2
uGFX-256062859a1b60dd93c73939b8d9a697e569f252.zip
15 files changed, 3956 insertions, 0 deletions
diff --git a/halext/drivers/gdispNokia6100/gdisp_lld.c b/halext/drivers/gdispNokia6100/gdisp_lld.c
new file mode 100644
index 00000000..0d039107
--- /dev/null
+++ b/halext/drivers/gdispNokia6100/gdisp_lld.c
@@ -0,0 +1,435 @@
+/*
+    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.c
+ * @brief   GDISP Graphics Driver subsystem low level driver source template.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gdisp.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 GDISP1;
+#endif
+
+/*===========================================================================*/
+/* Driver local variables.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver interrupt handlers.                                                */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions.                                                */
+/*===========================================================================*/
+
+/* ---- Required Routines ---- */
+/*
+	The following 4 routines are required.
+	All other routines are optional.
+*/
+
+/**
+ * @brief   Low level GDISP driver initialization.
+ *
+ * @notapi
+ */
+void gdisp_lld_init(void) {
+	/* Initialise the GDISP structure with the defaults for your display */
+	GDISP1.Width = 128;
+	GDISP1.Height = 128;
+	GDISP1.Orientation = portrait;
+	GDISP1.Powermode = powerOff;
+	
+	/* Now initialise your display to match */
+	/* Code here */
+}
+
+/**
+ * @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 equivelent to powerOn.
+ *
+ * @param[in] powerMode    The new power mode
+ *
+ * @notapi
+ */
+void gdisp_lld_setpowermode(gdisp_powermode_t powerMode) {
+	/* Code here */
+	/* if successful
+		GDISP1.Powermode = powerMode;
+	*/
+}
+
+/**
+ * @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) {
+	/* Code here */
+	/* if successful
+		GDISP1.Orientation = newOrientation;
+	*/
+}
+
+/**
+ * @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 >= GDISP1.Width || y >= GDISP1.Height) return;
+	#endif
+	/* Code here */
+}
+
+/* ---- 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_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) {
+		/* Code here */
+	}
+#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 >= GDISP1.Width || y >= GDISP1.Height) return;
+			if (x+cx > GDISP1.Width)	cx = GDISP1.Width - x;
+			if (y+cy > GDISP1.Height)	cy = GDISP1.Height - y;
+		#endif
+		/* Code here */
+	}
+#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) {
+		#if GDISP_NEED_VALIDATION
+			if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+			if (x+cx > GDISP1.Width || y+cy > GDISP1.Height) return;
+		#endif
+		/* Code here */
+	}
+#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) {
+		#if GDISP_NEED_VALIDATION
+			if (x >= GDISP1.Width || y >= GDISP1.Height) return 0;
+		#endif
+		/* Code here */
+	}
+#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) {
+		#if GDISP_NEED_VALIDATION
+			if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+			if (x+cx > GDISP1.Width)	cx = GDISP1.Width - x;
+			if (y+cy > GDISP1.Height)	cy = GDISP1.Height - y;
+		#endif
+		/* Code here */
+	}
+#endif
+
+#endif /* HAL_USE_GDISP */
+/** @} */
diff --git a/halext/drivers/gdispNokia6100/gdisp_lld.h b/halext/drivers/gdispNokia6100/gdisp_lld.h
new file mode 100644
index 00000000..221983f4
--- /dev/null
+++ b/halext/drivers/gdispNokia6100/gdisp_lld.h
@@ -0,0 +1,167 @@
+/*
+    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 GDISP1;
+#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 above.
+	 */
+
+	/* 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/gdispNokia6100/gdisp_lld.mk b/halext/drivers/gdispNokia6100/gdisp_lld.mk
new file mode 100644
index 00000000..1af40772
--- /dev/null
+++ b/halext/drivers/gdispNokia6100/gdisp_lld.mk
@@ -0,0 +1,5 @@
+# List the required driver.
+HALSRC += ${CHIBIOS}/os/halext/drivers/gdispNokia6100/gdisp_lld.c
+
+# Required include directories
+HALINC += ${CHIBIOS}/os/halext/drivers/gdispNokia6100
diff --git a/halext/drivers/gdispNokia6100/gdisp_lld_config.h b/halext/drivers/gdispNokia6100/gdisp_lld_config.h
new file mode 100644
index 00000000..0d54faf0
--- /dev/null
+++ b/halext/drivers/gdispNokia6100/gdisp_lld_config.h
@@ -0,0 +1,212 @@
+/*
+    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_config.h
+ * @brief   GDISP Graphic Driver subsystem low level driver header template.
+ *
+ * @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 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			FALSE
+
+	/**
+	 * @brief   Hardware accelerated rectangular fills.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_FILLS			FALSE
+
+	/**
+	 * @brief   Hardware accelerated fills from an image.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_BITFILLS			FALSE
+
+	/**
+	 * @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/halext.mk b/halext/halext.mk
new file mode 100644
index 00000000..f5f47157
--- /dev/null
+++ b/halext/halext.mk
@@ -0,0 +1,6 @@
+# List of all the ChibiOS/RT META files, there is no need to remove the files
+# from this list, you can disable parts of the kernel by editing halconf.h.
+HALSRC += ${CHIBIOS}/os/halext/src/gdisp.c
+
+# Required include directories
+HALINC += ${CHIBIOS}/os/halext/include
diff --git a/halext/include/gdisp.h b/halext/include/gdisp.h
new file mode 100644
index 00000000..036f2fd4
--- /dev/null
+++ b/halext/include/gdisp.h
@@ -0,0 +1,407 @@
+/*
+    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    gdisp.h
+ * @brief   GDISP Graphic Driver macros and structures.
+ *
+ * @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   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   Do the drawing functions need to be thread-safe.
+ * @details	Defaults to FALSE
+ * @note	Turning this on adds two context switches per transaction
+ *			so it can significantly slow graphics drawing.
+ */
+#ifndef GDISP_NEED_MULTITHREAD
+	#define GDISP_NEED_MULTITHREAD	FALSE
+#endif
+/** @} */
+
+/* Include the low level driver configuration information */
+#include "gdisp_lld_config.h"
+
+/*===========================================================================*/
+/* Derived constants and error checks.                                       */
+/*===========================================================================*/
+
+#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 data structures and types.                                         */
+/*===========================================================================*/
+
+/* Define the basic Macro's for the various pixel formats */
+
+#if defined(GDISP_PIXELFORMAT_RGB565) || 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 defined(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 defined(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 defined(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 defined(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 !defined(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 !defined(GDISP_PIXELFORMAT_RGB888) && !defined(GDISP_PIXELFORMAT_RGB444) && !defined(GDISP_PIXELFORMAT_RGB666) && !defined(GDISP_PIXELFORMAT_CUSTOM)
+	#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."
+#endif
+
+/**
+ * @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 of a structure representing a GDISP driver.
+ */
+typedef struct GDISPDriver GDISPDriver;
+/**
+ * @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;
+/**
+ * @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.                                                    */
+/*===========================================================================*/
+
+/* Include the low level driver information */
+#include "gdisp_lld.h"
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief   Predefined fonts.
+ */
+extern const struct font fontSmall;
+extern const struct font fontLarger;
+extern const struct font fontUI1;
+extern const struct font fontUI2;
+extern const struct font fontLargeNumbers;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if GDISP_NEED_MULTITHREAD
+
+	/* Base Functions */
+	void gdispInit(GDISPDriver *gdisp);
+	void gdispSetPowerMode(gdisp_powermode_t powerMode);
+	void gdispSetOrientation(gdisp_orientation_t newOrientation);
+
+	/* 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 gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, 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, 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
+
+#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 gdispSetPowerMode(powerMode)						gdisp_lld_setpowermode(powerMode)
+	#define gdispSetOrientation(newOrientation)					gdisp_lld_setorientation(newOrientation)
+	#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 gdispDrawBox(x, y, cx, cy, color)					gdisp_lld_drawbox(x, y, cx, cy, 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)
+
+#endif
+
+	/* 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(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
+	#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_USE_GDISP */
+
+#endif /* _GDISP_H */
+/** @} */
diff --git a/halext/include/glcd.h b/halext/include/glcd.h
new file mode 100644
index 00000000..f4b0b2a6
--- /dev/null
+++ b/halext/include/glcd.h
@@ -0,0 +1,116 @@
+/*
+    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
+*/
+
+/*
+	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.
+*/
+
+#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 orientation {portrait, landscape, portraitInv, landscapeInv};
+enum filled {frame, filled};
+enum transparency {solid, transparent};
+enum powermode {powerOff, powerOn, sleepOn, sleepOff};
+#define sleepOn		powerSleep
+#define sleepOff	powerOn
+
+#define font_Small					(&fontSmall)
+#define font_Larger					(&fontLarger)
+#define font_MediumBold				(&fontUI1)
+#define font_LargeNumbers			(&fontLargeNumbers)
+
+#define GLCDDriver	GDISPDriver
+#define GLCDD1		GDISP1
+
+enum glcd_result {	GLCD_DONE,
+					GLCD_FAILED,
+					GLCD_PROGRESS,
+				};
+
+typedef enum glcd_result glcd_result_t;
+
+/* Core functions */
+#define lcdInit(dvr)							gdispInit(dvr)
+#define lcdClear(color)							(gdispClear(color), GLCD_DONE)
+#define lcdSetOrientation(newO)					(gdispSetOrientation(newO), (GDISP1.Orientation == (newO) ? GLCD_DONE : GLCD_FAILED))
+#define lcdFillArea(x0,y0,x1,y1,c)				(gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)), GLCD_DONE)
+#define lcdWriteArea(x0,y0,x1,y1,b,n)			(gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b)), GLCD_DONE)
+#define lcdSetPowerMode(pm)						(gdispSetPowerMode(pm), (GDISP1.Powermode == (pm) ? GLCD_DONE : GLCD_FAILED))
+
+/* Drawing functions */
+#define lcdDrawPixel(x,y,c)						(gdispDrawPixel((x),(y),(c)), 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 */
+#define lcdDrawChar(x,y,h,f,c,b,t)				({if(t) gdispDrawChar((x),(y),(h),(f),(c)); else gdispFillChar((x),(y),(h),(f),(c),(b));}, (gdispGetCharWidth((h),(f))+(f)->charPadding))
+#define lcdDrawString(x,y,s,f,c,b,t)			({if(t) gdispDrawString((x),(y),(s),(f),(c)); else gdispFillString((x),(y),(s),(f),(c),(b));}, (gdispGetStringWidth((s),(f))+(f)->charPadding))
+
+/* Character measuring functions */
+#define lcdMeasureChar(h,f)						(gdispGetCharWidth((h),(f))+(f)->charPadding)
+#define lcdMeasureString(s,f)					(gdispGetStringWidth((s),(f))+(f)->charPadding)
+#define lcdGetFontHeight(font)					gdispGetFontMetric(font, fontHeight)
+
+/* Size and orientation related */
+#define lcdGetHeight()							(GDISP1.Height)
+#define lcdGetWidth()							(GDISP1.Width)
+#define lcdGetOrientation()						(GDISP1.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/halext/readme.txt b/halext/readme.txt
new file mode 100644
index 00000000..cfd4da2d
--- /dev/null
+++ b/halext/readme.txt
@@ -0,0 +1,18 @@
+To include any of these functions/drivers in your project...
+
+	1/ Place this halext directory into the $(CHIBIOS)/os directory
+	2/ In your project Makefile (amongst similiar lines but after the hal line) add the line...
+		include $(CHIBIOS)/os/halext/halext.mk
+	3/ In your project Makefile add the makefiles for any specific drivers you want e.g
+		include $(CHIBIOS)/os/halext/drivers/gdispNokia6610/gdisp.mk
+	4/ In your project halconf.h turn on the support you want eg.
+		/**
+		 * @brief   Enables the GDISP subsystem.
+		 */
+		#if !defined(HAL_USE_GDISP) || defined(__DOXYGEN__)
+			#define HAL_USE_GDISP           TRUE
+			/* Any driver specific defines required go here */
+			#define GDISP_NEED_MULTITHREAD	TRUE
+		#endif
+	5/ Do a make clean.
+
diff --git a/halext/src/gdisp.c b/halext/src/gdisp.c
new file mode 100644
index 00000000..7259db0a
--- /dev/null
+++ b/halext/src/gdisp.c
@@ -0,0 +1,771 @@
+/*
+    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    gdisp.c
+ * @brief   GDISP Driver code.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gdisp.h"
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+#if GDISP_NEED_MULTITHREAD
+	#warning "GDISP: Multithread support not complete"
+	#define MUTEX_ENTER		/* Not defined yet */
+	#define MUTEX_EXIT		/* Not defined yet */
+#endif
+
+/*===========================================================================*/
+/* 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
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   The size of a font column.
+	 * @note	If you font heights > 16 you would need to redefine this
+	 *			as a uint32_t instead of a uint16_t. Fonts would then take
+	 *			twice the internal program memory.
+	 */
+	typedef uint16_t	fontcolumn_t;
+
+	/**
+	 * @brief   Internal font structure.
+	 * @note	This structure is followed by:
+	 *			An array of column data offsets (relative to the font structure)
+	 *			An array of character widths (uint8_t)
+	 *			Each characters array of column data (fontcolumn_t)
+	 */
+	struct font {
+		uint8_t		height;
+		uint8_t		charPadding;
+		uint8_t		lineSpacing;
+		uint8_t		descenderHeight;
+		uint8_t		minWidth;
+		uint8_t		maxWidth;
+		char		minChar;
+		char		maxChar;
+		uint16_t	offsetTableOffset;
+		uint16_t	unused1;			/* ensure next field is padded to 8 byte boundary */
+		uint8_t		widthTable[];
+		};
+
+	/**
+	 * @brief   Macro's to get to the complex parts of the font structure.
+	 */
+	#define _getFontPart(f,o,t)		((t)(&((const uint8_t *)(f))[(o)]))
+	#define _getCharWidth(f,c)		(((c) < (f)->minChar || (c) > (f)->maxChar) ? 0 : (f)->widthTable[c - (f)->minChar])
+	#define _getCharOffset(f,c)		(_getFontPart((f), (f)->offsetTableOffset, const uint16_t *)[c - (f)->minChar])
+	#define _getCharData(f,c)		_getFontPart((f), _getCharOffset((f),(c)), const fontcolumn_t *)
+#endif
+
+/*===========================================================================*/
+/* Driver exported variables.                                                */
+/*===========================================================================*/
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	#include "gdisp_inc_fonts.c"
+#endif
+
+/*===========================================================================*/
+/* Driver local variables.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions.                                                */
+/*===========================================================================*/
+
+/* Include the software emulation routines */
+#include "gdisp_inc_emulation.c"
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   GDISP Driver initialization.
+	 * @note    This function is NOT currently implicitly invoked by @p halInit().
+	 *			It must be called manually.
+	 *
+	 * @init
+	 */
+	void gdispInit(GDISPDriver * UNUSED(gdisp)) {
+		/* No mutex required as nothing should happen until the init is complete */
+		gdisp_lld_init();
+		
+		/* ToDo - Initialise Mutex */
+	}
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Set the power mode for the display.
+	 * @pre     The GDISP unit must have been initialised using @p gdispInit().
+	 * @note    Depending on the hardware implementation this function may not
+	 *          support powerSleep. If not powerSleep is treated the same as powerOn.
+	 *          (sleep allows drawing to the display without the display updating).
+	 *
+	 * @param[in] powerMode The power mode to use
+	 *
+	 * @api
+	 */
+	void gdispSetPowerMode(gdisp_powermode_t powerMode) {
+		MUTEX_ENTER
+		gdisp_lld_setpowermode(powerMode);
+		MUTEX_EXIT
+	}
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Set the orientation of the display.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 * @note    Depending on the hardware implementation this function may clear
+	 *			the display when changing its orientation.
+	 *
+	 * @param[in] newOrientation The new orientation to use
+	 *
+	 * @api
+	 */
+	void gdispSetOrientation(gdisp_orientation_t newOrientation) {
+		MUTEX_ENTER
+		gdisp_lld_setorientation(newOrientation);
+		MUTEX_EXIT
+	}
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Clear the display to the specified color.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] color The color to use when clearing the screen
+	 *
+	 * @api
+	 */
+	void gdispClear(color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_clear(color);
+		MUTEX_EXIT
+	}
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Set a pixel in the specified color.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x,y   The position to set the pixel.
+	 * @param[in] color The color to use
+	 *
+	 * @api
+	 */
+	void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_drawpixel(x, y, color);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a line.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x0,y0   The start position
+	 * @param[in] x1,y1   The end position
+	 * @param[in] color The color to use
+	 *
+	 * @api
+	 */
+	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_drawline(x0, y0, x1, y1, color);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a rectangular 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
+	 *
+	 * @api
+	 */
+	void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_drawbox(x, y, cx, cy, color);
+		MUTEX_EXIT
+	}
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Fill an area with a color.
+	 * @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
+	 *
+	 * @api
+	 */
+	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_fillarea(x, y, cx, cy, color);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+	/**
+	 * @brief   Fill an area using the supplied bitmap.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 * @details The bitmap is in the pixel format specified by the low level driver
+	 * @note	If a packed pixel format is used and the width doesn't
+	 *			match a whole number of bytes, the next line will start on a
+	 *			non-byte boundary (no end-of-line padding).
+	 *
+	 * @param[in] x0,y0   The start position
+	 * @param[in] cx,cy   The size of the filled area
+	 * @param[in] buffer  The bitmap in the driver's pixel format.
+	 *
+	 * @api
+	 */
+	void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {
+		MUTEX_ENTER
+		gdisp_lld_blitarea(x, y, cx, cy, buffer);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a circle.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x0,y0   The center of the circle
+	 * @param[in] radius  The radius of the circle
+	 * @param[in] color   The color to use
+	 *
+	 * @api
+	 */
+	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_drawcircle(x, y, radius, color);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a filled circle.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x0,y0   The center of the circle
+	 * @param[in] radius  The radius of the circle
+	 * @param[in] color   The color to use
+	 *
+	 * @api
+	 */
+	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_fillcircle(x, y, radius, color);
+		MUTEX_EXIT
+	}
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw an ellipse.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x0,y0   The center of the ellipse
+	 * @param[in] a,b     The dimensions of the ellipse
+	 * @param[in] color   The color to use
+	 *
+	 * @api
+	 */
+	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_drawellipse(x, y, a, b, color);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a filled ellipse.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x0,y0   The center of the ellipse
+	 * @param[in] a,b     The dimensions of the ellipse
+	 * @param[in] color   The color to use
+	 *
+	 * @api
+	 */
+	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_fillellipse(x, y, a, b, color);
+		MUTEX_EXIT
+	}
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a text character.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x,y     The position for the text
+	 * @param[in] c       The character to draw
+	 * @param[in] color   The color to use
+	 *
+	 * @api
+	 */
+	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
+		MUTEX_ENTER
+		gdisp_lld_drawchar(x, y, c, font, color);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a text character with a filled background.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x,y     The position for the text
+	 * @param[in] c       The character to draw
+	 * @param[in] color   The color to use
+	 * @param[in] bgcolor The background color to use
+	 *
+	 * @api
+	 */
+	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+		MUTEX_ENTER
+		gdisp_lld_fillchar(x, y, c, font, color, bgcolor);
+		MUTEX_EXIT
+	}
+#endif
+	
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a text string.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x,y     The position for the text
+	 * @param[in] str     The string to draw
+	 * @param[in] color   The color to use
+	 *
+	 * @api
+	 */
+	void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color) {
+		/* No mutex required as we only call high level functions which have their own mutex */
+		coord_t		w;
+		char		c;
+		int			first;
+		
+		first = 1;
+		while(*str) {
+			/* Get the next printable character */
+			c = *str++;
+			w = _getCharWidth(font, c);
+			if (!w) continue;
+			
+			/* Handle inter-character padding */
+			if (font->charPadding) {
+				if (!first)
+					x += font->charPadding;
+				else
+					first = 0;
+			}
+			
+			/* Print the character */
+			gdispDrawChar(x, y, c, font, color);
+			x += w;
+		}
+	}
+#endif
+	
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a text string.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 *
+	 * @param[in] x,y     The position for the text
+	 * @param[in] str     The string to draw
+	 * @param[in] color   The color to use
+	 * @param[in] bgcolor The background color to use
+	 *
+	 * @api
+	 */
+	void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor) {
+		/* No mutex required as we only call high level functions which have their own mutex */
+		coord_t		w;
+		char		c;
+		int			first;
+		
+		first = 1;
+		while(*str) {
+			/* Get the next printable character */
+			c = *str++;
+			w = _getCharWidth(font, c);
+			if (!w) continue;
+			
+			/* Handle inter-character padding */
+			if (font->charPadding) {
+				if (!first) {
+					gdispFillArea(x, y, font->charPadding, font->height, bgcolor);
+					x += font->charPadding;
+				} else
+					first = 0;
+			}
+
+			/* Print the character */
+			gdispFillChar(x, y, c, font, color, bgcolor);
+			x += w;
+		}
+	}
+#endif
+	
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   Draw a text string verticly centered within the specified box.
+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
+	 * @note    The entire box is filled
+	 *
+	 * @param[in] x,y     The position for the text (need to define top-right or base-line - check code)
+	 * @param[in] str     The string to draw
+	 * @param[in] color   The color to use
+	 * @param[in] bgcolor The background color to use
+	 * @param[in] justify Justify the text left, center or right within the box
+	 *
+	 * @api
+	 */
+	void gdispDrawStringBox(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) {
+		/* No mutex required as we only call high level functions which have their own mutex */
+		coord_t		w, ypos, xpos;
+		char		c;
+		int			first;
+		const char *rstr;
+		
+		/* Oops - font too large for the area */
+		if (font->height > cy) return;
+
+		/* See if we need to fill above the font */
+		ypos = (cy - font->height)/2;
+		if (ypos > 0) {
+			gdispFillArea(x, y, cx, ypos, bgcolor);
+			y += ypos;
+			cy -= ypos;
+		}
+		
+		/* See if we need to fill below the font */
+		ypos = cy - font->height;
+		if (ypos > 0) {
+			gdispFillArea(x, y+cy-ypos, cx, ypos, bgcolor);
+			cy -= ypos;
+		}
+		
+		/* get the start of the printable string and the xpos */
+		switch(justify) {
+		case justifyCenter:
+			/* Get the length of the entire string */
+			w = gdispGetStringWidth(str, font);
+			if (w <= cx)
+				xpos = x + (cx - w)/2;
+			else {
+				/* Calculate how much of the string we need to get rid of */
+				ypos = (w - cx)/2;
+				xpos = 0;
+				first = 1;
+				while(*str) {
+					/* Get the next printable character */
+					c = *str++;
+					w = _getCharWidth(font, c);
+					if (!w) continue;
+					
+					/* Handle inter-character padding */
+					if (font->charPadding) {
+						if (!first) {
+							xpos += font->charPadding;
+							if (xpos > ypos) break;
+						} else
+							first = 0;
+					}
+
+					/* Print the character */
+					xpos += w;
+					if (xpos > ypos) break;
+				}
+				xpos = ypos - xpos + x;
+			}
+			break;
+		case justifyRight:
+			/* Find the end of the string */
+			for(rstr = str; *str; str++);
+			xpos = x+cx - 2;
+			first = 1;
+			for(str--; str >= rstr; str--) {
+				/* Get the next printable character */
+				c = *str;
+				w = _getCharWidth(font, c);
+				if (!w) continue;
+				
+				/* Handle inter-character padding */
+				if (font->charPadding) {
+					if (!first) {
+						if (xpos - font->charPadding < x) break;
+						xpos -= font->charPadding;
+					} else
+						first = 0;
+				}
+
+				/* Print the character */
+				if (xpos - w < x) break;
+				xpos -= w;
+			}
+			str++;
+			break;
+		case justifyLeft:
+			/* Fall through */
+		default:
+			xpos = x+1;
+			break;
+		}
+		
+		/* Fill any space to the left */
+		if (x < xpos)
+			gdispFillArea(x, y, xpos-x, cy, bgcolor);
+		
+		/* Print characters until we run out of room */
+		first = 1;
+		while(*str) {
+			/* Get the next printable character */
+			c = *str++;
+			w = _getCharWidth(font, c);
+			if (!w) continue;
+			
+			/* Handle inter-character padding */
+			if (font->charPadding) {
+				if (!first) {
+					if (xpos + font->charPadding > x+cx) break;
+					gdispFillArea(xpos, y, font->charPadding, cy, bgcolor);
+					xpos += font->charPadding;
+				} else
+					first = 0;
+			}
+
+			/* Print the character */
+			if (xpos + w > x+cx) break;
+			gdispFillChar(xpos, y, c, font, color, bgcolor);
+			xpos += w;
+		}
+		
+		/* Fill any space to the right */
+		if (xpos < x+cx)
+			gdispFillArea(xpos, y, x+cx-xpos, cy, bgcolor);
+	}
+#endif
+	
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   Get a metric of a font.
+	 * @return  The metric requested in pixels.
+	 *
+	 * @param[in] font    The font to test
+	 * @param[in] metric  The metric to measure
+	 *
+	 * @api
+	 */
+	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {
+		/* No mutex required as we only read static data */
+		switch(metric) {
+		case fontHeight:			return font->height;
+		case fontDescendersHeight:	return font->descenderHeight;
+		case fontLineSpacing:		return font->lineSpacing;
+		case fontCharPadding:		return font->charPadding;
+		case fontMinWidth:			return font->minWidth;
+		case fontMaxWidth:			return font->maxWidth;
+		}
+		return 0;
+	}
+#endif
+	
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   Get the pixel width of a character.
+	 * @return  The width of the character in pixels. Does not include any between character padding.
+	 *
+	 * @param[in] c       The character to draw
+	 * @param[in] font    The font to use
+	 *
+	 * @api
+	 */
+	coord_t gdispGetCharWidth(char c, font_t font) {
+		/* No mutex required as we only read static data */
+		return _getCharWidth(font, c);
+	}
+#endif
+	
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+	/**
+	 * @brief   Get the pixel width of a string.
+	 * @return  The width of the string in pixels.
+	 *
+	 * @param[in] str     The string to measure
+	 * @param[in] font    The font to use
+	 *
+	 * @api
+	 */
+	coord_t gdispGetStringWidth(const char* str, font_t font) {
+		/* No mutex required as we only read static data */
+		coord_t		w, x;
+		char		c;
+		int			first;
+		
+		first = 1;
+		x = 0;
+		while(*str) {
+			/* Get the next printable character */
+			c = *str++;
+			w = _getCharWidth(font, c);
+			if (!w) continue;
+			
+			/* Handle inter-character padding */
+			if (font->charPadding) {
+				if (!first)
+					x += font->charPadding;
+				else
+					first = 0;
+			}
+			
+			/* Add the character width */
+			x += w;
+		}
+		return x;
+	}
+#endif
+
+#if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM)) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Pack a pixel into a pixel buffer.
+	 * @note    This function performs no buffer boundary checking
+	 *			regardless of whether GDISP_NEED_CLIPPING has been specified.
+	 *
+	 * @param[in] buf		The buffer to put the pixel in
+	 * @param[in] cx		The width of a pixel line
+	 * @param[in] x, y		The location of the pixel to place
+	 * @param[in] color		The color to put into the buffer
+	 *
+	 * @api
+	 */
+	void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) {
+		/* No mutex required as we only read static data */
+		#if defined(GDISP_PIXELFORMAT_RGB888)
+			#error "GDISP: Packed pixels not supported yet"
+		#elif defined(GDISP_PIXELFORMAT_RGB444)
+			#error "GDISP: Packed pixels not supported yet"
+		#elif defined(GDISP_PIXELFORMAT_RGB666)
+			#error "GDISP: Packed pixels not supported yet"
+		#elif
+			#error "GDISP: Unsupported packed pixel format"
+		#endif
+	}
+#endif
+
+#if (GDISP_NEED_PIXELREAD && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Get the color of a pixel.
+	 * @return  The color of the pixel.
+	 *
+	 * @param[in] x,y     The position of the pixel
+	 *
+	 * @api
+	 */
+	color_t gdispGetPixelColor(coord_t x, coord_t y) {
+		color_t		c;
+		
+		MUTEX_ENTER
+		c = gdisp_lld_getpixelcolor(x, y);
+		MUTEX_EXIT
+		
+		return c;
+	}
+#endif
+
+#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+	/**
+	 * @brief   Scroll vertically a section of the screen.
+	 * @note    Optional.
+	 * @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.
+	 *
+	 * @api
+	 */
+	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+		MUTEX_ENTER
+		gdisp_lld_verticalscroll(x, y, cx, cy, lines, bgcolor);
+		MUTEX_EXIT
+	}
+#endif
+
+#endif /* HAL_USE_GDISP */
+/** @} */
diff --git a/halext/src/gdisp_inc_emulation.c b/halext/src/gdisp_inc_emulation.c
new file mode 100644
index 00000000..b2a69892
--- /dev/null
+++ b/halext/src/gdisp_inc_emulation.c
@@ -0,0 +1,422 @@
+/*
+    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
+*/
+
+/*
+	Emulation routines included into gdisp.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.
+*/
+
+#if !GDISP_HARDWARE_CLEARS 
+	void gdisp_lld_clear(color_t color) {
+		gdisp_lld_fillarea(0, 0, GDISP1.Width, GDISP1.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_BOX
+	void gdisp_lld_drawbox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+		coord_t	x1, y1;
+		
+		x1 = x+cx-1;
+		y1 = y+cy-1;
+
+		if (cx > 2) {
+			if (cy >= 1) {
+				gdisp_lld_drawline(x, y, x1, y, color);
+				if (cy >= 2) {
+					gdisp_lld_drawline(x, y1, x1, y1, color);
+					if (cy > 2) {
+						gdisp_lld_drawline(x, y+1, x, y1-1, color);
+						gdisp_lld_drawline(x1, y+1, x1, y1-1, color);
+					}
+				}
+			}
+		} else if (cx == 2) {
+			gdisp_lld_drawline(x, y, x, y1, color);
+			gdisp_lld_drawline(x1, y, x1, y1, color);
+		} else if (cx == 1) {
+			gdisp_lld_drawline(x, y, x, y1, color);
+		}
+	}
+#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, 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
+	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, i, j;
+
+		/* Check we actually have something to print */
+		width = _getCharWidth(font, c);
+		if (!width) return;
+		
+		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++) {
+			/* Get the font bitmap data for the column */
+			column = *ptr++;
+			
+			/* Draw each pixel */
+			for(j = 0; j < font->height; j++, column >>= 1) {
+				if (column & 0x01)
+					gdisp_lld_drawpixel(x+i, y+j, 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;
+		
+		/* Check we actually have something to print */
+		width = _getCharWidth(font, c);
+		if (!width) return;
+
+		/* 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, font->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;
+			
+			/* Working buffer for fast non-transparent text rendering [patch by Badger] */
+			static pixel_t		buf[sizeof(fontcolumn_t)*8];
+
+			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++) {
+				/* Get the font bitmap data for the column */
+				column = *ptr++;
+				
+				/* Draw each pixel */
+				for(j = 0; j < font->height; j++, column >>= 1) {
+					gdispPackPixels(buf, 1, i, 0, (column & 0x01) ? color : bgcolor);
+				}
+
+				gdisp_lld_blitarea(x+i, y, 1, font->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;
+			
+			/* Working buffer for fast non-transparent text rendering [patch by Badger]
+				This needs to be larger than the largest character we can print.
+			*/
+			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)];
+
+			#if GDISP_NEED_VALIDATION
+				/* Check our buffer is big enough */
+				if (width * font->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++) {
+				/* Get the font bitmap data for the column */
+				column = *ptr++;
+				
+				/* Draw each pixel */
+				for(j = 0; j < font->height; j++, column >>= 1) {
+					gdispPackPixels(buf, width, i, j, (column & 0x01) ? color : bgcolor);
+				}
+			}
+
+			/* [Patch by Badger] Write all in one stroke */
+			gdisp_lld_blitarea(x, y, width, font->height, buf);
+		}
+
+		/* Method 4: Draw pixel by pixel */
+		#else
+		{
+			const fontcolumn_t	*ptr;
+			fontcolumn_t		column;
+			coord_t				i, j;
+			
+			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++) {
+				/* Get the font bitmap data for the column */
+				column = *ptr++;
+				
+				/* Draw each pixel */
+				for(j = 0; j < font->height; j++, column >>= 1) {
+					gdisp_lld_drawpixel(x+i, y+j, (column & 0x01) ? color : bgcolor);
+				}
+			}
+		}
+		#endif
+	}
+#endif
diff --git a/halext/src/gdisp_inc_fonts.c b/halext/src/gdisp_inc_fonts.c
new file mode 100644
index 00000000..41c6a087
--- /dev/null
+++ b/halext/src/gdisp_inc_fonts.c
@@ -0,0 +1,578 @@
+/*
+    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
+*/
+
+/*
+	Font tables included into gdisp.c
+*/
+
+/* Offset building macros */
+#define SF		sizeof(struct font)
+#define SC		sizeof(fontcolumn_t)
+
+/* fontSmall - for side buttons */
+#if 1
+	const struct font fontSmall = { 11, 0, 14, 2, 2, 12, ' ', '~', SF+96, 0};
+	static const uint8_t fontSmall_Widths[] = {
+		2, 3, 6, 8, 7, 9, 7, 3, 4, 4, 5, 7, 4, 4, 3, 6,
+		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 4, 6, 7, 6, 7,
+		12, 8, 7, 8, 8, 7, 7, 8, 8, 3, 5, 8, 7, 9, 8, 8,
+		8, 8, 8, 7, 7, 8, 8, 12, 8, 8, 8, 4, 6, 4, 7, 7,
+		4, 7, 7, 7, 7, 7, 4, 7, 7, 3, 3, 7, 3, 9, 7, 7,
+		7, 7, 4, 6, 4, 7, 7, 9, 6, 6, 6, 5, 3, 5, 8, 0
+	};
+	static const uint16_t fontSmall_Offsets[] = {
+		SF+288+0*SC, SF+288+2*SC, SF+288+5*SC, SF+288+11*SC, SF+288+19*SC, SF+288+26*SC, SF+288+35*SC, SF+288+42*SC,
+		SF+288+45*SC, SF+288+49*SC, SF+288+53*SC, SF+288+58*SC, SF+288+65*SC, SF+288+69*SC, SF+288+73*SC, SF+288+76*SC,
+		SF+288+82*SC, SF+288+89*SC, SF+288+96*SC, SF+288+103*SC, SF+288+110*SC, SF+288+117*SC, SF+288+124*SC, SF+288+131*SC,
+		SF+288+138*SC, SF+288+145*SC, SF+288+152*SC, SF+288+155*SC, SF+288+159*SC, SF+288+165*SC, SF+288+172*SC, SF+288+178*SC,
+		SF+288+185*SC, SF+288+197*SC, SF+288+205*SC, SF+288+212*SC, SF+288+220*SC, SF+288+228*SC, SF+288+235*SC, SF+288+242*SC,
+		SF+288+250*SC, SF+288+258*SC, SF+288+261*SC, SF+288+266*SC, SF+288+274*SC, SF+288+281*SC, SF+288+290*SC, SF+288+298*SC,
+		SF+288+306*SC, SF+288+314*SC, SF+288+322*SC, SF+288+330*SC, SF+288+337*SC, SF+288+344*SC, SF+288+352*SC, SF+288+360*SC,
+		SF+288+372*SC, SF+288+380*SC, SF+288+388*SC, SF+288+396*SC, SF+288+400*SC, SF+288+406*SC, SF+288+410*SC, SF+288+417*SC,
+		SF+288+424*SC, SF+288+428*SC, SF+288+435*SC, SF+288+442*SC, SF+288+449*SC, SF+288+456*SC, SF+288+463*SC, SF+288+467*SC,
+		SF+288+474*SC, SF+288+481*SC, SF+288+484*SC, SF+288+487*SC, SF+288+494*SC, SF+288+497*SC, SF+288+506*SC, SF+288+513*SC,
+		SF+288+520*SC, SF+288+527*SC, SF+288+534*SC, SF+288+538*SC, SF+288+544*SC, SF+288+548*SC, SF+288+555*SC, SF+288+562*SC,
+		SF+288+571*SC, SF+288+577*SC, SF+288+583*SC, SF+288+589*SC, SF+288+594*SC, SF+288+597*SC, SF+288+602*SC, 0
+	};
+	static const fontcolumn_t fontSmall_Data[] = {
+		/*   */	0x0000, 0x0000,
+		/* ! */	0x0000, 0x017F, 0x017F,
+		/* " */	0x0000, 0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+		/* # */	0x0000, 0x0044, 0x01FF, 0x01FF, 0x0044, 0x01FF, 0x01FF, 0x0044,
+		/* $ */	0x0000, 0x008C, 0x019E, 0x03FF, 0x03FF, 0x01E6, 0x00C4,
+		/* % */	0x0000, 0x0082, 0x00C7, 0x0065, 0x00B7, 0x01DA, 0x014C, 0x01C6, 0x0082,
+		/* & */	0x0000, 0x00E6, 0x01FF, 0x013F, 0x01E6, 0x01E0, 0x0120,
+		/* ' */	0x0000, 0x0007, 0x0007,
+		/* ( */	0x0000, 0x03FE, 0x07FF, 0x0401,
+		/* ) */	0x0000, 0x0401, 0x07FF, 0x03FE,
+		/* * */	0x0000, 0x000A, 0x000E, 0x000E, 0x000A,
+		/* + */	0x0000, 0x0020, 0x0020, 0x00F8, 0x00F8, 0x0020, 0x0020,
+		/* , */	0x0000, 0x0200, 0x0300, 0x0100,
+		/* - */	0x0000, 0x0020, 0x0020, 0x0020,
+		/* . */	0x0000, 0x0100, 0x0100,
+		/* / */	0x0000, 0x0180, 0x01E0, 0x0078, 0x001F, 0x0007,
+		/* 0 */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x01FF, 0x00FE,
+		/* 1 */	0x0000, 0x0002, 0x0002, 0x01FF, 0x01FF, 0x0000, 0x0000,
+		/* 2 */	0x0000, 0x0182, 0x01C3, 0x0161, 0x0131, 0x011F, 0x010E,
+		/* 3 */	0x0000, 0x0082, 0x0183, 0x0111, 0x0111, 0x01FF, 0x00EE,
+		/* 4 */	0x0000, 0x0060, 0x0078, 0x005E, 0x01FF, 0x01FF, 0x0040,
+		/* 5 */	0x0000, 0x009F, 0x019F, 0x0109, 0x0109, 0x01F9, 0x00F1,
+		/* 6 */	0x0000, 0x00FE, 0x01FF, 0x0111, 0x0111, 0x01F3, 0x00E2,
+		/* 7 */	0x0000, 0x0001, 0x01C1, 0x01F1, 0x003D, 0x000F, 0x0003,
+		/* 8 */	0x0000, 0x00EE, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,
+		/* 9 */	0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01FF, 0x00FE,
+		/* : */	0x0000, 0x0108, 0x0108,
+		/* ; */	0x0000, 0x0200, 0x0308, 0x0108,
+		/* < */	0x0000, 0x0020, 0x0070, 0x00D8, 0x018C, 0x0104,
+		/* = */	0x0000, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050,
+		/* > */	0x0000, 0x0104, 0x018C, 0x00D8, 0x0070, 0x0020,
+		/* ? */	0x0000, 0x0002, 0x0003, 0x0161, 0x0171, 0x001F, 0x000E,
+		/* @ */	0x0000, 0x0078, 0x01FE, 0x0186, 0x0333, 0x0279, 0x0249, 0x0279, 0x027B, 0x0246, 0x007E, 0x0078,
+		/* A */	0x0180, 0x01F0, 0x007C, 0x004F, 0x004F, 0x007C, 0x01F0, 0x0180,
+		/* B */	0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,
+		/* C */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x0183, 0x0082,
+		/* D */	0x0000, 0x01FF, 0x01FF, 0x0101, 0x0101, 0x0183, 0x00FE, 0x007C,
+		/* E */	0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x0111, 0x0101,
+		/* F */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x0001,
+		/* G */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0111, 0x0191, 0x01F3, 0x01F2,
+		/* H */	0x0000, 0x01FF, 0x01FF, 0x0010, 0x0010, 0x0010, 0x01FF, 0x01FF,
+		/* I */	0x0000, 0x01FF, 0x01FF,
+		/* J */	0x00C0, 0x01C0, 0x0100, 0x01FF, 0x00FF,
+		/* K */	0x0000, 0x01FF, 0x01FF, 0x003C, 0x0066, 0x00C3, 0x0181, 0x0100,
+		/* L */	0x0000, 0x01FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x0100,
+		/* M */	0x0000, 0x01FF, 0x01FF, 0x003C, 0x00F0, 0x00F0, 0x003C, 0x01FF, 0x01FF,
+		/* N */	0x0000, 0x01FF, 0x01FF, 0x001E, 0x0038, 0x00E0, 0x01FF, 0x01FF,
+		/* O */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x01FF, 0x00FE,
+		/* P */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x001F, 0x000E,
+		/* Q */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0141, 0x01C1, 0x03FF, 0x02FE,
+		/* R */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x01FF, 0x01EE,
+		/* S */	0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01F3, 0x00E2,
+		/* T */	0x0000, 0x0001, 0x0001, 0x01FF, 0x01FF, 0x0001, 0x0001,
+		/* U */	0x0000, 0x00FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x01FF, 0x00FF,
+		/* V */	0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,
+		/* W */	0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,
+		/* X */	0x0183, 0x01C7, 0x006C, 0x0038, 0x0038, 0x006C, 0x01C7, 0x0183,
+		/* Y */	0x0003, 0x0007, 0x000C, 0x01F8, 0x01F8, 0x000C, 0x0007, 0x0003,
+		/* Z */	0x0181, 0x01C1, 0x0161, 0x0131, 0x0119, 0x010D, 0x0107, 0x0103,
+		/* [ */	0x0000, 0x07FF, 0x07FF, 0x0401,
+		/* \ */	0x0000, 0x0007, 0x001F, 0x0078, 0x01E0, 0x0180,
+		/* ] */	0x0000, 0x0401, 0x07FF, 0x07FF,
+		/* ^ */	0x0000, 0x0002, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,
+		/* _ */	0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+		/* ` */	0x0000, 0x0001, 0x0003, 0x0002,
+		/* a */	0x0000, 0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,
+		/* b */	0x0000, 0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* c */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x0198, 0x0090,
+		/* d */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,
+		/* e */	0x0000, 0x00F0, 0x01F8, 0x0128, 0x0128, 0x01B8, 0x00B0,
+		/* f */	0x0000, 0x01FE, 0x01FF, 0x0009,
+		/* g */	0x0000, 0x04F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,
+		/* h */	0x0000, 0x01FF, 0x01FF, 0x0018, 0x0008, 0x01F8, 0x01F0,
+		/* i */	0x0000, 0x01F9, 0x01F9,
+		/* j */	0x0000, 0x07F9, 0x07F9,
+		/* k */	0x0000, 0x01FF, 0x01FF, 0x0070, 0x00D8, 0x0188, 0x0100,
+		/* l */	0x0000, 0x01FF, 0x01FF,
+		/* m */	0x0000, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F0,
+		/* n */	0x0000, 0x01F8, 0x01F8, 0x0018, 0x0008, 0x01F8, 0x01F0,
+		/* o */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* p */	0x0000, 0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* q */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,
+		/* r */	0x0000, 0x01F8, 0x01F8, 0x0008,
+		/* s */	0x0000, 0x0090, 0x01B8, 0x0168, 0x01D8, 0x0090,
+		/* t */	0x0000, 0x00FE, 0x01FE, 0x0108,
+		/* u */	0x0000, 0x00F8, 0x01F8, 0x0100, 0x0180, 0x01F8, 0x01F8,
+		/* v */	0x0000, 0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,
+		/* w */	0x0000, 0x0078, 0x01F8, 0x01E0, 0x0078, 0x0078, 0x01E0, 0x01F8, 0x0078,
+		/* x */	0x0000, 0x0198, 0x01F8, 0x0060, 0x01F8, 0x0198,
+		/* y */	0x0400, 0x0478, 0x07F8, 0x0380, 0x00F8, 0x0078,
+		/* z */	0x0000, 0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,
+		/* { */	0x0000, 0x0010, 0x01FF, 0x03EF, 0x0200,
+		/* | */	0x0000, 0x03FF, 0x03FF,
+		/* } */	0x0000, 0x0200, 0x03EF, 0x01FF, 0x0010,
+		/* ~ */	0x0000, 0x0004, 0x0006, 0x0002, 0x0006, 0x0004, 0x0006, 0x0002
+	};
+#endif
+
+/* fontLarger - Tahoma, 11, Bold */
+#if 1
+	const struct font fontLarger = { 12, 1, 13, 2, 2, 13, ' ', '~', SF+96, 0};
+	static const uint8_t fontLarger_Widths[] = {
+		2, 3, 5, 8, 7, 13, 8, 2, 4, 4, 7, 8, 3, 4, 3, 5,
+		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 9, 8, 9, 6,
+		9, 8, 7, 7, 8, 6, 5, 7, 8, 4, 5, 7, 6, 10, 7, 8,
+		7, 8, 8, 7, 6, 7, 7, 11, 7, 6, 6, 4, 5, 4, 9, 8,
+		5, 6, 7, 5, 7, 6, 5, 7, 7, 2, 3, 6, 2, 10, 7, 7,
+		7, 7, 4, 5, 5, 7, 6, 10, 6, 6, 5, 6, 4, 6, 9, 0
+	};
+	static const uint16_t fontLarger_Offsets[] = {
+		SF+288+0*SC, SF+288+2*SC, SF+288+5*SC, SF+288+10*SC, SF+288+18*SC, SF+288+25*SC, SF+288+38*SC, SF+288+46*SC,
+		SF+288+48*SC, SF+288+52*SC, SF+288+56*SC, SF+288+63*SC, SF+288+71*SC, SF+288+74*SC, SF+288+78*SC, SF+288+81*SC,
+		SF+288+86*SC, SF+288+93*SC, SF+288+100*SC, SF+288+107*SC, SF+288+114*SC, SF+288+121*SC, SF+288+128*SC, SF+288+135*SC,
+		SF+288+142*SC, SF+288+149*SC, SF+288+156*SC, SF+288+159*SC, SF+288+162*SC, SF+288+171*SC, SF+288+179*SC, SF+288+188*SC,
+		SF+288+194*SC, SF+288+203*SC, SF+288+211*SC, SF+288+218*SC, SF+288+225*SC, SF+288+233*SC, SF+288+239*SC, SF+288+244*SC,
+		SF+288+251*SC, SF+288+259*SC, SF+288+263*SC, SF+288+268*SC, SF+288+275*SC, SF+288+281*SC, SF+288+291*SC, SF+288+298*SC,
+		SF+288+306*SC, SF+288+313*SC, SF+288+321*SC, SF+288+329*SC, SF+288+336*SC, SF+288+342*SC, SF+288+349*SC, SF+288+356*SC,
+		SF+288+367*SC, SF+288+374*SC, SF+288+380*SC, SF+288+386*SC, SF+288+390*SC, SF+288+395*SC, SF+288+399*SC, SF+288+408*SC,
+		SF+288+416*SC, SF+288+421*SC, SF+288+427*SC, SF+288+434*SC, SF+288+439*SC, SF+288+446*SC, SF+288+452*SC, SF+288+457*SC,
+		SF+288+464*SC, SF+288+471*SC, SF+288+473*SC, SF+288+476*SC, SF+288+482*SC, SF+288+484*SC, SF+288+494*SC, SF+288+501*SC,
+		SF+288+508*SC, SF+288+515*SC, SF+288+522*SC, SF+288+526*SC, SF+288+531*SC, SF+288+536*SC, SF+288+543*SC, SF+288+549*SC,
+		SF+288+559*SC, SF+288+565*SC, SF+288+571*SC, SF+288+576*SC, SF+288+582*SC, SF+288+586*SC, SF+288+592*SC, 0
+	};
+	static const fontcolumn_t fontLarger_Data[] = {
+		/*   */	0x0000, 0x0000,
+		/* ! */	0x0000, 0x037E, 0x037E,
+		/* " */	0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+		/* # */	0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,
+		/* $ */	0x0118, 0x023C, 0x0264, 0x0FFF, 0x0264, 0x03C4, 0x0188,
+		/* % */	0x001C, 0x003E, 0x0022, 0x023E, 0x011C, 0x00C0, 0x0020, 0x0018, 0x01C4, 0x03E2, 0x0220, 0x03E0,
+				0x01C0,
+		/* & */	0x01CC, 0x03FE, 0x0232, 0x0272, 0x03DE, 0x018C, 0x03E0, 0x0260,
+		/* ' */	0x0007, 0x0007,
+		/* ( */	0x01F8, 0x07FE, 0x0E07, 0x0801,
+		/* ) */	0x0801, 0x0E07, 0x07FE, 0x01F8,
+		/* * */	0x0000, 0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,
+		/* + */	0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,
+		/* , */	0x0000, 0x0F00, 0x0700,
+		/* - */	0x0020, 0x0020, 0x0020, 0x0020,
+		/* . */	0x0000, 0x0300, 0x0300,
+		/* / */	0x0C00, 0x0380, 0x0060, 0x001C, 0x0003,
+		/* 0 */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,
+		/* 1 */	0x0000, 0x0204, 0x0204, 0x03FE, 0x03FE, 0x0200, 0x0200,
+		/* 2 */	0x0204, 0x0302, 0x0382, 0x02C2, 0x0262, 0x023E, 0x021C,
+		/* 3 */	0x0104, 0x0202, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+		/* 4 */	0x0060, 0x0050, 0x0048, 0x0044, 0x03FE, 0x03FE, 0x0040,
+		/* 5 */	0x0100, 0x021E, 0x021E, 0x0212, 0x0212, 0x03F2, 0x01E2,
+		/* 6 */	0x01F8, 0x03FC, 0x0216, 0x0212, 0x0212, 0x03F2, 0x01E0,
+		/* 7 */	0x0002, 0x0002, 0x0382, 0x03E2, 0x007A, 0x001E, 0x0006,
+		/* 8 */	0x01DC, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+		/* 9 */	0x003C, 0x027E, 0x0242, 0x0242, 0x0342, 0x01FE, 0x00FC,
+		/* : */	0x0000, 0x0318, 0x0318,
+		/* ; */	0x0000, 0x0F18, 0x0718,
+		/* < */	0x0000, 0x0060, 0x0060, 0x0090, 0x0090, 0x0108, 0x0108, 0x0204, 0x0204,
+		/* = */	0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,
+		/* > */	0x0000, 0x0204, 0x0204, 0x0108, 0x0108, 0x0090, 0x0090, 0x0060, 0x0060,
+		/* ? */	0x0004, 0x0002, 0x0362, 0x0372, 0x001E, 0x000C,
+		/* @ */	0x01F8, 0x0204, 0x04F2, 0x05FA, 0x050A, 0x04FA, 0x05FA, 0x0104, 0x00F8,
+		/* A */	0x0380, 0x03F0, 0x00FC, 0x008E, 0x008E, 0x00FC, 0x03F0, 0x0380,
+		/* B */	0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+		/* C */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x018C,
+		/* D */	0x03FE, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0306, 0x01FC, 0x00F8,
+		/* E */	0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x0222,
+		/* F */	0x03FE, 0x03FE, 0x0022, 0x0022, 0x0022,
+		/* G */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0222, 0x03E2, 0x03EC,
+		/* H */	0x03FE, 0x03FE, 0x0020, 0x0020, 0x0020, 0x0020, 0x03FE, 0x03FE,
+		/* I */	0x0202, 0x03FE, 0x03FE, 0x0202,
+		/* J */	0x0200, 0x0202, 0x0202, 0x03FE, 0x01FE,
+		/* K */	0x03FE, 0x03FE, 0x0070, 0x00D8, 0x018C, 0x0306, 0x0202,
+		/* L */	0x03FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x0200,
+		/* M */	0x03FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x0030, 0x0018, 0x000C, 0x03FE, 0x03FE,
+		/* N */	0x03FE, 0x000E, 0x001C, 0x0070, 0x01E0, 0x0380, 0x03FE,
+		/* O */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,
+		/* P */	0x03FE, 0x03FE, 0x0042, 0x0042, 0x0042, 0x007E, 0x003C,
+		/* Q */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0602, 0x0E02, 0x0BFE, 0x09FC,
+		/* R */	0x03FE, 0x03FE, 0x0022, 0x0062, 0x00E2, 0x01BE, 0x031C, 0x0200,
+		/* S */	0x019C, 0x023E, 0x0222, 0x0222, 0x0222, 0x03E2, 0x01CC,
+		/* T */	0x0002, 0x0002, 0x03FE, 0x03FE, 0x0002, 0x0002,
+		/* U */	0x01FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x03FE, 0x01FE,
+		/* V */	0x000E, 0x007E, 0x03F0, 0x0380, 0x03F0, 0x007E, 0x000E,
+		/* W */	0x001E, 0x00FE, 0x03E0, 0x03E0, 0x00FC, 0x000E, 0x00FC, 0x03E0, 0x03E0, 0x00FE, 0x001E,
+		/* X */	0x0306, 0x038E, 0x00F8, 0x0070, 0x00F8, 0x038E, 0x0306,
+		/* Y */	0x000E, 0x003E, 0x03F0, 0x03F0, 0x003E, 0x000E,
+		/* Z */	0x0382, 0x03C2, 0x0262, 0x0232, 0x021E, 0x020E,
+		/* [ */	0x0FFF, 0x0FFF, 0x0801, 0x0801,
+		/* \ */	0x0003, 0x001C, 0x0060, 0x0380, 0x0C00,
+		/* ] */	0x0801, 0x0801, 0x0FFF, 0x0FFF,
+		/* ^ */	0x0000, 0x0010, 0x0008, 0x0004, 0x0002, 0x0002, 0x0004, 0x0008, 0x0010,
+		/* _ */	0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,
+		/* ` */	0x0000, 0x0000, 0x0001, 0x0003, 0x0002,
+		/* a */	0x0180, 0x03D0, 0x0248, 0x0248, 0x03F8, 0x03F0,
+		/* b */	0x03FF, 0x03FF, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,
+		/* c */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208,
+		/* d */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x03FF, 0x03FF,
+		/* e */	0x01F0, 0x03F8, 0x0248, 0x0248, 0x0278, 0x0170,
+		/* f */	0x0008, 0x03FE, 0x03FF, 0x0009, 0x0001,
+		/* g */	0x01F0, 0x0BF8, 0x0A08, 0x0A08, 0x0908, 0x0FF8, 0x07F8,
+		/* h */	0x03FF, 0x03FF, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,
+		/* i */	0x03FA, 0x03FA,
+		/* j */	0x0808, 0x0FFA, 0x07FA,
+		/* k */	0x03FF, 0x03FF, 0x00E0, 0x01B0, 0x0318, 0x0208,
+		/* l */	0x03FF, 0x03FF,
+		/* m */	0x03F8, 0x03F8, 0x0008, 0x0008, 0x03F8, 0x03F0, 0x0008, 0x0008, 0x03F8, 0x03F0,
+		/* n */	0x03F8, 0x03F8, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,
+		/* o */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208, 0x03F8, 0x01F0,
+		/* p */	0x0FF8, 0x0FF8, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,
+		/* q */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x0FF8, 0x0FF8,
+		/* r */	0x03F8, 0x03F8, 0x0010, 0x0018,
+		/* s */	0x0130, 0x0278, 0x0248, 0x03C8, 0x0190,
+		/* t */	0x0008, 0x01FE, 0x03FE, 0x0208, 0x0208,
+		/* u */	0x01F8, 0x03F8, 0x0200, 0x0200, 0x0100, 0x03F8, 0x03F8,
+		/* v */	0x0038, 0x00F8, 0x03C0, 0x03C0, 0x00F8, 0x0038,
+		/* w */	0x0018, 0x00F8, 0x03E0, 0x0380, 0x00F8, 0x00F8, 0x0380, 0x03E0, 0x00F8, 0x0018,
+		/* x */	0x0318, 0x03B8, 0x00E0, 0x00E0, 0x03B8, 0x0318,
+		/* y */	0x0038, 0x0CF8, 0x0FC0, 0x03C0, 0x00F8, 0x0038,
+		/* z */	0x0388, 0x03C8, 0x0268, 0x0238, 0x0218,
+		/* { */	0x0020, 0x0020, 0x07FE, 0x0FDF, 0x0801, 0x0801,
+		/* | */	0x0000, 0x0000, 0x0FFF, 0x0FFF,
+		/* } */	0x0801, 0x0801, 0x0FDF, 0x07FE, 0x0020, 0x0020,
+		/* ~ */	0x00E0, 0x0030, 0x0030, 0x0030, 0x0060, 0x00C0, 0x00C0, 0x00C0, 0x0070
+	};
+#endif
+
+/* fontUI1 - UI Font 1 Medium Bold */
+#if 1
+	const struct font fontUI1 = { 13, 0, 15, 2, 3, 13, ' ', '~', SF+96, 0};
+	static const uint8_t fontUI1_Widths[] = {
+		3, 3, 6, 8, 7, 13, 9, 3, 5, 5, 6, 8, 3, 5, 3, 7,
+		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 8, 8, 8, 6,
+		10, 8, 7, 7, 8, 7, 7, 8, 8, 5, 5, 7, 7, 9, 8, 8,
+		7, 8, 8, 7, 8, 8, 7, 11, 7, 7, 7, 5, 7, 5, 9, 8,
+		5, 7, 7, 6, 7, 7, 5, 7, 7, 3, 4, 7, 3, 11, 7, 7,
+		7, 7, 6, 6, 5, 7, 7, 9, 7, 7, 6, 7, 4, 7, 8, 0
+	};
+	static const uint16_t fontUI1_Offsets[] = {
+		SF+288+0*SC, SF+288+3*SC, SF+288+6*SC, SF+288+12*SC, SF+288+20*SC, SF+288+27*SC, SF+288+40*SC, SF+288+49*SC,
+		SF+288+52*SC, SF+288+57*SC, SF+288+62*SC, SF+288+68*SC, SF+288+76*SC, SF+288+79*SC, SF+288+84*SC, SF+288+87*SC,
+		SF+288+94*SC, SF+288+101*SC, SF+288+108*SC, SF+288+115*SC, SF+288+122*SC, SF+288+129*SC, SF+288+136*SC, SF+288+143*SC,
+		SF+288+150*SC, SF+288+157*SC, SF+288+164*SC, SF+288+167*SC, SF+288+170*SC, SF+288+178*SC, SF+288+186*SC, SF+288+194*SC,
+		SF+288+200*SC, SF+288+210*SC, SF+288+218*SC, SF+288+225*SC, SF+288+232*SC, SF+288+240*SC, SF+288+247*SC, SF+288+254*SC,
+		SF+288+262*SC, SF+288+270*SC, SF+288+275*SC, SF+288+280*SC, SF+288+287*SC, SF+288+294*SC, SF+288+303*SC, SF+288+311*SC,
+		SF+288+319*SC, SF+288+326*SC, SF+288+334*SC, SF+288+342*SC, SF+288+349*SC, SF+288+357*SC, SF+288+365*SC, SF+288+372*SC,
+		SF+288+383*SC, SF+288+390*SC, SF+288+397*SC, SF+288+404*SC, SF+288+409*SC, SF+288+416*SC, SF+288+421*SC, SF+288+430*SC,
+		SF+288+438*SC, SF+288+443*SC, SF+288+450*SC, SF+288+457*SC, SF+288+463*SC, SF+288+470*SC, SF+288+477*SC, SF+288+482*SC,
+		SF+288+489*SC, SF+288+496*SC, SF+288+499*SC, SF+288+503*SC, SF+288+510*SC, SF+288+513*SC, SF+288+524*SC, SF+288+531*SC,
+		SF+288+538*SC, SF+288+545*SC, SF+288+552*SC, SF+288+558*SC, SF+288+564*SC, SF+288+569*SC, SF+288+576*SC, SF+288+583*SC,
+		SF+288+592*SC, SF+288+599*SC, SF+288+606*SC, SF+288+612*SC, SF+288+619*SC, SF+288+623*SC, SF+288+630*SC, 0
+	};
+	static const fontcolumn_t fontUI1_Data[] = {
+		/*   */	0x0000, 0x0000, 0x0000,
+		/* ! */	0x0000, 0x02FC, 0x02FC,
+		/* " */	0x0000, 0x000E, 0x000E, 0x0000, 0x000E, 0x000E,
+		/* # */	0x0000, 0x0080, 0x0390, 0x00F0, 0x039C, 0x00F0, 0x009C, 0x0010,
+		/* $ */	0x0000, 0x0130, 0x0278, 0x0FC8, 0x027E, 0x03C8, 0x0190,
+		/* % */	0x0000, 0x0038, 0x007C, 0x0044, 0x007C, 0x0338, 0x00C0, 0x0030, 0x01CC, 0x03E0, 0x0220, 0x03E0,
+				0x01C0,
+		/* & */	0x0000, 0x01D8, 0x03FC, 0x0224, 0x027C, 0x02D8, 0x0180, 0x0360, 0x0220,
+		/* ' */	0x0000, 0x000E, 0x000E,
+		/* ( */	0x0000, 0x01F0, 0x07FC, 0x0E0E, 0x0802,
+		/* ) */	0x0000, 0x0802, 0x0E0E, 0x07FC, 0x01F0,
+		/* * */	0x0000, 0x0014, 0x0008, 0x003E, 0x0008, 0x0014,
+		/* + */	0x0000, 0x0040, 0x0040, 0x0040, 0x03F8, 0x0040, 0x0040, 0x0040,
+		/* , */	0x0000, 0x0F00, 0x0700,
+		/* - */	0x0000, 0x0040, 0x0040, 0x0040, 0x0040,
+		/* . */	0x0000, 0x0300, 0x0300,
+		/* / */	0x0000, 0x0C00, 0x0F00, 0x03E0, 0x00F8, 0x001E, 0x0006,
+		/* 0 */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x03FC, 0x01F8,
+		/* 1 */	0x0000, 0x0000, 0x0208, 0x03FC, 0x03FC, 0x0200, 0x0000,
+		/* 2 */	0x0000, 0x0308, 0x038C, 0x02C4, 0x0264, 0x023C, 0x0218,
+		/* 3 */	0x0000, 0x0108, 0x030C, 0x0224, 0x0224, 0x03FC, 0x01D8,
+		/* 4 */	0x0000, 0x00C0, 0x00A0, 0x0090, 0x03F8, 0x03FC, 0x0080,
+		/* 5 */	0x0000, 0x0100, 0x033C, 0x023C, 0x0224, 0x03E4, 0x01C4,
+		/* 6 */	0x0000, 0x01F0, 0x03F8, 0x022C, 0x0224, 0x03E4, 0x01C0,
+		/* 7 */	0x0000, 0x0004, 0x0304, 0x03C4, 0x00F4, 0x003C, 0x000C,
+		/* 8 */	0x0000, 0x01D8, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,
+		/* 9 */	0x0000, 0x0038, 0x027C, 0x0244, 0x0344, 0x01FC, 0x00F8,
+		/* : */	0x0000, 0x0330, 0x0330,
+		/* ; */	0x0000, 0x0F30, 0x0730,
+		/* < */	0x0000, 0x0040, 0x00A0, 0x00A0, 0x0110, 0x0110, 0x0208, 0x0208,
+		/* = */	0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,
+		/* > */	0x0000, 0x0208, 0x0208, 0x0110, 0x0110, 0x00A0, 0x00A0, 0x0040,
+		/* ? */	0x0000, 0x0008, 0x02C4, 0x02E4, 0x003C, 0x0018,
+		/* @ */	0x0000, 0x01F0, 0x0208, 0x04E4, 0x05F4, 0x0514, 0x05F4, 0x05F4, 0x0104, 0x00F8,
+		/* A */	0x0000, 0x0380, 0x03F0, 0x00FC, 0x008C, 0x00FC, 0x03F0, 0x0380,
+		/* B */	0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,
+		/* C */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x0108,
+		/* D */	0x0000, 0x03FC, 0x03FC, 0x0204, 0x0204, 0x030C, 0x01F8, 0x00F0,
+		/* E */	0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x0224, 0x0224,
+		/* F */	0x0000, 0x03FC, 0x03FC, 0x0024, 0x0024, 0x0024, 0x0024,
+		/* G */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0244, 0x03C4, 0x03C8,
+		/* H */	0x0000, 0x03FC, 0x03FC, 0x0020, 0x0020, 0x0020, 0x03FC, 0x03FC,
+		/* I */	0x0000, 0x0204, 0x03FC, 0x03FC, 0x0204,
+		/* J */	0x0200, 0x0204, 0x0204, 0x03FC, 0x01FC,
+		/* K */	0x0000, 0x03FC, 0x03FC, 0x00F0, 0x0198, 0x030C, 0x0204,
+		/* L */	0x0000, 0x03FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x0200,
+		/* M */	0x0000, 0x03FC, 0x001C, 0x0038, 0x0070, 0x0020, 0x0010, 0x03F8, 0x03FC,
+		/* N */	0x0000, 0x03FC, 0x0018, 0x0030, 0x0060, 0x00C0, 0x0180, 0x03FC,
+		/* O */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x03FC, 0x01F8,
+		/* P */	0x0000, 0x03FC, 0x03FC, 0x0044, 0x0044, 0x007C, 0x0038,
+		/* Q */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0604, 0x0E04, 0x0BFC, 0x09F8,
+		/* R */	0x0000, 0x03FC, 0x03FC, 0x0044, 0x00C4, 0x01FC, 0x0338, 0x0200,
+		/* S */	0x0000, 0x0138, 0x027C, 0x0264, 0x0264, 0x03E4, 0x01C8,
+		/* T */	0x0004, 0x0004, 0x0004, 0x03FC, 0x03FC, 0x0004, 0x0004, 0x0004,
+		/* U */	0x0000, 0x01FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x03FC, 0x01FC,
+		/* V */	0x0000, 0x001C, 0x00FC, 0x03E0, 0x03E0, 0x00FC, 0x001C,
+		/* W */	0x0000, 0x001C, 0x00FC, 0x03E0, 0x03C0, 0x007C, 0x007C, 0x03C0, 0x03E0, 0x00FC, 0x001C,
+		/* X */	0x0000, 0x030C, 0x039C, 0x00F0, 0x00F0, 0x039C, 0x030C,
+		/* Y */	0x0000, 0x000C, 0x003C, 0x03F0, 0x03F0, 0x003C, 0x000C,
+		/* Z */	0x0000, 0x0384, 0x03C4, 0x02E4, 0x0274, 0x023C, 0x021C,
+		/* [ */	0x0000, 0x0FFE, 0x0FFE, 0x0802, 0x0802,
+		/* \ */	0x0000, 0x0006, 0x001E, 0x00F8, 0x03E0, 0x0F00, 0x0C00,
+		/* ] */	0x0000, 0x0802, 0x0802, 0x0FFE, 0x0FFE,
+		/* ^ */	0x0000, 0x0020, 0x0030, 0x0018, 0x000C, 0x000C, 0x0018, 0x0030, 0x0020,
+		/* _ */	0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,
+		/* ` */	0x0000, 0x0000, 0x0002, 0x0006, 0x0004,
+		/* a */	0x0000, 0x0180, 0x03D0, 0x0250, 0x0250, 0x03F0, 0x03E0,
+		/* b */	0x0000, 0x03FE, 0x03FE, 0x0210, 0x0210, 0x03F0, 0x01E0,
+		/* c */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0210,
+		/* d */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03FE, 0x03FE,
+		/* e */	0x0000, 0x01E0, 0x03F0, 0x0250, 0x0250, 0x0270, 0x0160,
+		/* f */	0x0010, 0x03FC, 0x03FE, 0x0012, 0x0012,
+		/* g */	0x0000, 0x01E0, 0x0BF0, 0x0A10, 0x0A10, 0x0FF0, 0x07F0,
+		/* h */	0x0000, 0x03FE, 0x03FE, 0x0010, 0x0010, 0x03F0, 0x03E0,
+		/* i */	0x0000, 0x03F4, 0x03F4,
+		/* j */	0x0800, 0x0810, 0x0FF4, 0x07F4,
+		/* k */	0x0000, 0x03FE, 0x03FE, 0x00C0, 0x01E0, 0x0330, 0x0210,
+		/* l */	0x0000, 0x03FE, 0x03FE,
+		/* m */	0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0, 0x0010, 0x0010, 0x03F0, 0x03E0,
+		/* n */	0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0,
+		/* o */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03F0, 0x01E0,
+		/* p */	0x0000, 0x0FF0, 0x0FF0, 0x0210, 0x0210, 0x03F0, 0x01E0,
+		/* q */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0FF0, 0x0FF0,
+		/* r */	0x0000, 0x03F0, 0x03F0, 0x0020, 0x0030, 0x0030,
+		/* s */	0x0000, 0x0260, 0x02F0, 0x02D0, 0x03D0, 0x0190,
+		/* t */	0x0010, 0x01FC, 0x03FC, 0x0210, 0x0210,
+		/* u */	0x0000, 0x01F0, 0x03F0, 0x0200, 0x0200, 0x03F0, 0x03F0,
+		/* v */	0x0000, 0x0070, 0x01F0, 0x0380, 0x0380, 0x01F0, 0x0070,
+		/* w */	0x0000, 0x00F0, 0x03F0, 0x0300, 0x00F0, 0x00F0, 0x0300, 0x03F0, 0x00F0,
+		/* x */	0x0000, 0x0330, 0x03F0, 0x00C0, 0x00C0, 0x03F0, 0x0330,
+		/* y */	0x0000, 0x0030, 0x0CF0, 0x0FC0, 0x03C0, 0x00F0, 0x0030,
+		/* z */	0x0000, 0x0310, 0x0390, 0x02D0, 0x0270, 0x0230,
+		/* { */	0x0000, 0x0040, 0x0040, 0x07FC, 0x0FBE, 0x0802, 0x0802,
+		/* | */	0x0000, 0x0000, 0x0FFE, 0x0FFE,
+		/* } */	0x0000, 0x0802, 0x0802, 0x0FBE, 0x07FC, 0x0040, 0x0040,
+		/* ~ */	0x0000, 0x01C0, 0x0020, 0x0020, 0x00C0, 0x0100, 0x0100, 0x00E0
+	};
+#endif
+
+/* fontUI1 - UI Font 2 Medium Bold */
+#if 1
+	const struct font fontUI2 = { 11, 1, 13, 2, 2, 12, ' ', '~', SF+96, 0};
+	static const uint8_t fontUI2_Widths[] = {
+		2, 2, 5, 8, 6, 12, 8, 2, 4, 4, 6, 8, 2, 4, 2, 5,
+		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 8, 8, 8, 5,
+		9, 7, 6, 6, 7, 5, 5, 7, 7, 4, 5, 6, 5, 9, 6, 7,
+		6, 7, 7, 6, 6, 7, 6, 10, 6, 6, 6, 4, 5, 4, 7, 7,
+		4, 6, 6, 5, 6, 6, 4, 6, 6, 2, 3, 6, 2, 10, 6, 6,
+		6, 6, 4, 5, 4, 6, 6, 8, 6, 6, 5, 6, 4, 6, 8, 0
+	};
+	static const uint16_t fontUI2_Offsets[] = {
+		SF+288+0*SC, SF+288+2*SC, SF+288+4*SC, SF+288+9*SC, SF+288+17*SC, SF+288+23*SC, SF+288+35*SC, SF+288+43*SC,
+		SF+288+45*SC, SF+288+49*SC, SF+288+53*SC, SF+288+59*SC, SF+288+67*SC, SF+288+69*SC, SF+288+73*SC, SF+288+75*SC,
+		SF+288+80*SC, SF+288+86*SC, SF+288+92*SC, SF+288+98*SC, SF+288+104*SC, SF+288+110*SC, SF+288+116*SC, SF+288+122*SC,
+		SF+288+128*SC, SF+288+134*SC, SF+288+140*SC, SF+288+142*SC, SF+288+144*SC, SF+288+152*SC, SF+288+160*SC, SF+288+168*SC,
+		SF+288+173*SC, SF+288+182*SC, SF+288+189*SC, SF+288+195*SC, SF+288+201*SC, SF+288+208*SC, SF+288+213*SC, SF+288+218*SC,
+		SF+288+225*SC, SF+288+232*SC, SF+288+236*SC, SF+288+241*SC, SF+288+247*SC, SF+288+252*SC, SF+288+261*SC, SF+288+267*SC,
+		SF+288+274*SC, SF+288+280*SC, SF+288+287*SC, SF+288+294*SC, SF+288+300*SC, SF+288+306*SC, SF+288+313*SC, SF+288+319*SC,
+		SF+288+329*SC, SF+288+335*SC, SF+288+341*SC, SF+288+347*SC, SF+288+351*SC, SF+288+356*SC, SF+288+360*SC, SF+288+367*SC,
+		SF+288+374*SC, SF+288+378*SC, SF+288+384*SC, SF+288+390*SC, SF+288+395*SC, SF+288+401*SC, SF+288+407*SC, SF+288+411*SC,
+		SF+288+417*SC, SF+288+423*SC, SF+288+425*SC, SF+288+428*SC, SF+288+434*SC, SF+288+436*SC, SF+288+446*SC, SF+288+452*SC,
+		SF+288+458*SC, SF+288+464*SC, SF+288+470*SC, SF+288+474*SC, SF+288+479*SC, SF+288+483*SC, SF+288+489*SC, SF+288+495*SC,
+		SF+288+503*SC, SF+288+509*SC, SF+288+515*SC, SF+288+520*SC, SF+288+526*SC, SF+288+530*SC, SF+288+536*SC, 0
+	};
+	static const fontcolumn_t fontUI2_Data[] = {
+		/*   */	0x0000, 0x0000,
+		/* ! */	0x017E, 0x017E,
+		/* " */	0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+		/* # */	0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,
+		/* $ */	0x0098, 0x013C, 0x07E4, 0x013F, 0x01E4, 0x00C8,
+		/* % */	0x001C, 0x003E, 0x0022, 0x003E, 0x019C, 0x0060, 0x0018, 0x00E6, 0x01F0, 0x0110, 0x01F0, 0x00E0,
+		/* & */	0x00EC, 0x01FE, 0x0112, 0x013E, 0x016C, 0x00C0, 0x01B0, 0x0110,
+		/* ' */	0x0007, 0x0007,
+		/* ( */	0x00F8, 0x03FE, 0x0707, 0x0401,
+		/* ) */	0x0401, 0x0707, 0x03FE, 0x00F8,
+		/* * */	0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,
+		/* + */	0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,
+		/* , */	0x0780, 0x0380,
+		/* - */	0x0020, 0x0020, 0x0020, 0x0020,
+		/* . */	0x0180, 0x0180,
+		/* / */	0x0600, 0x0180, 0x0070, 0x000C, 0x0003,
+		/* 0 */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x01FE, 0x00FC,
+		/* 1 */	0x0000, 0x0104, 0x01FE, 0x01FE, 0x0100, 0x0000,
+		/* 2 */	0x0184, 0x01C6, 0x0162, 0x0132, 0x011E, 0x010C,
+		/* 3 */	0x0084, 0x0186, 0x0112, 0x0112, 0x01FE, 0x00EC,
+		/* 4 */	0x0060, 0x0050, 0x0048, 0x01FC, 0x01FE, 0x0040,
+		/* 5 */	0x0080, 0x019E, 0x011E, 0x0112, 0x01F2, 0x00E2,
+		/* 6 */	0x00FC, 0x01FE, 0x0112, 0x0112, 0x01F2, 0x00E0,
+		/* 7 */	0x0002, 0x0002, 0x01C2, 0x01FA, 0x003E, 0x0006,
+		/* 8 */	0x00EC, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,
+		/* 9 */	0x001C, 0x013E, 0x0122, 0x0122, 0x01FE, 0x00FC,
+		/* : */	0x0198, 0x0198,
+		/* ; */	0x0798, 0x0398,
+		/* < */	0x0000, 0x0020, 0x0050, 0x0050, 0x0088, 0x0088, 0x0104, 0x0104,
+		/* = */	0x0000, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048,
+		/* > */	0x0000, 0x0104, 0x0104, 0x0088, 0x0088, 0x0050, 0x0050, 0x0020,
+		/* ? */	0x0004, 0x0162, 0x0172, 0x001E, 0x000C,
+		/* @ */	0x00F8, 0x0104, 0x0272, 0x02FA, 0x028A, 0x027A, 0x02FA, 0x0084, 0x0078,
+		/* A */	0x01C0, 0x01F8, 0x007E, 0x0046, 0x007E, 0x01F8, 0x01C0,
+		/* B */	0x01FE, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,
+		/* C */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x0102,
+		/* D */	0x01FE, 0x01FE, 0x0102, 0x0102, 0x0186, 0x00FC, 0x0078,
+		/* E */	0x01FE, 0x01FE, 0x0112, 0x0112, 0x0112,
+		/* F */	0x01FE, 0x01FE, 0x0012, 0x0012, 0x0012,
+		/* G */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0122, 0x01E2, 0x01E2,
+		/* H */	0x01FE, 0x01FE, 0x0010, 0x0010, 0x0010, 0x01FE, 0x01FE,
+		/* I */	0x0102, 0x01FE, 0x01FE, 0x0102,
+		/* J */	0x0100, 0x0102, 0x0102, 0x01FE, 0x00FE,
+		/* K */	0x01FE, 0x01FE, 0x0078, 0x00CC, 0x0186, 0x0102,
+		/* L */	0x01FE, 0x01FE, 0x0100, 0x0100, 0x0100,
+		/* M */	0x01FE, 0x000E, 0x001C, 0x0038, 0x0030, 0x0018, 0x000C, 0x01FE, 0x01FE,
+		/* N */	0x01FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x01FE,
+		/* O */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x01FE, 0x00FC,
+		/* P */	0x01FE, 0x01FE, 0x0022, 0x0022, 0x003E, 0x001C,
+		/* Q */	0x00FC, 0x01FE, 0x0102, 0x0302, 0x0702, 0x05FE, 0x04FC,
+		/* R */	0x01FE, 0x01FE, 0x0022, 0x0062, 0x00FE, 0x019C, 0x0100,
+		/* S */	0x011C, 0x013E, 0x0132, 0x0132, 0x01F2, 0x00E2,
+		/* T */	0x0002, 0x0002, 0x01FE, 0x01FE, 0x0002, 0x0002,
+		/* U */	0x00FE, 0x01FE, 0x0100, 0x0100, 0x0100, 0x01FE, 0x00FE,
+		/* V */	0x000E, 0x007E, 0x01F0, 0x01F0, 0x007E, 0x000E,
+		/* W */	0x000E, 0x007E, 0x01F0, 0x01E0, 0x003E, 0x003E, 0x01E0, 0x01F0, 0x007E, 0x000E,
+		/* X */	0x0186, 0x01CE, 0x0078, 0x0078, 0x01CE, 0x0186,
+		/* Y */	0x0006, 0x001E, 0x01F8, 0x01F8, 0x001E, 0x0006,
+		/* Z */	0x01C2, 0x01E2, 0x0172, 0x013A, 0x011E, 0x010E,
+		/* [ */	0x07FF, 0x07FF, 0x0401, 0x0401,
+		/* \ */	0x0003, 0x000C, 0x0070, 0x0180, 0x0600,
+		/* ] */	0x0401, 0x0401, 0x07FF, 0x07FF,
+		/* ^ */	0x0010, 0x0008, 0x0004, 0x0002, 0x0004, 0x0008, 0x0010,
+		/* _ */	0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+		/* ` */	0x0000, 0x0001, 0x0003, 0x0002,
+		/* a */	0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,
+		/* b */	0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* c */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x0108,
+		/* d */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,
+		/* e */	0x00F0, 0x01F8, 0x0128, 0x0128, 0x0138, 0x0130,
+		/* f */	0x01FE, 0x01FF, 0x0009, 0x0001,
+		/* g */	0x00F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,
+		/* h */	0x01FF, 0x01FF, 0x0008, 0x0008, 0x01F8, 0x01F0,
+		/* i */	0x01FA, 0x01FA,
+		/* j */	0x0408, 0x07FA, 0x03FA,
+		/* k */	0x01FF, 0x01FF, 0x0060, 0x00F0, 0x0198, 0x0108,
+		/* l */	0x01FF, 0x01FF,
+		/* m */	0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0, 0x0008, 0x0008, 0x01F8, 0x01F0,
+		/* n */	0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0,
+		/* o */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* p */	0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* q */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,
+		/* r */	0x01F8, 0x01F8, 0x0010, 0x0018,
+		/* s */	0x0130, 0x0178, 0x0168, 0x01E8, 0x00C8,
+		/* t */	0x00FE, 0x01FE, 0x0108, 0x0108,
+		/* u */	0x00F8, 0x01F8, 0x0100, 0x0100, 0x01F8, 0x01F8,
+		/* v */	0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,
+		/* w */	0x0078, 0x01F8, 0x01C0, 0x0078, 0x0078, 0x01C0, 0x01F8, 0x0078,
+		/* x */	0x0198, 0x01F8, 0x0060, 0x0060, 0x01F8, 0x0198,
+		/* y */	0x0018, 0x0678, 0x07E0, 0x01E0, 0x0078, 0x0018,
+		/* z */	0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,
+		/* { */	0x0020, 0x0020, 0x03FE, 0x07DF, 0x0401, 0x0401,
+		/* | */	0x0000, 0x0000, 0x07FF, 0x07FF,
+		/* } */	0x0401, 0x0401, 0x07DF, 0x03FE, 0x0020, 0x0020,
+		/* ~ */	0x0060, 0x0010, 0x0010, 0x0030, 0x0060, 0x0040, 0x0040, 0x0030
+	};
+#endif
+
+/*
+	fontLargeNumbers:
+		Large numbers font, height = 16 (including the decenders)
+		Characters include:  0 - 9, -, +, ., %, :, Space, Comma
+*/
+#if 1
+	const struct font fontLargeNumbers = { 16, 2, 21, 1, 3, 15, '%', ':', SF+24, 0};
+	static const uint8_t fontLargeNumbers_Widths[] = {
+		15, 0, 0, 0, 0, 0, 11, 3, 6, 3, 0, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 4, 0, 0
+	};
+	static const uint16_t fontLargeNumbers_Offsets[] = {
+		SF+72+0*SC, 0, 0, 0, 0, 0, SF+72+15*SC, SF+72+26*SC,
+		SF+72+29*SC, SF+72+35*SC, 0, SF+72+38*SC, SF+72+48*SC, SF+72+58*SC, SF+72+68*SC, SF+72+78*SC,
+		SF+72+88*SC, SF+72+98*SC, SF+72+108*SC, SF+72+118*SC, SF+72+128*SC, SF+72+138*SC, 0, 0
+	};
+	static const fontcolumn_t fontLargeNumbers_Data[] = {
+		/* % */	0x007E, 0x00FF, 0x00C3, 0x80C3, 0xE0FF, 0x7C7E, 0x1F00, 0x07C0, 0x00F0, 0x7E3E, 0xFF0F, 0xC303,
+				0xC300, 0xFF00, 0x7E00,
+		/* + */	0x01C0, 0x01C0, 0x01C0, 0x01C0, 0x1FFC, 0x1FFC, 0x1FFC, 0x01C0, 0x01C0, 0x01C0, 0x01C0,
+		/* , */	0x7000, 0x7000, 0xF000,
+		/* - */	0x0700, 0x0700, 0x0700, 0x0700, 0x0700, 0x0700,
+		/* . */	0x7000, 0x7000, 0x7000,
+		/* 0 */	0x0FF8, 0x3FFE, 0x3FFE, 0x7007, 0x6003, 0x6003, 0x7007, 0x3FFE, 0x3FFE, 0x0FF8,
+		/* 1 */	0x0000, 0x0070, 0x0038, 0x0038, 0x001C, 0x7FFF, 0x7FFF, 0x7FFF, 0x0000, 0x0000,
+		/* 2 */	0x600C, 0x700E, 0x7C0F, 0x7E07, 0x6F03, 0x6783, 0x63C7, 0x61FF, 0x60FE, 0x603C,
+		/* 3 */	0x180C, 0x380E, 0x780F, 0x70C3, 0x60C3, 0x60E3, 0x71FF, 0x3FFE, 0x3F3C, 0x0E00,
+		/* 4 */	0x0F00, 0x0DC0, 0x0CE0, 0x0C38, 0x0C1E, 0x7FFF, 0x7FFF, 0x7FFF, 0x0C00, 0x0C00,
+		/* 5 */	0x18C0, 0x38FC, 0x78FF, 0x707F, 0x6063, 0x6063, 0x70E3, 0x3FE3, 0x3FC3, 0x0F80,
+		/* 6 */	0x0FF8, 0x3FFE, 0x3FFE, 0x70C7, 0x6063, 0x6063, 0x70E7, 0x3FEF, 0x3FC6, 0x0F04,
+		/* 7 */	0x0003, 0x0003, 0x7803, 0x7F03, 0x7FC3, 0x07F3, 0x00FB, 0x003F, 0x000F, 0x0007,
+		/* 8 */	0x1E1C, 0x3F3E, 0x7FFF, 0x71E7, 0x60C3, 0x60C3, 0x71E7, 0x7FFF, 0x3F3E, 0x1E1C,
+		/* 9 */	0x1078, 0x39FE, 0x7BFE, 0x7387, 0x6303, 0x6303, 0x7187, 0x3FFE, 0x3FFE, 0x0FF8,
+		/* : */	0x0000, 0x0E38, 0x0E38, 0x0E38
+	};
+#endif
diff --git a/halext/template/gdisp_lld.c b/halext/template/gdisp_lld.c
new file mode 100644
index 00000000..0d039107
--- /dev/null
+++ b/halext/template/gdisp_lld.c
@@ -0,0 +1,435 @@
+/*
+    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.c
+ * @brief   GDISP Graphics Driver subsystem low level driver source template.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gdisp.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 GDISP1;
+#endif
+
+/*===========================================================================*/
+/* Driver local variables.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver interrupt handlers.                                                */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions.                                                */
+/*===========================================================================*/
+
+/* ---- Required Routines ---- */
+/*
+	The following 4 routines are required.
+	All other routines are optional.
+*/
+
+/**
+ * @brief   Low level GDISP driver initialization.
+ *
+ * @notapi
+ */
+void gdisp_lld_init(void) {
+	/* Initialise the GDISP structure with the defaults for your display */
+	GDISP1.Width = 128;
+	GDISP1.Height = 128;
+	GDISP1.Orientation = portrait;
+	GDISP1.Powermode = powerOff;
+	
+	/* Now initialise your display to match */
+	/* Code here */
+}
+
+/**
+ * @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 equivelent to powerOn.
+ *
+ * @param[in] powerMode    The new power mode
+ *
+ * @notapi
+ */
+void gdisp_lld_setpowermode(gdisp_powermode_t powerMode) {
+	/* Code here */
+	/* if successful
+		GDISP1.Powermode = powerMode;
+	*/
+}
+
+/**
+ * @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) {
+	/* Code here */
+	/* if successful
+		GDISP1.Orientation = newOrientation;
+	*/
+}
+
+/**
+ * @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 >= GDISP1.Width || y >= GDISP1.Height) return;
+	#endif
+	/* Code here */
+}
+
+/* ---- 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_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) {
+		/* Code here */
+	}
+#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 >= GDISP1.Width || y >= GDISP1.Height) return;
+			if (x+cx > GDISP1.Width)	cx = GDISP1.Width - x;
+			if (y+cy > GDISP1.Height)	cy = GDISP1.Height - y;
+		#endif
+		/* Code here */
+	}
+#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) {
+		#if GDISP_NEED_VALIDATION
+			if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+			if (x+cx > GDISP1.Width || y+cy > GDISP1.Height) return;
+		#endif
+		/* Code here */
+	}
+#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) {
+		#if GDISP_NEED_VALIDATION
+			if (x >= GDISP1.Width || y >= GDISP1.Height) return 0;
+		#endif
+		/* Code here */
+	}
+#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) {
+		#if GDISP_NEED_VALIDATION
+			if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+			if (x+cx > GDISP1.Width)	cx = GDISP1.Width - x;
+			if (y+cy > GDISP1.Height)	cy = GDISP1.Height - y;
+		#endif
+		/* Code here */
+	}
+#endif
+
+#endif /* HAL_USE_GDISP */
+/** @} */
diff --git a/halext/template/gdisp_lld.h b/halext/template/gdisp_lld.h
new file mode 100644
index 00000000..221983f4
--- /dev/null
+++ b/halext/template/gdisp_lld.h
@@ -0,0 +1,167 @@
+/*
+    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 GDISP1;
+#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 above.
+	 */
+
+	/* 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/template/gdisp_lld.mk b/halext/template/gdisp_lld.mk
new file mode 100644
index 00000000..d0933492
--- /dev/null
+++ b/halext/template/gdisp_lld.mk
@@ -0,0 +1,5 @@
+# List the required driver.
+HALSRC += ${CHIBIOS}/os/halext/drivers/gdispYOURDEVICE/gdisp_lld.c
+
+# Required include directories
+HALINC += ${CHIBIOS}/os/halext/drivers/gdispYOURDEVICE
diff --git a/halext/template/gdisp_lld_config.h b/halext/template/gdisp_lld_config.h
new file mode 100644
index 00000000..0d54faf0
--- /dev/null
+++ b/halext/template/gdisp_lld_config.h
@@ -0,0 +1,212 @@
+/*
+    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_config.h
+ * @brief   GDISP Graphic Driver subsystem low level driver header template.
+ *
+ * @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 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			FALSE
+
+	/**
+	 * @brief   Hardware accelerated rectangular fills.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_FILLS			FALSE
+
+	/**
+	 * @brief   Hardware accelerated fills from an image.
+	 * @details If set to @p FALSE software emulation is used.
+	 */
+	#define GDISP_HARDWARE_BITFILLS			FALSE
+
+	/**
+	 * @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 */
+/** @} */
author	Andrew Hannam <andrewh@inmarket.com.au>	2012-07-31 14:34:10 +1000
committer	Andrew Hannam <andrewh@inmarket.com.au>	2012-07-31 14:34:10 +1000
commit	256062859a1b60dd93c73939b8d9a697e569f252 (patch)
tree	8dab6d09b8860878de07f9dc6aeef2fab2e47652 /halext
parent	d1bfbf2b339192a76306f37150c30cdcf690266f (diff)
download	uGFX-256062859a1b60dd93c73939b8d9a697e569f252.tar.gz uGFX-256062859a1b60dd93c73939b8d9a697e569f252.tar.bz2 uGFX-256062859a1b60dd93c73939b8d9a697e569f252.zip