From 8f9c956810cc2cc66306d41b8501b366eab9c035 Mon Sep 17 00:00:00 2001 From: Andrew Hannam Date: Thu, 9 Aug 2012 17:12:45 +1000 Subject: Multi-thread, Async Multi-thread & VMT --- halext/include/gdisp.h | 131 ++++------ halext/include/gdisp_emulation.c | 549 +++++++++++++++++++++++++++++++++++++++ halext/include/gdisp_lld.h | 235 ++++++++++++----- halext/include/gdisp_lld_msgs.h | 165 ++++++++++++ halext/include/glcd.h | 61 +++-- 5 files changed, 983 insertions(+), 158 deletions(-) create mode 100644 halext/include/gdisp_emulation.c create mode 100644 halext/include/gdisp_lld_msgs.h (limited to 'halext/include') diff --git a/halext/include/gdisp.h b/halext/include/gdisp.h index ddb12137..4963043b 100644 --- a/halext/include/gdisp.h +++ b/halext/include/gdisp.h @@ -68,79 +68,41 @@ * @{ */ /** - * @brief Should all operations be clipped to the screen and colors validated. - * @details Defaults to TRUE. - * @note If this is FALSE, any operations that extend beyond the - * edge of the screen will have undefined results. Any - * out-of-range colors will produce undefined results. - * @note If defined then all low level and high level driver routines - * must check the validity of inputs and do something sensible - * if they are out of range. It doesn't have to be efficient, - * just valid. - */ - #ifndef GDISP_NEED_VALIDATION - #define GDISP_NEED_VALIDATION TRUE - #endif - - /** - * @brief Are circle functions needed. - * @details Defaults to TRUE - */ - #ifndef GDISP_NEED_CIRCLE - #define GDISP_NEED_CIRCLE TRUE - #endif - - /** - * @brief Are ellipse functions needed. - * @details Defaults to TRUE - */ - #ifndef GDISP_NEED_ELLIPSE - #define GDISP_NEED_ELLIPSE TRUE - #endif - - /** - * @brief Are text functions needed. - * @details Defaults to TRUE - */ - #ifndef GDISP_NEED_TEXT - #define GDISP_NEED_TEXT TRUE - #endif - - /** - * @brief Is scrolling needed. - * @details Defaults to FALSE - */ - #ifndef GDISP_NEED_SCROLL - #define GDISP_NEED_SCROLL FALSE - #endif - - /** - * @brief Is the capability to read pixels back needed. - * @details Defaults to FALSE - */ - #ifndef GDISP_NEED_PIXELREAD - #define GDISP_NEED_PIXELREAD FALSE - #endif - - /** - * @brief Control some aspect of the drivers operation. + * @brief Do the drawing functions need to be thread-safe. * @details Defaults to FALSE + * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make + * the gdisp API thread-safe. + * @note This is more efficient than GDISP_NEED_ASYNC as it only + * requires a context switch if something else is already + * drawing. */ - #ifndef GDISP_NEED_CONTROL - #define GDISP_NEED_CONTROL FALSE + #ifndef GDISP_NEED_MULTITHREAD + #define GDISP_NEED_MULTITHREAD FALSE #endif /** - * @brief Do the drawing functions need to be thread-safe. + * @brief Use asynchronous calls (multi-thread safe). * @details Defaults to FALSE + * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make + * the gdisp API thread-safe. * @note Turning this on adds two context switches per transaction * so it can significantly slow graphics drawing. */ - #ifndef GDISP_NEED_MULTITHREAD - #define GDISP_NEED_MULTITHREAD FALSE + #ifndef GDISP_NEED_ASYNC + #define GDISP_NEED_ASYNC FALSE #endif /** @} */ +#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC + #error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined." +#endif + +#if GDISP_NEED_ASYNC + /* Messaging API is required for Async Multi-Thread */ + #undef GDISP_NEED_MSGAPI + #define GDISP_NEED_MSGAPI TRUE +#endif + /*===========================================================================*/ /* Low Level Driver details and error checks. */ /*===========================================================================*/ @@ -190,17 +152,18 @@ extern const struct font fontLargeNumbersNarrow; extern "C" { #endif -#if GDISP_NEED_MULTITHREAD +#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC /* Base Functions */ - void gdispInit(GDISPDriver *gdisp); + bool_t gdispInit(GDISPDriver *gdisp); + bool_t gdispIsBusy(void); /* Drawing Functions */ void gdispClear(color_t color); void gdispDrawPixel(coord_t x, coord_t y, color_t color); void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color); void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); - void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer); + void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer); /* Circle Functions */ #if GDISP_NEED_CIRCLE @@ -218,7 +181,6 @@ extern "C" { #if GDISP_NEED_TEXT void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color); void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor); - void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color); #endif /* Read a pixel Function */ @@ -233,27 +195,34 @@ extern "C" { /* Set driver specific control */ #if GDISP_NEED_CONTROL - void gdispControl(int what, void *value); + void gdispControl(unsigned what, void *value); + #endif + + /* Query driver specific data */ + #if GDISP_NEED_CONTROL + void *gdispQuery(unsigned what); #endif #else /* The same as above but use the low level driver directly if no multi-thread support is needed */ - #define gdispInit(gdisp) gdisp_lld_init() - #define gdispClear(color) gdisp_lld_clear(color) - #define gdispDrawPixel(x, y, color) gdisp_lld_drawpixel(x, y, color) - #define gdispDrawLine(x0, y0, x1, y1, color) gdisp_lld_drawline(x0, y0, x1, y1, color) - #define gdispFillArea(x, y, cx, cy, color) gdisp_lld_fillarea(x, y, cx, cy, color) - #define gdispBlitArea(x, y, cx, cy, buffer) gdisp_lld_blitarea(x, y, cx, cy, buffer) - #define gdispDrawCircle(x, y, radius, color) gdisp_lld_drawcircle(x, y, radius, color) - #define gdispFillCircle(x, y, radius, color) gdisp_lld_fillcircle(x, y, radius, color) - #define gdispDrawEllipse(x, y, a, b, color) gdisp_lld_drawellipse(x, y, a, b, color) - #define gdispFillEllipse(x, y, a, b, color) gdisp_lld_fillellipse(x, y, a, b, color) - #define gdispDrawChar(x, y, c, font, color) gdisp_lld_drawchar(x, y, c, font, color) - #define gdispFillChar(x, y, c, font, color, bgcolor) gdisp_lld_fillchar(x, y, c, font, color, bgcolor) - #define gdispGetPixelColor(x, y) gdisp_lld_getpixelcolor(x, y) - #define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) gdisp_lld_verticalscroll(x, y, cx, cy, lines, bgcolor) - #define gdispControl(what, value) gdisp_lld_control(what, value) + #define gdispInit(gdisp) GDISP_LLD(init)() + #define gdispIsBusy() FALSE + #define gdispClear(color) GDISP_LLD(clear)(color) + #define gdispDrawPixel(x, y, color) GDISP_LLD(drawpixel)(x, y, color) + #define gdispDrawLine(x0, y0, x1, y1, color) GDISP_LLD(drawline)(x0, y0, x1, y1, color) + #define gdispFillArea(x, y, cx, cy, color) GDISP_LLD(fillarea)(x, y, cx, cy, color) + #define gdispBlitArea(x, y, cx, cy, buffer) GDISP_LLD(blitarea)(x, y, cx, cy, buffer) + #define gdispDrawCircle(x, y, radius, color) GDISP_LLD(drawcircle)(x, y, radius, color) + #define gdispFillCircle(x, y, radius, color) GDISP_LLD(fillcircle)(x, y, radius, color) + #define gdispDrawEllipse(x, y, a, b, color) GDISP_LLD(drawellipse)(x, y, a, b, color) + #define gdispFillEllipse(x, y, a, b, color) GDISP_LLD(fillellipse)(x, y, a, b, color) + #define gdispDrawChar(x, y, c, font, color) GDISP_LLD(drawchar)(x, y, c, font, color) + #define gdispFillChar(x, y, c, font, color, bgcolor) GDISP_LLD(fillchar)(x, y, c, font, color, bgcolor) + #define gdispGetPixelColor(x, y) GDISP_LLD(getpixelcolor)(x, y) + #define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) GDISP_LLD(verticalscroll)(x, y, cx, cy, lines, bgcolor) + #define gdispControl(what, value) GDISP_LLD(control)(what, value) + #define gdispQuery(what) GDISP_LLD(query)(what) #endif diff --git a/halext/include/gdisp_emulation.c b/halext/include/gdisp_emulation.c new file mode 100644 index 00000000..cb3773a7 --- /dev/null +++ b/halext/include/gdisp_emulation.c @@ -0,0 +1,549 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + Emulation routines included into gdisp_lld.c +*/ + +/* + Even though this is a software emulation of a low level driver + most validation doesn't need to happen here as eventually + we call a real low level driver routine and if validation is + required - it will do it. +*/ +#ifndef GDISP_EMULATION_C +#define GDISP_EMULATION_C + +#if HAL_USE_GDISP || defined(__DOXYGEN__) + +#ifdef UNUSED +#elif defined(__GNUC__) +# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) +#elif defined(__LCLINT__) +# define UNUSED(x) /*@unused@*/ x +#else +# define UNUSED(x) x +#endif + +#ifndef GDISP_LLD_NO_STRUCT + static struct GDISPDriver { + coord_t Width; + coord_t Height; + gdisp_orientation_t Orientation; + gdisp_powermode_t Powermode; + coord_t Backlight; + coord_t Contrast; + } GDISP; +#endif + +#if !GDISP_HARDWARE_CLEARS + void GDISP_LLD(clear)(color_t color) { + GDISP_LLD(fillarea)(0, 0, GDISP.Width, GDISP.Height, color); + } +#endif + +#if !GDISP_HARDWARE_LINES + void GDISP_LLD(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) { + int16_t dy, dx; + int16_t addx, addy; + int16_t P, diff, i; + + #if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL + // speed improvement if vertical or horizontal + if (x0 == x1) { + if (y1 > y0) + GDISP_LLD(fillarea)(x0, y0, 1, y1-y0+1, color); + else + GDISP_LLD(fillarea)(x0, y1, 1, y0-y1+1, color); + return; + } + if (y0 == y1) { + if (x1 > x0) + GDISP_LLD(fillarea)(x0, y0, x1-x0+1, 1, color); + else + GDISP_LLD(fillarea)(x0, y1, x0-x1+1, 1, color); + return; + } + #endif + + if (x1 >= x0) { + dx = x1 - x0; + addx = 1; + } else { + dx = x0 - x1; + addx = -1; + } + if (y1 >= y0) { + dy = y1 - y0; + addy = 1; + } else { + dy = y0 - y1; + addy = -1; + } + + if (dx >= dy) { + dy *= 2; + P = dy - dx; + diff = P - dx; + + for(i=0; i<=dx; ++i) { + GDISP_LLD(drawpixel)(x0, y0, color); + if (P < 0) { + P += dy; + x0 += addx; + } else { + P += diff; + x0 += addx; + y0 += addy; + } + } + } else { + dx *= 2; + P = dx - dy; + diff = P - dy; + + for(i=0; i<=dy; ++i) { + GDISP_LLD(drawpixel)(x0, y0, color); + if (P < 0) { + P += dx; + y0 += addy; + } else { + P += diff; + x0 += addx; + y0 += addy; + } + } + } + } +#endif + +#if !GDISP_HARDWARE_FILLS + void GDISP_LLD(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) { + #if GDISP_HARDWARE_SCROLL + GDISP_LLD(verticalscroll)(x, y, cx, cy, cy, color); + #elif GDISP_HARDWARE_LINES + coord_t x1, y1; + + x1 = x + cx - 1; + y1 = y + cy; + for(; y < y1; y++) + GDISP_LLD(drawline)(x, y, x1, y, color); + #else + coord_t x0, x1, y1; + + x0 = x; + x1 = x + cx; + y1 = y + cy; + for(; y < y1; y++) + for(x = x0; x < x1; x++) + GDISP_LLD(drawpixel)(x, y, color); + #endif + } +#endif + +#if !GDISP_HARDWARE_BITFILLS + void GDISP_LLD(blitarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer) { + coord_t x0, x1, y1; + + x0 = x; + x1 = x + cx; + y1 = y + cy; + for(; y < y1; y++) + for(x = x0; x < x1; x++) + GDISP_LLD(drawpixel)(x, y, *buffer++); + } +#endif + +#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES + void GDISP_LLD(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color) { + int16_t a, b, P; + + a = 0; + b = radius; + P = 1 - radius; + + do { + GDISP_LLD(drawpixel)(a+x, b+y, color); + GDISP_LLD(drawpixel)(b+x, a+y, color); + GDISP_LLD(drawpixel)(x-a, b+y, color); + GDISP_LLD(drawpixel)(x-b, a+y, color); + GDISP_LLD(drawpixel)(b+x, y-a, color); + GDISP_LLD(drawpixel)(a+x, y-b, color); + GDISP_LLD(drawpixel)(x-a, y-b, color); + GDISP_LLD(drawpixel)(x-b, y-a, color); + if (P < 0) + P += 3 + 2*a++; + else + P += 5 + 2*(a++ - b--); + } while(a <= b); + } +#endif + +#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS + void GDISP_LLD(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color) { + int16_t a, b, P; + + a = 0; + b = radius; + P = 1 - radius; + + do { + GDISP_LLD(drawline)(x-a, y+b, x+a, y+b, color); + GDISP_LLD(drawline)(x-a, y-b, x+a, y-b, color); + GDISP_LLD(drawline)(x-b, y+a, x+b, y+a, color); + GDISP_LLD(drawline)(x-b, y-a, x+b, y-a, color); + if (P < 0) + P += 3 + 2*a++; + else + P += 5 + 2*(a++ - b--); + } while(a <= b); + } +#endif + +#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES + void GDISP_LLD(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) { + int dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */ + long a2 = a*a, b2 = b*b; + long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */ + + do { + GDISP_LLD(drawpixel)(x+dx, y+dy, color); /* I. Quadrant */ + GDISP_LLD(drawpixel)(x-dx, y+dy, color); /* II. Quadrant */ + GDISP_LLD(drawpixel)(x-dx, y-dy, color); /* III. Quadrant */ + GDISP_LLD(drawpixel)(x+dx, y-dy, color); /* IV. Quadrant */ + + e2 = 2*err; + if(e2 < (2*dx+1)*b2) { + dx++; + err += (2*dx+1)*b2; + } + if(e2 > -(2*dy-1)*a2) { + dy--; + err -= (2*dy-1)*a2; + } + } while(dy >= 0); + + while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */ + GDISP_LLD(drawpixel)(x+dx, y, color); /* -> Spitze der Ellipse vollenden */ + GDISP_LLD(drawpixel)(x-dx, y, color); + } + } +#endif + +#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS + void GDISP_LLD(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) { + int dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */ + long a2 = a*a, b2 = b*b; + long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */ + + do { + GDISP_LLD(drawline)(x-dx,y+dy,x+dx,y+dy, color); + GDISP_LLD(drawline)(x-dx,y-dy,x+dx,y-dy, color); + + e2 = 2*err; + if(e2 < (2*dx+1)*b2) { + dx++; + err += (2*dx+1)*b2; + } + if(e2 > -(2*dy-1)*a2) { + dy--; + err -= (2*dy-1)*a2; + } + } while(dy >= 0); + + while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */ + GDISP_LLD(drawpixel)(x+dx, y, color); /* -> Spitze der Ellipse vollenden */ + GDISP_LLD(drawpixel)(x-dx, y, color); + } + } +#endif + +#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT + #include "gdisp_fonts.h" +#endif + +#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT + void GDISP_LLD(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color) { + const fontcolumn_t *ptr; + fontcolumn_t column; + coord_t width, height, xscale, yscale; + coord_t i, j, xs, ys; + + /* Check we actually have something to print */ + width = _getCharWidth(font, c); + if (!width) return; + + xscale = font->xscale; + yscale = font->yscale; + height = font->height * yscale; + width *= xscale; + + ptr = _getCharData(font, c); + + /* Loop through the data and display. The font data is LSBit first, down the column */ + for(i=0; i < width; i+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j=0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + GDISP_LLD(drawpixel)(x+i+xs, y+j+ys, color); + } + } + } + } +#endif + +#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS + void GDISP_LLD(fillchar)(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) { + coord_t width, height; + coord_t xscale, yscale; + + /* Check we actually have something to print */ + width = _getCharWidth(font, c); + if (!width) return; + + xscale = font->xscale; + yscale = font->yscale; + height = font->height * yscale; + width *= xscale; + + /* Method 1: Use background fill and then draw the text */ + #if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW + + /* Fill the area */ + GDISP_LLD(fillarea)(x, y, width, height, bgcolor); + + /* Draw the text */ + GDISP_LLD(drawchar)(x, y, c, font, color); + + /* Method 2: Create a single column bitmap and then blit it */ + #elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN + { + const fontcolumn_t *ptr; + fontcolumn_t column; + coord_t i, j, xs, ys; + + /* Working buffer for fast non-transparent text rendering [patch by Badger] + This needs to be larger than the largest character we can print. + Assume the max is double sized by one column. + */ + static pixel_t buf[sizeof(fontcolumn_t)*8*2]; + + #if GDISP_NEED_VALIDATION + /* Check our buffer is big enough */ + if (height > sizeof(buf)/sizeof(buf[0])) return; + #endif + + ptr = _getCharData(font, c); + + /* Loop through the data and display. The font data is LSBit first, down the column */ + for(i = 0; i < width; i+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j = 0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, 1, j+ys, 0, color); + } else { + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, 1, j+ys, 0, bgcolor); + } + } + + for(xs=0; xs < xscale; xs++) + GDISP_LLD(blitarea)(x+i+xs, y, 1, height, buf); + } + } + + /* Method 3: Create a character bitmap and then blit it */ + #elif GDISP_HARDWARE_BITFILLS + { + const fontcolumn_t *ptr; + fontcolumn_t column; + coord_t i, j, xs, ys; + + /* Working buffer for fast non-transparent text rendering [patch by Badger] + This needs to be larger than the largest character we can print. + Assume the max is double sized. + */ + static pixel_t buf[20*(sizeof(fontcolumn_t)*8)*2]; + + #if GDISP_NEED_VALIDATION + /* Check our buffer is big enough */ + if ((unsigned)(width * height) > sizeof(buf)/sizeof(buf[0])) return; + #endif + + ptr = _getCharData(font, c); + + /* Loop through the data and display. The font data is LSBit first, down the column */ + for(i = 0; i < width; i+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j = 0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, width, i+xs, j+ys, color); + } else { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, width, i+xs, j+ys, bgcolor); + } + } + } + + /* [Patch by Badger] Write all in one stroke */ + GDISP_LLD(blitarea)(x, y, width, height, buf); + } + + /* Method 4: Draw pixel by pixel */ + #else + { + const fontcolumn_t *ptr; + fontcolumn_t column; + coord_t i, j, xs, ys; + + ptr = _getCharData(font, c); + + /* Loop through the data and display. The font data is LSBit first, down the column */ + for(i = 0; i < width; i+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j = 0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + GDISP_LLD(drawpixel)(x+i, y+j, color); + } else { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + GDISP_LLD(drawpixel)(x+i, y+j, bgcolor); + } + } + } + } + #endif + } +#endif + + +#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL + void GDISP_LLD(control)(unsigned UNUSED(what), void *UNUSED(value)) { + /* Ignore everything */ + } +#endif + +#if GDISP_NEED_QUERY && !GDISP_HARDWARE_QUERY +void *GDISP_LLD(query)(unsigned what) { + switch(what) { + case GDISP_QUERY_WIDTH: return (void *)(unsigned)GDISP.Width; + case GDISP_QUERY_HEIGHT: return (void *)(unsigned)GDISP.Height; + case GDISP_QUERY_POWER: return (void *)(unsigned)GDISP.Powermode; + case GDISP_QUERY_ORIENTATION: return (void *)(unsigned)GDISP.Orientation; + case GDISP_QUERY_BACKLIGHT: return (void *)(unsigned)GDISP.Backlight; + case GDISP_QUERY_CONTRAST: return (void *)(unsigned)GDISP.Contrast; + default: return (void *)-1; + } +} +#endif + +#if GDISP_NEED_MSGAPI + void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg) { + switch(msg->action) { + case GDISP_LLD_MSG_NOP: + break; + case GDISP_LLD_MSG_INIT: + GDISP_LLD(init)(); + break; + case GDISP_LLD_MSG_CLEAR: + GDISP_LLD(clear)(msg->clear.color); + break; + case GDISP_LLD_MSG_DRAWPIXEL: + GDISP_LLD(drawpixel)(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color); + break; + case GDISP_LLD_MSG_FILLAREA: + GDISP_LLD(fillarea)(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color); + break; + case GDISP_LLD_MSG_BLITAREA: + GDISP_LLD(blitarea)(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.buffer); + break; + case GDISP_LLD_MSG_DRAWLINE: + GDISP_LLD(drawline)(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color); + break; + #if GDISP_NEED_CIRCLE + case GDISP_LLD_MSG_DRAWCIRCLE: + GDISP_LLD(drawcircle)(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color); + break; + case GDISP_LLD_MSG_FILLCIRCLE: + GDISP_LLD(fillcircle)(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color); + break; + #endif + #if GDISP_NEED_ELLIPSE + case GDISP_LLD_MSG_DRAWELLIPSE: + GDISP_LLD(drawellipse)(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color); + break; + case GDISP_LLD_MSG_FILLELLIPSE: + GDISP_LLD(fillellipse)(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color); + break; + #endif + #if GDISP_NEED_TEXT + case GDISP_LLD_MSG_DRAWCHAR: + GDISP_LLD(drawchar)(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color); + break; + case GDISP_LLD_MSG_FILLCHAR: + GDISP_LLD(fillchar)(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor); + break; + #endif + #if GDISP_NEED_PIXELREAD + case GDISP_LLD_MSG_GETPIXELCOLOR: + msg->getpixelcolor.result = GDISP_LLD(getpixelcolor)(msg->getpixelcolor.x, msg->getpixelcolor.y); + break; + #endif + #if GDISP_NEED_SCROLL + case GDISP_LLD_MSG_VERTICALSCROLL: + GDISP_LLD(verticalscroll)(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor); + break; + #endif + #if GDISP_NEED_CONTROL + case GDISP_LLD_MSG_CONTROL: + GDISP_LLD(control)(msg->control.what, msg->control.value); + break; + #endif + #if GDISP_NEED_QUERY + case GDISP_LLD_MSG_QUERY: + msg->query.result = GDISP_LLD(query)(msg->query.what); + break; + #endif + } + } +#endif + +#endif /* HAL_USE_GDISP */ +#endif /* GDISP_EMULATION_C */ diff --git a/halext/include/gdisp_lld.h b/halext/include/gdisp_lld.h index e9edbe96..bf083a4f 100644 --- a/halext/include/gdisp_lld.h +++ b/halext/include/gdisp_lld.h @@ -30,6 +30,94 @@ #if HAL_USE_GDISP || defined(__DOXYGEN__) +/*===========================================================================*/ +/* Low level driver configuration needs */ +/*===========================================================================*/ + +/** + * @name GDISP low level driver more complex functionality to be compiled + * @{ + */ + /** + * @brief Should all operations be clipped to the screen and colors validated. + * @details Defaults to TRUE. + * @note If this is FALSE, any operations that extend beyond the + * edge of the screen will have undefined results. Any + * out-of-range colors will produce undefined results. + * @note If defined then all low level and high level driver routines + * must check the validity of inputs and do something sensible + * if they are out of range. It doesn't have to be efficient, + * just valid. + */ + #ifndef GDISP_NEED_VALIDATION + #define GDISP_NEED_VALIDATION TRUE + #endif + + /** + * @brief Are circle functions needed. + * @details Defaults to TRUE + */ + #ifndef GDISP_NEED_CIRCLE + #define GDISP_NEED_CIRCLE TRUE + #endif + + /** + * @brief Are ellipse functions needed. + * @details Defaults to TRUE + */ + #ifndef GDISP_NEED_ELLIPSE + #define GDISP_NEED_ELLIPSE TRUE + #endif + + /** + * @brief Are text functions needed. + * @details Defaults to TRUE + */ + #ifndef GDISP_NEED_TEXT + #define GDISP_NEED_TEXT TRUE + #endif + + /** + * @brief Is scrolling needed. + * @details Defaults to FALSE + */ + #ifndef GDISP_NEED_SCROLL + #define GDISP_NEED_SCROLL FALSE + #endif + + /** + * @brief Is the capability to read pixels back needed. + * @details Defaults to FALSE + */ + #ifndef GDISP_NEED_PIXELREAD + #define GDISP_NEED_PIXELREAD FALSE + #endif + + /** + * @brief Control some aspect of the drivers operation. + * @details Defaults to FALSE + */ + #ifndef GDISP_NEED_CONTROL + #define GDISP_NEED_CONTROL FALSE + #endif + + /** + * @brief Query some aspect of the drivers operation. + * @details Defaults to TRUE + */ + #ifndef GDISP_NEED_QUERY + #define GDISP_NEED_QUERY TRUE + #endif + + /** + * @brief Is the messaging api interface required. + * @details Defaults to FALSE + */ + #ifndef GDISP_NEED_MSGAPI + #define GDISP_NEED_MSGAPI FALSE + #endif +/** @} */ + /*===========================================================================*/ /* Include the low level driver configuration information */ /*===========================================================================*/ @@ -60,6 +148,39 @@ #define GDISP_CONTROL_CONTRAST 3 #define GDISP_CONTROL_LLD 1000 +/** + * @brief Driver Query Constants + * @detail Unsupported query codes return (void *)-1. + * @note There are some predefined and some specific to the low level driver. + * @note The result should be typecast the required type. + * @note GDISP_QUERY_WIDTH - Gets the width of the screen + * GDISP_QUERY_HEIGHT - Gets the height of the screen + * GDISP_QUERY_POWER - Get the current powermode + * GDISP_QUERY_ORIENTATION - Get the current orientation + * GDISP_QUERY_BACKLIGHT - Get the backlight state (0 to 100) + * GDISP_QUERY_CONTRAST - Get the contrast. + * GDISP_QUERY_LLD - Low level driver control constants start at + * this value. + */ +#define GDISP_QUERY_WIDTH 0 +#define GDISP_QUERY_HEIGHT 1 +#define GDISP_QUERY_POWER 2 +#define GDISP_QUERY_ORIENTATION 3 +#define GDISP_QUERY_BACKLIGHT 4 +#define GDISP_QUERY_CONTRAST 5 +#define GDISP_QUERY_LLD 1000 + +/** + * @brief Driver Pixel Format Constants + */ +#define GDISP_PIXELFORMAT_RGB565 565 +#define GDISP_PIXELFORMAT_RGB888 888 +#define GDISP_PIXELFORMAT_RGB444 444 +#define GDISP_PIXELFORMAT_RGB332 332 +#define GDISP_PIXELFORMAT_RGB666 666 +#define GDISP_PIXELFORMAT_CUSTOM 99999 +#define GDISP_PIXELFORMAT_ERROR 88888 + /*===========================================================================*/ /* Error checks. */ /*===========================================================================*/ @@ -171,6 +292,14 @@ #ifndef GDISP_HARDWARE_CONTROL #define GDISP_HARDWARE_CONTROL FALSE #endif + + /** + * @brief The driver supports a non-standard query. + * @details If set to @p FALSE there is no support for non-standard queries. + */ + #ifndef GDISP_HARDWARE_QUERY + #define GDISP_HARDWARE_QUERY FALSE + #endif /** @} */ /** @@ -205,19 +334,21 @@ */ /** * @brief The native pixel format for this device - * @note One of the following should be defined: + * @note Should be set to one of the following: * GDISP_PIXELFORMAT_RGB565 * GDISP_PIXELFORMAT_RGB888 * GDISP_PIXELFORMAT_RGB444 * GDISP_PIXELFORMAT_RGB332 * GDISP_PIXELFORMAT_RGB666 * GDISP_PIXELFORMAT_CUSTOM - * @note If you define GDISP_PIXELFORMAT_CUSTOM you need to also define + * @note If you set GDISP_PIXELFORMAT_CUSTOM you need to also define * color_t, RGB2COLOR(r,g,b), HTML2COLOR(h), * RED_OF(c), GREEN_OF(c), BLUE_OF(c), * COLOR(c) and MASKCOLOR. */ - #define GDISP_PIXELFORMAT_XXXXXX + #ifndef GDISP_PIXELFORMAT + #define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_ERROR + #endif /** * @brief Do pixels require packing for a blit @@ -287,7 +418,7 @@ */ #define BLUE_OF(c) (((c)&0x001F)<<3) -#elif defined(GDISP_PIXELFORMAT_RGB565) +#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565 typedef uint16_t color_t; #define COLOR(c) ((color_t)(c)) #define MASKCOLOR FALSE @@ -299,7 +430,7 @@ #define RGB565CONVERT(red, green, blue) (uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 )) -#elif defined(GDISP_PIXELFORMAT_RGB888) +#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888 typedef uint32_t color_t; #define COLOR(c) ((color_t)(((c) & 0xFFFFFF))) #define MASKCOLOR TRUE @@ -309,7 +440,7 @@ #define GREEN_OF(c) (((c)&0x00FF00)>>8) #define BLUE_OF(c) ((c)&0x0000FF) -#elif defined(GDISP_PIXELFORMAT_RGB444) +#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444 typedef uint16_t color_t; #define COLOR(c) ((color_t)(((c) & 0x0FFF))) #define MASKCOLOR TRUE @@ -319,7 +450,7 @@ #define GREEN_OF(c) ((c)&0x00F0) #define BLUE_OF(c) (((c)&0x000F)<<4) -#elif defined(GDISP_PIXELFORMAT_RGB332) +#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332 typedef uint8_t color_t; #define COLOR(c) ((color_t)(c)) #define MASKCOLOR FALSE @@ -329,7 +460,7 @@ #define GREEN_OF(c) (((c)&0x1C)<<3) #define BLUE_OF(c) (((c)&0x03)<<6) -#elif defined(GDISP_PIXELFORMAT_RGB666) +#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666 typedef uint32_t color_t; #define COLOR(c) ((color_t)(((c) & 0x03FFFF))) #define MASKCOLOR TRUE @@ -339,7 +470,7 @@ #define GREEN_OF(c) (((c)&0x00FC00)>>8) #define BLUE_OF(c) (((c)&0x00003F)<<2) -#elif !defined(GDISP_PIXELFORMAT_CUSTOM) +#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM #error "GDISP: No supported pixel format has been specified." #endif @@ -348,10 +479,10 @@ #define gdispPackPixels(buf,cx,x,y,c) { ((color_t *)(buf))[(y)*(cx)+(x)] = (c); } #elif !GDISP_HARDWARE_BITFILLS #error "GDISP: packed pixel formats are only supported for hardware accelerated drivers." -#elif !defined(GDISP_PIXELFORMAT_RGB888) \ - && !defined(GDISP_PIXELFORMAT_RGB444) \ - && !defined(GDISP_PIXELFORMAT_RGB666) \ - && !defined(GDISP_PIXELFORMAT_CUSTOM) +#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \ + && GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \ + && GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \ + && GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM #error "GDISP: A packed pixel format has been specified for an unsupported pixel format." #endif @@ -392,44 +523,13 @@ typedef enum orientation {portrait, landscape, portraitInv, landscapeInv} gdisp_ */ typedef enum powermode {powerOff, powerSleep, powerOn} gdisp_powermode_t; -/** - * @brief Structure representing a GDISP driver. - * @note Implementations may extend this structure to contain more, - * architecture dependent, fields by defining GDISP_DRIVER_EXT_FIELDS - */ -struct GDISPDriver { - /** - * @brief Width of the screen. - * @note Read-only. - */ - coord_t Width; - /** - * @brief Height of the screen. - * @note Read-only. - */ - coord_t Height; - /** - * @brief Current orientation of the screen. - * @note Read-only. - */ - gdisp_orientation_t Orientation; - /** - * @brief Current power mode of the screen. - * @note Read-only. - */ - gdisp_powermode_t Powermode; - - #if defined(GDISP_DRIVER_EXT_FIELDS) - GDISP_DRIVER_EXT_FIELDS - #endif -}; - /*===========================================================================*/ /* External declarations. */ /*===========================================================================*/ -#if !defined(__DOXYGEN__) - extern GDISPDriver GDISP; +#ifndef GDISP_LLD_VMT + /* Special magic stuff for the VMT driver */ + #define GDISP_LLD_VMT(x) GDISP_LLD(x) #endif #ifdef __cplusplus @@ -437,49 +537,60 @@ extern "C" { #endif /* Core functions */ - void gdisp_lld_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 gdisp_lld_config.h. */ /* Drawing functions */ - void gdisp_lld_clear(color_t color); - void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color); - void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); - void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer); - void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color); + extern void GDISP_LLD_VMT(clear)(color_t color); + extern void GDISP_LLD_VMT(drawpixel)(coord_t x, coord_t y, color_t color); + extern void GDISP_LLD_VMT(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); + extern void GDISP_LLD_VMT(blitarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer); + extern void GDISP_LLD_VMT(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color); /* Circular Drawing Functions */ #if GDISP_NEED_CIRCLE - void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color); - void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color); + extern void GDISP_LLD_VMT(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color); + extern void GDISP_LLD_VMT(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color); #endif #if GDISP_NEED_ELLIPSE - void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); - void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); + extern void GDISP_LLD_VMT(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); + extern void GDISP_LLD_VMT(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); #endif /* Text Rendering Functions */ #if GDISP_NEED_TEXT - void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color); - void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor); + extern void GDISP_LLD_VMT(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color); + extern void GDISP_LLD_VMT(fillchar)(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor); #endif /* Pixel readback */ #if GDISP_NEED_PIXELREAD - color_t gdisp_lld_getpixelcolor(coord_t x, coord_t y); + extern color_t GDISP_LLD_VMT(getpixelcolor)(coord_t x, coord_t y); #endif /* Scrolling Function - clears the area scrolled out */ #if GDISP_NEED_SCROLL - void gdisp_lld_verticalscroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor); + extern void GDISP_LLD_VMT(verticalscroll)(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor); #endif /* Set driver specific control */ #if GDISP_NEED_CONTROL - void gdisp_lld_control(int what, void *value); + extern void GDISP_LLD_VMT(control)(unsigned what, void *value); + #endif + + /* Query driver specific data */ + #if GDISP_NEED_QUERY + extern void *GDISP_LLD_VMT(query)(unsigned what); + #endif + + /* Messaging API */ + #if GDISP_NEED_MSGAPI + #include "gdisp_lld_msgs.h" + extern void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg); #endif #ifdef __cplusplus diff --git a/halext/include/gdisp_lld_msgs.h b/halext/include/gdisp_lld_msgs.h new file mode 100644 index 00000000..28a6707e --- /dev/null +++ b/halext/include/gdisp_lld_msgs.h @@ -0,0 +1,165 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/** + * @file gdisp_lld_msgs.h + * @brief GDISP Graphic Driver subsystem low level driver message structures. + * + * @addtogroup GDISP + * @{ + */ + +#ifndef _GDISP_LLD_MSGS_H +#define _GDISP_LLD_MSGS_H + +/* This file describes the message API for gdisp_lld */ +#if HAL_USE_GDISP && GDISP_NEED_MSGAPI + +typedef enum gdisp_msgaction { + GDISP_LLD_MSG_NOP, + GDISP_LLD_MSG_INIT, + GDISP_LLD_MSG_CLEAR, + GDISP_LLD_MSG_DRAWPIXEL, + GDISP_LLD_MSG_FILLAREA, + GDISP_LLD_MSG_BLITAREA, + GDISP_LLD_MSG_DRAWLINE, + #if GDISP_NEED_CIRCLE + GDISP_LLD_MSG_DRAWCIRCLE, + GDISP_LLD_MSG_FILLCIRCLE, + #endif + #if GDISP_NEED_ELLIPSE + GDISP_LLD_MSG_DRAWELLIPSE, + GDISP_LLD_MSG_FILLELLIPSE, + #endif + #if GDISP_NEED_TEXT + GDISP_LLD_MSG_DRAWCHAR, + GDISP_LLD_MSG_FILLCHAR, + #endif + #if GDISP_NEED_PIXELREAD + GDISP_LLD_MSG_GETPIXELCOLOR, + #endif + #if GDISP_NEED_SCROLL + GDISP_LLD_MSG_VERTICALSCROLL, + #endif + #if GDISP_NEED_CONTROL + GDISP_LLD_MSG_CONTROL, + #endif + #if GDISP_NEED_QUERY + GDISP_LLD_MSG_QUERY, + #endif +} gdisp_msgaction_t; + +typedef union gdisp_lld_msg { + gdisp_msgaction_t action; + struct gdisp_lld_msg_init { + gdisp_msgaction_t action; // GDISP_LLD_MSG_INIT + } init; + struct gdisp_lld_msg_clear { + gdisp_msgaction_t action; // GDISP_LLD_MSG_CLEAR + color_t color; + } clear; + struct gdisp_lld_msg_drawpixel { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWPIXEL + coord_t x, y; + color_t color; + } drawpixel; + struct gdisp_lld_msg_fillarea { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLAREA + coord_t x, y; + coord_t cx, cy; + color_t color; + } fillarea; + struct gdisp_lld_msg_blitarea { + gdisp_msgaction_t action; // GDISP_LLD_MSG_BLITAREA + coord_t x, y; + coord_t cx, cy; + const pixel_t *buffer; + } blitarea; + struct gdisp_lld_msg_drawline { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWLINE + coord_t x0, y0; + coord_t x1, y1; + color_t color; + } drawline; + struct gdisp_lld_msg_drawcircle { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCIRCLE + coord_t x, y; + coord_t radius; + color_t color; + } drawcircle; + struct gdisp_lld_msg_fillcircle { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCIRCLE + coord_t x, y; + coord_t radius; + color_t color; + } fillcircle; + struct gdisp_lld_msg_drawellipse { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWELLIPSE + coord_t x, y; + coord_t a, b; + color_t color; + } drawellipse; + struct gdisp_lld_msg_fillellipse { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLELLIPSE + coord_t x, y; + coord_t a, b; + color_t color; + } fillellipse; + struct gdisp_lld_msg_drawchar { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCHAR + coord_t x, y; + char c; + font_t font; + color_t color; + } drawchar; + struct gdisp_lld_msg_fillchar { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCHAR + coord_t x, y; + char c; + font_t font; + color_t color; + color_t bgcolor; + } fillchar; + struct gdisp_lld_msg_getpixelcolor { + gdisp_msgaction_t action; // GDISP_LLD_MSG_GETPIXELCOLOR + coord_t x, y; + color_t result; + } getpixelcolor; + struct gdisp_lld_msg_verticalscroll { + gdisp_msgaction_t action; // GDISP_LLD_MSG_VERTICALSCROLL + coord_t x, y; + coord_t cx, cy; + int lines; + color_t bgcolor; + } verticalscroll; + struct gdisp_lld_msg_control { + gdisp_msgaction_t action; // GDISP_LLD_MSG_CONTROL + int what; + void * value; + } control; + struct gdisp_lld_msg_query { + gdisp_msgaction_t action; // GDISP_LLD_MSG_QUERY + int what; + void * result; + } query; +} gdisp_lld_msg_t; + +#endif /* HAL_USE_GDISP */ +#endif /* _GDISP_LLD_MSGS_H */ +/** @} */ diff --git a/halext/include/glcd.h b/halext/include/glcd.h index 54c5158d..670d160e 100644 --- a/halext/include/glcd.h +++ b/halext/include/glcd.h @@ -24,6 +24,8 @@ some code changes may be necessary. Note it does not replicate the GLCD low level driver, just the high level interface. + You may also need to define the various GDISP_NEED_XXX in your + halconf.h in order to turn on the functionality you need. */ #ifndef GLCD_H @@ -38,10 +40,8 @@ #define RGB565CONVERT(r, g, b) RGB2COLOR(r,g,b) -enum orientation {portrait, landscape, portraitInv, landscapeInv}; enum filled {frame, filled}; enum transparency {solid, transparent}; -enum powermode {powerOff, powerOn, sleepOn, sleepOff}; #define sleepOn powerSleep #define sleepOff powerOn @@ -70,14 +70,33 @@ typedef enum glcd_result glcd_result_t; /* Core functions */ #define lcdInit(dvr) gdispInit(dvr) -#define lcdClear(color) (gdispClear(color), GLCD_DONE) -#define lcdSetOrientation(newO) (gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(int)newO), (GDISP1.Orientation == (newO) ? GLCD_DONE : GLCD_FAILED)) -#define lcdFillArea(x0,y0,x1,y1,c) (gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)), GLCD_DONE) -#define lcdWriteArea(x0,y0,x1,y1,b,n) (gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b)), GLCD_DONE) -#define lcdSetPowerMode(pm) (gdispControl(GDISP_CONTROL_POWER, (void *)(int)pm), (GDISP1.Powermode == (pm) ? GLCD_DONE : GLCD_FAILED)) +static __inline glcd_result_t lcdClear(color_t color) { + gdispClear(color); + return GLCD_DONE; +} +static __inline glcd_result_t lcdSetOrientation(enum orientation newO) { + gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(int)newO); + return ((enum orientation)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) == (newO) ? GLCD_DONE : GLCD_FAILED; +} +static __inline glcd_result_t lcdFillArea(coord_t x0, coord_t y0, coord_t x1, coord_t y1,color_t c) { + gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)); + return GLCD_DONE; +} +static __inline glcd_result_t lcdWriteArea(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const pixel_t *b, coord_t n) { + (void)n; + gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b)); + return GLCD_DONE; +} +static __inline glcd_result_t lcdSetPowerMode(enum powermode pm) { + gdispControl(GDISP_CONTROL_POWER, (void *)(int)pm); + return ((enum powermode)(unsigned)gdispQuery(GDISP_QUERY_POWER)) == (pm) ? GLCD_DONE : GLCD_FAILED; +} /* Drawing functions */ -#define lcdDrawPixel(x,y,c) (gdispDrawPixel((x),(y),(c)), GLCD_DONE) +static __inline glcd_result_t lcdDrawPixel(coord_t x, coord_t y, color_t c) { + gdispDrawPixel((x),(y),(c)); + return GLCD_DONE; +} #define lcdDrawLine(x0,y0,x1,y1,c) gdispDrawLine((x0),(y0),(x1),(y1),(c)) #define lcdDrawRect(x0,y0,x1,y1,f,c) {if(f) gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)); else gdispDrawBox((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c));} #define lcdDrawRectString(x0,y0,x1,y1,s,f,c,b) gdispFillStringBox((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(s),(f),(c),(b),justifyLeft) @@ -85,18 +104,30 @@ typedef enum glcd_result glcd_result_t; #define lcdDrawEllipse(x,y,a,b,f,c) {if(f) gdispFillEllipse((x),(y),(a),(b),(c)); else gdispDrawEllipse((x),(y),(a),(b),(c));} /* Text Rendering Functions */ -#define lcdDrawChar(x,y,h,f,c,b,t) ({if(t) gdispDrawChar((x),(y),(h),(f),(c)); else gdispFillChar((x),(y),(h),(f),(c),(b));}, (gdispGetCharWidth((h),(f))+(f)->charPadding)) -#define lcdDrawString(x,y,s,f,c,b,t) ({if(t) gdispDrawString((x),(y),(s),(f),(c)); else gdispFillString((x),(y),(s),(f),(c),(b));}, (gdispGetStringWidth((s),(f))+(f)->charPadding)) +static __inline coord_t lcdDrawChar(coord_t x, coord_t y, char h, font_t f, color_t c, color_t b, bool_t t) { + if (t) + gdispDrawChar((x),(y),(h),(f),(c)); + else + gdispFillChar((x),(y),(h),(f),(c),(b)); + return gdispGetCharWidth((h),(f))+gdispGetFontMetric((f), fontCharPadding); +} +static __inline coord_t lcdDrawString(coord_t x, coord_t y, const char *s, font_t f, color_t c, color_t b, bool_t t) { + if (t) + gdispDrawString((x),(y),(s),(f),(c)); + else + gdispFillString((x),(y),(s),(f),(c),(b)); + return gdispGetStringWidth((s),(f))+gdispGetFontMetric((f), fontCharPadding); +} /* Character measuring functions */ -#define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(f))+(f)->charPadding) -#define lcdMeasureString(s,f) (gdispGetStringWidth((s),(f))+(f)->charPadding) +#define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(f))+gdispGetFontMetric((f), fontCharPadding)) +#define lcdMeasureString(s,f) (gdispGetStringWidth((s),(f))+gdispGetFontMetric((f), fontCharPadding)) #define lcdGetFontHeight(f) gdispGetFontMetric((f), fontHeight) /* Size and orientation related */ -#define lcdGetHeight() (GDISP.Height) -#define lcdGetWidth() (GDISP.Width) -#define lcdGetOrientation() (GDISP.Orientation) +#define lcdGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT)) +#define lcdGetWidth() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH)) +#define lcdGetOrientation() ((enum orientation)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) /* BGR->RGB and pixel readback */ #define lcdBGR2RGB(c) RGB2COLOR(BLUE_OF(c),GREEN_OF(c),RED_OF(c)) -- cgit v1.2.3