Merge branch 'master' into SSD2119

demos/modules/gadc/gfxconf.h

@@ -0,0 +1,105 @@
+/**
+ * This file has a different license to the rest of the GFX system.
+ * You can copy, modify and distribute this file as you see fit.
+ * You do not need to publish your source modifications to this file.
+ * The only thing you are not permitted to do is to relicense it
+ * under a different license.
+ */
+
+/**
+ * Copy this file into your project directory and rename it as gfxconf.h
+ * Edit your copy to turn on the GFX features you want to use.
+ */
+
+#ifndef _GFXCONF_H
+#define _GFXCONF_H
+
+/* GFX sub-systems to turn on */
+#define GFX_USE_GDISP			TRUE
+#define GFX_USE_TDISP			FALSE
+#define GFX_USE_GWIN			TRUE
+#define GFX_USE_GEVENT			FALSE
+#define GFX_USE_GTIMER			TRUE
+#define GFX_USE_GINPUT			FALSE
+#define GFX_USE_GADC			TRUE
+#define GFX_USE_GAUDIN			FALSE
+#define GFX_USE_GAUDOUT			FALSE
+#define GFX_USE_GMISC			FALSE
+
+/* Features for the GDISP sub-system. */
+#define GDISP_NEED_VALIDATION	TRUE
+#define GDISP_NEED_CLIP			TRUE
+#define GDISP_NEED_TEXT			TRUE
+#define GDISP_NEED_CIRCLE		FALSE
+#define GDISP_NEED_ELLIPSE		FALSE
+#define GDISP_NEED_ARC			FALSE
+#define GDISP_NEED_SCROLL		FALSE
+#define GDISP_NEED_PIXELREAD	FALSE
+#define GDISP_NEED_CONTROL		TRUE
+#define GDISP_NEED_MULTITHREAD	TRUE
+#define GDISP_NEED_ASYNC		FALSE
+#define GDISP_NEED_MSGAPI		FALSE
+
+/* GDISP - builtin fonts */
+#define GDISP_OLD_FONT_DEFINITIONS		FALSE
+#define GDISP_INCLUDE_FONT_SMALL		FALSE
+#define GDISP_INCLUDE_FONT_LARGER		FALSE
+#define GDISP_INCLUDE_FONT_UI1			FALSE
+#define GDISP_INCLUDE_FONT_UI2			TRUE
+#define GDISP_INCLUDE_FONT_LARGENUMBERS	FALSE
+
+/* Features for the TDISP subsystem. */
+#define TDISP_NEED_MULTITHREAD	FALSE
+
+/* Features for the GWIN sub-system. */
+#define GWIN_NEED_BUTTON		FALSE
+#define GWIN_NEED_CONSOLE		TRUE
+#define GWIN_NEED_GRAPH			FALSE
+
+/* Features for the GEVENT sub-system. */
+#define GEVENT_ASSERT_NO_RESOURCE	FALSE
+
+/* Features for the GTIMER sub-system. */
+/* NONE */
+
+/* Features for the GINPUT sub-system. */
+#define GINPUT_NEED_MOUSE		FALSE
+#define GINPUT_NEED_KEYBOARD	FALSE
+#define GINPUT_NEED_TOGGLE		FALSE
+#define GINPUT_NEED_DIAL		FALSE
+
+/* Features for the GADC sub-system. */
+/* NONE */
+
+/* Features for the GAUDIN sub-system. */
+/* NONE */
+
+/* Features for the GAUDOUT sub-system. */
+/* NONE */
+
+/* Features for the GMISC sub-system. */
+#define GMISC_NEED_ARRAYOPS		FALSE
+
+/* Optional Parameters for various sub-systems */
+/*
+	#define GDISP_MAX_FONT_HEIGHT			16
+	#define GEVENT_MAXIMUM_SIZE				32
+	#define GEVENT_MAX_SOURCE_LISTENERS		32
+	#define GTIMER_THREAD_WORKAREA_SIZE		512
+	#define GADC_MAX_LOWSPEED_DEVICES		4
+*/
+
+/* Optional Low Level Driver Definitions */
+/*
+	#define GDISP_USE_CUSTOM_BOARD		FALSE
+	#define GDISP_SCREEN_WIDTH			320
+	#define GDISP_SCREEN_HEIGHT			240
+	#define GDISP_USE_FSMC
+	#define GDISP_USE_GPIO
+	#define GDISP_VMT_NAME1(x)			x##YourDriver1
+	#define GDISP_VMT_NAME2(x)			x##YourDriver2
+	#define TDISP_COLUMNS				16
+	#define TDISP_ROWS					2
+*/
+
+#endif /* _GFXCONF_H */

demos/modules/gadc/gwinosc.c

@@ -0,0 +1,183 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX 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/>.
+*/
+
+/**
+ * --------------------------- Our Custom GWIN Oscilloscope ---------------
+ *
+ * This GWIN superset implements a simple audio oscilloscope using the GADC high speed device.
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#include "gwinosc.h"
+
+/* Include internal GWIN routines so we can build our own superset class */
+#include "gwin/internal.h"
+
+/* Our GWIN identifier */
+#define GW_SCOPE				(GW_FIRST_USER_WINDOW+0)
+
+/* The size of our dynamically allocated audio buffer */
+#define AUDIOBUFSZ				64*2
+
+/* How many flat-line sample before we trigger */
+#define FLATLINE_SAMPLES		8
+
+GHandle gwinCreateScope(GScopeObject *gs, coord_t x, coord_t y, coord_t cx, coord_t cy, uint32_t physdev, uint32_t frequency) {
+	/* Initialise the base class GWIN */
+	if (!(gs = (GScopeObject *)_gwinInit((GWindowObject *)gs, x, y, cx, cy, sizeof(GScopeObject))))
+		return 0;
+
+	/* Initialise the scope object members and allocate memory for buffers */
+	gs->gwin.type = GW_SCOPE;
+	chBSemInit(&gs->bsem, TRUE);
+	gs->nextx = 0;
+	if (!(gs->lastscopetrace = (coord_t *)chHeapAlloc(NULL, gs->gwin.width * sizeof(coord_t))))
+		return 0;
+	if (!(gs->audiobuf = (adcsample_t *)chHeapAlloc(NULL, AUDIOBUFSZ * sizeof(adcsample_t))))
+		return 0;
+#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
+	gs->lasty = gs->gwin.height/2;
+#elif TRIGGER_METHOD == TRIGGER_MINVALUE
+	gs->lasty = gs->gwin.height/2;
+	gs->scopemin = 0;
+#endif
+
+	/* Start the GADC high speed converter */
+	gadcHighSpeedInit(physdev, frequency, gs->audiobuf, AUDIOBUFSZ, AUDIOBUFSZ/2);
+	gadcHighSpeedSetBSem(&gs->bsem, &gs->myEvent);
+	gadcHighSpeedStart();
+
+	return (GHandle)gs;
+}
+
+void gwinWaitForScopeTrace(GHandle gh) {
+	#define 		gs	((GScopeObject *)(gh))
+	int				i;
+	coord_t			x, y;
+	coord_t			yoffset;
+	adcsample_t		*pa;
+	coord_t			*pc;
+#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
+	bool_t			rdytrigger;
+	int				flsamples;
+#elif TRIGGER_METHOD == TRIGGER_MINVALUE
+	bool_t			rdytrigger;
+	int				flsamples;
+	coord_t			scopemin;
+#endif
+
+	/* Wait for a set of audio conversions */
+	chBSemWait(&gs->bsem);
+
+	/* Ensure we are drawing in the right area */
+	#if GDISP_NEED_CLIP
+		gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+	#endif
+
+	yoffset = gh->height/2 + (1<<SCOPE_Y_BITS)/2;
+	x = gs->nextx;
+	pc = gs->lastscopetrace+x;
+	pa = gs->myEvent.buffer;
+#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
+	rdytrigger = FALSE;
+	flsamples = 0;
+#elif TRIGGER_METHOD == TRIGGER_MINVALUE
+	rdytrigger = FALSE;
+	flsamples = 0;
+	scopemin = 0;
+#endif
+
+	for(i = gs->myEvent.count; i; i--) {
+
+		/* Calculate the new scope value - re-scale using simple shifts for efficiency, re-center and y-invert */
+		#if GADC_BITS_PER_SAMPLE > SCOPE_Y_BITS
+			y = yoffset - (*pa++ >> (GADC_BITS_PER_SAMPLE - SCOPE_Y_BITS));
+		#else
+			y = yoffset - (*pa++ << (SCOPE_Y_BITS - GADC_BITS_PER_SAMPLE));
+		#endif
+
+#if TRIGGER_METHOD == TRIGGER_MINVALUE
+		/* Calculate the scopemin ready for the next trace */
+		if (y > scopemin)
+			scopemin = y;
+#endif
+
+		/* Have we reached the end of a scope trace? */
+		if (x >= gh->width) {
+
+#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP || TRIGGER_METHOD == TRIGGER_MINVALUE
+			/* Handle triggering - we trigger on the next sample minimum (y value maximum) or a flat-line */
+
+			#if TRIGGER_METHOD == TRIGGER_MINVALUE
+				/* Arm when we reach the sample minimum (y value maximum) of the previous trace */
+				if (!rdytrigger && y >= gs->scopemin)
+					rdytrigger = TRUE;
+			#endif
+
+			if (y == gs->lasty) {
+				/* Trigger if we get too many flat-line samples regardless of the armed state */
+				if (++flsamples < FLATLINE_SAMPLES)
+					continue;
+				flsamples = 0;
+			} else if (y > gs->lasty) {
+				gs->lasty = y;
+				flsamples = 0;
+				#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
+					/* Arm the trigger when samples fall (y increases) ie. negative slope */
+					rdytrigger = TRUE;
+				#endif
+				continue;
+			} else {
+				/* If the trigger is armed, Trigger when samples increases (y decreases) ie. positive slope */
+				gs->lasty = y;
+				flsamples = 0;
+				if (!rdytrigger)
+					continue;
+			}
+
+			/* Ready for a the next trigger cycle */
+			rdytrigger = FALSE;
+#endif
+
+			/* Prepare for a scope trace */
+			x = 0;
+			pc = gs->lastscopetrace;
+		}
+
+		/* Clear the old scope pixel and then draw the new scope value */
+		gdispDrawPixel(gh->x+x, gh->y+pc[0], gh->bgcolor);
+		gdispDrawPixel(gh->x+x, gh->y+y, gh->color);
+
+		/* Save the value */
+		*pc++ = y;
+		x++;
+		#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP || TRIGGER_METHOD == TRIGGER_MINVALUE
+			gs->lasty = y;
+		#endif
+	}
+	gs->nextx = x;
+#if TRIGGER_METHOD == TRIGGER_MINVALUE
+	gs->scopemin = scopemin;
+#endif
+
+	#undef gs
+}

demos/modules/gadc/gwinosc.h

@@ -0,0 +1,89 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX 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/>.
+*/
+
+#ifndef _GWINOSC_H
+#define _GWINOSC_H
+
+/**
+ * --------------------------- Our Custom GWIN Oscilloscope ---------------
+ *
+ * This GWIN superset implements a simple audio oscilloscope using the GADC high speed device.
+ */
+
+/* The extent of scaling for our audio data - fixed scale at the moment */
+#ifndef SCOPE_Y_BITS
+	#define SCOPE_Y_BITS			7					// 7 bits = 0..128
+#endif
+
+/* Trigger methods */
+#define TRIGGER_NONE			0					/* No triggering */
+#define TRIGGER_POSITIVERAMP	1					/* Trigger on a positive going signal */
+#define TRIGGER_MINVALUE		2					/* Trigger on reaching the minimum value from the last scope */
+
+/**
+ * Which trigger we want to use.
+ * Experiments suggests that TRIGGER_MINVALUE gives the best result
+ */
+#ifndef TRIGGER_METHOD
+	#define TRIGGER_METHOD			TRIGGER_MINVALUE
+#endif
+
+/* A scope window object. Treat it as a black box */
+typedef struct GScopeObject_t {
+	GWindowObject		gwin;					// Base Class
+
+	coord_t				*lastscopetrace;		// To store last scope trace
+	BinarySemaphore		bsem;					// We get signalled on this
+	adcsample_t			*audiobuf;				// To store audio samples
+	GEventADC			myEvent;				// Information on received samples
+	coord_t				nextx;					// Where we are up to
+#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
+	coord_t				lasty;					// The last y value - used for trigger slope detection
+#elif TRIGGER_METHOD == TRIGGER_MINVALUE
+	coord_t				lasty;					// The last y value - used for trigger slope detection
+	coord_t				scopemin;				// The last scopes minimum value
+#endif
+	} GScopeObject;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	/**
+	 * Create a scope window.
+	 */
+	GHandle gwinCreateScope(GScopeObject *gs, coord_t x, coord_t y, coord_t cx, coord_t cy, uint32_t physdev, uint32_t frequency);
+
+	/**
+	 * Wait for a scope trace to be ready and then draw it.
+	 */
+	void gwinWaitForScopeTrace(GHandle gh);
+
+	/**
+	 * We should also have a special destroy routine here as we have dynamically
+	 * allocated some memory. There is no point implementing this however as, for
+	 * this demo, we never destroy the window.
+	 */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _GWINOSC_H */

demos/modules/gadc/main.c

@@ -0,0 +1,176 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * This demo demonstrates the use of the GADC module using it read both a microphone,
+ * an analogue dial wheel and a temperature sensor.
+ * The microphone gets read at high frequency to display a very simple oscilloscope.
+ * The dial and temperature gets read at a low frequency to just print when
+ * it changes value.
+ *
+ * It also demonstrates how to write your own custom GWIN window type.
+ */
+#include "ch.h"
+#include "hal.h"
+#include "chprintf.h"
+
+#include "gfx.h"
+
+/* Include our custom gwin oscilloscope */
+#include "gwinosc.h"
+
+/*
+ * Match these to your hardware
+ * If you don't have a DIAL device or a TEMP device - just don't define it.
+ */
+#define MY_MIC_DEVICE		GADC_PHYSDEV_MICROPHONE
+#define MY_DIAL_DEVICE		GADC_PHYSDEV_DIAL
+#define MY_TEMP_DEVICE		GADC_PHYSDEV_TEMPERATURE
+#define MY_DIAL_JITTER		1
+#define MY_TEMP_JITTER		3
+
+/* Specify our timing parameters */
+#define	MY_MIC_FREQUENCY	4000			/* 4khz */
+#define MY_LS_DELAY			200				/* 200ms (5 times per second) for the dial and temperature */
+
+/* The desired size for our scope window */
+#define SCOPE_CX			64
+#define SCOPE_CY			64
+
+/* Data */
+static GScopeObject			gScopeWindow;
+static GConsoleObject		gTextWindow;
+static GTimer				lsTimer;
+
+#ifdef MY_DIAL_DEVICE
+	static adcsample_t			dialvalue;
+	static adcsample_t			lastdial = -(MY_DIAL_JITTER+1);
+
+	/**
+	 * We have got a dial reading - handle it
+	 */
+	static void GotDialReading(adcsample_t *buffer, void *param) {
+		(void) buffer;
+
+		/* Buffer should always point to "dialvalue" anyway */
+
+		/* Remove jitter from the value */
+		if ((dialvalue > lastdial && dialvalue - lastdial > MY_DIAL_JITTER)
+				|| (lastdial > dialvalue && lastdial - dialvalue > MY_DIAL_JITTER)) {
+
+			/* Write the value */
+			chprintf((BaseSequentialStream *)param, "DIAL: %u\n", dialvalue);
+
+			/* Save for next time */
+			lastdial = dialvalue;
+		}
+	}
+#endif
+
+#ifdef MY_TEMP_DEVICE
+	static adcsample_t			tempvalue;
+	static adcsample_t			lasttemp = -(MY_TEMP_JITTER+1);
+
+	/**
+	 * We have got a temperature reading - handle it
+	 */
+	static void GotTempReading(adcsample_t *buffer, void *param) {
+		(void) buffer;
+
+		/* Buffer should always point to "tempvalue" anyway */
+
+		/* Remove jitter from the value */
+		if ((tempvalue > lasttemp && tempvalue - lasttemp > MY_TEMP_JITTER)
+				|| (lasttemp > tempvalue && lasttemp - tempvalue > MY_TEMP_JITTER)) {
+
+			/* Write the value */
+			chprintf((BaseSequentialStream *)param, "TEMP: %u\n", tempvalue);
+
+			/* Save for next time */
+			lasttemp = tempvalue;
+		}
+	}
+#endif
+
+#if defined(MY_DIAL_DEVICE) || defined(MY_TEMP_DEVICE)
+	/**
+	 * Start a read of the dial and temperature
+	 */
+	static void LowSpeedTimer(void *param) {
+		/* We are not checking for an error here - but who cares, this is just a demo */
+		#ifdef MY_DIAL_DEVICE
+			gadcLowSpeedStart(MY_DIAL_DEVICE, &dialvalue, GotDialReading, param);
+		#endif
+		#ifdef MY_TEMP_DEVICE
+			gadcLowSpeedStart(MY_TEMP_DEVICE, &tempvalue, GotTempReading, param);
+		#endif
+	}
+#endif
+
+/*
+ * Application entry point.
+ */
+int main(void) {
+	GHandle					ghScope;
+	coord_t					swidth, sheight;
+	#if defined(MY_DIAL_DEVICE) || defined(MY_TEMP_DEVICE)
+		GHandle					ghText;
+		BaseSequentialStream	*gsText;
+		font_t					font;
+	#endif
+
+	halInit();
+	chSysInit();
+	gdispInit();
+	gdispClear(Black);
+
+	/* Get the screen dimensions */
+	swidth = gdispGetWidth();
+	sheight = gdispGetHeight();
+
+	#if defined(MY_DIAL_DEVICE) || defined(MY_TEMP_DEVICE)
+		/* Set up the console window we use for dial readings */
+		font = gdispOpenFont("UI2");
+		ghText = gwinCreateConsole(&gTextWindow, 0, 0, swidth-SCOPE_CX, sheight, font);
+		gwinSetBgColor(ghText, Black);
+		gwinSetColor(ghText, Yellow);
+		gwinClear(ghText);
+		gsText = gwinGetConsoleStream(ghText);
+
+		/* Start our timer for reading the dial */
+		gtimerInit(&lsTimer);
+		gtimerStart(&lsTimer, LowSpeedTimer, gsText, TRUE, MY_LS_DELAY);
+	#endif
+
+	/* Set up the scope window in the top right on the screen */
+	ghScope = gwinCreateScope(&gScopeWindow, swidth-SCOPE_CX, 0, SCOPE_CX, SCOPE_CY, MY_MIC_DEVICE, MY_MIC_FREQUENCY);
+	gwinSetBgColor(ghScope, White);
+	gwinSetColor(ghScope, Red);
+	gwinClear(ghScope);
+
+	/* Just keep displaying the scope traces */
+	while (TRUE) {
+		/**
+		 * The function below internally performs a wait thus giving the timer thread a
+		 * chance to run.
+		 */
+		gwinWaitForScopeTrace(ghScope);
+	}
+}

