Multi-thread, Async Multi-thread & VMT

3 files changed, 377 insertions, 572 deletions

diff --git a/halext/src/gdisp-readme.txt b/halext/src/gdisp-readme.txt
index 28b86077..12b00e2c 100644
--- a/halext/src/gdisp-readme.txt
+++ b/halext/src/gdisp-readme.txt
@@ -1,10 +1,10 @@
-The new GDISP driver is an architecture independent rewrite of the GLCD interface.

-This new architecture independence should allow many new low level drivers to be easily added.

+The new GDISP driver is an architecture independant rewrite of the GLCD interface.

+This new architecture independance should allow many new low level drivers to be easily added.

 

 GDISP allows low-level driver hardware accelerated drawing routines while providing a software emulation

 if the low level driver can not provide it. A basic low level driver now only requires 2 routines to be written.

 

-A glcd.h compatibility file has been included that allow applications written to use the existing GLCD driver to

+A glcd.h compatability file has been included that allow applications written to use the existing GLCD driver to

 use the GDISP driver with little or no change.

 

 It is written in the ChibiOS style with ChibiOS style includes and documentation.

diff --git a/halext/src/gdisp.c b/halext/src/gdisp.c
index de3761cd..90b4582d 100644
--- a/halext/src/gdisp.c
+++ b/halext/src/gdisp.c
@@ -29,19 +29,15 @@
 #include "hal.h"

 #include "gdisp.h"

 

+#ifndef _GDISP_C

+#define _GDISP_C

+

 #if HAL_USE_GDISP || defined(__DOXYGEN__)

 

 #ifdef GDISP_NEED_TEXT

 	#include "gdisp_fonts.h"

 #endif

 

-#if GDISP_NEED_MULTITHREAD

-	#warning "GDISP: Multithread support not complete"

-	#define MUTEX_INIT		/* Not defined yet */

-	#define MUTEX_ENTER		/* Not defined yet */

-	#define MUTEX_EXIT		/* Not defined yet */

-#endif

-

 /*===========================================================================*/

 /* Driver local definitions.                                                 */

 /*===========================================================================*/

@@ -55,6 +51,18 @@
 # define UNUSED(x) x

 #endif

 

+#if GDISP_NEED_MULTITHREAD

+	#if !CH_USE_MUTEXES

+		#error "GDISP: CH_USE_MUTEXES must be defined in chconf.h because GDISP_NEED_MULTITHREAD is defined"

+	#endif

+#endif

+

+#if GDISP_NEED_ASYNC

+	#if !CH_USE_MAILBOXES || !CH_USE_MUTEXES || !CH_USE_SEMAPHORES

+		#error "GDISP: CH_USE_MAILBOXES, CH_USE_SEMAPHORES and CH_USE_MUTEXES must be defined in chconf.h because GDISP_NEED_ASYNC is defined"

+	#endif

+#endif

+

 /*===========================================================================*/

 /* Driver exported variables.                                                */

 /*===========================================================================*/

@@ -63,10 +71,77 @@
 /* Driver local variables.                                                   */

 /*===========================================================================*/

 

+#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC

+	static Mutex			gdispMutex;

+#endif

+

+#if GDISP_NEED_ASYNC

+	#define GDISP_THREAD_STACK_SIZE	512		/* Just a number - not yet a reflection of actual use */

+	#define GDISP_QUEUE_SIZE		8		/* We only allow a short queue */

+

+	static Thread *			lldThread;

+	static Mailbox			gdispMailbox;

+	static msg_t 			gdispMailboxQueue[GDISP_QUEUE_SIZE];

+	static Semaphore		gdispMsgsSem;

+	static Mutex			gdispMsgsMutex;

+	static gdisp_lld_msg_t	gdispMsgs[GDISP_QUEUE_SIZE];

+	static WORKING_AREA(waGDISPThread, GDISP_THREAD_STACK_SIZE);

+#endif

+

 /*===========================================================================*/

 /* Driver local functions.                                                   */

 /*===========================================================================*/

 

+#if GDISP_NEED_ASYNC

