uGFX/ugfx
2
0
Fork 0
Code Issues 2 Pull requests Projects Releases Wiki Activity

more GDISP_LLD() cleanup

Browse source
This commit is contained in:
Joel Bodenmann 2013-02-11 10:26:34 +01:00
parent 1bfc5a9f85
commit 60b16e8685
24 changed files with 58 additions and 547 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
drivers/gdisp/ILI9320/gdisp_lld.c
View file

@ -81,28 +81,28 @@ static __inline void lld_lcdDelay(uint16_t us) {
} }
static __inline void lld_lcdWriteIndex(uint16_t index) { static __inline void lld_lcdWriteIndex(uint16_t index) {
GDISP_LLD(write_index)(index); lld_gdisp_write_index(index);
} }
static __inline void lld_lcdWriteData(uint16_t data) { static __inline void lld_lcdWriteData(uint16_t data) {
GDISP_LLD(write_data)(data); lld_gdisp_write_data(data);
} }
static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) { static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
GDISP_LLD(write_index)(lcdReg); lld_gdisp_write_index(lcdReg);
GDISP_LLD(write_data)(lcdRegValue); lld_gdisp_write_data(lcdRegValue);
} }
static __inline uint16_t lld_lcdReadData(void) { static __inline uint16_t lld_lcdReadData(void) {
/* fix this! */ /* fix this! */
//return GDISP_LLD(read_data); //return lld_gdisp_read_data;
return GDISP_RAM; return GDISP_RAM;
} }
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) { static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
volatile uint16_t dummy; volatile uint16_t dummy;
GDISP_LLD(write_index)(lcdReg); lld_gdisp_write_index(lcdReg);
dummy = lld_lcdReadData(); dummy = lld_lcdReadData();
(void)dummy; (void)dummy;
@ -145,12 +145,12 @@ static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
bool_t lld_gdisp_init(void) { bool_t lld_gdisp_init(void) {
/* Initialise your display */ /* Initialise your display */
GDISP_LLD(init_board)(); lld_gdisp_init_board();
/* Hardware reset */ /* Hardware reset */
GDISP_LLD(setpin_reset)(TRUE); lld_gdisp_reset_pin(TRUE);
lld_lcdDelay(1000); lld_lcdDelay(1000);
GDISP_LLD(setpin_reset)(FALSE); lld_gdisp_reset_pin(FALSE);
lld_lcdDelay(1000); lld_lcdDelay(1000);
DISPLAY_CODE = lld_lcdReadReg(0); DISPLAY_CODE = lld_lcdReadReg(0);
@ -215,7 +215,7 @@ bool_t lld_gdisp_init(void) {
lld_lcdWriteReg(0x0007, 0x0173); //display On lld_lcdWriteReg(0x0007, 0x0173); //display On
// Turn on the backlight // Turn on the backlight
GDISP_LLD(set_backlight)(GDISP_INITIAL_BACKLIGHT); lld_gdisp_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */ /* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH; GDISP.Width = GDISP_SCREEN_WIDTH;
@ -457,7 +457,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0011, 0x0000); lld_lcdWriteReg(0x0011, 0x0000);
lld_lcdWriteReg(0x0012, 0x0000); lld_lcdWriteReg(0x0012, 0x0000);
lld_lcdWriteReg(0x0013, 0x0000); lld_lcdWriteReg(0x0013, 0x0000);
GDISP_LLD(set_backlight)(0); lld_gdisp_backlight(0);
break; break;
case powerOn: case powerOn:
@ -476,7 +476,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */ lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */
lld_lcdDelay(500); lld_lcdDelay(500);
lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */ lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */
GDISP_LLD(set_backlight)(GDISP.Backlight); lld_gdisp_backlight(GDISP.Backlight);
if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep) if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep)
lld_gdisp_init(); lld_gdisp_init();
break; break;
@ -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_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */ lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */ lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
GDISP_LLD(set_backlight)(0); lld_gdisp_backlight(0);
break; break;
case powerDeepSleep: 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_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */ lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */ lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
GDISP_LLD(set_backlight)(0); lld_gdisp_backlight(0);
break; break;
default: default:
@ -554,7 +554,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
case GDISP_CONTROL_BACKLIGHT: case GDISP_CONTROL_BACKLIGHT:
if((unsigned)value > 100) value = (void *)100; if((unsigned)value > 100) value = (void *)100;
GDISP_LLD(set_backlight)((unsigned)value); lld_gdisp_backlight((unsigned)value);
GDISP.Backlight = (unsigned)value; GDISP.Backlight = (unsigned)value;
break; break;

12
drivers/gdisp/ILI9320/gdisp_lld_board_example.h
View file

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

12
drivers/gdisp/ILI9320/gdisp_lld_board_olimex_stm32_lcd.h
View file

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

1
drivers/gdisp/ILI9320/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "ILI9320" #define GDISP_DRIVER_NAME "ILI9320"
#define GDISP_LLD(x) gdisp_lld_##x##_ILI9320
#define GDISP_HARDWARE_CLEARS TRUE #define GDISP_HARDWARE_CLEARS TRUE
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE

30
drivers/gdisp/ILI9325/gdisp_lld.c
View file

@ -81,28 +81,28 @@ static __inline void lld_lcdDelay(uint16_t us) {
} }
static __inline void lld_lcdWriteIndex(uint16_t index) { static __inline void lld_lcdWriteIndex(uint16_t index) {
GDISP_LLD(write_index)(index); lld_gdisp_write_index(index);
} }
static __inline void lld_lcdWriteData(uint16_t data) { static __inline void lld_lcdWriteData(uint16_t data) {
GDISP_LLD(write_data)(data); lld_gdisp_write_data(data);
} }
static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) { static __inline void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
GDISP_LLD(write_index)(lcdReg); lld_gdisp_write_index(lcdReg);
GDISP_LLD(write_data)(lcdRegValue); lld_gdisp_write_data(lcdRegValue);
} }
static __inline uint16_t lld_lcdReadData(void) { static __inline uint16_t lld_lcdReadData(void) {
/* fix this! */ /* fix this! */
//return GDISP_LLD(read_data); //return lld_gdisp_read_data;
return GDISP_RAM; return GDISP_RAM;
} }
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) { static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
volatile uint16_t dummy; volatile uint16_t dummy;
GDISP_LLD(write_index)(lcdReg); lld_gdisp_write_index(lcdReg);
dummy = lld_lcdReadData(); dummy = lld_lcdReadData();
(void)dummy; (void)dummy;
@ -145,12 +145,12 @@ static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
bool_t lld_gdisp_init(void) { bool_t lld_gdisp_init(void) {
/* Initialise your display */ /* Initialise your display */
GDISP_LLD(init_board)(); lld_gdisp_init_board();
/* Hardware reset */ /* Hardware reset */
GDISP_LLD(setpin_reset)(TRUE); lld_gdisp_reset_pin(TRUE);
lld_lcdDelay(1000); lld_lcdDelay(1000);
GDISP_LLD(setpin_reset)(FALSE); lld_gdisp_reset_pin(FALSE);
lld_lcdDelay(1000); lld_lcdDelay(1000);
// chinese code starts here // chinese code starts here
@ -210,7 +210,7 @@ bool_t lld_gdisp_init(void) {
// chinese code ends here // chinese code ends here
// Turn on the backlight // Turn on the backlight
GDISP_LLD(set_backlight)(GDISP_INITIAL_BACKLIGHT); lld_gdisp_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */ /* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH; GDISP.Width = GDISP_SCREEN_WIDTH;
@ -461,7 +461,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0011, 0x0000); lld_lcdWriteReg(0x0011, 0x0000);
lld_lcdWriteReg(0x0012, 0x0000); lld_lcdWriteReg(0x0012, 0x0000);
lld_lcdWriteReg(0x0013, 0x0000); lld_lcdWriteReg(0x0013, 0x0000);
GDISP_LLD(set_backlight)(0); lld_gdisp_backlight(0);
break; break;
case powerOn: case powerOn:
@ -480,7 +480,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */ lld_lcdWriteReg(0x0029, 0x0009); /* VCM[4:0] for VCOMH */
lld_lcdDelay(500); lld_lcdDelay(500);
lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */ lld_lcdWriteReg(0x0007, 0x0173); /* 262K color and display ON */
GDISP_LLD(set_backlight)(GDISP.Backlight); lld_gdisp_backlight(GDISP.Backlight);
if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep) if(GDISP.Powermode != powerSleep || GDISP.Powermode != powerDeepSleep)
lld_gdisp_init(); lld_gdisp_init();
break; break;
@ -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_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */ lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */ lld_lcdWriteReg(0x0010, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
GDISP_LLD(set_backlight)(0); lld_gdisp_backlight(0);
break; break;
case powerDeepSleep: 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_lcdWriteReg(0x0013, 0x0000); /* VDV[4:0] for VCOM amplitude */
lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */ lld_lcdDelay(2000); /* Dis-charge capacitor power voltage */
lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */ lld_lcdWriteReg(0x0010, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
GDISP_LLD(set_backlight)(0); lld_gdisp_backlight(0);
break; break;
default: default:
@ -564,7 +564,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
case GDISP_CONTROL_BACKLIGHT: case GDISP_CONTROL_BACKLIGHT:
if((unsigned)value > 100) value = (void *)100; if((unsigned)value > 100) value = (void *)100;
GDISP_LLD(set_backlight)((unsigned)value); lld_gdisp_backlight((unsigned)value);
GDISP.Backlight = (unsigned)value; GDISP.Backlight = (unsigned)value;
break; break;

12
drivers/gdisp/ILI9325/gdisp_lld_board_example.h
View file

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

12
drivers/gdisp/ILI9325/gdisp_lld_board_hy_stm32_100p.h
View file

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

1
drivers/gdisp/ILI9325/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "ILI9325" #define GDISP_DRIVER_NAME "ILI9325"
#define GDISP_LLD(x) gdisp_lld_##x##_ILI9325
#define GDISP_HARDWARE_CLEARS TRUE #define GDISP_HARDWARE_CLEARS TRUE
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE

1
drivers/gdisp/Nokia6610GE12/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "Nokia6610GE12" #define GDISP_DRIVER_NAME "Nokia6610GE12"
#define GDISP_LLD(x) gdisp_lld_##x##_Nokia6610GE12
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE
#define GDISP_HARDWARE_BITFILLS TRUE #define GDISP_HARDWARE_BITFILLS TRUE

1
drivers/gdisp/Nokia6610GE8/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "Nokia6610GE8" #define GDISP_DRIVER_NAME "Nokia6610GE8"
#define GDISP_LLD(x) gdisp_lld_##x##_Nokia6610GE8
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE
#define GDISP_HARDWARE_BITFILLS TRUE #define GDISP_HARDWARE_BITFILLS TRUE

2
drivers/gdisp/S6D1121/gdisp_lld.c
View file

@ -508,7 +508,7 @@ void lld_gdisp_draw_pixel(coord_t x, coord_t y, color_t color) {
/* Code here */ /* Code here */
/* You may need this --- /* You may need this ---
if (GDISP.Powermode != powerSleep) if (GDISP.Powermode != powerSleep)
GDISP_LLD(init(); lld_gdisp_init();
*/ */
/* break; */ /* break; */
case powerSleep: case powerSleep:

1
drivers/gdisp/S6D1121/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "S6D1121" #define GDISP_DRIVER_NAME "S6D1121"
#define GDISP_LLD(x) gdisp_lld_##x##_S6D1121
#define GDISP_HARDWARE_CLEARS TRUE #define GDISP_HARDWARE_CLEARS TRUE
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE

1
drivers/gdisp/SSD1289/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "SSD1289" #define GDISP_DRIVER_NAME "SSD1289"
#define GDISP_LLD(x) gdisp_lld_##x##_SSD1289
#define GDISP_HARDWARE_CLEARS TRUE #define GDISP_HARDWARE_CLEARS TRUE
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE

1
drivers/gdisp/TestStub/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "TestStub" #define GDISP_DRIVER_NAME "TestStub"
#define GDISP_LLD(x) gdisp_lld_##x##_TestStub
#define GDISP_HARDWARE_SCROLL GDISP_NEED_SCROLL #define GDISP_HARDWARE_SCROLL GDISP_NEED_SCROLL
#define GDISP_HARDWARE_PIXELREAD GDISP_NEED_PIXELREAD #define GDISP_HARDWARE_PIXELREAD GDISP_NEED_PIXELREAD

271
drivers/gdisp/VMT/gdisp_lld.c
View file

@ -1,271 +0,0 @@
/*
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/gdisp/VMT/gdisp_lld.c
* @brief GDISP Graphics Driver subsystem low level driver source for VMT.
*
* @addtogroup GDISP
* @{
*/
#include "ch.h"
#include "hal.h"
#include "gfx.h"
#if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/
#define GDISP_LLD_NO_STRUCT
/* Include the emulation code for things we don't support */
#include "gdisp/lld/emulation.c"
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
#define GDISP_LLD1(x) GDISP_VMT_NAME1(gdisp_lld_##x##_)
#define GDISP_LLD2(x) GDISP_VMT_NAME2(gdisp_lld_##x##_)
/* Prototypes for lld driver functions */
bool_t GDISP_LLD1(init)(void);
void *GDISP_LLD1(query)(unsigned what);
void GDISP_LLD1(clear)(color_t color);
void GDISP_LLD1(drawpixel)(coord_t x, coord_t y, color_t color);
void GDISP_LLD1(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
void GDISP_LLD1(blitareaex)(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_LLD1(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
#if GDISP_NEED_CLIP
void GDISP_LLD1(setclip)(coord_t x, coord_t y, coord_t cx, coord_t cy);
#endif
#if GDISP_NEED_CIRCLE
void GDISP_LLD1(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color);
void GDISP_LLD1(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color);
#endif
#if GDISP_NEED_ELLIPSE
void GDISP_LLD1(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
void GDISP_LLD1(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
#endif
#if GDISP_NEED_ARC
void GDISP_LLD1(drawarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
void GDISP_LLD1(fillarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
#endif
#if GDISP_NEED_TEXT
void GDISP_LLD1(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color);
void GDISP_LLD1(fillchar)(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
#endif
#if GDISP_NEED_PIXELREAD
color_t GDISP_LLD1(getpixelcolor)(coord_t x, coord_t y);
#endif
#if GDISP_NEED_SCROLL
void GDISP_LLD1(verticalscroll)(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
#endif
#if GDISP_NEED_CONTROL
void GDISP_LLD1(control)(unsigned what, void *value);
#endif
bool_t GDISP_LLD2(init)(void);
void *GDISP_LLD2(query)(unsigned what);
void GDISP_LLD2(clear)(color_t color);
void GDISP_LLD2(drawpixel)(coord_t x, coord_t y, color_t color);
void GDISP_LLD2(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
void GDISP_LLD2(blitareaex)(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_LLD2(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
#if GDISP_NEED_CLIP
void GDISP_LLD2(setclip)(coord_t x, coord_t y, coord_t cx, coord_t cy);
#endif
#if GDISP_NEED_CIRCLE
void GDISP_LLD2(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color);
void GDISP_LLD2(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color);
#endif
#if GDISP_NEED_ELLIPSE
void GDISP_LLD2(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
void GDISP_LLD2(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
#endif
#if GDISP_NEED_ARC
void GDISP_LLD2(drawarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
void GDISP_LLD2(fillarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
#endif
#if GDISP_NEED_TEXT
void GDISP_LLD2(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color);
void GDISP_LLD2(fillchar)(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
#endif
#if GDISP_NEED_PIXELREAD
color_t GDISP_LLD2(getpixelcolor)(coord_t x, coord_t y);
#endif
#if GDISP_NEED_SCROLL
void GDISP_LLD2(verticalscroll)(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
#endif
#if GDISP_NEED_CONTROL
void GDISP_LLD2(control)(unsigned what, void *value);
#endif
/*===========================================================================*/
/* Driver exported variables. */
/*===========================================================================*/
/* Our VMT table variables */
void *GDISP_LLD_VMT(query)(unsigned what);
void GDISP_LLD_VMT(clear)(color_t color);
void GDISP_LLD_VMT(drawpixel)(coord_t x, coord_t y, color_t color);
void GDISP_LLD_VMT(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
void GDISP_LLD_VMT(blitareaex)(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_VMT(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
#if GDISP_NEED_CIRCLE
void GDISP_LLD_VMT(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color);
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_VMT(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
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_VMT(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color);
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_VMT(getpixelcolor)(coord_t x, coord_t y);
#endif
/* Scrolling Function - clears the area scrolled out */
#if GDISP_NEED_SCROLL
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_VMT(control)(unsigned what, void *value);
#endif
/* Clipping Functions */
#if GDISP_NEED_CLIP
void GDISP_LLD_VMT(setclip)(coord_t x, coord_t y, coord_t cx, coord_t cy);
#endif
/*===========================================================================*/
/* Driver local variables. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver local functions. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver interrupt handlers. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver exported functions. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver exported functions. */
/*===========================================================================*/
bool_t gdisp_lld_init_VMT(void) {
if (GDISP_VMT_NAME1(gdisp_lld_init_)()) {
gdisp_lld_query_VMT = GDISP_VMT_NAME1(gdisp_lld_query_);
gdisp_lld_clear_VMT = GDISP_VMT_NAME1(gdisp_lld_clear_);
gdisp_lld_drawpixel_VMT = GDISP_VMT_NAME1(gdisp_lld_drawpixel_);
gdisp_lld_fillarea_VMT = GDISP_VMT_NAME1(gdisp_lld_fillarea_);
gdisp_lld_blitareaex_VMT = GDISP_VMT_NAME1(gdisp_lld_blitareaex_);
gdisp_lld_drawline_VMT = GDISP_VMT_NAME1(gdisp_lld_drawline_);
#if GDISP_NEED_CIRCLE
gdisp_lld_drawcircle_VMT = GDISP_VMT_NAME1(gdisp_lld_drawcircle_);
gdisp_lld_fillcircle_VMT = GDISP_VMT_NAME1(gdisp_lld_fillcircle_);
#endif
#if GDISP_NEED_ELLIPSE
gdisp_lld_drawellipse_VMT = GDISP_VMT_NAME1(gdisp_lld_drawellipse_);
gdisp_lld_fillellipse_VMT = GDISP_VMT_NAME1(gdisp_lld_fillellipse_);
#endif
#if GDISP_NEED_ARC
gdisp_lld_drawarc_VMT = GDISP_VMT_NAME1(gdisp_lld_drawarc_);
gdisp_lld_fillarc_VMT = GDISP_VMT_NAME1(gdisp_lld_fillarc_);
#endif
#if GDISP_NEED_TEXT
gdisp_lld_drawchar_VMT = GDISP_VMT_NAME1(gdisp_lld_drawchar_);
gdisp_lld_fillchar_VMT = GDISP_VMT_NAME1(gdisp_lld_fillchar_);
#endif
#if GDISP_NEED_PIXELREAD
gdisp_lld_getpixelcolor_VMT = GDISP_VMT_NAME1(gdisp_lld_pixelread_);
#endif
#if GDISP_NEED_SCROLL
gdisp_lld_verticalscroll_VMT = GDISP_VMT_NAME1(gdisp_lld_scroll_);
#endif
#if GDISP_NEED_CONTROL
gdisp_lld_control_VMT = GDISP_VMT_NAME1(gdisp_lld_control_);
#endif
#if GDISP_NEED_CLIP
gdisp_lld_setclip_VMT = GDISP_VMT_NAME1(gdisp_lld_setclip_);
#endif
return TRUE;
}
if (GDISP_VMT_NAME2(gdisp_lld_init_)()) {
gdisp_lld_query_VMT = GDISP_VMT_NAME2(gdisp_lld_query_);
gdisp_lld_clear_VMT = GDISP_VMT_NAME2(gdisp_lld_clear_);
gdisp_lld_drawpixel_VMT = GDISP_VMT_NAME2(gdisp_lld_drawpixel_);
gdisp_lld_fillarea_VMT = GDISP_VMT_NAME2(gdisp_lld_fillarea_);
gdisp_lld_blitareaex_VMT = GDISP_VMT_NAME2(gdisp_lld_blitareaex_);
gdisp_lld_drawline_VMT = GDISP_VMT_NAME2(gdisp_lld_drawline_);
#if GDISP_NEED_CIRCLE
gdisp_lld_drawcircle_VMT = GDISP_VMT_NAME2(gdisp_lld_drawcircle_);
gdisp_lld_fillcircle_VMT = GDISP_VMT_NAME2(gdisp_lld_fillcircle_);
#endif
#if GDISP_NEED_ELLIPSE
gdisp_lld_drawellipse_VMT = GDISP_VMT_NAME2(gdisp_lld_drawellipse_);
gdisp_lld_fillellipse_VMT = GDISP_VMT_NAME2(gdisp_lld_fillellipse_);
#endif
#if GDISP_NEED_ARC
gdisp_lld_drawarc_VMT = GDISP_VMT_NAME2(gdisp_lld_drawarc_);
gdisp_lld_fillarc_VMT = GDISP_VMT_NAME2(gdisp_lld_fillarc_);
#endif
#if GDISP_NEED_TEXT
gdisp_lld_drawchar_VMT = GDISP_VMT_NAME2(gdisp_lld_drawchar_);
gdisp_lld_fillchar_VMT = GDISP_VMT_NAME2(gdisp_lld_fillchar_);
#endif
#if GDISP_NEED_PIXELREAD
gdisp_lld_getpixelcolor_VMT = GDISP_VMT_NAME2(gdisp_lld_pixelread_);
#endif
#if GDISP_NEED_SCROLL
gdisp_lld_verticalscroll_VMT = GDISP_VMT_NAME2(gdisp_lld_scroll_);
#endif
#if GDISP_NEED_CONTROL
gdisp_lld_control_VMT = GDISP_VMT_NAME2(gdisp_lld_control_);
#endif
#if GDISP_NEED_CLIP
gdisp_lld_setclip_VMT = GDISP_VMT_NAME2(gdisp_lld_setclip_);
#endif
return TRUE;
}
return FALSE;
}
#endif /* GFX_USE_GDISP */
/** @} */

7
drivers/gdisp/VMT/gdisp_lld.mk
View file

@ -1,7 +0,0 @@
# List the required driver.
GFXSRC += $(GFXLIB)/drivers/gdisp/VMT/gdisp_lld.c \
$(GFXLIB)/drivers/gdisp/VMT/gdisp_lld_driver1.c \
$(GFXLIB)//drivers/gdisp/VMT/gdisp_lld_driver2.c
# Required include directories
GFXINC += $(GFXLIB)/drivers/gdisp/VMT

71
drivers/gdisp/VMT/gdisp_lld_config.h
View file

@ -1,71 +0,0 @@
/*
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/gdisp/VMT/gdisp_lld_config.h
* @brief GDISP Graphic Driver subsystem low level driver header template.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_CONFIG_H
#define _GDISP_LLD_CONFIG_H
#if GFX_USE_GDISP
/*===========================================================================*/
/* Driver hardware support. */
/*===========================================================================*/
#define GDISP_DRIVER_NAME "VMT"
#define GDISP_LLD(x) gdisp_lld_##x##_VMT
#define GDISP_LLD_VMT(x) (*GDISP_LLD(x))
#define GDISP_HARDWARE_LINES TRUE
#define GDISP_HARDWARE_CLEARS TRUE
#define GDISP_HARDWARE_FILLS TRUE
#define GDISP_HARDWARE_BITFILLS TRUE
#define GDISP_HARDWARE_CIRCLES TRUE
#define GDISP_HARDWARE_CIRCLEFILLS TRUE
#define GDISP_HARDWARE_ELLIPSES TRUE
#define GDISP_HARDWARE_ELLIPSEFILLS TRUE
#define GDISP_HARDWARE_ARCS TRUE
#define GDISP_HARDWARE_ARCFILLS TRUE
#define GDISP_HARDWARE_TEXT TRUE
#define GDISP_HARDWARE_TEXTFILLS TRUE
#define GDISP_HARDWARE_SCROLL TRUE
#define GDISP_HARDWARE_PIXELREAD TRUE
#define GDISP_HARDWARE_CONTROL TRUE
#define GDISP_HARDWARE_QUERY TRUE
#define GDISP_HARDWARE_CLIP TRUE
#define GDISP_SOFTWARE_TEXTFILLDRAW FALSE
#define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE
#define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB565
#define GDISP_PACKED_PIXELS FALSE
#define GDISP_PACKED_LINES FALSE
#endif /* GFX_USE_GDISP */
#endif /* _GDISP_LLD_CONFIG_H */
/** @} */

52
drivers/gdisp/VMT/gdisp_lld_driver1.c
View file

@ -1,52 +0,0 @@
/*
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/gdisp/VMT/gdisp_lld_driver1.c
* @brief GDISP Graphics Driver subsystem low level driver source for VMT.
*
* @addtogroup GDISP
* @{
*/
#include "ch.h"
#include "hal.h"
#if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/
#define CONFIGFILE() <../GDISP_VMT_NAME1()/gdisp_lld_config.h>
#define DRIVERFILE() <../GDISP_VMT_NAME1()/gdisp_lld.c>
/* We don't need these in our VMT referenced driver */
#undef GDISP_NEED_MSGAPI
#define GDISP_NEED_MSGAPI FALSE
/* Include the specific config file we want */
#include CONFIGFILE()
/* Bring in our API */
#include "gfx.h"
/* Add the low level driver */
#include DRIVERFILE()
#endif /* GFX_USE_GDISP */
/** @} */

52
drivers/gdisp/VMT/gdisp_lld_driver2.c
View file

@ -1,52 +0,0 @@
/*
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/gdisp/VMT/gdisp_lld_driver2.c
* @brief GDISP Graphics Driver subsystem low level driver source for VMT.
*
* @addtogroup GDISP
* @{
*/
#include "ch.h"
#include "hal.h"
#if GFX_USE_GDISP /*|| defined(__DOXYGEN__)*/
#define CONFIGFILE() <../GDISP_VMT_NAME2()/gdisp_lld_config.h>
#define DRIVERFILE() <../GDISP_VMT_NAME2()/gdisp_lld.c>
/* We don't need these in our VMT referenced driver */
#undef GDISP_NEED_MSGAPI
#define GDISP_NEED_MSGAPI FALSE
/* Include the specific config file we want */
#include CONFIGFILE()
/* Bring in our API */
#include "gfx.h"
/* Add the low level driver */
#include DRIVERFILE()
#endif /* GFX_USE_GDISP */
/** @} */

23
drivers/gdisp/VMT/readme.txt
View file

@ -1,23 +0,0 @@
This driver enables you to have two underlying drivers handling different hardware.
A choice is made at run-time of which driver to call based on which driver succeeds
to initialise first (init returns TRUE).
To use this driver:
1. Add in your halconf.h:
a) #define GFX_USE_GDISP TRUE
b) Any optional high level driver defines (see gdisp.h) eg: GDISP_NEED_MULTITHREAD
c) Define these:
#define GDISP_VMT_NAME1(x) x##YourDriver1
#define GDISP_VMT_NAME2(x) x##YourDriver2
Note YourDriver1 & 2 are the basenames of the directories containing the driver.
Note that both drivers must be the same pixel format which is
GDISP_PIXELFORMAT_RGB565 by default. Alter gdispVMT/gdisp_lld_config.h if your
pixel format is different on both drivers.
d) Any driver specific defines. If both drivers use the same defines then they must
accept the same values for the define.
2. To your makefile add the following lines:
include $(CHIBIOS)/os/halext/halext.mk
include $(CHIBIOS)/os/halext/drivers/gdispVMT/gdisp_lld.mk

1
drivers/multiple/Win32/gdisp_lld_config.h
View file

@ -36,7 +36,6 @@
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "Win32" #define GDISP_DRIVER_NAME "Win32"
#define GDISP_LLD(x) gdisp_lld_##x##_Win32
#define GDISP_HARDWARE_LINES TRUE #define GDISP_HARDWARE_LINES TRUE
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE

2
include/gdisp/lld/emulation.c
View file

@ -685,7 +685,7 @@ void *lld_gdisp_query(unsigned what) {
#endif #endif
#if GDISP_NEED_MSGAPI #if GDISP_NEED_MSGAPI
void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg) { void lld_gdisp_msg_dispatch(gdisp_lld_msg_t *msg) {
switch(msg->action) { switch(msg->action) {
case GDISP_LLD_MSG_NOP: case GDISP_LLD_MSG_NOP:
break; break;

7
include/gdisp/lld/gdisp_lld.h
View file

@ -458,11 +458,6 @@ typedef enum powermode {powerOff, powerSleep, powerDeepSleep, powerOn} gdisp_pow
/* External declarations. */ /* External declarations. */
/*===========================================================================*/ /*===========================================================================*/
#ifndef GDISP_LLD_VMT
/* Special magic stuff for the VMT driver */
#define GDISP_LLD_VMT(x) GDISP_LLD(x)
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@ -530,7 +525,7 @@ extern "C" {
/* Messaging API */ /* Messaging API */
#if GDISP_NEED_MSGAPI #if GDISP_NEED_MSGAPI
#include "gdisp_lld_msgs.h" #include "gdisp_lld_msgs.h"
extern void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg); extern void lld_gdisp_msg_dispatch(gdisp_lld_msg_t *msg);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

2
src/gdisp/gdisp.c
View file

@ -95,7 +95,7 @@
/* OK - we need to obtain the mutex in case a synchronous operation is occurring */ /* OK - we need to obtain the mutex in case a synchronous operation is occurring */
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
GDISP_LLD(msgdispatch)(pmsg); lld_gdisp_msg_dispatch(pmsg);
chMtxUnlock(); chMtxUnlock();
/* Mark the message as free */ /* Mark the message as free */