drivers/gadc/AT91SAM7/gadc_lld.c

@@ -0,0 +1,102 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file    include/gadc/lld/gadc_lld.c
+ * @brief   GADC - Periodic ADC driver source file for the AT91SAM7 cpu.
+ *
+ * @defgroup Driver Driver
+ * @ingroup GADC
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GADC
+
+#include "gadc/lld/gadc_lld.h"
+
+static ADCConversionGroup acg = {
+		FALSE,					// circular
+		1,						// num_channels
+		GADC_ISR_CompleteI,		// end_cb
+		GADC_ISR_ErrorI,		// error_cb
+		0,						// channelselects
+		0,						// trigger
+		0,						// frequency
+		};
+
+void gadc_lld_init(void) {
+	adcStart(&ADCD1, NULL);
+}
+
+size_t gadc_lld_samples_per_conversion(uint32_t physdev) {
+	size_t	cnt;
+	int		i;
+
+	/* The AT91SAM7 has AD0..7 - physdev is a bitmap of those channels */
+	for(cnt = 0, i = 0; i < 8; i++, physdev >>= 1)
+		if (physdev & 0x01)
+			cnt++;
+	return cnt;
+}
+
+void gadc_lld_start_timer(uint32_t physdev, uint32_t frequency) {
+	(void) physdev;
+	/**
+	 * The AT91SAM7 ADC driver supports triggering the ADC using a timer without having to implement
+	 * an interrupt handler for the timer. The driver also initialises the timer correctly for us.
+	 * Because we aren't trapping the interrupt ourselves we can't increment GADC_Timer_Missed if an
+	 * interrupt is missed.
+	 */
+	acg.frequency = frequency;
+}
+
+void gadc_lld_stop_timer(uint32_t physdev) {
+	(void) physdev;
+	if ((acg.trigger & ~ADC_TRIGGER_SOFTWARE) == ADC_TRIGGER_TIMER)
+		adcStop(&ADCD1);
+}
+
+void gadc_lld_adc_timerI(GadcLldTimerData *pgtd) {
+	/**
+	 *  We don't need to calculate num_channels because the AT91SAM7 ADC does this for us.
+	 */
+	acg.channelselects = pgtd->physdev;
+	acg.trigger = pgtd->now ? (ADC_TRIGGER_TIMER|ADC_TRIGGER_SOFTWARE) : ADC_TRIGGER_TIMER;
+
+	adcStartConversionI(&ADCD1, &acg, pgtd->buffer, pgtd->count);
+
+	/* Next time assume the same (still running) timer */
+	acg.frequency = 0;
+}
+
+void gadc_lld_adc_nontimerI(GadcLldNonTimerData *pgntd) {
+	/**
+	 *  We don't need to calculate num_channels because the AT91SAM7 ADC does this for us.
+	 */
+	acg.channelselects = pgntd->physdev;
+	acg.trigger = ADC_TRIGGER_SOFTWARE;
+	adcStartConversionI(&ADCD1, &acg, pgntd->buffer, 1);
+}
+
+#endif /* GFX_USE_GADC */
+/** @} */

drivers/gadc/AT91SAM7/gadc_lld.mk

@@ -0,0 +1,5 @@
+# List the required driver.
+GFXSRC += $(GFXLIB)/drivers/gadc/AT91SAM7/gadc_lld.c
+
+# Required include directories
+GFXINC += $(GFXLIB)/drivers/gadc/AT91SAM7

drivers/gadc/AT91SAM7/gadc_lld_board_olimexsam7ex256.h

@@ -1,5 +1,5 @@
 /*
-    ChibiOS/GFX - Copyright (C) 2012
+    ChibiOS/GFX - Copyright (C) 2012, 2013
                  Joel Bodenmann aka Tectu <joel@unormal.org>
 
     This file is part of ChibiOS/GFX.
@@ -19,27 +19,28 @@
 */
 
 /**
- * @file    drivers/tdisp/HD44780/tdisp_lld_config.h
- * @brief   TDISP Driver subsystem low level driver header for the HD44780 display.
+ * @file    drivers/gadc/AT91SAM7/gadc_lld_board_olimexsam7ex256.h
+ * @brief   GADC Driver config file.
  *
- * @addtogroup TDISP
+ * @addtogroup GADC
  * @{
  */
 
-#ifndef _TDISP_LLD_CONFIG_H
-#define _TDISP_LLD_CONFIG_H
+#ifndef _GADC_LLD_BOARD_OLIMEXSAM7EX256_H
+#define _GADC_LLD_BOARD_OLIMEXSAM7EX256_H
 
-#if GFX_USE_TDISP
+#if GFX_USE_GADC
 
 /*===========================================================================*/
-/* Driver hardware support.                                                  */
+/* Analogue devices on this board                                            */
 /*===========================================================================*/
 
-#define TDISP_DRIVER_NAME				"HD44780"
+#define GADC_PHYSDEV_MICROPHONE			0x00000080
+#define GADC_PHYSDEV_DIAL				0x00000040
+#define GADC_PHYSDEV_TEMPERATURE		0x00000020
 
-#define TDISP_MAX_CUSTOM_CHARS			0x07
+#endif	/* GFX_USE_GADC */
 
-#endif	/* GFX_USE_TDISP */
-
-#endif	/* _TDISP_LLD_CONFIG_H */
+#endif	/* _GADC_LLD_BOARD_OLIMEXSAM7EX256_H */
 /** @} */
+

drivers/gadc/AT91SAM7/gadc_lld_config.h

@@ -0,0 +1,78 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    drivers/gadc/AT91SAM7/gadc_lld_config.h
+ * @brief   GADC Driver config file.
+ *
+ * @addtogroup GADC
+ * @{
+ */
+
+#ifndef GADC_LLD_CONFIG_H
+#define GADC_LLD_CONFIG_H
+
+#if GFX_USE_GADC
+
+/*===========================================================================*/
+/* Driver hardware support.                                                  */
+/*===========================================================================*/
+
+/**
+ * @brief	ChibiOS has a nasty bug in its _adc_isr_full_code() routine (defined in adc.h as a macro).
+ * 			Do we have the version of ChibiOS with this bug.
+ * @detail	Set to TRUE if ChibiOS has this bug.
+ * @note	Fixed in ChibiOS 2.4.4stable and 2.5.2unstable (and the repository from 18th Feb 2013)
+ * @note	This bug prevents us re-calling adcStartConversionI() from with the ISR even though
+ * 			it is clearly designed to handle it. For some reason (on this micro) the high speed timer
+ * 			is not affected only the single sample low speed timer. In that situation we wait until
+ * 			we get back to thread land. This is terrible for the accuracy of the high speed timer
+ * 			but what can we do (other than fix the bug).
+ * @note	For the AT91SAM7 ADC driver, it post-dates the finding of the bug so we safely
+ * 			say that the bug doesn't exist for this driver.
+ */
+#define ADC_ISR_FULL_CODE_BUG				FALSE
+
+/**
+ * @brief	The maximum sample frequency supported by this CPU
+ */
+#define GADC_MAX_SAMPLE_FREQUENCY			132000
+
+/**
+ * @brief	The number of bits in a sample
+ */
+#define GADC_BITS_PER_SAMPLE				AT91_ADC1_RESOLUTION
+
+/* Pull in board specific defines */
+#if defined(GADC_USE_CUSTOM_BOARD) && GADC_USE_CUSTOM_BOARD
+	/* Include the user supplied board definitions */
+	#include "gadc_lld_board.h"
+#elif defined(BOARD_OLIMEX_SAM7_EX256)
+	#include "gadc_lld_board_olimexsam7ex256.h"
+#else
+	/* Include the user supplied board definitions */
+	#include "gadc_lld_board.h"
+#endif
+
+#endif	/* GFX_USE_GADC */
+
+#endif	/* _GDISP_LLD_CONFIG_H */
+/** @} */
+

drivers/gdisp/ILI9320/gdisp_lld.c

@@ -81,28 +81,28 @@ static __inline void lld_lcdDelay(uint16_t us) {
 }
 
 static __inline void lld_lcdWriteIndex(uint16_t index) {
-	lld_gdisp_write_index(index);
+	gdisp_lld_write_index(index);
 }
 
 static __inline void lld_lcdWriteData(uint16_t data) {
-	lld_gdisp_write_data(data);
+	gdisp_lld_write_data(data);
 }
 
 static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
-	lld_gdisp_write_index(lcdReg);
-	lld_gdisp_write_data(lcdRegValue);
+	gdisp_lld_write_index(lcdReg);
+	gdisp_lld_write_data(lcdRegValue);
 }
 
 static __inline uint16_t lld_lcdReadData(void) {
 	/* fix this! */
-	//return lld_gdisp_read_data;
+	//return gdisp_lld_read_data;
 	return GDISP_RAM;
 }
 
 static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
     volatile uint16_t dummy;
 
-    lld_gdisp_write_index(lcdReg);
+    gdisp_lld_write_index(lcdReg);
     dummy = lld_lcdReadData();
     (void)dummy;
 
@@ -143,14 +143,14 @@ static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
 		buffer[i] = lld_lcdReadData();
 }
 
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise your display */
-	lld_gdisp_init_board();
+	gdisp_lld_init_board();
 
 	/* Hardware reset */
-	lld_gdisp_reset_pin(TRUE);
+	gdisp_lld_reset_pin(TRUE);
 	lld_lcdDelay(1000);
-	lld_gdisp_reset_pin(FALSE);
+	gdisp_lld_reset_pin(FALSE);
 	lld_lcdDelay(1000);
 
     DISPLAY_CODE = lld_lcdReadReg(0);
@@ -215,7 +215,7 @@ bool_t lld_gdisp_init(void) {
     lld_lcdWriteReg(0x0007, 0x0173); //display On
 
 	// Turn on the backlight
-	lld_gdisp_backlight(GDISP_INITIAL_BACKLIGHT);
+	gdisp_lld_backlight(GDISP_INITIAL_BACKLIGHT);
 	
     /* Initialise the GDISP structure */
     GDISP.Width = GDISP_SCREEN_WIDTH;
@@ -298,7 +298,7 @@ static __inline void lld_lcdResetViewPort(void) {
     }
 }
 
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
     #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
         if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
     #endif
@@ -307,7 +307,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 }
 
 #if GDISP_HARDWARE_CLEARS || defined(__DOXYGEN__)