+	static msg_t GDISPThreadHandler(void *UNUSED(arg)) {

+		gdisp_lld_msg_t	*pmsg;

+

+		#if CH_USE_REGISTRY

+			chRegSetThreadName("GDISPAsyncAPI");

+		#endif

+

+		while(1) {

+			/* Wait for msg with work to do. */

+			chMBFetch(&gdispMailbox, (msg_t *)&pmsg, TIME_INFINITE);

+

+			/* OK - we need to obtain the mutex in case a synchronous operation is occurring */

+			chMtxLock(&gdispMutex);

+			GDISP_LLD(msgdispatch)(pmsg);

+			chMtxUnlock();

+

+			/* Mark the message as free */

+			pmsg->action = GDISP_LLD_MSG_NOP;

+			chSemSignal(&gdispMsgsSem);

+		}

+		return 0;

+	}

+

+	static gdisp_lld_msg_t *gdispAllocMsg(gdisp_msgaction_t action) {

+		gdisp_lld_msg_t	*p;

+

+		while(1) {		/* To be sure, to be sure */

+

+			/* Wait for a slot */

+			chSemWait(&gdispMsgsSem);

+

+			/* Find the slot */

+			chMtxLock(&gdispMsgsMutex);

+			for(p=gdispMsgs; p < &gdispMsgs[GDISP_QUEUE_SIZE]; p++) {

+				if (p->action == GDISP_LLD_MSG_NOP) {

+					/* Allocate it */

+					p->action = action;

+					chMtxUnlock();

+					return p;

+				}

+			}

+			chMtxUnlock();

+

+			/* Oops - none found, try again */

+			chSemSignal(&gdispMsgsSem);

+		}

+	}

+#endif

+

 /*===========================================================================*/

 /* Driver exported functions.                                                */

 /*===========================================================================*/

@@ -79,14 +154,62 @@
 	 *

 	 * @init

 	 */

-	void gdispInit(GDISPDriver * UNUSED(gdisp)) {

+	bool_t gdispInit(GDISPDriver * UNUSED(gdisp)) {

+		bool_t	res;

+

 		/* Initialise Mutex */

-		MUTEX_INIT

+		chMtxInit(&gdispMutex);

 

 		/* Initialise driver */

-		MUTEX_ENTER

-		gdisp_lld_init();

-		MUTEX_EXIT

+		chMtxLock(&gdispMutex);

+		res = GDISP_LLD(init)();

+		chMtxUnlock();

+

+		return res;

+	}

+#elif GDISP_NEED_ASYNC

+	bool_t gdispInit(GDISPDriver * UNUSED(gdisp)) {

+		bool_t		res;

+		unsigned	i;

+

+		/* Mark all the Messages as free */

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

+			gdispMsgs[i].action = GDISP_LLD_MSG_NOP;

+

+		/* Initialise our Mailbox, Mutex's and Counting Semaphore.

+		 * 	A Mutex is required as well as the Mailbox and Thread because some calls have to be synchronous.

+		 *	Synchronous calls get handled by the calling thread, asynchronous by our worker thread.

+		 */

+		chMBInit(&gdispMailbox, gdispMailboxQueue, sizeof(gdispMailboxQueue)/sizeof(gdispMailboxQueue[0]));

+		chMtxInit(&gdispMutex);

+		chMtxInit(&gdispMsgsMutex);

+		chSemInit(&gdispMsgsSem, GDISP_QUEUE_SIZE);

+

+		lldThread = chThdCreateStatic(waGDISPThread, sizeof(waGDISPThread), NORMALPRIO, GDISPThreadHandler, NULL);

+

+		/* Initialise driver - synchronous */

+		chMtxLock(&gdispMutex);

+		res = GDISP_LLD(init)();

+		chMtxUnlock();

+

+		return res;

+	}

+#endif

+

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Test if the GDISP engine is currently drawing.

+	 * @note    This function will always return FALSE if

+	 * 			 GDISP_NEED_ASYNC is not defined.

+	 *

+	 * @init

+	 */

+	bool_t gdispIsBusy(void) {

+		return FALSE;

+	}

+#elif GDISP_NEED_ASYNC

+	bool_t gdispIsBusy(void) {

+		return chMBGetUsedCountI(&gdispMailbox) != FALSE;

 	}

 #endif

 

@@ -100,9 +223,15 @@
 	 * @api

 	 */

 	void gdispClear(color_t color) {

-		MUTEX_ENTER

-		gdisp_lld_clear(color);

-		MUTEX_EXIT

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(clear)(color);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ASYNC

+	void gdispClear(color_t color) {

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_CLEAR);

+		p->clear.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 

@@ -117,9 +246,17 @@
 	 * @api

 	 */

 	void gdispDrawPixel(coord_t x, coord_t y, color_t color) {

-		MUTEX_ENTER

-		gdisp_lld_drawpixel(x, y, color);

-		MUTEX_EXIT

+		chMtxLock(&gdispMutex);

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

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWPIXEL);

+		p->drawpixel.x = x;

+		p->drawpixel.y = y;

+		p->drawpixel.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

@@ -135,9 +272,19 @@
 	 * @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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(drawline)(x0, y0, x1, y1, color);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWLINE);

+		p->drawline.x0 = x0;

+		p->drawline.y0 = y0;

+		p->drawline.x1 = x1;

+		p->drawline.y1 = y1;

+		p->drawline.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

@@ -153,9 +300,19 @@
 	 * @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

+		chMtxLock(&gdispMutex);

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

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLAREA);