-	void lld_gdisp_clear(color_t color) {
+	void gdisp_lld_clear(color_t color) {
 	    unsigned i;
 
 	    lld_lcdSetCursor(0, 0);
@@ -321,7 +321,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 			if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
 			if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@@ -343,7 +343,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		coord_t endx, endy;
 		unsigned lg;
 
@@ -372,7 +372,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		color_t color;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -392,7 +392,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		static color_t buf[((GDISP_SCREEN_HEIGHT > GDISP_SCREEN_WIDTH ) ? GDISP_SCREEN_HEIGHT : GDISP_SCREEN_WIDTH)];
 		coord_t row0, row1;
 		unsigned i, gap, abslines;
@@ -445,7 +445,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if (GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL) || defined(__DOXYGEN__)
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		switch(what) {
 			case GDISP_CONTROL_POWER:
 				if(GDISP.Powermode == (gdisp_powermode_t)value)
@@ -457,7 +457,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 						lld_lcdWriteReg(0x0011, 0x0000);
 						lld_lcdWriteReg(0x0012, 0x0000);
 						lld_lcdWriteReg(0x0013, 0x0000);
-						lld_gdisp_backlight(0);
+						gdisp_lld_backlight(0);
 						break;
 			
 					case powerOn:
@@ -476,9 +476,9 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 						lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */
 						lld_lcdDelay(500);
 						lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */	
-						lld_gdisp_backlight(GDISP.Backlight);
+						gdisp_lld_backlight(GDISP.Backlight);
 						if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep)
-							lld_gdisp_init();
+							gdisp_lld_init();
 						break;
 	
 					case powerSleep:
@@ -489,7 +489,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	                  	lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
 	                  	lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
 	                   	lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */				
-						lld_gdisp_backlight(0);
+						gdisp_lld_backlight(0);
 						break;
 
 					case powerDeepSleep:
@@ -500,7 +500,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	   					lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
 	   					lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
 	  					lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
-						lld_gdisp_backlight(0);
+						gdisp_lld_backlight(0);
 						break;
 
 					default:
@@ -554,7 +554,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 
 			case GDISP_CONTROL_BACKLIGHT:
 				if((unsigned)value > 100) value = (void *)100;
-				lld_gdisp_backlight((unsigned)value);
+				gdisp_lld_backlight((unsigned)value);
 				GDISP.Backlight = (unsigned)value;
 				break;
 			

drivers/gdisp/ILI9320/gdisp_lld_board_example.h

@@ -29,28 +29,28 @@
 #ifndef GDISP_LLD_BOARD_H
 #define GDISP_LLD_BOARD_H
 
-static __inline void lld_gdisp_init_board(void) {
+static __inline void gdisp_lld_init_board(void) {
 	#error "ILI9320: You must implement the init_board routine for your board"
 }
 
-static __inline void lld_gdisp_reset_pin(bool_t state) {
+static __inline void gdisp_lld_reset_pin(bool_t state) {
 	#error "ILI9320: You must implement setpin_reset routine for your board"
 }
 
-static __inline void lld_gdisp_write_index(uint16_t data) {
+static __inline void gdisp_lld_write_index(uint16_t data) {
 	#error "ILI9320: You must implement write_index routine for your board"
 }
 
-static __inline void lld_gdisp_write_data(uint16_t data) {
+static __inline void gdisp_lld_write_data(uint16_t data) {
 	#error "ILI9320: You must implement write_data routine for your board"
 }
 
-static __inline uint16_t lld_gdisp_read_data(void) {
+static __inline uint16_t gdisp_lld_read_data(void) {
 	#error "ILI9320: You must implement read_data routine for your board"
 }
 
 /* if not available, just ignore the argument and return */
-static __inline uint16_t lld_gdisp_backlight(uint8_t percentage) {
+static __inline uint16_t gdisp_lld_backlight(uint8_t percentage) {
 	#error "ILI9320: You must implement set_backlight routine for your board"
 }
 

drivers/gdisp/ILI9320/gdisp_lld_board_olimex_stm32_lcd.h

@@ -32,7 +32,7 @@
 #define GDISP_REG              (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
 #define GDISP_RAM              (*((volatile uint16_t *) 0x60100000)) /* RS = 1 */
 
-static __inline void lld_gdisp_init_board(void) {
+static __inline void gdisp_lld_init_board(void) {
 	/* FSMC setup for F1 */
 	rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
 
@@ -54,26 +54,26 @@ static __inline void lld_gdisp_init_board(void) {
     FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN;
 }
 
-static __inline void lld_gdisp_reset_pin(bool_t state) {
+static __inline void gdisp_lld_reset_pin(bool_t state) {
 	if(state)
 		palClearPad(GPIOE, GPIOE_TFT_RST);
 	else
 		palSetPad(GPIOE, GPIOE_TFT_RST);
 }
 
-static __inline void lld_gdisp_write_index(uint16_t reg) {
+static __inline void gdisp_lld_write_index(uint16_t reg) {
 	GDISP_REG = reg;
 }
 
-static __inline void lld_gdisp_write_data(uint16_t data) {
+static __inline void gdisp_lld_write_data(uint16_t data) {
 	GDISP_RAM = data;
 }
 
-static __inline uint16_t lld_gdisp_read_data(void) {
+static __inline uint16_t gdisp_lld_read_data(void) {
 	return GDISP_RAM;
 }
 
-static __inline void lld_gdisp_backlight(uint8_t percent) {
+static __inline void gdisp_lld_backlight(uint8_t percent) {
 	if(percent == 100)
 		palClearPad(GPIOD, GPIOD_TFT_LIGHT);
 	else

drivers/gdisp/ILI9325/gdisp_lld.c

@@ -81,28 +81,28 @@ static __inline void lld_lcdDelay(uint16_t us) {
 }
 
 static __inline void lld_lcdWriteIndex(uint16_t index) {
-	lld_gdisp_write_index(index);
+	gdisp_lld_write_index(index);
 }
 
 static __inline void lld_lcdWriteData(uint16_t data) {
-	lld_gdisp_write_data(data);
+	gdisp_lld_write_data(data);
 }
 
 static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
-	lld_gdisp_write_index(lcdReg);
-	lld_gdisp_write_data(lcdRegValue);
+	gdisp_lld_write_index(lcdReg);
+	gdisp_lld_write_data(lcdRegValue);
 }
 
 static __inline uint16_t lld_lcdReadData(void) {
 	/* fix this! */
-	//return lld_gdisp_read_data;
+	//return gdisp_lld_read_data;
 	return GDISP_RAM;
 }
 
 static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
     volatile uint16_t dummy;
 
-    lld_gdisp_write_index(lcdReg);
+    gdisp_lld_write_index(lcdReg);
     dummy = lld_lcdReadData();
     (void)dummy;
 
@@ -143,14 +143,14 @@ static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
 		buffer[i] = lld_lcdReadData();
 }
 
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise your display */
-	lld_gdisp_init_board();
+	gdisp_lld_init_board();
 
 	/* Hardware reset */
-	lld_gdisp_reset_pin(TRUE);
+	gdisp_lld_reset_pin(TRUE);
 	lld_lcdDelay(1000);
-	lld_gdisp_reset_pin(FALSE);
+	gdisp_lld_reset_pin(FALSE);
 	lld_lcdDelay(1000);
 
 	// chinese code starts here
@@ -210,7 +210,7 @@ bool_t lld_gdisp_init(void) {
 	// chinese code ends here
 
 	// Turn on the backlight
-	lld_gdisp_backlight(GDISP_INITIAL_BACKLIGHT);
+	gdisp_lld_backlight(GDISP_INITIAL_BACKLIGHT);
 	
     /* Initialise the GDISP structure */
     GDISP.Width = GDISP_SCREEN_WIDTH;
@@ -302,7 +302,7 @@ static __inline void lld_lcdResetViewPort(void) {
     }
 }
 
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
     #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
         if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
     #endif
@@ -311,7 +311,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 }
 
 #if GDISP_HARDWARE_CLEARS || defined(__DOXYGEN__)
-	void lld_gdisp_clear(color_t color) {
+	void gdisp_lld_clear(color_t color) {
 	    unsigned i;
 
 	    lld_lcdSetCursor(0, 0);
@@ -325,7 +325,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 			if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
 			if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@@ -347,7 +347,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		coord_t endx, endy;
 		unsigned lg;
 
@@ -376,7 +376,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		color_t color;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -396,7 +396,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		static color_t buf[((GDISP_SCREEN_HEIGHT > GDISP_SCREEN_WIDTH ) ? GDISP_SCREEN_HEIGHT : GDISP_SCREEN_WIDTH)];
 		coord_t row0, row1;
 		unsigned i, gap, abslines;
@@ -449,7 +449,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 #endif
 
 #if (GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL) || defined(__DOXYGEN__)
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		switch(what) {
 			case GDISP_CONTROL_POWER:
 				if(GDISP.Powermode == (gdisp_powermode_t)value)
@@ -461,7 +461,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 						lld_lcdWriteReg(0x0011, 0x0000);
 						lld_lcdWriteReg(0x0012, 0x0000);
 						lld_lcdWriteReg(0x0013, 0x0000);
-						lld_gdisp_backlight(0);
+						gdisp_lld_backlight(0);
 						break;
 			
 					case powerOn:
@@ -480,9 +480,9 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 						lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */
 						lld_lcdDelay(500);
 						lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */	
-						lld_gdisp_backlight(GDISP.Backlight);
+						gdisp_lld_backlight(GDISP.Backlight);
 						if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep)
-							lld_gdisp_init();
+							gdisp_lld_init();
 						break;
 	
 					case powerSleep:
@@ -493,7 +493,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	                  	lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
 	                  	lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
 	                   	lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */				
-						lld_gdisp_backlight(0);
+						gdisp_lld_backlight(0);
 						break;
 
 					case powerDeepSleep:
@@ -504,7 +504,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	   					lld_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
 	   					lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
 	  					lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
-						lld_gdisp_backlight(0);
+						gdisp_lld_backlight(0);
 						break;
 
 					default:
@@ -564,7 +564,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 
 			case GDISP_CONTROL_BACKLIGHT:
 				if((unsigned)value > 100) value = (void *)100;
-				lld_gdisp_backlight((unsigned)value);
+				gdisp_lld_backlight((unsigned)value);
 				GDISP.Backlight = (unsigned)value;
 				break;
 			

drivers/gdisp/ILI9325/gdisp_lld_board_example.h

@@ -29,28 +29,28 @@
 #ifndef GDISP_LLD_BOARD_H
 #define GDISP_LLD_BOARD_H
 
-static __inline void lld_gdisp_init_board(void) {
+static __inline void gdisp_lld_init_board(void) {
 	#error "ILI9325: You must implement the init_board routine for your board"
 }
 
-static __inline void lld_gdisp_reset_pin(bool_t state) {
+static __inline void gdisp_lld_reset_pin(bool_t state) {
 	#error "ILI9325: You must implement setpin_reset routine for your board"
 }
 
-static __inline void lld_gdisp_write_index(uint16_t data) {
+static __inline void gdisp_lld_write_index(uint16_t data) {
 	#error "ILI9325: You must implement write_index routine for your board"
 }
 
-static __inline void lld_gdisp_write_data(uint16_t data) {
+static __inline void gdisp_lld_write_data(uint16_t data) {
 	#error "ILI9325: You must implement write_data routine for your board"
 }
 
-static __inline uint16_t lld_gdisp_read_data(void) {
+static __inline uint16_t gdisp_lld_read_data(void) {
 	#error "ILI9325: You must implement read_data routine for your board"
 }
 
 /* if not available, just ignore the argument and return */
-static __inline uint16_t lld_gdisp_backlight(uint8_t percentage) {
+static __inline uint16_t gdisp_lld_backlight(uint8_t percentage) {
 	#error "ILI9325: You must implement set_backlight routine for your board"
 }
 

drivers/gdisp/ILI9325/gdisp_lld_board_hy_stm32_100p.h

@@ -45,7 +45,7 @@
 #define GDISP_REG              (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
 #define GDISP_RAM              (*((volatile uint16_t *) 0x60020000)) /* RS = 1 */
 
-static __inline void lld_gdisp_init_board(void) {
+static __inline void gdisp_lld_init_board(void) {
 	/* FSMC setup for F1 */
 	rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
 
@@ -68,26 +68,26 @@ static __inline void lld_gdisp_init_board(void) {
 	
 }
 
-static __inline void lld_gdisp_reset_pin(bool_t state) {
+static __inline void gdisp_lld_reset_pin(bool_t state) {
 	if(state)
 		palClearPad(GPIOE, GPIOE_TFT_RST);
 	else
 		palSetPad(GPIOE, GPIOE_TFT_RST);
 }
 
-static __inline void lld_gdisp_write_index(uint16_t reg) {
+static __inline void gdisp_lld_write_index(uint16_t reg) {
 	GDISP_REG = reg;
 }
 
-static __inline void lld_gdisp_write_data(uint16_t data) {
+static __inline void gdisp_lld_write_data(uint16_t data) {
 	GDISP_RAM = data;
 }
 
-static __inline uint16_t lld_gdisp_read_data(void) {
+static __inline uint16_t gdisp_lld_read_data(void) {
 	return GDISP_RAM;
 }
 
-static __inline void lld_gdisp_backlight(uint8_t percent) {
+static __inline void gdisp_lld_backlight(uint8_t percent) {
 	percent=percent;	// avoid a warning
 }
 

drivers/gdisp/Nokia6610GE12/gdisp_lld.c

@@ -113,7 +113,7 @@ static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
  *
  * @notapi
  */
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise your display */
 	init_board();
 
@@ -219,7 +219,7 @@ bool_t lld_gdisp_init(void) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 		if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
 	#endif
@@ -241,7 +241,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		unsigned i, tuples;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -276,7 +276,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		coord_t endx, endy, lg;
 		color_t	c1, c2;
 		#if GDISP_PACKED_PIXELS
@@ -386,7 +386,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		/* NOT IMPLEMENTED */
 		/* Some board hardware might support this in the future.
 		 * The Olimex board doesn't.
@@ -407,7 +407,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		/* NOT IMPLEMENTED */
 		/* The hardware seems capable of doing this.
 		 * It is just really complex so we leave it out for now.
@@ -435,7 +435,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		/* The hardware is capable of supporting...
 		 * 	GDISP_CONTROL_POWER				- not implemented yet
 		 * 	GDISP_CONTROL_ORIENTATION		- not implemented yet
@@ -456,7 +456,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 					// 	Code here
 					/* You may need this ---
 					 *	if (GDISP.Powermode != powerSleep)
-					 *		lld_gdisp_init();
+					 *		gdisp_lld_init();
 					 */
 					break;
 				case powerSleep:

drivers/gdisp/Nokia6610GE8/gdisp_lld.c

@@ -112,7 +112,7 @@ static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
  *
  * @notapi
  */
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise your display */
 	init_board();
 
@@ -174,7 +174,7 @@ bool_t lld_gdisp_init(void) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 		if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
 	#endif
@@ -196,7 +196,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		unsigned i, tuples;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -231,7 +231,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		coord_t endx, endy, lg;
 		color_t	c1, c2;
 		#if GDISP_PACKED_PIXELS
@@ -341,7 +341,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		/* NOT IMPLEMENTED */
 		/* Some board hardware might support this in the future.
 		 * The Olimex board doesn't.
@@ -362,7 +362,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		/* NOT IMPLEMENTED */
 		/* The hardware seems capable of doing this.
 		 * It is just really complex so we leave it out for now.
@@ -390,7 +390,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		/* The hardware is capable of supporting...
 		 * 	GDISP_CONTROL_POWER				- not implemented yet
 		 * 	GDISP_CONTROL_ORIENTATION		- not implemented yet
@@ -411,7 +411,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 					// 	Code here
 					/* You may need this ---
 					 *	if (GDISP.Powermode != powerSleep)
-					 *		lld_gdisp_init();
+					 *		gdisp_lld_init();
 					 */
 					break;
 				case powerSleep:

drivers/gdisp/S6D1121/gdisp_lld.c

@@ -150,7 +150,7 @@ static __inline void reset_viewport(void) {
 	}
 }
 
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* initialize the hardware */
 	init_board();
 
@@ -255,7 +255,7 @@ bool_t lld_gdisp_init(void) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 		if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
 	#endif
@@ -277,7 +277,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_clear(color_t color) {
+	void gdisp_lld_clear(color_t color) {
 	    unsigned i;
 
 		acquire_bus();
@@ -303,7 +303,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		unsigned i, area;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -339,7 +339,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		coord_t endx, endy;
 		unsigned lg;
 
@@ -379,7 +379,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		/* This routine is marked "DO NOT USE" in the original
 		 *  GLCD driver. We just keep our GDISP_HARDWARE_READPIXEL
 		 *  turned off for now.
@@ -418,7 +418,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		/* This is marked as "TODO: Test this" in the original GLCD driver.
 		 * For now we just leave the GDISP_HARDWARE_SCROLL off.
 		 */
@@ -495,7 +495,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		switch(what) {
 		case GDISP_CONTROL_POWER:
 			if (GDISP.Powermode == (gdisp_powermode_t)value)
@@ -508,7 +508,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 					/* 	Code here */
 					/* You may need this ---
 						if (GDISP.Powermode != powerSleep)
-							lld_gdisp_init();
+							gdisp_lld_init();
 					*/
 					/* break; */
 				case powerSleep:

drivers/gdisp/SSD1289/gdisp_lld.c

@@ -157,7 +157,7 @@ static __inline void reset_viewport(void) {
  *
  * @notapi
  */
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise your display */
 	init_board();
 
@@ -243,7 +243,7 @@ bool_t lld_gdisp_init(void) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 		if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
 	#endif
@@ -280,7 +280,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_clear(color_t color) {
+	void gdisp_lld_clear(color_t color) {
 		unsigned i;
 
 		acquire_bus();
@@ -305,7 +305,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		unsigned i, area;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -341,7 +341,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		coord_t endx, endy;
 		unsigned lg;
 
@@ -380,7 +380,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		color_t color;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -413,7 +413,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		static color_t buf[((GDISP_SCREEN_HEIGHT > GDISP_SCREEN_WIDTH ) ? GDISP_SCREEN_HEIGHT : GDISP_SCREEN_WIDTH)];
 		coord_t row0, row1;
 		unsigned i, gap, abslines, j;
@@ -489,7 +489,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		switch(what) {
 		case GDISP_CONTROL_POWER:
 			if (GDISP.Powermode == (gdisp_powermode_t)value)
@@ -508,7 +508,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 				write_reg(0x0010, 0x0000);	// leave sleep mode
 				release_bus();
 				if (GDISP.Powermode != powerSleep)
-					lld_gdisp_init();
+					gdisp_lld_init();
 				break;
 			case powerSleep:
 				acquire_bus();

drivers/gdisp/SSD1963/gdisp_lld.c

@@ -187,7 +187,7 @@ __inline void GDISP_LLD(readstream)(uint16_t *buffer, size_t size) {
  *
  * @notapi
  */
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise the display */
 
 #if defined(GDISP_USE_FSMC)
@@ -358,7 +358,7 @@ void GDISP_LLD(setwindow)(coord_t x0, coord_t y0, coord_t x1, coord_t y1) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 	if (x < GDISP.clipx0 || y < GDISP.clipy0 || x >= GDISP.clipx1 || y >= GDISP.clipy1) return;
 	#endif
@@ -381,7 +381,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
     
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 			if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
@@ -430,7 +430,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 			if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; srcx += GDISP.clipx0 - x; x = GDISP.clipx0; }
@@ -486,7 +486,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
 			if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
 			if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@@ -535,7 +535,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		/* NOT IMPLEMENTED YET */
 		switch(what) {
 			case GDISP_CONTROL_POWER:
@@ -552,7 +552,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 					GDISP_LLD(readreg)(0x0000); chThdSleepMicroseconds(5000); // 2x Dummy reads to wake up from deep sleep
 					GDISP_LLD(readreg)(0x0000); chThdSleepMicroseconds(5000);
 					if (GDISP.Powermode != powerSleep)
-						lld_gdisp_init();
+						gdisp_lld_init();
 					GDISP_LLD(writeindex)(SSD1963_SET_DISPLAY_ON);
 
 					break;

drivers/gdisp/TestStub/gdisp_lld.c

@@ -53,7 +53,7 @@
  *
  * @notapi
  */
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	/* Initialise the GDISP structure */
 	GDISP.Width = GDISP_SCREEN_WIDTH;
 	GDISP.Height = GDISP_SCREEN_HEIGHT;
@@ -79,7 +79,7 @@ bool_t lld_gdisp_init(void) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	(void)x;
 	(void)y;
 	(void)color;
@@ -97,7 +97,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		(void)x;
 		(void)y;
 
@@ -119,7 +119,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		(void)x;
 		(void)y;
 		(void)cx;

drivers/multiple/Win32/gdisp_lld.c

@@ -314,7 +314,7 @@ static DWORD WINAPI WindowThread(LPVOID lpParameter) {
  *
  * @notapi
  */
-bool_t lld_gdisp_init(void) {
+bool_t gdisp_lld_init(void) {
 	RECT rect;
 
 	/* Set the window dimensions */
@@ -356,7 +356,7 @@ bool_t lld_gdisp_init(void) {
  *
  * @notapi
  */
-void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
+void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color) {
 	HDC dc;
 	#if WIN32_USE_MSG_REDRAW
 		RECT	rect;
@@ -422,7 +422,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+	void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
 		POINT p;
 		HPEN pen;
 		HDC dc;
@@ -550,7 +550,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		HDC dc;
 		RECT rect;
 		HBRUSH hbr;
@@ -681,7 +681,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		BITMAPV4HEADER bmpInfo;
 		RECT	rect;
 		#if GDISP_NEED_CONTROL
@@ -788,7 +788,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y) {
+	color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y) {
 		color_t color;
 
 		#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
@@ -834,7 +834,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+	void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		RECT	rect, frect, srect;
 		HBRUSH	hbr;
 		
@@ -958,7 +958,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
 	 *
 	 * @notapi
 	 */
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		switch(what) {
 		case GDISP_CONTROL_ORIENTATION:
 			if (GDISP.Orientation == (gdisp_orientation_t)value)

drivers/tdisp/HD44780/tdisp_lld.c

@@ -32,120 +32,131 @@
 
 #if GFX_USE_TDISP /*|| defined(__DOXYGEN__)*/
 
-#include "tdisp_lld_board_example.h"
+/* Include the hardware interface details */
+#if defined(TDISP_USE_CUSTOM_BOARD) && TDISP_USE_CUSTOM_BOARD
+	/* Include the user supplied board definitions */
+	#include "tdisp_lld_board.h"
+#elif defined(BOARD_UNKNOWN)
+	#include "gdisp_lld_board_unknown.h"
+#else
+	/* Include the user supplied board definitions */
+	#include "gdisp_lld_board.h"
+#endif
 
-static void _writeData(uint8_t data) {
-	write_bus(data);
+/* The user may override the default display size */
+#ifndef TDISP_COLUMNS
+	#define TDISP_COLUMNS		16
+#endif
+#ifndef TDISP_ROWS
+	#define TDISP_ROWS			2
+#endif
 
-	setpin_e(TRUE);
-	chThdSleepMicroseconds(1);
-	setpin_e(FALSE);
-	chThdSleepMicroseconds(5);
-}
+/* Controller Specific Properties */
+#define CUSTOM_CHAR_COUNT		8
+#define CUSTOM_CHAR_XBITS		5
+#define CUSTOM_CHAR_YBITS		8
 
-void tdisp_lld_write_cmd(uint8_t data) {
-	setpin_rs(FALSE);
-	setpin_rw(FALSE);
+/* Define the properties of our controller */
+tdispStruct	TDISP = {
+		TDISP_COLUMNS, TDISP_ROWS,				/* cols, rows */
+		CUSTOM_CHAR_XBITS, CUSTOM_CHAR_YBITS,	/* charBitsX, charBitsY */
+		CUSTOM_CHAR_COUNT						/* maxCustomChars */
+		};
 
-	#if TDISP_NEED_4BIT_MODE
-	_writeData(data>>4);
-	#endif
-	_writeData(data);
-}
+/* Our display control */
+#define DISPLAY_ON		0x04
+#define CURSOR_ON		0x02
+#define CURSOR_BLINK	0x01
 
-void tdisp_lld_write_data(uint8_t data) {
-	setpin_rs(TRUE);
-	setpin_rw(FALSE);
+static uint8_t	displaycontrol;
 
-	#if TDISP_NEED_4BIT_MODE
-	_writeData(data>>4);
-	#endif
-	_writeData(data);
-}
 
 bool_t tdisp_lld_init(void) { 
-	/* initialise MCU hardware */
+	/* initialise hardware */
 	init_board();
 
 	/* wait some time */
 	chThdSleepMilliseconds(50);
 
-	tdisp_lld_write_cmd(0x38);
+	write_cmd(0x38);
 	chThdSleepMilliseconds(64);
 
-	tdisp_lld_write_cmd(0x0f);	
+	displaycontrol = DISPLAY_ON | CURSOR_ON | CURSOR_BLINK;		// The default displaycontrol
+	write_cmd(0x08 | displaycontrol);
 	chThdSleepMicroseconds(50);
 
-	tdisp_lld_write_cmd(0x01);
+	write_cmd(0x01);					// Clear the screen
 	chThdSleepMilliseconds(5);
 
-	tdisp_lld_write_cmd(0x06);
+	write_cmd(0x06);
 	chThdSleepMicroseconds(50);
 
 	return TRUE;
 }
 
-void tdisp_lld_set_cursor(coord_t col, coord_t row) {
-	uint8_t row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
-
-	if(row >= TDISP_ROWS)
-		row = TDISP_ROWS - 1;
-
-	tdisp_lld_write_cmd(0x80 | (col + row_offsets[row]));
-}
-
-void tdisp_lld_create_char(uint8_t address, char *charmap) {
-	uint8_t i;
-
-	/* make sure we don't write somewhere we're not supposed to */
-	address &= TDISP_MAX_CUSTOM_CHARS;
-
-	tdisp_lld_write_cmd(0x40 | (address << 3));
-
-	for(i = 0; i < 8; i++) {
-		tdisp_lld_write_data(charmap[i]);
-	}
-}
-
 void tdisp_lld_clear(void) {
-	tdisp_lld_write_cmd(0x01);
+	write_cmd(0x01);
 }
 
-void tdisp_lld_home(void) {
-	tdisp_lld_write_cmd(0x02);
+void tdisp_lld_draw_char(char c) {
+	write_data(c);
+}
+
+void tdisp_lld_set_cursor(coord_t col, coord_t row) {
+	static const uint8_t row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
+
+	/*
+	 *  Short-cut:
+	 *
+	 *  If x and y = 0 then use the home command.
+	 *
+	 *  Note: There is probably no advantage as both commands are a single byte
+	 */
+//	if (col == 0 && row == 0) {
+//		write_cmd(0x02);
+//		return;
+//	}
+
+	write_cmd(0x80 | (col + row_offsets[row]));
+}
+
+void tdisp_lld_create_char(uint8_t address, uint8_t *charmap) {
+	int i;
+
+	write_cmd(0x40 | (address << 3));
+	for(i = 0; i < CUSTOM_CHAR_YBITS; i++)
+		write_data(charmap[i]);
 }
 
 void tdisp_lld_control(uint16_t what, void *value) {
-	(void)what;
-	(void)value;
-/*
-	switch(attributes) {
-		case TDISP_ON:
-			_displaycontrol |= 0x04;
-			tdisp_lld_write_cmd(0x08 | _displaycontrol);
+	switch(what) {
+		case TDISP_CTRL_BACKLIGHT:
+			if ((uint8_t)value)
+				displaycontrol |= DISPLAY_ON;
+			else
+				displaycontrol &= ~DISPLAY_ON;
+			write_cmd(0x08 | displaycontrol);
 			break;
-		case TDISP_OFF:
-			_displaycontrol &=~ 0x04;
-			tdisp_lld_write_cmd(0x08 | _displaycontrol);
-			break;
-		case TDISP_CURSOR_ON:
-			_displaycontrol |= 0x02;
-			tdisp_lld_write_cmd(0x08 | _displaycontrol);
-			break;
-		case TDISP_CURSOR_OFF:
-			_displaycontrol &=~ 0x02;
-			tdisp_lld_write_cmd(0x08 | _displaycontrol);
-			break;
-		case TDISP_CURSOR_BLINK_ON:
-			_displaycontrol |= 0x00;
-			tdisp_lld_write_cmd(0x08 | _displaycontrol);
-			break;
-		case TDISP_CURSOR_BLINK_OFF:
-			_displaycontrol &=~ 0x00;
-			tdisp_lld_write_cmd(0x08 | _displaycontrol);
+		case TDISP_CTRL_CURSOR:
+			switch((cursorshape)value) {
+			case cursorOff:
+				displaycontrol &= ~CURSOR_ON;
+				break;
+			case cursorBlock:
+			case cursorUnderline:
+			case cursorBar:
+				displaycontrol = (displaycontrol | CURSOR_ON) & ~CURSOR_BLINK;
+				break;
+			case cursorBlinkingBlock:
+			case cursorBlinkingUnderline:
+			case cursorBlinkingBar:
+			default:
+				displaycontrol |= (CURSOR_ON | CURSOR_BLINK);
+				break;
+			}
+			write_cmd(0x08 | displaycontrol);
 			break;
 	}
-*/
 }
 
 #endif /* GFX_USE_TDISP */

drivers/tdisp/HD44780/tdisp_lld_board_example.h

@@ -29,36 +29,33 @@
 #ifndef _TDISP_LLD_BOARD_H
 #define _TDISP_LLD_BOARD_H
 
-void init_board(void) {
-	palSetGroupMode(GPIOE, PAL_WHOLE_PORT, 0, PAL_MODE_OUTPUT_PUSHPULL);
-	palSetGroupMode(GPIOG, PAL_WHOLE_PORT, 0, PAL_MODE_OUTPUT_PUSHPULL);
+/**
+ * The board may override the default display size.
+ * Uncomment the below if your board needs a non-standard size.
+ */
+/*
+#ifndef TDISP_COLUMNS
+	#define TDISP_COLUMNS		16
+#endif
+#ifndef TDISP_ROWS
+	#define TDISP_ROWS			2
+#endif
+*/
+
+static void init_board(void) {
+	/* Code here */
+	#error "tdispHD44780: You must supply a definition for init_board for your board"
 }
 
-void setpin_e(bool_t state) {
-	if(state)
-		palSetPad(GPIOE, 2);
-	else
-		palClearPad(GPIOE, 2);
+static void write_cmd(uint8_t data) {
+	/* Code here */
+	#error "tdispHD44780: You must supply a definition for write_cmd for your board"
 }
 
-void setpin_rs(bool_t state) {
-	if(state)
-		palSetPad(GPIOE, 0);
-	else
-		palClearPad(GPIOE, 0);
-}
-
-void setpin_rw(bool_t state) {
-	if(state)
-		palSetPad(GPIOE, 1);
-	else
-		palClearPad(GPIOE, 1);
-}
-
-void write_bus(uint8_t data) {
-	palWritePort(GPIOG, data);
+static void write_data(uint8_t data) {
+	/* Code here */
+	#error "tdispHD44780: You must supply a definition for write_data for your board"
 }
 
 #endif /* _TDISP_LLD_BOARD_H */
 /** @} */
-

drivers/tdisp/HD44780/tdisp_lld_board_unknown.h

@@ -0,0 +1,71 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    drivers/tdisp/HD44780/tdisp_lld_board_unknown.h
+ * @brief   TDISP driver subsystem board interface for the HD44780 display
+ *
+ * @addtogroup TDISP
+ * @{
+ */
+
+#ifndef _TDISP_LLD_BOARD_H
+#define _TDISP_LLD_BOARD_H
+
+/* Configure these to match the hardware connections on your board */
+#define BUS_4BITS	FALSE
+#define PORT_DATA	GPIOG
+#define PORT_CTRL	GPIOE
+#define PIN_RS		0
+#define PIN_RW		1
+#define PIN_EN		2
+
+static void init_board(void) {
+	palSetGroupMode(PORT_CTRL, PAL_WHOLE_PORT, 0, PAL_MODE_OUTPUT_PUSHPULL);
+	palSetGroupMode(PORT_DATA, PAL_WHOLE_PORT, 0, PAL_MODE_OUTPUT_PUSHPULL);
+	palClearPad(PORT_CTRL, PIN_RW);
+}
+
+static void writeToLCD(uint8_t data) {
+	palWritePort(PORT_DATA, data);
+	palSetPad(PORT_CTRL, PIN_EN);
+	chThdSleepMicroseconds(1);
+	palClearPad(PORT_CTRL, PIN_EN);
+	chThdSleepMicroseconds(5);
+}
+
+static void write_cmd(uint8_t data) {
+	palClearPad(PORT_CTRL, PIN_RS);
+	#if BUS_4BITS
+		writeToLCD(data>>4);
+	#endif
+	writeToLCD(data);
+}
+
+static void write_data(uint8_t data) {
+	palSetPad(PORT_CTRL, PIN_RS);
+	#if BUS_4BITS
+		writeToLCD(data>>4);
+	#endif
+	writeToLCD(data);
+}
+
+#endif /* _TDISP_LLD_BOARD_H */
+/** @} */

gfxconf.example.h

@@ -48,11 +48,8 @@
 #define GDISP_INCLUDE_FONT_UI2			TRUE
 #define GDISP_INCLUDE_FONT_LARGENUMBERS	TRUE
 
-/* TDISP options */
-#define TDISP_COLUMNS			16
-#define TDISP_ROWS				2
-#define TDISP_NEED_4BIT_MODE	FALSE
-#define TDISP_NEED_8BIT_MODE	FALSE
+/* Features for the TDISP subsystem. */
+#define TDISP_NEED_MULTITHREAD	FALSE
 
 /* Features for the GWIN subsystem. */
 #define GWIN_NEED_BUTTON		FALSE
@@ -99,7 +96,8 @@
 	#define GDISP_SCREEN_HEIGHT			240
 	#define GDISP_USE_FSMC
 	#define GDISP_USE_GPIO
+	#define TDISP_COLUMNS				16
+	#define TDISP_ROWS					2
 */
 
 #endif /* _GFXCONF_H */
-

include/gadc/gadc.h

@@ -1,5 +1,5 @@
 /*
-    ChibiOS/GFX - Copyright (C) 2012
+    ChibiOS/GFX - Copyright (C) 2012, 2013
                  Joel Bodenmann aka Tectu <joel@unormal.org>
 
     This file is part of ChibiOS/GFX.
@@ -68,10 +68,13 @@
  * @{
  */
 typedef struct GEventADC_t {
-	/**
-	 * @brief The type of this event (GEVENT_ADC)
-	 */
-	GEventType		type;
+	#if GFX_USE_GEVENT || defined(__DOXYGEN__)
+		/**
+		 * @brief The type of this event (GEVENT_ADC)
+		 */
+		GEventType		type;
+	#endif
+
 	/**
 	 * @brief The event flags
 	 */
@@ -115,7 +118,11 @@ extern "C" {
  * @param[in] bufcount		The total number of conversions that will fit in the buffer.
  * @param[in] countPerEvent	The number of conversions to do before returning an event.
  *
- * @note				If the high speed ADC is running it will be stopped.
+ * @note				If the high speed ADC is running it will be stopped. The Event subsystem is
+ * 						disconnected from the high speed ADC and any binary semaphore event is forgotten.
+ * @note				bufcount must be greater than countPerEvent (usually 2 or more times) otherwise
+ * 						the buffer will be overwitten with new data while the application is still trying
+ * 						to process the old data.
  * @note				Due to a bug in Chibi-OS countPerEvent must be even. If bufcount is not
  * 						evenly divisable by countPerEvent, the remainder must also be even.
  * @note				The physdev parameter may be used to turn on more than one ADC channel.
@@ -151,7 +158,7 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
 	 * @note				The high speed ADC will not use the GEVENT system unless this is
 	 * 						called first. This saves processing time if the application does
 	 * 						not want to use the GEVENT sub-system for the high speed ADC.
-	 * 						Once turned on it cannot be turned off.
+	 * 						Once turned on it can only be turned off by calling @p gadcHighSpeedInit() again.
 	 * @note				The high speed ADC is capable of signalling via this method and a binary semaphore
 	 * 						at the same time.
 	 *
@@ -166,7 +173,8 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer
  * @param[in] pbsem			The binary semaphore is signaled when data is available.
  * @param[in] pEvent		The static event buffer to place the result information.
  *
- * @note				Passing a NULL for pbsem or pEvent will turn off signalling via this method.
+ * @note				Passing a NULL for pbsem or pEvent will turn off signalling via this method as will calling
+ * 						@p gadcHighSpeedInit().
  * @note				The high speed ADC is capable of signalling via this method and the GEVENT
  * 						sub-system at the same time.
  *
@@ -180,7 +188,7 @@ void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent);
  *
  * @api
  */
-GSourceHandle gadcHighSpeedStart(void);
+void gadcHighSpeedStart(void);
 
 /**
  * @brief   Stop the high speed ADC conversions.
@@ -237,7 +245,7 @@ void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer);
  *
  * @api
  */
-bool gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);
+bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param);
 
 #ifdef __cplusplus
 }

include/gadc/lld/gadc_lld.h

@@ -0,0 +1,190 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file    include/gadc/lld/gadc_lld.h
+ * @brief   GADC - Periodic ADC driver header file.
+ *
+ * @defgroup Driver Driver
+ * @ingroup GADC
+ * @{
+ */
+
+#ifndef _GADC_LLD_H
+#define _GADC_LLD_H
+
+#include "gfx.h"
+
+#if GFX_USE_GADC || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Type definitions                                                          */
+/*===========================================================================*/
+
+/**
+ * @brief				The structure passed to start a timer conversion
+ * @note				We use the structure instead of parameters purely to save
+ * 						interrupt stack space which is very limited in some platforms.
+ * @{
+ */
+typedef struct GadcLldTimerData_t {
+	uint32_t		physdev;		/* @< A value passed to describe which physical ADC devices/channels to use. */
+	adcsample_t		*buffer;		/* @< The static buffer to put the ADC samples into. */
+	size_t			count;			/* @< The number of conversions to do before doing a callback and stopping the ADC. */
+	bool_t			now;			/* @< Trigger the first conversion now rather than waiting for the first timer interrupt (if possible) */
+	} GadcLldTimerData;
+/* @} */
+
+/**
+ * @brief				The structure passed to start a non-timer conversion
+ * @note				We use the structure instead of parameters purely to save
+ * 						interrupt stack space which is very limited in some platforms.
+ * @{
+ */
+typedef struct GadcLldNonTimerData_t {
+	uint32_t		physdev;		/* @< A value passed to describe which physical ADC devices/channels to use. */
+	adcsample_t		*buffer;		/* @< The static buffer to put the ADC samples into. */
+	} GadcLldNonTimerData;
+/* @} */
+
+/**
+ * @brief				These routines are the callbacks that the driver uses.
+ * @details				Defined in the high level GADC code.
+ *
+ * @notapi
+ * @{
+ */
+extern void GADC_ISR_CompleteI(ADCDriver *adcp, adcsample_t *buffer, size_t n);
+extern void GADC_ISR_ErrorI(ADCDriver *adcp, adcerror_t err);
+/**
+ * @}
+ */
+
+/**
+ * @brief				This can be incremented by the low level driver if a timer interrupt is missed.
+ * @details				Defined in the high level GADC code.
+ *
+ * @notapi
+ */
+extern volatile bool_t GADC_Timer_Missed;
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief				Initialise the driver
+ *
+ * @api
+ */
+void gadc_lld_init(void);
+
+/**
+ * @brief				Get the number of samples in a conversion.
+ * @details				Calculates and returns the number of samples per conversion for the specified physdev.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ *
+ * @note				A physdev describing a mono device would return 1, a stereo device would return 2.
+ * 						For most ADC's physdev is a bitmap so it is only a matter of counting the bits.
+ *
+ * @api
+ */
+size_t gadc_lld_samples_per_conversion(uint32_t physdev);
+
+/**
+ * @brief				Start a periodic timer for high frequency conversions.
+ *
+ * @param[in] physdev		A value passed to describe which physical ADC devices/channels to use.
+ * @param[in] frequency		The frequency to create ADC conversions
+ *
+ * @note				The exact meaning of physdev is hardware dependent. It describes the channels
+ * 						the will be used later on when a "timer" conversion is actually scheduled.
+ * @note				It is assumed that the timer is capable of free-running even when the ADC
+ * 						is stopped or doing something else.
+ * @details				When a timer interrupt occurs a conversion should start if these is a "timer" conversion
+ * 						active.
+ * @note				If the ADC is stopped, doesn't have a "timer" conversion active or is currently executing
+ * 						a non-timer conversion then the interrupt can be ignored other than (optionally) incrementing
+ * 						the GADC_Timer_Missed variable.
+ *
+ * @api
+ */
+void gadc_lld_start_timer(uint32_t physdev, uint32_t frequency);
+
+/**
+ * @brief				Stop the periodic timer for high frequency conversions.
+ * @details				Also stops any current "timer" conversion (but not a current "non-timer" conversion).
+ *
+ * @param[in] physdev	A value passed to describe which physical ADC devices/channels in use.
+ *
+ * @note				The exact meaning of physdev is hardware dependent.
+ *
+ * @api
+ */
+void gadc_lld_stop_timer(uint32_t physdev);
+
+/**
+ * @brief				Start a "timer" conversion.
+ * @details				Starts a series of conversions triggered by the timer.
+ *
+ * @param[in] pgtd		Contains the parameters for the timer conversion.
+ *
+ * @note				The exact meaning of physdev is hardware dependent. It is likely described in the
+ * 						drivers gadc_lld_config.h
+ * @note				Some versions of ChibiOS actually call the callback function more than once, once
+ * 						at the half-way point and once on completion. The high level code handles this.
+ * @note				The driver should call @p GADC_ISR_CompleteI() when it completes the operation
+ * 						(or at the half-way point), or @p GAD_ISR_ErrorI() on an error.
+ * @note				The high level code ensures that this is not called while a non-timer conversion is in
+ * 						progress
+ *
+ * @iclass
+ */
+void gadc_lld_adc_timerI(GadcLldTimerData *pgtd);
+
+/**
+ * @brief				Start a "non-timer" conversion.
+ * @details				Starts a single conversion now.
+ *
+ * @param[in] pgntd		Contains the parameters for the non-timer conversion.
+ *
+ * @note				The exact meaning of physdev is hardware dependent. It is likely described in the
+ * 						drivers gadc_lld_config.h
+ * @note				The driver should call @p GADC_ISR_CompleteI() when it completes the operation
+ * 						or @p GAD_ISR_ErrorI() on an error.
+ * @note				The high level code ensures that this is not called while a timer conversion is in
+ * 						progress
+ *
+ * @iclass
+ */
+void gadc_lld_adc_nontimerI(GadcLldNonTimerData *pgntd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GFX_USE_GADC */
+
+#endif /* _GADC_LLD_H */
+/** @} */

include/gadc/options.h

@@ -1,5 +1,5 @@
 /*
-    ChibiOS/GFX - Copyright (C) 2012
+    ChibiOS/GFX - Copyright (C) 2012, 2013
                  Joel Bodenmann aka Tectu <joel@unormal.org>
 
     This file is part of ChibiOS/GFX.
@@ -40,16 +40,14 @@
  * @{
  */
 	/**
-	 * @brief   The maximum simultaneous GADC low speed device conversions
-	 * @details	Defaults to 4
-	 * @note	This value must be less than the number of conversions that can occur
-	 * 			in a single high speed ADC cycle including the high speed ADC conversion.
-	 * 			For example, if the ADC can run at 132k samples per second and the high speed
-	 * 			virtual ADC is using 44kHz then GADC_MAX_LOWSPEED_DEVICES should be set to
-	 * 			132/44 - 1 = 2
+	 * @brief   The maximum GADC sample rate
+	 * @details	Defaults to 44000
+	 * @note	This value must be less than half the maximum sample rate allowed by the CPU.
+	 * 			This is to ensure there is time between high speed samples to perform low
+	 * 			speed device sampling.
 	 */
-	#ifndef GADC_MAX_LOWSPEED_DEVICES
-		#define GADC_MAX_LOWSPEED_DEVICES	4
+	#ifndef GADC_MAX_HIGH_SPEED_SAMPLERATE
+		#define GADC_MAX_HIGH_SPEED_SAMPLERATE	44000
 	#endif
 /** @} */
 

include/gdisp/gdisp.h

@@ -201,26 +201,26 @@ extern "C" {
 #else
 
 	/* The same as above but use the low level driver directly if no multi-thread support is needed */
-	#define gdispInit(gdisp)									lld_gdisp_init()
+	#define gdispInit(gdisp)									gdisp_lld_init()
 	#define gdispIsBusy()										FALSE
-	#define gdispClear(color)									lld_gdisp_clear(color)
-	#define gdispDrawPixel(x, y, color)							lld_gdisp_draw_pixel(x, y, color)
-	#define gdispDrawLine(x0, y0, x1, y1, color)				lld_gdisp_draw_line(x0, y0, x1, y1, color)
-	#define gdispFillArea(x, y, cx, cy, color)					lld_gdisp_fill_area(x, y, cx, cy, color)
-	#define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf)		lld_gdisp_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf)
-	#define gdispSetClip(x, y, cx, cy)							lld_gdisp_set_clip(x, y, cx, cy)
-	#define gdispDrawCircle(x, y, radius, color)				lld_gdisp_draw_circle(x, y, radius, color)
-	#define gdispFillCircle(x, y, radius, color)				lld_gdisp_fill_circle(x, y, radius, color)
-	#define gdispDrawArc(x, y, radius, sangle, eangle, color)	lld_gdisp_draw_arc(x, y, radius, sangle, eangle, color)
-	#define gdispFillArc(x, y, radius, sangle, eangle, color)	lld_gdisp_fill_arc(x, y, radius, sangle, eangle, color)
-	#define gdispDrawEllipse(x, y, a, b, color)					lld_gdisp_draw_ellipse(x, y, a, b, color)
-	#define gdispFillEllipse(x, y, a, b, color)					lld_gdisp_fill_ellipse(x, y, a, b, color)
-	#define gdispDrawChar(x, y, c, font, color)					lld_gdisp_draw_char(x, y, c, font, color)
-	#define gdispFillChar(x, y, c, font, color, bgcolor)		lld_gdisp_fill_char(x, y, c, font, color, bgcolor)
-	#define gdispGetPixelColor(x, y)							lld_gdisp_get_pixel_color(x, y)
-	#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor)	lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor)
-	#define gdispControl(what, value)							lld_gdisp_control(what, value)
-	#define gdispQuery(what)									lld_gdisp_query(what)
+	#define gdispClear(color)									gdisp_lld_clear(color)
+	#define gdispDrawPixel(x, y, color)							gdisp_lld_draw_pixel(x, y, color)
+	#define gdispDrawLine(x0, y0, x1, y1, color)				gdisp_lld_draw_line(x0, y0, x1, y1, color)
+	#define gdispFillArea(x, y, cx, cy, color)					gdisp_lld_fill_area(x, y, cx, cy, color)
+	#define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf)		gdisp_lld_blit_area_ex(x, y, cx, cy, sx, sy, scx, buf)
+	#define gdispSetClip(x, y, cx, cy)							gdisp_lld_set_clip(x, y, cx, cy)
+	#define gdispDrawCircle(x, y, radius, color)				gdisp_lld_draw_circle(x, y, radius, color)
+	#define gdispFillCircle(x, y, radius, color)				gdisp_lld_fill_circle(x, y, radius, color)
+	#define gdispDrawArc(x, y, radius, sangle, eangle, color)	gdisp_lld_draw_arc(x, y, radius, sangle, eangle, color)
+	#define gdispFillArc(x, y, radius, sangle, eangle, color)	gdisp_lld_fill_arc(x, y, radius, sangle, eangle, color)
+	#define gdispDrawEllipse(x, y, a, b, color)					gdisp_lld_draw_ellipse(x, y, a, b, color)
+	#define gdispFillEllipse(x, y, a, b, color)					gdisp_lld_fill_ellipse(x, y, a, b, color)
+	#define gdispDrawChar(x, y, c, font, color)					gdisp_lld_draw_char(x, y, c, font, color)
+	#define gdispFillChar(x, y, c, font, color, bgcolor)		gdisp_lld_fill_char(x, y, c, font, color, bgcolor)
+	#define gdispGetPixelColor(x, y)							gdisp_lld_get_pixel_color(x, y)
+	#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor)	gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor)
+	#define gdispControl(what, value)							gdisp_lld_control(what, value)
+	#define gdispQuery(what)									gdisp_lld_query(what)
 
 #endif
 

include/gdisp/lld/emulation.c

@@ -52,13 +52,13 @@
 #endif
 
 #if !GDISP_HARDWARE_CLEARS 
-	void lld_gdisp_clear(color_t color) {
-		lld_gdisp_fill_area(0, 0, GDISP.Width, GDISP.Height, color);
+	void gdisp_lld_clear(color_t color) {
+		gdisp_lld_fill_area(0, 0, GDISP.Width, GDISP.Height, color);
 	}
 #endif
 
 #if !GDISP_HARDWARE_LINES 
-	void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+	void gdisp_lld_draw_line(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;
@@ -67,16 +67,16 @@
 		// speed improvement if vertical or horizontal
 		if (x0 == x1) {
 			if (y1 > y0)
-				lld_gdisp_fill_area(x0, y0, 1, y1-y0+1, color);
+				gdisp_lld_fill_area(x0, y0, 1, y1-y0+1, color);
 			else
-				lld_gdisp_fill_area(x0, y1, 1, y0-y1+1, color);
+				gdisp_lld_fill_area(x0, y1, 1, y0-y1+1, color);
 			return;
 		}
 		if (y0 == y1) {
 			if (x1 > x0)
-				lld_gdisp_fill_area(x0, y0, x1-x0+1, 1, color);
+				gdisp_lld_fill_area(x0, y0, x1-x0+1, 1, color);
 			else
-				lld_gdisp_fill_area(x0, y1, x0-x1+1, 1, color);
+				gdisp_lld_fill_area(x0, y1, x0-x1+1, 1, color);
 			return;
 		}
 		#endif
@@ -102,7 +102,7 @@
 			diff = P - dx;
 
 			for(i=0; i<=dx; ++i) {
-				lld_gdisp_draw_pixel(x0, y0, color);
+				gdisp_lld_draw_pixel(x0, y0, color);
 				if (P < 0) {
 					P  += dy;
 					x0 += addx;
@@ -118,7 +118,7 @@
 			diff = P - dy;
 
 			for(i=0; i<=dy; ++i) {
-				lld_gdisp_draw_pixel(x0, y0, color);
+				gdisp_lld_draw_pixel(x0, y0, color);
 				if (P < 0) {
 					P  += dx;
 					y0 += addy;
@@ -133,16 +133,16 @@
 #endif
 
 #if !GDISP_HARDWARE_FILLS
-	void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+	void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		#if GDISP_HARDWARE_SCROLL
-			lld_gdisp_vertical_scroll(x, y, cx, cy, cy, color);
+			gdisp_lld_vertical_scroll(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++)
-				lld_gdisp_draw_line(x, y, x1, y, color);
+				gdisp_lld_draw_line(x, y, x1, y, color);
 		#else
 			coord_t x0, x1, y1;
 			
@@ -151,13 +151,13 @@
 			y1 = y + cy;
 			for(; y < y1; y++)
 				for(x = x0; x < x1; x++)
-					lld_gdisp_draw_pixel(x, y, color);
+					gdisp_lld_draw_pixel(x, y, color);
 		#endif
 	}
 #endif
 
 #if !GDISP_HARDWARE_BITFILLS
-	void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
+	void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 			coord_t x0, x1, y1;
 			
 			x0 = x;
@@ -167,12 +167,12 @@
 			srccx -= cx;
 			for(; y < y1; y++, buffer += srccx)
 				for(x=x0; x < x1; x++)
-					lld_gdisp_draw_pixel(x, y, *buffer++);
+					gdisp_lld_draw_pixel(x, y, *buffer++);
 	}
 #endif
 
 #if GDISP_NEED_CLIP && !GDISP_HARDWARE_CLIP
-	void lld_gdisp_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
+	void gdisp_lld_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
 		#if GDISP_NEED_VALIDATION
 			if (x >= GDISP.Width || y >= GDISP.Height || cx < 0 || cy < 0)
 				return;
@@ -189,7 +189,7 @@
 #endif
 
 #if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES
-	void lld_gdisp_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
+	void gdisp_lld_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
 		coord_t a, b, P;
 
 		a = 0;
@@ -197,14 +197,14 @@
 		P = 1 - radius;
 
 		do {
-			lld_gdisp_draw_pixel(x+a, y+b, color);
-			lld_gdisp_draw_pixel(x+b, y+a, color);
-			lld_gdisp_draw_pixel(x-a, y+b, color);
-			lld_gdisp_draw_pixel(x-b, y+a, color);
-			lld_gdisp_draw_pixel(x+b, y-a, color);
-			lld_gdisp_draw_pixel(x+a, y-b, color);
-			lld_gdisp_draw_pixel(x-a, y-b, color);
-			lld_gdisp_draw_pixel(x-b, y-a, color);
+			gdisp_lld_draw_pixel(x+a, y+b, color);
+			gdisp_lld_draw_pixel(x+b, y+a, color);
+			gdisp_lld_draw_pixel(x-a, y+b, color);
+			gdisp_lld_draw_pixel(x-b, y+a, color);
+			gdisp_lld_draw_pixel(x+b, y-a, color);
+			gdisp_lld_draw_pixel(x+a, y-b, color);
+			gdisp_lld_draw_pixel(x-a, y-b, color);
+			gdisp_lld_draw_pixel(x-b, y-a, color);
 			if (P < 0)
 				P += 3 + 2*a++;
 			else
@@ -214,7 +214,7 @@
 #endif
 
 #if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS
-	void lld_gdisp_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
+	void gdisp_lld_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color) {
 		coord_t a, b, P;
 		
 		a = 0;
@@ -222,10 +222,10 @@
 		P = 1 - radius;
 
 		do {
-			lld_gdisp_draw_line(x-a, y+b, x+a, y+b, color);
-			lld_gdisp_draw_line(x-a, y-b, x+a, y-b, color);
-			lld_gdisp_draw_line(x-b, y+a, x+b, y+a, color);
-			lld_gdisp_draw_line(x-b, y-a, x+b, y-a, color);
+			gdisp_lld_draw_line(x-a, y+b, x+a, y+b, color);
+			gdisp_lld_draw_line(x-a, y-b, x+a, y-b, color);
+			gdisp_lld_draw_line(x-b, y+a, x+b, y+a, color);
+			gdisp_lld_draw_line(x-b, y-a, x+b, y-a, color);
 			if (P < 0)
 				P += 3 + 2*a++;
 			else
@@ -235,16 +235,16 @@
 #endif
 
 #if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES
-	void lld_gdisp_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+	void gdisp_lld_draw_ellipse(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 {
-			lld_gdisp_draw_pixel(x+dx, y+dy, color); /* I. Quadrant */
-			lld_gdisp_draw_pixel(x-dx, y+dy, color); /* II. Quadrant */
-			lld_gdisp_draw_pixel(x-dx, y-dy, color); /* III. Quadrant */
-			lld_gdisp_draw_pixel(x+dx, y-dy, color); /* IV. Quadrant */
+			gdisp_lld_draw_pixel(x+dx, y+dy, color); /* I. Quadrant */
+			gdisp_lld_draw_pixel(x-dx, y+dy, color); /* II. Quadrant */
+			gdisp_lld_draw_pixel(x-dx, y-dy, color); /* III. Quadrant */
+			gdisp_lld_draw_pixel(x+dx, y-dy, color); /* IV. Quadrant */
 
 			e2 = 2*err;
 			if(e2 <  (2*dx+1)*b2) {
@@ -258,21 +258,21 @@
 		} while(dy >= 0); 
 
 		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
-			lld_gdisp_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
-			lld_gdisp_draw_pixel(x-dx, y, color);
+			gdisp_lld_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
+			gdisp_lld_draw_pixel(x-dx, y, color);
 	   }   
 	}
 #endif
 
 #if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS
-	void lld_gdisp_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+	void gdisp_lld_fill_ellipse(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 {
-			lld_gdisp_draw_line(x-dx,y+dy,x+dx,y+dy, color);
-			lld_gdisp_draw_line(x-dx,y-dy,x+dx,y-dy, color);
+			gdisp_lld_draw_line(x-dx,y+dy,x+dx,y+dy, color);
+			gdisp_lld_draw_line(x-dx,y-dy,x+dx,y-dy, color);
 
 			e2 = 2*err;
 			if(e2 <  (2*dx+1)*b2) {
@@ -286,8 +286,8 @@
 		} while(dy >= 0); 
 
 		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
-			lld_gdisp_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
-			lld_gdisp_draw_pixel(x-dx, y, color);
+			gdisp_lld_draw_pixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
+			gdisp_lld_draw_pixel(x-dx, y, color);
 	   }   
 	}
 #endif
@@ -325,13 +325,13 @@
 
 	        do {
 	            if(x-a <= x_maxI && x-a >= x_minI)
-	            	lld_gdisp_draw_pixel(x-a, y-b, color);
+	            	gdisp_lld_draw_pixel(x-a, y-b, color);
 	            if(x+a <= x_maxI && x+a >= x_minI)
-	            	lld_gdisp_draw_pixel(x+a, y-b, color);
+	            	gdisp_lld_draw_pixel(x+a, y-b, color);
 	            if(x-b <= x_maxI && x-b >= x_minI)
-	            	lld_gdisp_draw_pixel(x-b, y-a, color);
+	            	gdisp_lld_draw_pixel(x-b, y-a, color);
 	            if(x+b <= x_maxI && x+b >= x_minI)
-	            	lld_gdisp_draw_pixel(x+b, y-a, color);
+	            	gdisp_lld_draw_pixel(x+b, y-a, color);
 
 	            if (P < 0) {
 	                P = P + 3 + 2*a;
@@ -359,13 +359,13 @@
 
 	        do {
 	            if(x-a <= x_maxII && x-a >= x_minII)
-	            	lld_gdisp_draw_pixel(x-a, y+b, color);
+	            	gdisp_lld_draw_pixel(x-a, y+b, color);
 	            if(x+a <= x_maxII && x+a >= x_minII)
-	            	lld_gdisp_draw_pixel(x+a, y+b, color);
+	            	gdisp_lld_draw_pixel(x+a, y+b, color);
 	            if(x-b <= x_maxII && x-b >= x_minII)
-	            	lld_gdisp_draw_pixel(x-b, y+a, color);
+	            	gdisp_lld_draw_pixel(x-b, y+a, color);
 	            if(x+b <= x_maxII && x+b >= x_minII)
-	            	lld_gdisp_draw_pixel(x+b, y+a, color);
+	            	gdisp_lld_draw_pixel(x+b, y+a, color);
 
 	            if (P < 0) {
 	                P = P + 3 + 2*a;
@@ -379,7 +379,7 @@
 	    }
 	}
 
-	void lld_gdisp_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
+	void gdisp_lld_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
 		if(endangle < startangle) {
 	        _draw_arc(x, y, startangle, 360, radius, color);
 	        _draw_arc(x, y, 0, endangle, radius, color);
@@ -419,13 +419,13 @@
 
 	        do {
 	            if(x-a <= x_maxI && x-a >= x_minI)
-	            	lld_gdisp_draw_line(x, y, x-a, y-b, color);
+	            	gdisp_lld_draw_line(x, y, x-a, y-b, color);
 	            if(x+a <= x_maxI && x+a >= x_minI)
-	            	lld_gdisp_draw_line(x, y, x+a, y-b, color);
+	            	gdisp_lld_draw_line(x, y, x+a, y-b, color);
 	            if(x-b <= x_maxI && x-b >= x_minI)
-	            	lld_gdisp_draw_line(x, y, x-b, y-a, color);
+	            	gdisp_lld_draw_line(x, y, x-b, y-a, color);
 	            if(x+b <= x_maxI && x+b >= x_minI)
-	            	lld_gdisp_draw_line(x, y, x+b, y-a, color);
+	            	gdisp_lld_draw_line(x, y, x+b, y-a, color);
 
 	            if (P < 0) {
 	                P = P + 3 + 2*a;
@@ -453,13 +453,13 @@
 
 	        do {
 	            if(x-a <= x_maxII && x-a >= x_minII)
-	            	lld_gdisp_draw_line(x, y, x-a, y+b, color);
+	            	gdisp_lld_draw_line(x, y, x-a, y+b, color);
 	            if(x+a <= x_maxII && x+a >= x_minII)
-	            	lld_gdisp_draw_line(x, y, x+a, y+b, color);
+	            	gdisp_lld_draw_line(x, y, x+a, y+b, color);
 	            if(x-b <= x_maxII && x-b >= x_minII)
-	            	lld_gdisp_draw_line(x, y, x-b, y+a, color);
+	            	gdisp_lld_draw_line(x, y, x-b, y+a, color);
 	            if(x+b <= x_maxII && x+b >= x_minII)
-	            	lld_gdisp_draw_line(x, y, x+b, y+a, color);
+	            	gdisp_lld_draw_line(x, y, x+b, y+a, color);
 
 	            if (P < 0) {
 	                P = P + 3 + 2*a;
@@ -473,7 +473,7 @@
 	    }
 	}
 
-	void lld_gdisp_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
+	void gdisp_lld_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {
 		if(endangle < startangle) {
 	        _fill_arc(x, y, startangle, 360, radius, color);
 	        _fill_arc(x, y, 0, endangle, radius, color);
@@ -488,7 +488,7 @@
 #endif
 
 #if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
-	void lld_gdisp_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color) {
+	void gdisp_lld_draw_char(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;
@@ -515,7 +515,7 @@
 				if (column & 0x01) {
 					for(xs=0; xs < xscale; xs++)
 						for(ys=0; ys < yscale; ys++)
-							lld_gdisp_draw_pixel(x+i+xs, y+j+ys, color);
+							gdisp_lld_draw_pixel(x+i+xs, y+j+ys, color);
 				}
 			}
 		}
@@ -523,7 +523,7 @@
 #endif
 
 #if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS
-	void lld_gdisp_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+	void gdisp_lld_fill_char(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;
 		
@@ -540,10 +540,10 @@
 		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW
 			
 			/* Fill the area */
-			lld_gdisp_fill_area(x, y, width, height, bgcolor);
+			gdisp_lld_fill_area(x, y, width, height, bgcolor);
 			
 			/* Draw the text */
-			lld_gdisp_draw_char(x, y, c, font, color);
+			gdisp_lld_draw_char(x, y, c, font, color);
 
 		/* Method 2: Create a single column bitmap and then blit it */
 		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN
@@ -582,7 +582,7 @@
 				}
 
 				for(xs=0; xs < xscale; xs++)
-					lld_gdisp_blit_area_ex(x+i+xs, y, 1, height, 0, 0, 1, buf);
+					gdisp_lld_blit_area_ex(x+i+xs, y, 1, height, 0, 0, 1, buf);
 			}
 		}
 
@@ -626,7 +626,7 @@
 			}
 
 			/* [Patch by Badger] Write all in one stroke */
-			lld_gdisp_blit_area_ex(x, y, width, height, 0, 0, width, buf);
+			gdisp_lld_blit_area_ex(x, y, width, height, 0, 0, width, buf);
 		}
 
 		/* Method 4: Draw pixel by pixel */
@@ -648,11 +648,11 @@
 					if (column & 0x01) {
 						for(xs=0; xs < xscale; xs++)
 							for(ys=0; ys < yscale; ys++)
-								lld_gdisp_draw_pixel(x+i+xs, y+j+ys, color);
+								gdisp_lld_draw_pixel(x+i+xs, y+j+ys, color);
 					} else {
 						for(xs=0; xs < xscale; xs++)
 							for(ys=0; ys < yscale; ys++)
-								lld_gdisp_draw_pixel(x+i+xs, y+j+ys, bgcolor);
+								gdisp_lld_draw_pixel(x+i+xs, y+j+ys, bgcolor);
 					}
 				}
 			}
@@ -663,7 +663,7 @@
 
 
 #if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL
-	void lld_gdisp_control(unsigned what, void *value) {
+	void gdisp_lld_control(unsigned what, void *value) {
 		(void)what;
 		(void)value;
 		/* Ignore everything */
@@ -671,7 +671,7 @@
 #endif
 
 #if !GDISP_HARDWARE_QUERY
-void *lld_gdisp_query(unsigned what) {
+void *gdisp_lld_query(unsigned what) {
 	switch(what) {
 	case GDISP_QUERY_WIDTH:			return (void *)(unsigned)GDISP.Width;
 	case GDISP_QUERY_HEIGHT:		return (void *)(unsigned)GDISP.Height;
@@ -685,82 +685,82 @@ void *lld_gdisp_query(unsigned what) {
 #endif
 
 #if GDISP_NEED_MSGAPI
-	void lld_gdisp_msg_dispatch(gdisp_lld_msg_t *msg) {
+	void gdisp_lld_msg_dispatch(gdisp_lld_msg_t *msg) {
 		switch(msg->action) {
 		case GDISP_LLD_MSG_NOP:
 			break;
 		case GDISP_LLD_MSG_INIT:
-			lld_gdisp_init();
+			gdisp_lld_init();
 			break;
 		case GDISP_LLD_MSG_CLEAR:
-			lld_gdisp_clear(msg->clear.color);
+			gdisp_lld_clear(msg->clear.color);
 			break;
 		case GDISP_LLD_MSG_DRAWPIXEL:
-			lld_gdisp_draw_pixel(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);
+			gdisp_lld_draw_pixel(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);
 			break;
 		case GDISP_LLD_MSG_FILLAREA:
-			lld_gdisp_fill_area(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);
+			gdisp_lld_fill_area(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);
 			break;
 		case GDISP_LLD_MSG_BLITAREA:
-			lld_gdisp_blit_area_ex(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);
+			gdisp_lld_blit_area_ex(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);
 			break;
 		case GDISP_LLD_MSG_DRAWLINE:
-			lld_gdisp_draw_line(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);
+			gdisp_lld_draw_line(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);
 			break;
 		#if GDISP_NEED_CLIP
 			case GDISP_LLD_MSG_SETCLIP:
-				lld_gdisp_set_clip(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);
+				gdisp_lld_set_clip(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);
 				break;
 		#endif
 		#if GDISP_NEED_CIRCLE
 			case GDISP_LLD_MSG_DRAWCIRCLE:
-				lld_gdisp_draw_circle(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);
+				gdisp_lld_draw_circle(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);
 				break;
 			case GDISP_LLD_MSG_FILLCIRCLE:
-				lld_gdisp_fill_circle(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);
+				gdisp_lld_fill_circle(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);
 				break;
 		#endif
 		#if GDISP_NEED_ELLIPSE
 			case GDISP_LLD_MSG_DRAWELLIPSE:
-				lld_gdisp_draw_ellipse(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);
+				gdisp_lld_draw_ellipse(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);
 				break;
 			case GDISP_LLD_MSG_FILLELLIPSE:
-				lld_gdisp_fill_ellipse(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);
+				gdisp_lld_fill_ellipse(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);
 				break;
 		#endif
 		#if GDISP_NEED_ARC
 			case GDISP_LLD_MSG_DRAWARC:
-				lld_gdisp_draw_circle(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);
+				gdisp_lld_draw_circle(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);
 				break;
 			case GDISP_LLD_MSG_FILLARC:
-				lld_gdisp_fill_circle(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);
+				gdisp_lld_fill_circle(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);
 				break;
 		#endif
 		#if GDISP_NEED_TEXT
 			case GDISP_LLD_MSG_DRAWCHAR:
-				lld_gdisp_draw_char(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);
+				gdisp_lld_draw_char(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);
 				break;
 			case GDISP_LLD_MSG_FILLCHAR:
-				lld_gdisp_fill_char(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);
+				gdisp_lld_fill_char(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);
 				break;
 		#endif
 		#if GDISP_NEED_PIXELREAD
 			case GDISP_LLD_MSG_GETPIXELCOLOR:
-				msg->getpixelcolor.result = lld_gdisp_get_pixel_color(msg->getpixelcolor.x, msg->getpixelcolor.y);
+				msg->getpixelcolor.result = gdisp_lld_get_pixel_color(msg->getpixelcolor.x, msg->getpixelcolor.y);
 				break;
 		#endif
 		#if GDISP_NEED_SCROLL
 			case GDISP_LLD_MSG_VERTICALSCROLL:
-				lld_gdisp_vertical_scroll(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);
+				gdisp_lld_vertical_scroll(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);
 				break;
 		#endif
 		#if GDISP_NEED_CONTROL
 			case GDISP_LLD_MSG_CONTROL:
-				lld_gdisp_control(msg->control.what, msg->control.value);
+				gdisp_lld_control(msg->control.what, msg->control.value);
 				break;
 		#endif
 			case GDISP_LLD_MSG_QUERY:
-				msg->query.result = lld_gdisp_query(msg->query.what);
+				msg->query.result = gdisp_lld_query(msg->query.what);
 				break;
 		}
 	}

include/gdisp/lld/gdisp_lld.h

@@ -19,7 +19,7 @@
 */
 
 /**
- * @file    include/gdisp/lld/lld_gdisp.h
+ * @file    include/gdisp/lld/gdisp_lld.h
  * @brief   GDISP Graphic Driver subsystem low level driver header.
  *
  * @addtogroup GDISP
@@ -463,69 +463,69 @@ extern "C" {
 #endif
 
 	/* Core functions */
-	extern bool_t lld_gdisp_init(void);
+	extern bool_t gdisp_lld_init(void);
 
 	/* Some of these functions will be implemented in software by the high level driver
-	   depending on the GDISP_HARDWARE_XXX macros defined in lld_gdisp_config.h.
+	   depending on the GDISP_HARDWARE_XXX macros defined in gdisp_lld_config.h.
 	 */
 
 	/* Drawing functions */
-	extern void lld_gdisp_clear(color_t color);
-	extern void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color);
-	extern void lld_gdisp_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
-	extern void lld_gdisp_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);
-	extern void lld_gdisp_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
+	extern void gdisp_lld_clear(color_t color);
+	extern void gdisp_lld_draw_pixel(coord_t x, coord_t y, color_t color);
+	extern void gdisp_lld_fill_area(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+	extern void gdisp_lld_blit_area_ex(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);
+	extern void gdisp_lld_draw_line(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
 
 	/* Circular Drawing Functions */
 	#if GDISP_NEED_CIRCLE
-	extern void lld_gdisp_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color);
-	extern void lld_gdisp_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color);
+	extern void gdisp_lld_draw_circle(coord_t x, coord_t y, coord_t radius, color_t color);
+	extern void gdisp_lld_fill_circle(coord_t x, coord_t y, coord_t radius, color_t color);
 	#endif
 
 	#if GDISP_NEED_ELLIPSE
-	extern void lld_gdisp_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
-	extern void lld_gdisp_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	extern void gdisp_lld_draw_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+	extern void gdisp_lld_fill_ellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
 	#endif
 
 	/* Arc Drawing Functions */
 	#if GDISP_NEED_ARC
-	extern void lld_gdisp_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
-	extern void lld_gdisp_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+	extern void gdisp_lld_draw_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+	extern void gdisp_lld_fill_arc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
 	#endif
 
 	/* Text Rendering Functions */
 	#if GDISP_NEED_TEXT
-	extern void lld_gdisp_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color);
-	extern void lld_gdisp_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
+	extern void gdisp_lld_draw_char(coord_t x, coord_t y, char c, font_t font, color_t color);
+	extern void gdisp_lld_fill_char(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
 	#endif
 
 	/* Pixel readback */
 	#if GDISP_NEED_PIXELREAD
-	extern color_t lld_gdisp_get_pixel_color(coord_t x, coord_t y);
+	extern color_t gdisp_lld_get_pixel_color(coord_t x, coord_t y);
 	#endif
 
 	/* Scrolling Function - clears the area scrolled out */
 	#if GDISP_NEED_SCROLL
-	extern void lld_gdisp_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
+	extern void gdisp_lld_vertical_scroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
 	#endif
 
 	/* Set driver specific control */
 	#if GDISP_NEED_CONTROL
-	extern void lld_gdisp_control(unsigned what, void *value);
+	extern void gdisp_lld_control(unsigned what, void *value);
 	#endif
 
 	/* Query driver specific data */
-	extern void *lld_gdisp_query(unsigned what);
+	extern void *gdisp_lld_query(unsigned what);
 
 	/* Clipping Functions */
 	#if GDISP_NEED_CLIP
-	extern void lld_gdisp_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy);
+	extern void gdisp_lld_set_clip(coord_t x, coord_t y, coord_t cx, coord_t cy);
 	#endif
 
 	/* Messaging API */
 	#if GDISP_NEED_MSGAPI
-	#include "lld_gdisp_msgs.h"
-	extern void lld_gdisp_msg_dispatch(lld_gdisp_msg_t *msg);
+	#include "gdisp_lld_msgs.h"
+	extern void gdisp_lld_msg_dispatch(gdisp_lld_msg_t *msg);
 	#endif
 
 #ifdef __cplusplus

include/gdisp/lld/gdisp_lld_msgs.h

@@ -140,14 +140,14 @@ typedef union gdisp_lld_msg {
 		coord_t				radius;
 		coord_t				startangle, endangle;
 		color_t				color;
-	} drawcircle;
+	} drawarc;
 	struct gdisp_lld_msg_fillarc {
 		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLARC
 		coord_t				x, y;
 		coord_t				radius;
 		coord_t				startangle, endangle;
 		color_t				color;
-	} fillcircle;
+	} fillarc;
 	struct gdisp_lld_msg_drawchar {
 		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCHAR
 		coord_t				x, y;

include/gfx_rules.h

@@ -99,6 +99,17 @@
 #if GFX_USE_TDISP
 #endif
 
+#if GFX_USE_GADC
+	#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
+		#error "GADC: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
+	#endif
+	#if !GFX_USE_GTIMER
+		#warning "GADC: GFX_USE_GTIMER is required if GFX_USE_GADC is TRUE. It has been turned on for you."
+		#undef GFX_USE_GTIMER
+		#define	GFX_USE_GTIMER		TRUE
+	#endif
+#endif
+
 #if GFX_USE_GEVENT
 	#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
 		#error "GEVENT: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
@@ -118,9 +129,6 @@
 #if GFX_USE_GAUDOUT
 #endif
 
-#if GFX_USE_GADC
-#endif
-
 #if GFX_USE_GMISC
 #endif
 

include/tdisp/lld/tdisp_lld.h

@@ -31,20 +31,16 @@
 
 #if GFX_USE_TDISP || defined(__DOXYGEN__)
 
-#include "tdisp_lld_config.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-extern void		tdisp_lld_write_cmd(uint8_t data);
-extern void		tdisp_lld_write_data(uint8_t data);
-extern bool_t	tdisp_lld_init(void);
-extern void 	tdisp_lld_set_cursor(coord_t col, coord_t row);
-extern void		tdisp_lld_create_char(uint8_t address, char *charmap);
-extern void		tdisp_lld_clear(void);
-extern void		tdisp_lld_home(void);
-extern void		tdisp_lld_control(uint16_t what, void *value);
+	bool_t	tdisp_lld_init(void);
+	void	tdisp_lld_clear(void);
+	void	tdisp_lld_draw_char(char c);
+	void 	tdisp_lld_set_cursor(coord_t col, coord_t row);
+	void	tdisp_lld_create_char(uint8_t address, uint8_t *charmap);
+	void	tdisp_lld_control(uint16_t what, void *value);
 
 #ifdef __cplusplus
 }

include/tdisp/options.h

@@ -31,53 +31,44 @@
 
 #if GFX_USE_TDISP
 /**
- * @name    TDISP configuration
+ * @name    TDISP Functionality to be included
  * @{
  */
-
-	/**
-	 * @brief	How many rows of characters the TDISP provides
-	 */
-	#ifndef TDISP_ROWS
-		#define TDISP_ROWS		2
-	#endif
-
-	/**
-	 * @brief	How many columns of characters the TDISP provides
-	 */
-	#ifndef TDISP_COLUMNS
-		#define TDISP_COLUMNS	16
-	#endif
-
-/** @} */
-
 /**
- * @name	TDISP interface configuration
- * @note	Only one of these interfaces can be selected at a time!
+ * @}
+ *
+ * @name    TDISP Multi-Threading Options
  * @{
  */
 	/**
-	 * @brief	Use the 4-bit paralle interface
+	 * @brief   Do the display functions need to be thread-safe.
+	 * @details	Defaults to FALSE
 	 */
-	#ifndef TDISP_NEED_4BIT_MODE
-		#define TDISP_NEED_4BIT_MODE	FALSE
+	#ifndef TDISP_NEED_MULTITHREAD
+		#define TDISP_NEED_MULTITHREAD	FALSE
 	#endif
-
+/**
+ * @}
+ *
+ * @name    TDISP Optional Low Level Driver Defines
+ * @{
+ */
 	/**
-	 * @brief	Use the 8-bit parallel interface
+	 * @brief   Use a custom board definition even if a board definition exists.
+	 * @details	Defaults to FALSE
+	 * @details	If TRUE, add tdisp_lld_board.h to your project directory and customise it.
+	 * @note	Not all TDISP low level drivers currently use board definition files.
 	 */
-	#ifndef TDISP_NEED_8BIT_MODE
-		#define TDISP_NEED_8BIT_MODE	FALSE
+	#ifndef TDISP_USE_CUSTOM_BOARD
+		#define TDISP_USE_CUSTOM_BOARD		FALSE
 	#endif
-
-	#if (!TDISP_NEED_4BIT_MODE && !TDISP_NEED_8BIT_MODE)
-		#error "Either TDISP_NEED_4BIT_MODE or TDISP_NEED_8BIT_MODE needs to be set to TRUE in your gfxconf.h!"
-	#endif
-
-	#if (TDISP_NEED_4BIT_MODE && TDISP_NEED_8BIT_MODE)
-		#error "Only TDISP_NEED_4BIT_MODE or TDISP_NEED_8BIT_MODE can be set to TRUE, not both at one!"
-	#endif
-
+	/**
+	 * @brief   Set the screen height and width.
+	 * @note	Ignored by some low level GDISP drivers, optional for others.
+	 * @note	Where these values are allowed, a default is always provided by the low level driver.
+	 */
+	/* #define TDISP_COLUMNS		16 */
+	/* #define TDISP_ROWS			2  */
 /** @} */
 
 #endif /* GFX_USE_TDISP */

include/tdisp/tdisp.h

@@ -39,21 +39,46 @@
 
 #if GFX_USE_TDISP || defined(__DOXYGEN__)
 
-/* Include the low level driver information */
-#include "tdisp/lld/tdisp_lld.h"
+/**
+ * @brief	TDISP cursor shape definitions
+ */
+typedef enum cursorshape_e {
+	cursorOff,
+	cursorBlock,
+	cursorBlinkingBlock,
+	cursorUnderline,
+	cursorBlinkingUnderline,
+	cursorBar,
+	cursorBlinkingBar,
+	} cursorshape;
 
 /**
- * @name	TDISP display attributes
+ * @name	TDISP control values
+ * @note	The low level driver may define extra control values
  * @{
  */
-#define	TDISP_ON				0x01
-#define TDISP_OFF				0x02
-#define TDISP_CURSOR_ON			0x03
-#define TDISP_CURSOR_OFF		0x04
-#define TDISP_CURSOR_BLINK_ON	0x05
-#define TDISP_CURSOR_BLINK_OFF	0x06
+#define	TDISP_CTRL_BACKLIGHT	0x0000
+#define TDISP_CTRL_CURSOR		0x0001
 /** @} */
 
+/**
+ * @brief	The TDISP structure definition
+ */
+typedef struct tdispStruct_t {
+	coord_t		columns, rows;
+	coord_t		charBitsX, charBitsY;
+	uint16_t	maxCustomChars;
+	} tdispStruct;
+
+/**
+ * @brief	The TDISP structure
+ */
+extern tdispStruct	TDISP;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * @brief	TDISP driver initialisation
  * @note	This function is not implicitly invoked by @p halInit().
@@ -65,10 +90,63 @@
  */
 bool_t tdispInit(void);
 
+/**
+ * @brief	Clears the display
+ */
+void tdispClear(void);
+
+/**
+ * @brief	Sets the cursor to it's home position ( 0, 0 )
+ */
+void tdispHome(void);
+
+/**
+ * @brief	Set cursor to a specified position
+ *
+ * @param[in] col	The column	(x)
+ * @param[in] row	The row		(y)
+ */
+void tdispSetCursor(coord_t col, coord_t row);
+
+/**
+ * @brief	Store a custom character into the display
+ *
+ * @note	This usually must be done after each power-up since most
+ *			LCDs lose their RAM content.
+ *
+ * @param[in] address		On which address to store the character from 0 up to (@p tdispGetNumCustomChars() - 1)
+ * @param[in] charmap		The character to be stored.
+ *
+ * @note					The charmap is made up of @p tdispGetCharBitHieght() data values. Each data value is
+ * 							made up of @p tdispGetCharBitWidth() bits of data. Note that bits in multiple rows are not
+ * 							packed.
+ */
+void tdispCreateChar(uint8_t address, uint8_t *charmap);
+
+/**
+ * @brief	Draws a single character at the current cursor position and advances the cursor
+ *
+ * @param[in] c		The character to be drawn
+ *
+ * @note			Writing past the end of a row leaves the cursor in an undefined position.
+ */
+void tdispDrawChar(char c);
+
+/**
+ * @brief	Draws a string at the current cursor position and advances the cursor
+ *
+ * @param[in] s		The string to be drawn
+ *
+ * @note			Any characters written past the end of a row may or may not be displayed on
+ * 					the next row. The cursor is also left in an undefined position.
+ */
+void tdispDrawString(char *s);
+
 /**
  * @brief	Control different display properties
  * @note	A wrapper macro exists for each option, please use them
- *			instead of this function manually.
+ *			instead of this function manually unless calling a low
+ *			level driver specific value.
  *
  * @param[in] what		What you want to control
  * @param[in] value		The value to be assigned
@@ -76,69 +154,50 @@ bool_t tdispInit(void);
 void tdispControl(uint16_t what, void *value);
 
 /**
- * @brief	Clears the display
+ * @brief	Set the backlight level
+ *
+ * @param[in] percent	A percentage from 0 to 100%. 0% will turn off the display
  */
-void tdispClear(void);
+#define tdispSetBacklight(percent)		tdispControl(TDISP_CTRL_BACKLIGHT, (void *)((uint8_t)(percent)))
 
 /**
- * @brief	Sets the cursor to it's home position ( 0/0 )
+ * @brief	Set the cursor shape
+ *
+ * @param[in] shape	The shape to set the cursor.
+ *
+ * @note			Not all shapes are necessarily supported. The driver will make a similar
+ * 					choice if the one specified is not available.
  */
-void tdispHome(void);
+#define tdispSetCursorShape(shape)		tdispControl(TDISP_CTRL_CURSOR, (void *)((cursorshape)(shape)))
 
 /**
- * @brief	Set cursor to a certain position
- *
- * @param[in] col	The column
- * @param[in] row	The row
+ * @brief	Get the number of columns (width) in the display
  */
-void tdispSetCursor(coord_t col, coord_t row);
+#define tdispGetColumns()				(TDISP.columns)
 
 /**
- * @brief	Store a custom character in RAM
- *
- * @note	This usually must be done after each power-up since most
- *			LCDs lose their RAM content.
- *
- * @param[in] address		On which address to store the character (from 0 up to max)
- * @param[in] charmap		The character to be stored.
+ * @brief	Get the number of rows (height) in the display
  */
-void tdispCreateChar(uint8_t address, char *charmap);
+#define tdispGetRows()					(TDISP.columns)
 
 /**
- * @brief	Draws a single character at the current cursor position
- *
- * @param[in] c		The character to be drawn
+ * @brief	Get the number of bits in width of a character
  */
-void tdispDrawChar(char c);
+#define tdispGetCharBitWidth()			(TDISP.charBitsX)
 
 /**
- * @brief	Draws a string at the current cursor position
- *
- * @param[in] s		The string to be drawn
+ * @brief	Get the number of bits in height of a character
  */
-void tdispDrawString(char *s);
+#define tdispGetCharBitHeight()			(TDISP.charBitsY)
 
 /**
- * @brief	Draws a single character at a given position
- * @note	This function manipulates the cursor position and it will not be
- *			reset to it's original state
- *
- * @param[in] col	The column
- * @param[in] row	The row
- * @param[in] c		The character to be drawn
+ * @brief	Get the number of custom characters
  */
-void tdispDrawCharLocation(coord_t col, coord_t row, char c);
+#define tdispGetNumCustomChars()		(TDISP.maxCustomChars)
 
-/**
- * @brief	Draws a string at a given position
- * @note	This function manipulates the cursor position and it will not be
- *			reset to it's original state
- *
- * @param[in] col	The column
- * @param[in] row	The row
- * @param[in] s		The string to be drawn
- */
-void tdispDrawStringLocation(coord_t col, coord_t row, char *s);
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GFX_USE_TDISP */
 

src/gadc/gadc.c

@@ -1,5 +1,5 @@
 /*
-    ChibiOS/GFX - Copyright (C) 2012
+    ChibiOS/GFX - Copyright (C) 2012, 2013
                  Joel Bodenmann aka Tectu <joel@unormal.org>
 
     This file is part of ChibiOS/GFX.
@@ -29,9 +29,436 @@
 #include "hal.h"
 #include "gfx.h"
 
-#if GFX_USE_GADC || defined(__DOXYGEN__)
+#if GFX_USE_GADC
 
-	#error "GADC: Not implemented yet"
+/* Include the driver defines */
+#include "gadc/lld/gadc_lld.h"
+
+#if GADC_MAX_HIGH_SPEED_SAMPLERATE > GADC_MAX_SAMPLE_FREQUENCY/2
+	#error "GADC: GADC_MAX_HIGH_SPEED_SAMPLERATE has been set too high. It must be less than half the maximum CPU rate"
+#endif
+
+#define GADC_MAX_LOWSPEED_DEVICES	((GADC_MAX_SAMPLE_FREQUENCY/GADC_MAX_HIGH_SPEED_SAMPLERATE)-1)
+#if GADC_MAX_LOWSPEED_DEVICES > 4
+	#undef GADC_MAX_LOWSPEED_DEVICES
+	#define GADC_MAX_LOWSPEED_DEVICES	4
+#endif
+
+volatile bool_t GADC_Timer_Missed;
+
+static SEMAPHORE_DECL(gadcsem, GADC_MAX_LOWSPEED_DEVICES);
+static MUTEX_DECL(gadcmutex);
+static GTIMER_DECL(LowSpeedGTimer);
+#if GFX_USE_GEVENT
+	static GTIMER_DECL(HighSpeedGTimer);
+#endif
+
+static volatile uint16_t	gflags = 0;
+	#define GADC_GFLG_INITDONE	0x0001
+	#define GADC_GFLG_ISACTIVE	0x0002
+
+#define GADC_FLG_ISACTIVE	0x0001
+#define GADC_FLG_ISDONE		0x0002
+#define GADC_FLG_ERROR		0x0004
+#define GADC_FLG_GTIMER		0x0008
+
+static struct hsdev {
+	// Our status flags
+	uint16_t				flags;
+
+	// What we started with
+	uint32_t				frequency;
+	adcsample_t				*buffer;
+	size_t					bufcount;
+	size_t					samplesPerEvent;
+
+	// The last set of results
+	size_t					lastcount;
+	adcsample_t				*lastbuffer;
+	uint16_t				lastflags;
+
+	// Other stuff we need to track progress and for signalling
+	GadcLldTimerData		lld;
+	size_t					samplesPerConversion;
+	size_t					remaining;
+	BinarySemaphore			*bsem;
+	GEventADC				*pEvent;
+	} hs;
+
+static struct lsdev {
+	// Our status flags
+	uint16_t				flags;
+
+	// What we started with
+	GadcLldNonTimerData		lld;
+	GADCCallbackFunction	fn;
+	void					*param;
+	} ls[GADC_MAX_LOWSPEED_DEVICES];
+
+static struct lsdev *curlsdev;
+
+/* Find the next conversion to activate */
+static __inline void FindNextConversionI(void) {
+	if (curlsdev) {
+		/**
+		 * Now we have done a low speed conversion - start looking for the next conversion
+		 * We only look forward to ensure we get a high speed conversion at least once
+		 * every GADC_MAX_LOWSPEED_DEVICES conversions.
+		 */
+		curlsdev++;
+
+	} else {
+
+		/* Now we have done a high speed conversion - start looking for low speed conversions */
+		curlsdev = ls;
+	}
+
+	/**
+	 * Look for the next thing to do.
+	 */
+	while(curlsdev < &ls[GADC_MAX_LOWSPEED_DEVICES]) {
+		if ((curlsdev->flags & (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) == GADC_FLG_ISACTIVE) {
+			gadc_lld_adc_nontimerI(&curlsdev->lld);
+			return;
+		}
+		curlsdev++;
+	}
+	curlsdev = 0;
+
+	/* No more low speed devices - do a high speed conversion */
+	if (hs.flags & GADC_FLG_ISACTIVE) {
+		hs.lld.now = GADC_Timer_Missed ? TRUE : FALSE;
+		GADC_Timer_Missed = 0;
+		gadc_lld_adc_timerI(&hs.lld);
+		return;
+	}
+
+	/* Nothing more to do */
+	gflags &= ~GADC_GFLG_ISACTIVE;
+}
+
+void GADC_ISR_CompleteI(ADCDriver *adcp, adcsample_t *buffer, size_t n) {
+	(void) adcp;
+
+	if (curlsdev) {
+		/* This interrupt must be in relation to the low speed device */
+
+		if (curlsdev->flags & GADC_FLG_ISACTIVE) {
+			/**
+			 * As we only handle a single low speed conversion at a time, we know
+			 * we know we won't get any half completion interrupts.
+			 */
+			curlsdev->flags |= GADC_FLG_ISDONE;
+			gtimerJabI(&LowSpeedGTimer);
+		}
+
+		#if ADC_ISR_FULL_CODE_BUG
+			/**
+			 * Oops - We have just finished a low speed conversion but a bug prevents us
+			 * restarting the ADC here. Other code will restart it in the thread based
+			 * ADC handler.
+			 */
+			gflags &= ~GADC_GFLG_ISACTIVE;
+			return;
+
+		#endif
+
+	} else {
+		/* This interrupt must be in relation to the high speed device */
+
+		if (hs.flags & GADC_FLG_ISACTIVE) {
+			/* Save the details */
+			hs.lastcount = n;
+			hs.lastbuffer = buffer;
+			hs.lastflags = GADC_Timer_Missed ? GADC_HSADC_LOSTEVENT : 0;
+
+			/* Signal the user with the data */
+			if (hs.pEvent) {
+				#if GFX_USE_GEVENT
+					hs.pEvent->type = GEVENT_ADC;
+				#endif
+				hs.pEvent->count = hs.lastcount;
+				hs.pEvent->buffer = hs.lastbuffer;
+				hs.pEvent->flags = hs.lastflags;
+			}
+			if (hs.bsem)
+				chBSemSignalI(hs.bsem);
+
+			#if GFX_USE_GEVENT
+				if (hs.flags & GADC_FLG_GTIMER)
+					gtimerJabI(&HighSpeedGTimer);
+			#endif
+
+			/* Adjust what we have left to do */
+			hs.lld.count -= n;
+			hs.remaining -= n;
+
+			/* Half completion - We have done all we can for now - wait for the next interrupt */
+			if (hs.lld.count)
+				return;
+
+			/* Our buffer is cyclic - set up the new buffer pointers */
+			if (hs.remaining) {
+				hs.lld.buffer = buffer + (n * hs.samplesPerConversion);
+			} else {
+				hs.remaining = hs.bufcount;
+				hs.lld.buffer = hs.buffer;
+			}
+			hs.lld.count = hs.remaining < hs.samplesPerEvent ? hs.remaining : hs.samplesPerEvent;
+		}
+	}
+
+	/**
+	 * Look for the next thing to do.
+	 */
+	FindNextConversionI();
+}
+
+void GADC_ISR_ErrorI(ADCDriver *adcp, adcerror_t err) {
+	(void) adcp;
+	(void) err;
+
+	if (curlsdev) {
+		if ((curlsdev->flags & (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) == GADC_FLG_ISACTIVE)
+			/* Mark the error then try to repeat it */
+			curlsdev->flags |= GADC_FLG_ERROR;
+
+		#if ADC_ISR_FULL_CODE_BUG
+			/**
+			 * Oops - We have just finished a low speed conversion but a bug prevents us
+			 * restarting the ADC here. Other code will restart it in the thread based
+			 * ADC handler.
+			 */
+			gflags &= ~GADC_GFLG_ISACTIVE;
+			gtimerJabI(&LowSpeedGTimer);
+			return;
+
+		#endif
+
+	} else {
+		if (hs.flags & GADC_FLG_ISACTIVE)
+			/* Mark the error and then try to repeat it */
+			hs.flags |= GADC_FLG_ERROR;
+	}
+
+	/* Start the next conversion */
+	FindNextConversionI();
+}
+
+static __inline void DoInit(void) {
+	if (!(gflags & GADC_GFLG_INITDONE)) {
+		gflags |= GADC_GFLG_INITDONE;
+		gadc_lld_init();
+	}
+}
+
+static __inline void StartADC(bool_t onNoHS) {
+	chSysLock();
+	if (!(gflags & GADC_GFLG_ISACTIVE) || (onNoHS && !curlsdev))
+		FindNextConversionI();
+	chSysUnlock();
+}
+
+static void BSemSignalCallback(adcsample_t *buffer, void *param) {
+	(void) buffer;
+
+	/* Signal the BinarySemaphore parameter */
+	chBSemSignal((BinarySemaphore *)param);
+}
+
+#if GFX_USE_GEVENT
+	static void HighSpeedGTimerCallback(void *param) {
+		(void) param;
+		GSourceListener	*psl;
+		GEventADC		*pe;
+
+		psl = 0;
+		while ((psl = geventGetSourceListener((GSourceHandle)(&HighSpeedGTimer), psl))) {
+			if (!(pe = (GEventADC *)geventGetEventBuffer(psl))) {
+				// This listener is missing - save this.
+				psl->srcflags |= GADC_HSADC_LOSTEVENT;
+				continue;
+			}
+
+			pe->type = GEVENT_ADC;
+			pe->count = hs.lastcount;
+			pe->buffer = hs.lastbuffer;
+			pe->flags = hs.lastflags | psl->srcflags;
+			psl->srcflags = 0;
+			geventSendEvent(psl);
+		}
+	}
+#endif
+
+static void LowSpeedGTimerCallback(void *param) {
+	(void) param;
+	GADCCallbackFunction	fn;
+	void					*prm;
+	adcsample_t				*buffer;
+	struct lsdev			*p;
+
+	#if ADC_ISR_FULL_CODE_BUG
+		/* Ensure the ADC is running if it needs to be - Bugfix HACK */
+		StartADC(FALSE);
+	#endif
+
+	/**
+	 * Look for completed low speed timers.
+	 * We don't need to take the mutex as we are the only place that things are freed and we
+	 * do that atomically.
+	 */
+	for(p=ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
+		if ((p->flags & (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) == (GADC_FLG_ISACTIVE|GADC_FLG_ISDONE)) {
+			/* This item is done - perform its callback */
+			fn = p->fn;				// Save the callback details
+			prm = p->param;
+			buffer = p->lld.buffer;
+			p->fn = 0;				// Needed to prevent the compiler removing the local variables
+			p->param = 0;			// Needed to prevent the compiler removing the local variables
+			p->lld.buffer = 0;		// Needed to prevent the compiler removing the local variables
+			p->flags = 0;			// The slot is available (indivisible operation)
+			chSemSignal(&gadcsem);	// Tell everyone
+			fn(buffer, prm);		// Perform the callback
+		}
+	}
+
+}
+
+void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency, adcsample_t *buffer, size_t bufcount, size_t samplesPerEvent)
+{
+	gadcHighSpeedStop();		/* This does the init for us */
+
+	/* Just save the details and reset everything for now */
+	hs.frequency = frequency;
+	hs.buffer = buffer;
+	hs.bufcount = bufcount;
+	hs.samplesPerEvent = samplesPerEvent;
+	hs.lastcount = 0;
+	hs.lastbuffer = 0;
+	hs.lastflags = 0;
+	hs.lld.physdev = physdev;
+	hs.lld.buffer = buffer;
+	hs.lld.count = samplesPerEvent;
+	hs.lld.now = FALSE;
+	hs.samplesPerConversion = gadc_lld_samples_per_conversion(physdev);
+	hs.remaining = bufcount;
+	hs.bsem = 0;
+	hs.pEvent = 0;
+}
+
+#if GFX_USE_GEVENT
+	GSourceHandle gadcHighSpeedGetSource(void) {
+		DoInit();
+		if (!gtimerIsActive(&HighSpeedGTimer))
+			gtimerStart(&HighSpeedGTimer, HighSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
+		hs.flags |= GADC_FLG_GTIMER;
+		return (GSourceHandle)&HighSpeedGTimer;
+	}
+#endif
+
+void gadcHighSpeedSetBSem(BinarySemaphore *pbsem, GEventADC *pEvent) {
+	DoInit();
+
+	/* Use the system lock to ensure they occur atomically */
+	chSysLock();
+	hs.pEvent = pEvent;
+	hs.bsem = pbsem;
+	chSysUnlock();
+}
+
+void gadcHighSpeedStart(void) {
+	DoInit();
+
+	/* If its already going we don't need to do anything */
+	if (hs.flags & GADC_FLG_ISACTIVE)
+		return;
+
+	gadc_lld_start_timer(hs.lld.physdev, hs.frequency);
+	hs.flags = GADC_FLG_ISACTIVE;
+	StartADC(FALSE);
+}
+
+void gadcHighSpeedStop(void) {
+	DoInit();
+
+	if (hs.flags & GADC_FLG_ISACTIVE) {
+		/* No more from us */
+		hs.flags = 0;
+		gadc_lld_stop_timer(hs.lld.physdev);
+		/*
+		 * We have to pass TRUE to StartADC() as we might have the ADC marked as active when it isn't
+		 * due to stopping the timer while it was converting.
+		 */
+		StartADC(TRUE);
+	}
+}
+
+void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer) {
+	struct lsdev *p;
+	BSEMAPHORE_DECL(mysem, TRUE);
+
+	/* Start the Low Speed Timer */
+	chMtxLock(&gadcmutex);
+	if (!gtimerIsActive(&LowSpeedGTimer))
+		gtimerStart(&LowSpeedGTimer, LowSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
+	chMtxUnlock();
+
+	while(1) {
+		/* Wait for an available slot */
+		chSemWait(&gadcsem);
+
+		/* Find a slot */
+		chMtxLock(&gadcmutex);
+		for(p = ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
+			if (!(p->flags & GADC_FLG_ISACTIVE)) {
+				p->lld.physdev = physdev;
+				p->lld.buffer = buffer;
+				p->fn = BSemSignalCallback;
+				p->param = &mysem;
+				p->flags = GADC_FLG_ISACTIVE;
+				chMtxUnlock();
+				StartADC(FALSE);
+				chBSemWait(&mysem);
+				return;
+			}
+		}
+		chMtxUnlock();
+
+		/**
+		 *  We should never get here - the count semaphore must be wrong.
+		 *  Decrement it and try again.
+		 */
+	}
+}
+
+bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param) {
+	struct lsdev *p;
+
+	DoInit();
+
+	/* Start the Low Speed Timer */
+	chMtxLock(&gadcmutex);
+	if (!gtimerIsActive(&LowSpeedGTimer))
+		gtimerStart(&LowSpeedGTimer, LowSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
+
+	/* Find a slot */
+	for(p = ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
+		if (!(p->flags & GADC_FLG_ISACTIVE)) {
+			/* We know we have a slot - this should never wait anyway */
+			chSemWaitTimeout(&gadcsem, TIME_IMMEDIATE);
+			p->lld.physdev = physdev;
+			p->lld.buffer = buffer;
+			p->fn = fn;
+			p->param = param;
+			p->flags = GADC_FLG_ISACTIVE;
+			chMtxUnlock();
+			StartADC(FALSE);
+			return TRUE;
+		}
+	}
+	chMtxUnlock();
+	return FALSE;
+}
 
 #endif /* GFX_USE_GADC */
 /** @} */

src/gdisp/gdisp.c

@@ -95,7 +95,7 @@
 
 			/* OK - we need to obtain the mutex in case a synchronous operation is occurring */
 			chMtxLock(&gdispMutex);
-			lld_gdisp_msg_dispatch(pmsg);
+			gdisp_lld_msg_dispatch(pmsg);
 			chMtxUnlock();
 
 			/* Mark the message as free */
@@ -153,7 +153,7 @@
 
 		/* Initialise driver */
 		chMtxLock(&gdispMutex);
-		res = lld_gdisp_init();
+		res = gdisp_lld_init();
 		chMtxUnlock();
 
 		return res;
@@ -180,7 +180,7 @@
 
 		/* Initialise driver - synchronous */
 		chMtxLock(&gdispMutex);
-		res = lld_gdisp_init();
+		res = gdisp_lld_init();
 		chMtxUnlock();
 
 		return res;
@@ -216,7 +216,7 @@
 	 */
 	void gdispClear(color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_clear(color);
+		gdisp_lld_clear(color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ASYNC
@@ -238,7 +238,7 @@
 	 */
 	void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_draw_pixel(x, y, color);
+		gdisp_lld_draw_pixel(x, y, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ASYNC
@@ -263,7 +263,7 @@
 	 */
 	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_draw_line(x0, y0, x1, y1, color);
+		gdisp_lld_draw_line(x0, y0, x1, y1, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ASYNC
@@ -290,7 +290,7 @@
 	 */
 	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_fill_area(x, y, cx, cy, color);
+		gdisp_lld_fill_area(x, y, cx, cy, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ASYNC
@@ -326,7 +326,7 @@
 	 */
 	void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
+		gdisp_lld_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ASYNC
@@ -355,7 +355,7 @@
 	 */
 	void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_set_clip(x, y, cx, cy);
+		gdisp_lld_set_clip(x, y, cx, cy);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_CLIP && GDISP_NEED_ASYNC
@@ -381,7 +381,7 @@
 	 */
 	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_draw_circle(x, y, radius, color);
+		gdisp_lld_draw_circle(x, y, radius, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC
@@ -407,7 +407,7 @@
 	 */
 	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_fill_circle(x, y, radius, color);
+		gdisp_lld_fill_circle(x, y, radius, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC
@@ -433,7 +433,7 @@
 	 */
 	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_draw_ellipse(x, y, a, b, color);
+		gdisp_lld_draw_ellipse(x, y, a, b, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC
@@ -460,7 +460,7 @@
 	 */
 	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_fill_ellipse(x, y, a, b, color);
+		gdisp_lld_fill_ellipse(x, y, a, b, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC
@@ -489,7 +489,7 @@
 	 */
 	void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_draw_arc(x, y, radius, start, end, color);
+		gdisp_lld_draw_arc(x, y, radius, start, end, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ARC && GDISP_NEED_ASYNC
@@ -520,7 +520,7 @@
 	 */
 	void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_fill_arc(x, y, radius, start, end, color);
+		gdisp_lld_fill_arc(x, y, radius, start, end, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_ARC && GDISP_NEED_ASYNC
@@ -605,7 +605,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
 	 */
 	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_draw_char(x, y, c, font, color);
+		gdisp_lld_draw_char(x, y, c, font, color);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC
@@ -634,7 +634,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
 	 */
 	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_fill_char(x, y, c, font, color, bgcolor);
+		gdisp_lld_fill_char(x, y, c, font, color, bgcolor);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC
@@ -664,7 +664,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
 
 		/* Always synchronous as it must return a value */
 		chMtxLock(&gdispMutex);
-		c = lld_gdisp_get_pixel_color(x, y);
+		c = gdisp_lld_get_pixel_color(x, y);
 		chMtxUnlock();
 
 		return c;
@@ -687,7 +687,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
 	 */
 	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor);
+		gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor);
 		chMtxUnlock();
 	}
 #elif GDISP_NEED_SCROLL && GDISP_NEED_ASYNC
@@ -717,7 +717,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
 	 */
 	void gdispControl(unsigned what, void *value) {
 		chMtxLock(&gdispMutex);
-		lld_gdisp_control(what, value);
+		gdisp_lld_control(what, value);
 		chMtxUnlock();
 		chThdSleepMilliseconds(100);
 	}
@@ -746,7 +746,7 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
 		void *res;
 
 		chMtxLock(&gdispMutex);
-		res = lld_gdisp_query(what);
+		res = gdisp_lld_query(what);
 		chMtxUnlock();
 		return res;
 	}

src/tdisp/tdisp.c

@@ -31,55 +31,87 @@
 
 #if GFX_USE_TDISP || defined(__DOXYGEN__)
 
-static uint8_t _displaycontrol;
+#include "tdisp/lld/tdisp_lld.h"
+
+#if TDISP_NEED_MULTITHREAD
+	#if !CH_USE_MUTEXES
+		#error "TDISP: CH_USE_MUTEXES must be defined in chconf.h because TDISP_NEED_MULTITHREAD is defined"
+	#endif
+
+	static Mutex			tdispMutex;
+
+	#define MUTEX_INIT()	chMtxInit(&tdispMutex)
+	#define MUTEX_ENTER()	chMtxLock(&tdispMutex)
+	#define MUTEX_LEAVE()	chMtxUnlock()
+
+#else
+
+	#define MUTEX_INIT()
+	#define MUTEX_ENTER()
+	#define MUTEX_LEAVE()
+
+#endif
 
 bool_t tdispInit(void) {
-	bool_t ret;
+	bool_t		res;
 
-	ret = tdisp_lld_init();
+	MUTEX_INIT();
 
-	return ret;
-}
+	MUTEX_ENTER();
+	res = tdisp_lld_init();
+	MUTEX_LEAVE();
 
-void tdispControl(uint16_t what, void *value) {
-	tdisp_lld_control(what, value);
+	return res;
 }
 
 void tdispClear(void) {
+	MUTEX_ENTER();
 	tdisp_lld_clear();
+	MUTEX_LEAVE();
 }
 
 void tdispHome(void) {
-	tdisp_lld_home();
-}
-
-void tdispCreateChar(uint8_t address, char *charmap) {
-	tdisp_lld_create_char(address, charmap);
+	MUTEX_ENTER();
+	tdisp_lld_set_cursor(0, 0);
+	MUTEX_LEAVE();
 }
 
 void tdispSetCursor(coord_t col, coord_t row) {
+	/* Keep the input range valid */
+	if (row >= TDISP.rows)
+		row = TDISP.rows - 1;
+	MUTEX_ENTER();
 	tdisp_lld_set_cursor(col, row);
+	MUTEX_LEAVE();
+}
+
+void tdispCreateChar(uint8_t address, uint8_t *charmap) {
+	/* make sure we don't write somewhere we're not supposed to */
+	if (address < TDISP.maxCustomChars) {
+		MUTEX_ENTER();
+		tdisp_lld_create_char(address, charmap);
+		MUTEX_LEAVE();
+	}
 }
 
 void tdispDrawChar(char c) {
-	tdisp_lld_write_data(c);
+	MUTEX_ENTER();
+	tdisp_lld_draw_char(c);
+	MUTEX_LEAVE();
 }
 
 void tdispDrawString(char *s) {
+	MUTEX_ENTER();
 	while(*s)
-		tdispDrawChar(*s++);
+		tdisp_lld_draw_char(*s++);
+	MUTEX_LEAVE();
 }
 
-void tdispDrawCharLocation(coord_t col, coord_t row, char c) {
-	tdispSetCursor(col, row);
-	tdispDrawChar(c);
-}
-
-void tdispDrawStringLocation(coord_t col, coord_t row, char *s) {
-	tdispSetCursor(col, row);
-	tdispDrawString(s);
+void tdispControl(uint16_t what, void *value) {
+	MUTEX_ENTER();
+	tdisp_lld_control(what, value);
+	MUTEX_LEAVE();
 }
 
 #endif /* GFX_USE_TDISP */
 /** @} */
-