+		p->fillarea.x = x;

+		p->fillarea.y = y;

+		p->fillarea.cx = cx;

+		p->fillarea.cy = cy;

+		p->fillarea.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

@@ -167,6 +324,9 @@
 	 * @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).

+	 * @note	If GDISP_NEED_ASYNC is defined then the buffer must be static

+	 * 			or at least retained until this call has finished the blit. You can

+	 * 			tell when all graphics drawing is finished by @p gdispIsBusy() going FALSE.

 	 *

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

 	 * @param[in] cx,cy   The size of the filled area

@@ -174,10 +334,20 @@
 	 *

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

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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(blitarea)(x, y, cx, cy, buffer);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_BLITAREA);

+		p->blitarea.x = x;

+		p->blitarea.y = y;

+		p->blitarea.cx = cx;

+		p->blitarea.cy = cy;

+		p->blitarea.buffer = buffer;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

@@ -193,9 +363,18 @@
 	 * @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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(drawcircle)(x, y, radius, color);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWCIRCLE);

+		p->drawcircle.x = x;

+		p->drawcircle.y = y;

+		p->drawcircle.radius = radius;

+		p->drawcircle.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

@@ -211,9 +390,18 @@
 	 * @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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(fillcircle)(x, y, radius, color);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLCIRCLE);

+		p->fillcircle.x = x;

+		p->fillcircle.y = y;

+		p->fillcircle.radius = radius;

+		p->fillcircle.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 

@@ -229,9 +417,19 @@
 	 * @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

+		chMtxLock(&gdispMutex);

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

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWELLIPSE);

+		p->drawellipse.x = x;

+		p->drawellipse.y = y;

+		p->drawellipse.a = a;

+		p->drawellipse.b = b;

+		p->drawellipse.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

@@ -247,9 +445,19 @@
 	 * @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

+		chMtxLock(&gdispMutex);

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

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLELLIPSE);

+		p->fillellipse.x = x;

+		p->fillellipse.y = y;

+		p->fillellipse.a = a;

+		p->fillellipse.b = b;

+		p->fillellipse.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 

@@ -265,13 +473,53 @@
 	 * @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

+		chMtxLock(&gdispMutex);

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

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWCHAR);

+		p->drawchar.x = x;

+		p->drawchar.y = y;

+		p->drawchar.c = c;

+		p->drawchar.font = font;

+		p->drawchar.color = color;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

+	}

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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(fillchar)(x, y, c, font, color, bgcolor);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLCHAR);

+		p->fillchar.x = x;

+		p->fillchar.y = y;

+		p->fillchar.c = c;

+		p->fillchar.font = font;

+		p->fillchar.color = color;

+		p->fillchar.bgcolor = bgcolor;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 	

-#if (GDISP_NEED_PIXELREAD && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+#if (GDISP_NEED_PIXELREAD && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC)) || defined(__DOXYGEN__)

 	/**

 	 * @brief   Get the color of a pixel.

 	 * @return  The color of the pixel.

@@ -283,9 +531,10 @@
 	color_t gdispGetPixelColor(coord_t x, coord_t y) {

 		color_t		c;

 

-		MUTEX_ENTER

-		c = gdisp_lld_getpixelcolor(x, y);

-		MUTEX_EXIT

+		/* Always synchronous as it must return a value */

+		chMtxLock(&gdispMutex);

+		c = GDISP_LLD(getpixelcolor)(x, y);

+		chMtxUnlock();

 

 		return c;

 	}

@@ -305,47 +554,66 @@
 	 * @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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(verticalscroll)(x, y, cx, cy, lines, bgcolor);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_SCROLL && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_VERTICALSCROLL);

+		p->verticalscroll.x = x;

+		p->verticalscroll.y = y;

+		p->verticalscroll.cx = cx;

+		p->verticalscroll.cy = cy;

+		p->verticalscroll.lines = lines;

+		p->verticalscroll.bgcolor = bgcolor;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

 

-#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+#if (GDISP_NEED_CONTROL && 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.

+	 * @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 some codes. They will be ignored.

 	 *

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

+	 * @param[in] powerMode The power mode 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

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

+		chMtxLock(&gdispMutex);

+		GDISP_LLD(control)(what, value);

+		chMtxUnlock();

+	}

+#elif GDISP_NEED_CONTROL && GDISP_NEED_ASYNC

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

+		gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_CONTROL);

+		p->control.what = what;

+		p->control.value = value;

+		chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);

 	}

 #endif

-	

-#if (GDISP_NEED_CONTROL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+

+#if (GDISP_NEED_QUERY && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC)) || defined(__DOXYGEN__)

 	/**

-	 * @brief   Set the power mode for the display.

+	 * @brief   Query a property of 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).

+	 * @note    The result must be typecast to the correct type.

+	 * @note    An uunsupported query will return (void *)-1.

 	 *

-	 * @param[in] powerMode The power mode to use

+	 * @param[in] what		What to query

 	 *

 	 * @api

 	 */

-	void gdispControl(int what, void *value) {

-		MUTEX_ENTER

-		gdisp_lld_control(what, value);

-		MUTEX_EXIT

+	void *gdispQuery(unsigned what) {

+		void *res;

+

+		chMtxLock(&gdispMutex);

+		res = GDISP_LLD(query)(what);

+		chMtxUnlock();

+		return res;

 	}

 #endif

 

@@ -353,44 +621,42 @@
 /* High Level Driver Routines.                                               */

 /*===========================================================================*/

 

-#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) {

-		/* No mutex required as we only call high level functions which have their own mutex */

-		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);

-					}

+/**

+ * @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) {

+	/* No mutex required as we only call high level functions which have their own mutex */

+	coord_t	x1, y1;

+

+	x1 = x+cx-1;

+	y1 = y+cy-1;

+

+	if (cx > 2) {

+		if (cy >= 1) {

+			gdispDrawLine(x, y, x1, y, color);

+			if (cy >= 2) {

+				gdispDrawLine(x, y1, x1, y1, color);

+				if (cy > 2) {

+					gdispDrawLine(x, y+1, x, y1-1, color);

+					gdispDrawLine(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);

 		}

+	} else if (cx == 2) {

+		gdispDrawLine(x, y, x, y1, color);

+		gdispDrawLine(x1, y, x1, y1, color);

+	} else if (cx == 1) {

+		gdispDrawLine(x, y, x, y1, color);

 	}

-#endif

+}

 

 #if GDISP_NEED_TEXT || defined(__DOXYGEN__)

 	/**

@@ -726,4 +992,6 @@
 #endif

 

 #endif /* HAL_USE_GDISP */

+

+#endif /* _GDISP_C */

 /** @} */

diff --git a/halext/src/gdisp_emulation.c b/halext/src/gdisp_emulation.c
deleted file mode 100644
index 26562e92..00000000
--- a/halext/src/gdisp_emulation.c
+++ /dev/null
@@ -1,463 +0,0 @@
-/*

-    ChibiOS/RT - Copyright (C) 2012

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

-

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

-

-    ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify

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

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

-    (at your option) any later version.

-

-    ChibiOS-LCD-Driver is distributed in the hope that it will be useful,

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

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

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

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

-*/

-

-/*

-	Emulation routines included into gdisp_lld.c

-*/

-

-/*

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

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

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

-	required - it will do it.

-*/

-#include "ch.h"

-#include "hal.h"

-#include "gdisp.h"

-

-#if HAL_USE_GDISP || defined(__DOXYGEN__)

-

-#ifdef UNUSED

-#elif defined(__GNUC__)

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

-#elif defined(__LCLINT__)

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

-#else

-# define UNUSED(x) x

-#endif

-

-#if !GDISP_HARDWARE_POWERCONTROL

-	void gdisp_lld_setpowermode(gdisp_powermode_t UNUSED(powerMode)) {

-	}

-#endif

-

-#if !GDISP_HARDWARE_ORIENTATION

-	void gdisp_lld_setorientation(gdisp_orientation_t UNUSED(newOrientation)) {

-	}

-#endif

-

-#if !GDISP_HARDWARE_CLEARS 

-	void gdisp_lld_clear(color_t color) {

-		gdisp_lld_fillarea(0, 0, GDISP.Width, GDISP.Height, color);

-	}

-#endif

-

-#if !GDISP_HARDWARE_LINES 

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

-		int16_t dy, dx;

-		int16_t addx, addy;

-		int16_t P, diff, i;

-

-		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL

-		// speed improvement if vertical or horizontal

-		if (x0 == x1) {

-			if (y1 > y0)

-				gdisp_lld_fillarea(x0, y0, 1, y1-y0+1, color);

-			else

-				gdisp_lld_fillarea(x0, y1, 1, y0-y1+1, color);

-			return;

-		}

-		if (y0 == y1) {

-			if (x1 > x0)

-				gdisp_lld_fillarea(x0, y0, x1-x0+1, 1, color);

-			else

-				gdisp_lld_fillarea(x0, y1, x0-x1+1, 1, color);

-			return;

-		}

-		#endif

-

-		if (x1 >= x0) {

-			dx = x1 - x0;

-			addx = 1;

-		} else {

-			dx = x0 - x1;

-			addx = -1;

-		}

-		if (y1 >= y0) {

-			dy = y1 - y0;

-			addy = 1;

-		} else {

-			dy = y0 - y1;

-			addy = -1;

-		}

-

-		if (dx >= dy) {

-			dy *= 2;

-			P = dy - dx;

-			diff = P - dx;

-

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

-				gdisp_lld_drawpixel(x0, y0, color);

-				if (P < 0) {

-					P  += dy;

-					x0 += addx;

-				} else {

-					P  += diff;

-					x0 += addx;

-					y0 += addy;

-				}

-			}

-		} else {

-			dx *= 2;

-			P = dx - dy;

-			diff = P - dy;

-

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

-				gdisp_lld_drawpixel(x0, y0, color);

-				if (P < 0) {

-					P  += dx;

-					y0 += addy;

-				} else {

-					P  += diff;

-					x0 += addx;

-					y0 += addy;

-				}

-			}

-		}

-	}

-#endif

-

-#if !GDISP_HARDWARE_FILLS

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

-		#if GDISP_HARDWARE_SCROLL

-			gdisp_lld_verticalscroll(x, y, cx, cy, cy, color);

-		#elif GDISP_HARDWARE_LINES

-			coord_t x1, y1;

-			

-			x1 = x + cx - 1;

-			y1 = y + cy;

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

-				gdisp_lld_drawline(x, y, x1, y, color);

-		#else

-			coord_t x0, x1, y1;

-			

-			x0 = x;

-			x1 = x + cx;

-			y1 = y + cy;

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

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

-					gdisp_lld_drawpixel(x, y, color);

-		#endif

-	}

-#endif

-

-#if !GDISP_HARDWARE_BITFILLS

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

-			coord_t x0, x1, y1;

-			

-			x0 = x;

-			x1 = x + cx;

-			y1 = y + cy;

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

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

-					gdisp_lld_drawpixel(x, y, *buffer++);

-	}

-#endif

-

-#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES

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

-		int16_t a, b, P;

-

-		a = 0;

-		b = radius;

-		P = 1 - radius;

-

-		do {

-			gdisp_lld_drawpixel(a+x, b+y, color);

-			gdisp_lld_drawpixel(b+x, a+y, color);

-			gdisp_lld_drawpixel(x-a, b+y, color);

-			gdisp_lld_drawpixel(x-b, a+y, color);

-			gdisp_lld_drawpixel(b+x, y-a, color);

-			gdisp_lld_drawpixel(a+x, y-b, color);

-			gdisp_lld_drawpixel(x-a, y-b, color);

-			gdisp_lld_drawpixel(x-b, y-a, color);

-			if (P < 0)

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

-			else

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

-		} while(a <= b);

-	}

-#endif

-

-#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS

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

-		int16_t a, b, P;

-		

-		a = 0;

-		b = radius;

-		P = 1 - radius;

-

-		do {

-			gdisp_lld_drawline(x-a, y+b, x+a, y+b, color);

-			gdisp_lld_drawline(x-a, y-b, x+a, y-b, color);

-			gdisp_lld_drawline(x-b, y+a, x+b, y+a, color);

-			gdisp_lld_drawline(x-b, y-a, x+b, y-a, color);

-			if (P < 0)

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

-			else

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

-		} while(a <= b);

-	}

-#endif

-

-#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES

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

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

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

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

-

-		do {

-			gdisp_lld_drawpixel(x+dx, y+dy, color); /* I. Quadrant */

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

-			gdisp_lld_drawpixel(x-dx, y-dy, color); /* III. Quadrant */

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

-

-			e2 = 2*err;

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

-				dx++;

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

-			}

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

-				dy--;

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

-			}

-		} while(dy >= 0); 

-

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

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

-			gdisp_lld_drawpixel(x-dx, y, color);

-	   }   

-	}

-#endif

-

-#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS

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

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

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

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

-

-		do {

-			gdisp_lld_drawline(x-dx,y+dy,x+dx,y+dy, color);

-			gdisp_lld_drawline(x-dx,y-dy,x+dx,y-dy, color);

-

-			e2 = 2*err;

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

-				dx++;

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

-			}

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

-				dy--;

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

-			}

-		} while(dy >= 0); 

-

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

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

-			gdisp_lld_drawpixel(x-dx, y, color);

-	   }   

-	}

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

-	#include "gdisp_fonts.h"

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

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

-		const fontcolumn_t	*ptr;

-		fontcolumn_t		column;

-		coord_t				width, height, xscale, yscale;

-		coord_t				i, j, xs, ys;

-

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

-		width = _getCharWidth(font, c);

-		if (!width) return;

-		

-		xscale = font->xscale;

-		yscale = font->yscale;

-		height = font->height * yscale;

-		width *= xscale;

-

-		ptr = _getCharData(font, c);

-

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

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

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

-			column = *ptr++;

-			

-			/* Draw each pixel */

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

-				if (column & 0x01) {

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

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

-							gdisp_lld_drawpixel(x+i+xs, y+j+ys, color);

-				}

-			}

-		}

-	}

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS

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

-		coord_t			width, height;

-		coord_t			xscale, yscale;

-		

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

-		width = _getCharWidth(font, c);

-		if (!width) return;

-

-		xscale = font->xscale;

-		yscale = font->yscale;

-		height = font->height * yscale;

-		width *= xscale;

-

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

-		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW

-			

-			/* Fill the area */

-			gdisp_lld_fillarea(x, y, width, height, bgcolor);

-			

-			/* Draw the text */

-			gdisp_lld_drawchar(x, y, c, font, color);

-

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

-		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-

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

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

-				Assume the max is double sized by one column.

-			*/

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

-

-			#if GDISP_NEED_VALIDATION

-				/* Check our buffer is big enough */

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

-			#endif

-

-			ptr = _getCharData(font, c);

-

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

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

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

-				column = *ptr++;

-				

-				/* Draw each pixel */

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

-					if (column & 0x01) {

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

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

-					} else {

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

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

-					}

-				}

-

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

-					gdisp_lld_blitarea(x+i+xs, y, 1, height, buf);

-			}

-		}

-

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

-		#elif GDISP_HARDWARE_BITFILLS

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-			

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

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

-				Assume the max is double sized.

-			*/

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

-

-			#if GDISP_NEED_VALIDATION

-				/* Check our buffer is big enough */

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

-			#endif

-

-			ptr = _getCharData(font, c);

-

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

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

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

-				column = *ptr++;

-				

-				/* Draw each pixel */

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

-					if (column & 0x01) {

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

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

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

-					} else {

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

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

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

-					}

-				}

-			}

-

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

-			gdisp_lld_blitarea(x, y, width, height, buf);

-		}

-

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

-		#else

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-

-			ptr = _getCharData(font, c);

-

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

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

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

-				column = *ptr++;

-				

-				/* Draw each pixel */

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

-					if (column & 0x01) {

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

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

-								gdisp_lld_drawpixel(x+i, y+j, color);

-					} else {

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

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

-								gdisp_lld_drawpixel(x+i, y+j, bgcolor);

-					}

-				}

-			}

-		}

-		#endif

-	}

-#endif

-

-

-#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL

-	void gdisp_lld_control(int UNUSED(what), void *UNUSED(value)) {

-		/* Ignore everything */

-	}

-#endif

-

-#endif  /* HAL_USE_GDISP */