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

gdisp Nokia and SSD1289 updates 

Convert SSD1289 to use board files.
Update Nokia driver to use short names in the board files.
Full expanded names are not needed as they are all static inline
routines.
ugfx_release_2.6
Andrew Hannam 2012-11-17 18:11:05 +10:00
parent 59c13aa33b
commit bbb2d434c4
9 changed files with 708 additions and 558 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
drivers/gdisp/Nokia6610/gdisp_lld.c
View File

@ -81,11 +81,9 @@
#endif
// Some macros just to make reading the code easier
#define write_data(d1) GDISP_LLD(write_data)(d1)
#define delayms(ms) chThdSleepMilliseconds(ms)
#define write_data2(d1, d2) { write_data(d1); write_data(d2); }
#define write_data3(d1, d2, d3) { write_data(d1); write_data(d2); write_data(d3); }
#define write_cmd(cmd) GDISP_LLD(write_cmd)(cmd)
#define write_cmd1(cmd, d1) { write_cmd(cmd); write_data(d1); }
#define write_cmd2(cmd, d1, d2) { write_cmd(cmd); write_data2(d1, d2); }
#define write_cmd3(cmd, d1, d2, d3) { write_cmd(cmd); write_data3(d1, d2, d3); }
@ -118,16 +116,16 @@ static __inline void setviewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
*/
bool_t GDISP_LLD(init)(void) {
/* Initialise your display */
GDISP_LLD(init_board)();
init_board();
// Hardware reset
GDISP_LLD(setpin_reset)(TRUE);
chThdSleepMilliseconds(20);
GDISP_LLD(setpin_reset)(FALSE);
chThdSleepMilliseconds(20);
setpin_reset(TRUE);
delayms(20);
setpin_reset(FALSE);
delayms(20);
// Get the bus for the following initialisation commands
GDISP_LLD(get_bus);
get_bus();
#if defined(GDISP_USE_GE8)
write_cmd3(DISCTL, 0x00, 0x20, 0x00); // Display control
@ -145,7 +143,7 @@ bool_t GDISP_LLD(init)(void) {
write_cmd2(VOLCTR, GDISP_INITIAL_CONTRAST, 0x03); // Voltage control (contrast setting)
// P1 = Contrast
// P2 = 3 resistance ratio (only value that works)
chThdSleepMilliseconds(100); // allow power supply to stabilize
delayms(100); // allow power supply to stabilize
write_cmd(DISON); // Turn on the display
#elif defined(GDISP_USE_GE12)
@ -156,14 +154,14 @@ bool_t GDISP_LLD(init)(void) {
write_cmd1(COLMOD, 0x03); // Color Interface Pixel Format - 0x03 = 12 bits-per-pixel
write_cmd1(MADCTL, 0xC8); // Memory access controler - 0xC0 = mirror x and y, reverse rgb
write_cmd1(SETCON, GDISP_INITIAL_CONTRAST); // Write contrast
chThdSleepMilliseconds(20);
delayms(20);
write_cmd(DISPON); // Display On
#else
// Alternative
write_cmd(SOFTRST); // Software Reset
chThdSleepMilliseconds(20);
delayms(20);
write_cmd(INITESC); // Initial escape
chThdSleepMilliseconds(20);
delayms(20);
write_cmd1(REFSET, 0x00); // Refresh set
write_cmd(DISPCTRL); // Set Display control - really 7 bytes of data
write_data(128); // Set the lenght of one selection term
@ -203,7 +201,7 @@ bool_t GDISP_LLD(init)(void) {
// write_data(0x7f); // full voltage control
// write_data(0x03); // must be "1"
write_cmd1(CONTRAST, GDISP_INITIAL_CONTRAST); // Write contrast
chThdSleepMilliseconds(20);
delayms(20);
write_cmd(TEMPGRADIENT); // Temperature gradient - really 14 bytes of data
for(i=0; i<14; i++)
write_data(0);
@ -213,10 +211,10 @@ bool_t GDISP_LLD(init)(void) {
#endif
// Release the bus
GDISP_LLD(release_bus);
release_bus();
/* Turn on the back-light */
GDISP_LLD(set_backlight)(GDISP_INITIAL_BACKLIGHT);
set_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure to match */
GDISP.Width = GDISP_SCREEN_WIDTH;
@ -247,10 +245,10 @@ void GDISP_LLD(drawpixel)(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
GDISP_LLD(get_bus);
get_bus();
setviewport(x, y, 1, 1);
write_cmd3(RAMWR, 0, (color>>8) & 0x0F, color & 0xFF);
GDISP_LLD(release_bus);
release_bus();
}
/* ---- Optional Routines ---- */
@ -279,12 +277,12 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
tuples = (cx*cy+1)/2; // With an odd sized area we over-print by one pixel.
// This extra pixel is ignored by the controller.
GDISP_LLD(get_bus);
get_bus();
setviewport(x, y, cx, cy);
write_cmd(RAMWR);
for(i=0; i < tuples; i++)
write_data3(((color >> 4) & 0xFF), (((color << 4) & 0xF0)|((color >> 8) & 0x0F)), (color & 0xFF));
GDISP_LLD(release_bus);
release_bus();
}
#endif
@ -321,7 +319,7 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
endx = srcx + cx;
endy = y + cy;
GDISP_LLD(get_bus);
get_bus();
setviewport(x, y, cx, cy);
write_cmd(RAMWR);
@ -397,7 +395,7 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
}
}
#endif
GDISP_LLD(release_bus);
release_bus();
}
#endif
@ -534,18 +532,18 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
#endif
case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)value > 100) value = (void *)100;
GDISP_LLD(set_backlight)((uint8_t)(unsigned)value);
set_backlight((unsigned)value);
GDISP.Backlight = (unsigned)value;
return;
case GDISP_CONTROL_CONTRAST:
if ((unsigned)value > 100) value = (void *)100;
GDISP_LLD(get_bus);
get_bus();
#if defined(GDISP_USE_GE8)
write_cmd2(VOLCTR, (unsigned)value, 0x03);
#elif defined(GDISP_USE_GE12)
write_cmd1(CONTRAST,(unsigned)value);
#endif
GDISP_LLD(release_bus);
release_bus();
GDISP.Contrast = (unsigned)value;
return;
}

16
drivers/gdisp/Nokia6610/gdisp_lld_board_example.h
View File

@ -39,7 +39,7 @@
*
* @notapi
*/
static __inline void GDISP_LLD(init_board)(void) {
static __inline void init_board(void) {
/* Code here */
#error "gdispNokia6610: You must supply a definition for init_board for your board"
}
@ -51,7 +51,7 @@ static __inline void GDISP_LLD(init_board)(void) {
*
* @notapi
*/
static __inline void GDISP_LLD(setpin_reset)(bool_t state) {
static __inline void setpin_reset(bool_t state) {
/* Code here */
#error "gdispNokia6610: You must supply a definition for setpin_reset for your board"
}
@ -66,7 +66,7 @@ static __inline void GDISP_LLD(setpin_reset)(bool_t state) {
*
* @notapi
*/
static __inline void GDISP_LLD(set_backlight)(uint8_t percent) {
static __inline void set_backlight(uint8_t percent) {
/* Code here */
#error "gdispNokia6610: You must supply a definition for set_backlight for your board"
}
@ -76,7 +76,7 @@ static __inline void GDISP_LLD(set_backlight)(uint8_t percent) {
*
* @notapi
*/
static __inline void GDISP_LLD(get_bus)(void) {
static __inline void get_bus(void) {
#error "gdispNokia6610: You must supply a definition for get_bus for your board"
}
@ -85,7 +85,7 @@ static __inline void GDISP_LLD(get_bus)(void) {
*
* @notapi
*/
static __inline void GDISP_LLD(release_bus)(void) {
static __inline void release_bus(void) {
#error "gdispNokia6610: You must supply a definition for release_bus for your board"
}
@ -96,7 +96,7 @@ static __inline void GDISP_LLD(release_bus)(void) {
*
* @notapi
*/
static __inline void GDISP_LLD(write_cmd)(uint16_t cmd) {
static __inline void write_cmd(uint16_t cmd) {
/* Code here */
#error "gdispNokia6610: You must supply a definition for write_cmd for your board"
}
@ -108,7 +108,7 @@ static __inline void GDISP_LLD(write_cmd)(uint16_t cmd) {
*
* @notapi
*/
static __inline void GDISP_LLD(write_data)(uint16_t data) {
static __inline void write_data(uint16_t data) {
/* Code here */
#error "gdispNokia6610: You must supply a definition for write_data for your board"
}
@ -123,7 +123,7 @@ static __inline void GDISP_LLD(write_data)(uint16_t data) {
*
* @notapi
*/
static __inline uint16_t GDISP_LLD(read_data)(void) {
static __inline uint16_t read_data(void) {
/* Code here */
#error "gdispNokia6610: You must supply a definition for read_data for your board"
}

64
drivers/gdisp/Nokia6610/gdisp_lld_board_olimexsam7ex256.h
View File

@ -29,40 +29,6 @@
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
// mask definitions
#define BIT0 0x00000001
#define BIT1 0x00000002
#define BIT2 0x00000004
#define BIT3 0x00000008
#define BIT4 0x00000010
#define BIT5 0x00000020
#define BIT6 0x00000040
#define BIT7 0x00000080
#define BIT8 0x00000100
#define BIT9 0x00000200
#define BIT10 0x00000400
#define BIT11 0x00000800
#define BIT12 0x00001000
#define BIT13 0x00002000
#define BIT14 0x00004000
#define BIT15 0x00008000
#define BIT16 0x00010000
#define BIT17 0x00020000
#define BIT18 0x00040000
#define BIT19 0x00080000
#define BIT20 0x00100000
#define BIT21 0x00200000
#define BIT22 0x00400000
#define BIT23 0x00800000
#define BIT24 0x01000000
#define BIT25 0x02000000
#define BIT26 0x04000000
#define BIT27 0x08000000
#define BIT28 0x10000000
#define BIT29 0x20000000
#define BIT30 0x40000000
#define BIT31 0x80000000
// ******************************************************
// Pointers to AT91SAM7X256 peripheral data structures
// ******************************************************
@ -82,7 +48,7 @@ volatile AT91PS_PDC pPDC = AT91C_BASE_PDC_SPI0;
*
* @notapi
*/
static __inline void GDISP_LLD(init_board)(void) {
static __inline void init_board(void) {
// *********************************************************************************************
// InitSpi( )
//
@ -108,8 +74,8 @@ static __inline void GDISP_LLD(init_board)(void) {
pPIOA->PIO_OER = PIOA_LCD_RESET_MASK; // Configure PA2 as output
// CS pin - this seems to be ignored
// pPIOA->PIO_SODR = BIT12; // Set PA2 to HIGH
// pPIOA->PIO_OER = BIT12; // Configure PA2 as output
// pPIOA->PIO_SODR = 1<<12; // Set PA2 to HIGH
// pPIOA->PIO_OER = 1<<12; // Configure PA2 as output
// Init SPI0
// Disable the following pins from PIO control (will be used instead by the SPI0 peripheral)
@ -117,8 +83,8 @@ static __inline void GDISP_LLD(init_board)(void) {
// BIT16 = PA16 -> SPI0_MISO Master In - Slave Out (not used in LCD interface)
// BIT17 = PA17 -> SPI0_MOSI Master Out - Slave In pin (Serial Data to LCD slave)
// BIT18 = PA18 -> SPI0_SPCK Serial Clock (to LCD slave)
pPIOA->PIO_PDR = BIT12 | BIT16 | BIT17 | BIT18;
pPIOA->PIO_ASR = BIT12 | BIT16 | BIT17 | BIT18;
pPIOA->PIO_PDR = (1<<12) | (1<<16) | (1<<17) | (1<<18);
pPIOA->PIO_ASR = (1<<12) | (1<<16) | (1<<17) | (1<<18);
pPIOA->PIO_BSR = 0;
//enable the clock of SPI
@ -142,13 +108,11 @@ static __inline void GDISP_LLD(init_board)(void) {
*
* @notapi
*/
static __inline void GDISP_LLD(setpin_reset)(bool_t state) {
static __inline void setpin_reset(bool_t state) {
if (state)
palClearPad(IOPORT1, PIOA_LCD_RESET);
// pPIOA->PIO_CODR = PIOA_LCD_RESET_MASK;
else
palSetPad(IOPORT1, PIOA_LCD_RESET);
// pPIOA->PIO_SODR = PIOA_LCD_RESET_MASK;
}
/**
@ -161,13 +125,11 @@ static __inline void GDISP_LLD(setpin_reset)(bool_t state) {
*
* @notapi
*/
static __inline void GDISP_LLD(set_backlight)(uint8_t percent) {
static __inline void set_backlight(uint8_t percent) {
if (percent)
palSetPad(IOPORT2, PIOB_LCD_BL);
// pPIOB->PIO_SODR = PIOB_LCD_BL_MASK;
else
palClearPad(IOPORT2, PIOB_LCD_BL);
// pPIOB->PIO_CODR = PIOB_LCD_BL_MASK;
}
/**
@ -175,7 +137,7 @@ static __inline void GDISP_LLD(set_backlight)(uint8_t percent) {
*
* @notapi
*/
static __inline void GDISP_LLD(get_bus)(void) {
static __inline void get_bus(void) {
// Nothing to do for this board as the LCD is the only device on the SPI port
}
@ -184,7 +146,7 @@ static __inline void GDISP_LLD(get_bus)(void) {
*
* @notapi
*/
static __inline void GDISP_LLD(release_bus)(void) {
static __inline void release_bus(void) {
// Nothing to do for this board as the LCD is the only device on the SPI port
}
@ -195,11 +157,11 @@ static __inline void GDISP_LLD(release_bus)(void) {
*
* @notapi
*/
static __inline void GDISP_LLD(write_cmd)(uint16_t cmd) {
static __inline void write_cmd(uint16_t cmd) {
// wait for the previous transfer to complete
while((pSPI->SPI_SR & AT91C_SPI_TXEMPTY) == 0);
// send the command
pSPI->SPI_TDR = data & 0xFF;
pSPI->SPI_TDR = cmd & 0xFF;
}
/**
@ -209,7 +171,7 @@ static __inline void GDISP_LLD(write_cmd)(uint16_t cmd) {
*
* @notapi
*/
static __inline void GDISP_LLD(write_data)(uint16_t data) {
static __inline void write_data(uint16_t data) {
// wait for the previous transfer to complete
while((pSPI->SPI_SR & AT91C_SPI_TXEMPTY) == 0);
// send the data
@ -224,7 +186,7 @@ static __inline void GDISP_LLD(write_data)(uint16_t data) {
*
* @notapi
*/
static __inline uint16_t GDISP_LLD(read_data)(void) {
static __inline uint16_t read_data(void) {
#error "gdispNokia6610: GDISP_HARDWARE_READPIXEL and GDISP_HARDWARE_SCROLL are not supported on this board"
return 0;
}

360
drivers/gdisp/SSD1289/gdisp_lld.c
View File

@ -35,7 +35,101 @@
/* Include the emulation code for things we don't support */
#include "gdisp_emulation.c"
#include "ssd1289_lld.c.h"
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
#ifndef GDISP_SCREEN_HEIGHT
#define GDISP_SCREEN_HEIGHT 240
#endif
#ifndef GDISP_SCREEN_WIDTH
#define GDISP_SCREEN_WIDTH 320
#endif
#define GDISP_INITIAL_CONTRAST 50
#define GDISP_INITIAL_BACKLIGHT 100
/*===========================================================================*/
/* Driver local functions. */
/*===========================================================================*/
#if defined(BOARD_FIREBULL_STM32_F103)
#include "gdisp_lld_board_firebullstm32f103.h"
#else
/* Include the user supplied board definitions */
#include "gdisp_lld_board.h"
#endif
// Some common routines and macros
#define write_reg(reg, data) { write_index(reg); write_data(data); }
#define stream_start() write_reg(0x0022);
#define stream_stop()
#define delay(us) chThdSleepMicroseconds(us)
#define delayms(ms) chThdSleepMilliseconds(ms)
static __inline void set_cursor(coord_t x, coord_t y) {
/* Reg 0x004E is an 8 bit value
* Reg 0x004F is 9 bit
* Use a bit mask to make sure they are not set too high
*/
switch(GDISP.Orientation) {
case GDISP_ROTATE_180:
write_reg(0x004e, (GDISP_SCREEN_WIDTH-1-x) & 0x00FF);
write_reg(0x004f, (GDISP_SCREEN_HEIGHT-1-y) & 0x01FF);
break;
case GDISP_ROTATE_0:
write_reg(0x004e, x & 0x00FF);
write_reg(0x004f, y & 0x01FF);
break;
case GDISP_ROTATE_270:
write_reg(0x004e, y & 0x00FF);
write_reg(0x004f, x & 0x01FF);
break;
case GDISP_ROTATE_90:
write_reg(0x004e, (GDISP_SCREEN_WIDTH - y - 1) & 0x00FF);
write_reg(0x004f, (GDISP_SCREEN_HEIGHT - x - 1) & 0x01FF);
break;
}
}
static __inline void set_viewport(coord_t x, coord_t y, coord_t cx, coord_t cy) {
set_cursor(x, y);
/* Reg 0x44 - Horizontal RAM address position
* Upper Byte - HEA
* Lower Byte - HSA
* 0 <= HSA <= HEA <= 0xEF
* Reg 0x45,0x46 - Vertical RAM address position
* Lower 9 bits gives 0-511 range in each value
* 0 <= Reg(0x45) <= Reg(0x46) <= 0x13F
*/
switch(GDISP.Orientation) {
case GDISP_ROTATE_0:
write_reg(0x44, (((x+cx-1) << 8) & 0xFF00 ) | (x & 0x00FF));
write_reg(0x45, y & 0x01FF);
write_reg(0x46, (y+cy-1) & 0x01FF);
break;
case GDISP_ROTATE_270:
write_reg(0x44, (((x+cx-1) << 8) & 0xFF00 ) | (y & 0x00FF));
write_reg(0x45, x & 0x01FF);
write_reg(0x46, (x+cx-1) & 0x01FF);
break;
case GDISP_ROTATE_180:
write_reg(0x44, (((GDISP_SCREEN_WIDTH-x-1) & 0x00FF) << 8) | ((GDISP_SCREEN_WIDTH - (x+cx)) & 0x00FF));
write_reg(0x45, (GDISP_SCREEN_HEIGHT-(y+cy)) & 0x01FF);
write_reg(0x46, (GDISP_SCREEN_HEIGHT-y-1) & 0x01FF);
break;
case GDISP_ROTATE_90:
write_reg(0x44, (((GDISP_SCREEN_WIDTH - y - 1) & 0x00FF) << 8) | ((GDISP_SCREEN_WIDTH - (y+cy)) & 0x00FF));
write_reg(0x45, (GDISP_SCREEN_HEIGHT - (x+cx)) & 0x01FF);
write_reg(0x46, (GDISP_SCREEN_HEIGHT - x - 1) & 0x01FF);
break;
}
set_cursor(x, y);
}
/*===========================================================================*/
/* Driver interrupt handlers. */
@ -57,98 +151,73 @@
* @notapi
*/
bool_t GDISP_LLD(init)(void) {
#if defined(GDISP_USE_FSMC)
/* Initialise your display */
init_board();
#if defined(STM32F1XX) || defined(STM32F3XX)
/* FSMC setup for F1/F3 */
rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
// Hardware reset
setpin_reset(TRUE);
delayms(20);
setpin_reset(FALSE);
delayms(20);
#if defined(GDISP_USE_DMA) && defined(GDISP_DMA_STREAM)
#error "DMA not implemented for F1/F3 Devices"
#endif
#elif defined(STM32F4XX) || defined(STM32F2XX)
/* STM32F2-F4 FSMC init */
rccEnableAHB3(RCC_AHB3ENR_FSMCEN, 0);
// Get the bus for the following initialisation commands
get_bus();
write_reg(0x0000,0x0001); delay(5);
write_reg(0x0003,0xA8A4); delay(5);
write_reg(0x000C,0x0000); delay(5);
write_reg(0x000D,0x080C); delay(5);
write_reg(0x000E,0x2B00); delay(5);
write_reg(0x001E,0x00B0); delay(5);
write_reg(0x0001,0x2B3F); delay(5);
write_reg(0x0002,0x0600); delay(5);
write_reg(0x0010,0x0000); delay(5);
write_reg(0x0011,0x6070); delay(5);
write_reg(0x0005,0x0000); delay(5);
write_reg(0x0006,0x0000); delay(5);
write_reg(0x0016,0xEF1C); delay(5);
write_reg(0x0017,0x0003); delay(5);
write_reg(0x0007,0x0133); delay(5);
write_reg(0x000B,0x0000); delay(5);
write_reg(0x000F,0x0000); delay(5);
write_reg(0x0041,0x0000); delay(5);
write_reg(0x0042,0x0000); delay(5);
write_reg(0x0048,0x0000); delay(5);
write_reg(0x0049,0x013F); delay(5);
write_reg(0x004A,0x0000); delay(5);
write_reg(0x004B,0x0000); delay(5);
write_reg(0x0044,0xEF00); delay(5);
write_reg(0x0045,0x0000); delay(5);
write_reg(0x0046,0x013F); delay(5);
write_reg(0x0030,0x0707); delay(5);
write_reg(0x0031,0x0204); delay(5);
write_reg(0x0032,0x0204); delay(5);
write_reg(0x0033,0x0502); delay(5);
write_reg(0x0034,0x0507); delay(5);
write_reg(0x0035,0x0204); delay(5);
write_reg(0x0036,0x0204); delay(5);
write_reg(0x0037,0x0502); delay(5);
write_reg(0x003A,0x0302); delay(5);
write_reg(0x003B,0x0302); delay(5);
write_reg(0x0023,0x0000); delay(5);
write_reg(0x0024,0x0000); delay(5);
write_reg(0x0025,0x8000); delay(5);
write_reg(0x004f,0x0000); delay(5);
write_reg(0x004e,0x0000); delay(5);
#if defined(GDISP_USE_DMA) && defined(GDISP_DMA_STREAM)
if (dmaStreamAllocate(GDISP_DMA_STREAM, 0, NULL, NULL)) chSysHalt();
dmaStreamSetMemory0(GDISP_DMA_STREAM, &GDISP_RAM);
dmaStreamSetMode(GDISP_DMA_STREAM, STM32_DMA_CR_PL(0) | STM32_DMA_CR_PSIZE_HWORD | STM32_DMA_CR_MSIZE_HWORD | STM32_DMA_CR_DIR_M2M);
#endif
#else
#error "FSMC not implemented for this device"
#endif
// Release the bus
release_bus();
/* Turn on the back-light */
set_backlight(GDISP_INITIAL_BACKLIGHT);
/* set pins to FSMC mode */
IOBus busD = {GPIOD, (1 << 0) | (1 << 1) | (1 << 4) | (1 << 5) | (1 << 7) | (1 << 8) |
(1 << 9) | (1 << 10) | (1 << 11) | (1 << 14) | (1 << 15), 0};
IOBus busE = {GPIOE, (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 12) |
(1 << 13) | (1 << 14) | (1 << 15), 0};
palSetBusMode(&busD, PAL_MODE_ALTERNATE(12));
palSetBusMode(&busE, PAL_MODE_ALTERNATE(12));
const unsigned char FSMC_Bank = 0;
/* FSMC timing */
FSMC_Bank1->BTCR[FSMC_Bank+1] = (FSMC_BTR1_ADDSET_1 | FSMC_BTR1_ADDSET_3) \
| (FSMC_BTR1_DATAST_1 | FSMC_BTR1_DATAST_3) \
| (FSMC_BTR1_BUSTURN_1 | FSMC_BTR1_BUSTURN_3) ;
/* Bank1 NOR/SRAM control register configuration
* This is actually not needed as already set by default after reset */
FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN;
#endif
lld_lcdWriteReg(0x0000,0x0001); lld_lcdDelay(5);
lld_lcdWriteReg(0x0003,0xA8A4); lld_lcdDelay(5);
lld_lcdWriteReg(0x000C,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x000D,0x080C); lld_lcdDelay(5);
lld_lcdWriteReg(0x000E,0x2B00); lld_lcdDelay(5);
lld_lcdWriteReg(0x001E,0x00B0); lld_lcdDelay(5);
lld_lcdWriteReg(0x0001,0x2B3F); lld_lcdDelay(5);
lld_lcdWriteReg(0x0002,0x0600); lld_lcdDelay(5);
lld_lcdWriteReg(0x0010,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0011,0x6070); lld_lcdDelay(5);
lld_lcdWriteReg(0x0005,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0006,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0016,0xEF1C); lld_lcdDelay(5);
lld_lcdWriteReg(0x0017,0x0003); lld_lcdDelay(5);
lld_lcdWriteReg(0x0007,0x0133); lld_lcdDelay(5);
lld_lcdWriteReg(0x000B,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x000F,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0041,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0042,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0048,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0049,0x013F); lld_lcdDelay(5);
lld_lcdWriteReg(0x004A,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x004B,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0044,0xEF00); lld_lcdDelay(5);
lld_lcdWriteReg(0x0045,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0046,0x013F); lld_lcdDelay(5);
lld_lcdWriteReg(0x0030,0x0707); lld_lcdDelay(5);
lld_lcdWriteReg(0x0031,0x0204); lld_lcdDelay(5);
lld_lcdWriteReg(0x0032,0x0204); lld_lcdDelay(5);
lld_lcdWriteReg(0x0033,0x0502); lld_lcdDelay(5);
lld_lcdWriteReg(0x0034,0x0507); lld_lcdDelay(5);
lld_lcdWriteReg(0x0035,0x0204); lld_lcdDelay(5);
lld_lcdWriteReg(0x0036,0x0204); lld_lcdDelay(5);
lld_lcdWriteReg(0x0037,0x0502); lld_lcdDelay(5);
lld_lcdWriteReg(0x003A,0x0302); lld_lcdDelay(5);
lld_lcdWriteReg(0x003B,0x0302); lld_lcdDelay(5);
lld_lcdWriteReg(0x0023,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0024,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x0025,0x8000); lld_lcdDelay(5);
lld_lcdWriteReg(0x004f,0x0000); lld_lcdDelay(5);
lld_lcdWriteReg(0x004e,0x0000); lld_lcdDelay(5);
/* Initialise the GDISP structure */
/* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH;
GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Orientation = GDISP_ROTATE_0;
GDISP.Powermode = powerOn;
GDISP.Backlight = 100;
GDISP.Contrast = 50;
GDISP.Backlight = GDISP_INITIAL_BACKLIGHT;
GDISP.Contrast = GDISP_INITIAL_CONTRAST;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
GDISP.clipx0 = 0;
GDISP.clipy0 = 0;
@ -171,8 +240,11 @@ void GDISP_LLD(drawpixel)(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
lld_lcdSetCursor(x, y);
lld_lcdWriteReg(0x0022, color);
get_bus();
set_cursor(x, y);
write_reg(0x0022, color);
release_bus();
}
/* ---- Optional Routines ---- */
@ -204,13 +276,13 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
void GDISP_LLD(clear)(color_t color) {
unsigned i;
lld_lcdSetCursor(0, 0);
lld_lcdWriteStreamStart();
get_bus();
set_cursor(0, 0);
stream_start();
for(i = 0; i < GDISP_SCREEN_WIDTH * GDISP_SCREEN_HEIGHT; i++)
lld_lcdWriteData(color);
lld_lcdWriteStreamStop();
write_data(color);
stream_stop();
release_bus();
}
#endif
@ -226,6 +298,8 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
* @notapi
*/
void GDISP_LLD(fillarea)(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
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
if (y < GDISP.clipy0) { cy -= GDISP.clipy0 - y; y = GDISP.clipy0; }
@ -234,15 +308,15 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
if (y+cy > GDISP.clipy1) cy = GDISP.clipy1 - y;
#endif
unsigned i, area;
area = cx*cy;
lld_lcdSetViewPort(x, y, cx, cy);
lld_lcdWriteStreamStart();
get_bus();
set_viewport(x, y, cx, cy);
stream_start();
for(i = 0; i < area; i++)
lld_lcdWriteData(color);
lld_lcdWriteStreamStop();
lld_lcdResetViewPort();
write_data(color);
stream_stop();
release_bus();
}
#endif
@ -272,8 +346,9 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
if (y+cy > GDISP.clipy1) cy = GDISP.clipy1 - y;
#endif
lld_lcdSetViewPort(x, y, cx, cy);
lld_lcdWriteStreamStart();
get_bus();
set_viewport(x, y, cx, cy);
stream_start();
endx = srcx + cx;
endy = y + cy;
@ -281,9 +356,9 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
buffer += srcx + srcy * srccx;
for(; y < endy; y++, buffer += lg)
for(x=srcx; x < endx; x++)
lld_lcdWriteData(*buffer++);
lld_lcdWriteStreamStop();
lld_lcdResetViewPort();
write_data(*buffer++);
stream_stop();
release_bus();
}
#endif
@ -304,14 +379,13 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
if (x < 0 || x >= GDISP.Width || y < 0 || y >= GDISP.Height) return 0;
#endif
lld_lcdSetCursor(x, y);
lld_lcdWriteStreamStart();
color = lld_lcdReadData();
color = lld_lcdReadData();
lld_lcdWriteStreamStop();
get_bus();
set_cursor(x, y);
stream_start();
color = read_data(); // dummy read
color = read_data();
stream_stop();
release_bus();
return color;
}
#endif
@ -333,7 +407,7 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
void GDISP_LLD(verticalscroll)(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;
unsigned i, gap, abslines, j;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
if (x < GDISP.clipx0) { cx -= GDISP.clipx0 - x; x = GDISP.clipx0; }
@ -345,6 +419,7 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
abslines = lines < 0 ? -lines : lines;
get_bus();
if (abslines >= cy) {
abslines = cy;
gap = 0;
@ -360,25 +435,28 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
}
/* read row0 into the buffer and then write at row1*/
lld_lcdSetViewPort(x, row0, cx, 1);
lld_lcdReadStreamStart();
lld_lcdReadStream(buf, cx);
lld_lcdReadStreamStop();
set_viewport(x, row0, cx, 1);
stream_start();
j = read_data(); // dummy read
for (j = 0; j < cx; j++)
buf[j] = read_data();
stream_stop();
lld_lcdSetViewPort(x, row1, cx, 1);
lld_lcdWriteStreamStart();
lld_lcdWriteStream(buf, cx);
lld_lcdWriteStreamStop();
set_viewport(x, row1, cx, 1);
stream_start();
for (j = 0; j < cx; j++)
write_data(buf[j]);
stream_stop();
}
}
/* fill the remaining gap */
lld_lcdSetViewPort(x, lines > 0 ? (y+gap) : y, cx, abslines);
lld_lcdWriteStreamStart();
set_viewport(x, lines > 0 ? (y+gap) : y, cx, abslines);
stream_start();
gap = cx*abslines;
for(i = 0; i < gap; i++) lld_lcdWriteData(bgcolor);
lld_lcdWriteStreamStop();
lld_lcdResetViewPort();
for(i = 0; i < gap; i++) write_data(bgcolor);
stream_stop();
release_bus();
}
#endif
@ -409,18 +487,18 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
return;
switch((gdisp_powermode_t)value) {
case powerOff:
lld_lcdWriteReg(0x0010, 0x0000); // leave sleep mode
lld_lcdWriteReg(0x0007, 0x0000); // halt operation
lld_lcdWriteReg(0x0000, 0x0000); // turn off oszillator
lld_lcdWriteReg(0x0010, 0x0001); // enter sleepmode
write_reg(0x0010, 0x0000); // leave sleep mode
write_reg(0x0007, 0x0000); // halt operation
write_reg(0x0000, 0x0000); // turn off oszillator
write_reg(0x0010, 0x0001); // enter sleepmode
break;
case powerOn:
lld_lcdWriteReg(0x0010, 0x0000); // leave sleep mode
write_reg(0x0010, 0x0000); // leave sleep mode
if (GDISP.Powermode != powerSleep)
GDISP_LLD(init)();
break;
case powerSleep:
lld_lcdWriteReg(0x0010, 0x0001); // enter sleep mode
write_reg(0x0010, 0x0001); // enter sleep mode
break;
default:
return;
@ -432,30 +510,30 @@ void GDISP_LLD(drawpixel)(coord_t x, coord_t y, color_t color) {
return;
switch((gdisp_orientation_t)value) {
case GDISP_ROTATE_0:
lld_lcdWriteReg(0x0001, 0x2B3F);
write_reg(0x0001, 0x2B3F);
/* ID = 11 AM = 0 */
lld_lcdWriteReg(0x0011, 0x6070);
write_reg(0x0011, 0x6070);
GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Width = GDISP_SCREEN_WIDTH;
break;
case GDISP_ROTATE_90:
lld_lcdWriteReg(0x0001, 0x293F);
write_reg(0x0001, 0x293F);
/* ID = 11 AM = 1 */
lld_lcdWriteReg(0x0011, 0x6078);
write_reg(0x0011, 0x6078);
GDISP.Height = GDISP_SCREEN_WIDTH;
GDISP.Width = GDISP_SCREEN_HEIGHT;
break;
case GDISP_ROTATE_180:
lld_lcdWriteReg(0x0001, 0x2B3F);
write_reg(0x0001, 0x2B3F);
/* ID = 01 AM = 0 */
lld_lcdWriteReg(0x0011, 0x6040);
write_reg(0x0011, 0x6040);
GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Width = GDISP_SCREEN_WIDTH;
break;
case GDISP_ROTATE_270:
lld_lcdWriteReg(0x0001, 0x293F);
write_reg(0x0001, 0x293F);
/* ID = 01 AM = 1 */
lld_lcdWriteReg(0x0011, 0x6048);
write_reg(0x0011, 0x6048);
GDISP.Height = GDISP_SCREEN_WIDTH;
GDISP.Width = GDISP_SCREEN_HEIGHT;
break;

125
drivers/gdisp/SSD1289/gdisp_lld_board_example.h 100644
View File

@ -0,0 +1,125 @@
/*
ChibiOS/RT - 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/SSD1289/gdisp_lld_board_example.h
* @brief GDISP Graphic Driver subsystem board interface for the SSD1289 display.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
/**
* @brief Initialise the board for the display.
*
* @notapi
*/
static __inline void init_board(void) {
/* Code here */
#error "SSD1289: You must supply a definition for init_board for your board"
}
/**
* @brief Set or clear the lcd reset pin.
*
* @param[in] state TRUE = lcd in reset, FALSE = normal operation
*
* @notapi
*/
static __inline void setpin_reset(bool_t state) {
/* Code here */
#error "SSD1289: You must supply a definition for setpin_reset for your board"
}
/**
* @brief Set the lcd back-light level.
*
* @param[in] percent 0 to 100%
*
* @notapi
*/
static __inline void set_backlight(uint8_t percent) {
/* Code here */
#error "SSD1289: You must supply a definition for set_backlight for your board"
}
/**
* @brief Take exclusive control of the bus
*
* @notapi
*/
static __inline void get_bus(void) {
#error "SSD1289: You must supply a definition for get_bus for your board"
}
/**
* @brief Release exclusive control of the bus
*
* @notapi
*/
static __inline void release_bus(void) {
#error "SSD1289: You must supply a definition for release_bus for your board"
}
/**
* @brief Send data to the index register.
*
* @param[in] index The index register to set
*
* @notapi
*/
static __inline void write_index(uint16_t index) {
/* Code here */
#error "SSD1289: You must supply a definition for write_index for your board"
}
/**
* @brief Send data to the lcd.
*
* @param[in] data The data to send
*
* @notapi
*/
static __inline void write_data(uint16_t data) {
/* Code here */
#error "SSD1289: You must supply a definition for write_data for your board"
}
#if GDISP_HARDWARE_READPIXEL || GDISP_HARDWARE_SCROLL || defined(__DOXYGEN__)
/**
* @brief Read data from the lcd.
*
* @return The data from the lcd
* @note The chip select may need to be asserted/de-asserted
* around the actual spi read
*
* @notapi
*/
static __inline uint16_t read_data(void) {
/* Code here */
#error "SSD1289: You must supply a definition for read_data for your board"
}
#endif
#endif /* _GDISP_LLD_BOARD_H */
/** @} */

164
drivers/gdisp/SSD1289/gdisp_lld_board_example_fsmc.h 100644
View File

@ -0,0 +1,164 @@
/*
ChibiOS/RT - 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/SSD1289/gdisp_lld_board_example_fsmc.h
* @brief GDISP Graphic Driver subsystem board interface for the SSD1289 display.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
#define GDISP_REG ((volatile uint16_t *) 0x60000000)[0] /* RS = 0 */
#define GDISP_RAM ((volatile uint16_t *) 0x60020000)[0] /* RS = 1 */
/**
* @brief Initialise the board for the display.
* @notes Performs the following functions:
* 1. initialise the io port used by your display
* 2. initialise the reset pin (initial state not-in-reset)
* 3. initialise the chip select pin (initial state not-active)
* 4. initialise the backlight pin (initial state back-light off)
*
* @notapi
*/
static __inline void init_board(void) {
const unsigned char FSMC_Bank;
#if defined(STM32F1XX) || defined(STM32F3XX)
/* FSMC setup for F1/F3 */
rccEnableAHB(RCC_AHBENR_FSMCEN, 0);
#if defined(GDISP_USE_DMA) && defined(GDISP_DMA_STREAM)
#error "DMA not implemented for F1/F3 Devices"
#endif
#elif defined(STM32F4XX) || defined(STM32F2XX)
/* STM32F2-F4 FSMC init */
rccEnableAHB3(RCC_AHB3ENR_FSMCEN, 0);
#if defined(GDISP_USE_DMA) && defined(GDISP_DMA_STREAM)
if (dmaStreamAllocate(GDISP_DMA_STREAM, 0, NULL, NULL)) chSysHalt();
dmaStreamSetMemory0(GDISP_DMA_STREAM, &GDISP_RAM);
dmaStreamSetMode(GDISP_DMA_STREAM, STM32_DMA_CR_PL(0) | STM32_DMA_CR_PSIZE_HWORD | STM32_DMA_CR_MSIZE_HWORD | STM32_DMA_CR_DIR_M2M);
#endif
#else
#error "FSMC not implemented for this device"
#endif
/* set pins to FSMC mode */
IOBus busD = {GPIOD, (1 << 0) | (1 << 1) | (1 << 4) | (1 << 5) | (1 << 7) | (1 << 8) |
(1 << 9) | (1 << 10) | (1 << 11) | (1 << 14) | (1 << 15), 0};
IOBus busE = {GPIOE, (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 12) |
(1 << 13) | (1 << 14) | (1 << 15), 0};
palSetBusMode(&busD, PAL_MODE_ALTERNATE(12));
palSetBusMode(&busE, PAL_MODE_ALTERNATE(12));
FSMC_Bank = 0;
/* FSMC timing */
FSMC_Bank1->BTCR[FSMC_Bank+1] = (FSMC_BTR1_ADDSET_1 | FSMC_BTR1_ADDSET_3) \
| (FSMC_BTR1_DATAST_1 | FSMC_BTR1_DATAST_3) \
| (FSMC_BTR1_BUSTURN_1 | FSMC_BTR1_BUSTURN_3) ;
/* Bank1 NOR/SRAM control register configuration
* This is actually not needed as already set by default after reset */
FSMC_Bank1->BTCR[FSMC_Bank] = FSMC_BCR1_MWID_0 | FSMC_BCR1_WREN | FSMC_BCR1_MBKEN;
}
/**
* @brief Set or clear the lcd reset pin.
*
* @param[in] state TRUE = lcd in reset, FALSE = normal operation
*
* @notapi
*/
static __inline void setpin_reset(bool_t state) {
(void) state;
/* Nothing to do here */
}
/**
* @brief Set the lcd back-light level.
*
* @param[in] percent 0 to 100%
*
* @notapi
*/
static __inline void set_backlight(uint8_t percent) {
(void) percent;
/* Nothing to do here */
}
/**
* @brief Take exclusive control of the bus
*
* @notapi
*/
static __inline void get_bus(void) {
/* Nothing to do here */
}
/**
* @brief Release exclusive control of the bus
*
* @notapi
*/
static __inline void release_bus(void) {
/* Nothing to do here */
}
/**
* @brief Send data to the index register.
*
* @param[in] index The index register to set
*
* @notapi
*/
static __inline void write_index(uint16_t index) { GDISP_REG = index; }
/**
* @brief Send data to the lcd.
*
* @param[in] data The data to send
*
* @notapi
*/
static __inline void write_data(uint16_t data) { GDISP_RAM = data; }
#if GDISP_HARDWARE_READPIXEL || GDISP_HARDWARE_SCROLL || defined(__DOXYGEN__)
/**
* @brief Read data from the lcd.
*
* @return The data from the lcd
* @note The chip select may need to be asserted/de-asserted
* around the actual spi read
*
* @notapi
*/
static __inline uint16_t read_data(void) { return GDISP_RAM; }
#endif
#endif /* _GDISP_LLD_BOARD_H */
/** @} */

150
drivers/gdisp/SSD1289/gdisp_lld_board_firebullstm32f103.h 100644
View File

@ -0,0 +1,150 @@
/*
ChibiOS/RT - 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/SSD1289/gdisp_lld_board_firebullstm32f103.h
* @brief GDISP Graphic Driver subsystem board interface for the SSD1289 display.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
#define SET_CS palSetPad(GDISP_CMD_PORT, GDISP_CS);
#define CLR_CS palClearPad(GDISP_CMD_PORT, GDISP_CS);
#define SET_RS palSetPad(GDISP_CMD_PORT, GDISP_RS);
#define CLR_RS palClearPad(GDISP_CMD_PORT, GDISP_RS);
#define SET_WR palSetPad(GDISP_CMD_PORT, GDISP_WR);
#define CLR_WR palClearPad(GDISP_CMD_PORT, GDISP_WR);
#define SET_RD palSetPad(GDISP_CMD_PORT, GDISP_RD);
#define CLR_RD palClearPad(GDISP_CMD_PORT, GDISP_RD);
/**
* @brief Initialise the board for the display.
* @notes This board definition uses GPIO and assumes exclusive access to these GPIO pins
*
* @notapi
*/
static __inline void init_board(void) {
// This should set the GPIO port up for the correct hardware config here
// Configure the pins to a well know state
SET_RS; SET_RD; SET_RW; CLR_CS;
}
/**
* @brief Set or clear the lcd reset pin.
*
* @param[in] state TRUE = lcd in reset, FALSE = normal operation
*
* @notapi
*/
static __inline void setpin_reset(bool_t state) {
(void) state;
/* Nothing to do here */
}
/**
* @brief Set the lcd back-light level.
*
* @param[in] percent 0 to 100%
*
* @notapi
*/
static __inline void set_backlight(uint8_t percent) {
(void) percent;
/* Nothing to do here */
}
/**
* @brief Take exclusive control of the bus
*
* @notapi
*/
static __inline void get_bus(void) {
/* Nothing to do here */
}
/**
* @brief Release exclusive control of the bus
*
* @notapi
*/
static __inline void release_bus(void) {
/* Nothing to do here */
}
/**
* @brief Send data to the index register.
*
* @param[in] index The index register to set
*
* @notapi
*/
static __inline void write_index(uint16_t index) {
palWritePort(GDISP_DATA_PORT, index);
CLR_RS; CLR_WR; SET_WR; SET_RS;
}
/**
* @brief Send data to the lcd.
*
* @param[in] data The data to send
*
* @notapi
*/
static __inline void write_data(uint16_t data) {
palWritePort(GDISP_DATA_PORT, data);
CLR_WR; SET_WR;
}
#if GDISP_HARDWARE_READPIXEL || GDISP_HARDWARE_SCROLL || defined(__DOXYGEN__)
/**
* @brief Read data from the lcd.
*
* @return The data from the lcd
* @note The chip select may need to be asserted/de-asserted
* around the actual spi read
*
* @notapi
*/
static __inline uint16_t read_data(void) {
uint16_t value;
// change pin mode to digital input
GDISP_DATA_PORT->CRH = 0x44444444;
GDISP_DATA_PORT->CRL = 0x44444444;
CLR_RD;
value = palReadPort(GDISP_DATA_PORT);
SET_RD;
// change pin mode back to digital output
GDISP_DATA_PORT->CRH = 0x33333333;
GDISP_DATA_PORT->CRL = 0x33333333;
return value;
}
#endif
#endif /* _GDISP_LLD_BOARD_H */
/** @} */

12
drivers/gdisp/SSD1289/readme.txt
View File

@ -5,15 +5,15 @@ To use this driver:
b) Any optional high level driver defines (see gdisp.h) eg: GDISP_NEED_MULTITHREAD
c) One (only) of:
#define GDISP_USE_GPIO
#define GDISP_USE_SPI
#define GDISP_USE_FSMC
c) If you are not using a known board then create a gdisp_lld_board.h file
and ensure it is on your include path.
Use the gdisp_lld_board_example.h or gdisp_lld_board_fsmc.h file as a basis.
Currently known boards are:
BOARD_FIREBULL_STM32_F103 - GPIO interface: requires GDISP_CMD_PORT and GDISP_DATA_PORT to be defined
d) All of the following (with appropriate values):
d) The following are optional - define them if you are not using the defaults below:
#define GDISP_SCREEN_WIDTH 320
#define GDISP_SCREEN_HEIGHT 240
2. To your makefile add the following lines:
include $(GFXLIB)/drivers/gdisp/SSD1289/gdisp_lld.mk

327
drivers/gdisp/SSD1289/ssd1289_lld.c.h
View File

@ -1,327 +0,0 @@
/*
ChibiOS/RT - 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/>.
*/
#ifndef SSD1289_H
#define SSD1289_H
#if defined(GDISP_USE_GPIO)
#define Set_CS palSetPad(GDISP_CMD_PORT, GDISP_CS);
#define Clr_CS palClearPad(GDISP_CMD_PORT, GDISP_CS);
#define Set_RS palSetPad(GDISP_CMD_PORT, GDISP_RS);
#define Clr_RS palClearPad(GDISP_CMD_PORT, GDISP_RS);
#define Set_WR palSetPad(GDISP_CMD_PORT, GDISP_WR);
#define Clr_WR palClearPad(GDISP_CMD_PORT, GDISP_WR);
#define Set_RD palSetPad(GDISP_CMD_PORT, GDISP_RD);
#define Clr_RD palClearPad(GDISP_CMD_PORT, GDISP_RD);
extern void gdisp_write_gpio_lld(uint16_t data);
extern uint16_t gdisp_read_gpio_lld(void);
static __inline void lld_lcdWriteIndex(uint16_t index) {
Clr_RS; Set_RD;
gdisp_write_gpio_lld(index);
Clr_WR; Set_WR;
}
static __inline void lld_lcdWriteData(uint16_t data) {
Set_RS;
gdisp_write_gpio_lld(data);
Clr_WR; Set_WR;
}
static __inline void lld_lcdWriteReg(uint16_t lcdReg,uint16_t lcdRegValue) {
Clr_CS;
lld_lcdWriteIndex(lcdReg);
lld_lcdWriteData(lcdRegValue);
Set_CS;
}
static __inline uint16_t lld_lcdReadData(void) {
uint16_t value;
Set_RS; Set_WR; Clr_RD;
value = gdisp_read_gpio_lld();
Set_RD;
return value;
}
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
uint16_t value;
Clr_CS;
lld_lcdWriteIndex(lcdReg);
value = lld_lcdReadData();
Set_CS;
return value;
}
static __inline void lld_lcdWriteStreamStart(void) {
Clr_CS;
lld_lcdWriteIndex(0x0022);
}
static __inline void lld_lcdWriteStreamStop(void) {
Set_CS;
}
static __inline void lld_lcdWriteStream(uint16_t *buffer, uint16_t size) {
uint16_t i;
Set_RS;
for(i = 0; i < size; i++) { gdisp_write_gpio_lld(buffer[i]); Clr_WR; Set_WR; }
}
static __inline void lld_lcdReadStreamStart(void) {
Clr_CS
lld_lcdWriteIndex(0x0022);
}
static __inline void lld_lcdReadStreamStop(void) {
Set_CS;
}
static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
uint16_t i;
volatile uint16_t dummy;
dummy = lld_lcdReadData();
for(i = 0; i < size; i++) buffer[i] = lld_lcdReadData();
(void)dummy;
}
#elif defined(GDISP_USE_FSMC)
/* LCD Registers */
#define R0 0x00
#define R1 0x01
#define R2 0x02
#define R3 0x03
#define R4 0x04
#define R5 0x05
#define R6 0x06
#define R7 0x07
#define R8 0x08
#define R9 0x09
#define R10 0x0A
#define R12 0x0C
#define R13 0x0D
#define R14 0x0E
#define R15 0x0F
#define R16 0x10
#define R17 0x11
#define R18 0x12
#define R19 0x13
#define R20 0x14
#define R21 0x15
#define R22 0x16
#define R23 0x17
#define R24 0x18
#define R25 0x19
#define R26 0x1A
#define R27 0x1B
#define R28 0x1C
#define R29 0x1D
#define R30 0x1E
#define R31 0x1F
#define R32 0x20
#define R33 0x21
#define R34 0x22
#define R36 0x24
#define R37 0x25
#define R40 0x28
#define R41 0x29
#define R43 0x2B
#define R45 0x2D
#define R48 0x30
#define R49 0x31
#define R50 0x32
#define R51 0x33
#define R52 0x34
#define R53 0x35
#define R54 0x36
#define R55 0x37
#define R56 0x38
#define R57 0x39
#define R59 0x3B
#define R60 0x3C
#define R61 0x3D
#define R62 0x3E
#define R63 0x3F
#define R64 0x40
#define R65 0x41
#define R66 0x42
#define R67 0x43
#define R68 0x44
#define R69 0x45
#define R70 0x46
#define R71 0x47
#define R72 0x48
#define R73 0x49
#define R74 0x4A
#define R75 0x4B
#define R76 0x4C
#define R77 0x4D
#define R78 0x4E
#define R79 0x4F
#define R80 0x50
#define R81 0x51
#define R82 0x52
#define R83 0x53
#define R96 0x60
#define R97 0x61
#define R106 0x6A
#define R118 0x76
#define R128 0x80
#define R129 0x81
#define R130 0x82
#define R131 0x83
#define R132 0x84
#define R133 0x85
#define R134 0x86
#define R135 0x87
#define R136 0x88
#define R137 0x89
#define R139 0x8B
#define R140 0x8C
#define R141 0x8D
#define R143 0x8F
#define R144 0x90
#define R145 0x91
#define R146 0x92
#define R147 0x93
#define R148 0x94
#define R149 0x95
#define R150 0x96
#define R151 0x97
#define R152 0x98
#define R153 0x99
#define R154 0x9A
#define R157 0x9D
#define R192 0xC0
#define R193 0xC1
#define R229 0xE5
#define GDISP_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
#define GDISP_RAM (*((volatile uint16_t *) 0x60020000)) /* RS = 1 */
static __inline void lld_lcdWriteIndex(uint16_t index) { GDISP_REG = index; }
static __inline void lld_lcdWriteData(uint16_t data) { GDISP_RAM = data; }
static __inline void lld_lcdWriteReg(uint16_t lcdReg,uint16_t lcdRegValue) {
GDISP_REG = lcdReg;
GDISP_RAM = lcdRegValue;
}
static __inline uint16_t lld_lcdReadData(void) { return (GDISP_RAM); }
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
volatile uint16_t dummy;
GDISP_REG = lcdReg;
dummy = GDISP_RAM;
return (GDISP_RAM);
}
static __inline void lld_lcdWriteStreamStart(void) { GDISP_REG = 0x0022; }
static __inline void lld_lcdWriteStreamStop(void) {}
static __inline void lld_lcdWriteStream(uint16_t *buffer, uint16_t size) {
uint16_t i;
for(i = 0; i < size; i++) GDISP_RAM = buffer[i];
}
static __inline void lld_lcdReadStreamStart(void) { GDISP_REG = 0x0022; }
static __inline void lld_lcdReadStreamStop(void) {}
static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
uint16_t i;
volatile uint16_t dummy;
dummy = GDISP_RAM; /* throw away first value read */
for(i = 0; i < size; i++) buffer[i] = GDISP_RAM;
}
#elif defined(GDISP_USE_SPI)
#error "gdispSsd1289: GDISP_USE_SPI not implemented yet"
#endif
static __inline void lld_lcdDelay(uint16_t us) {
chThdSleepMicroseconds(us);
}
static void lld_lcdSetCursor(uint16_t x, uint16_t y) {
/* Reg 0x004E is an 8 bit value
* Reg 0x004F is 9 bit
* Use a bit mask to make sure they are not set too high
*/
switch(GDISP.Orientation) {
case GDISP_ROTATE_180:
lld_lcdWriteReg(0x004e, (GDISP_SCREEN_WIDTH-1-x) & 0x00FF);
lld_lcdWriteReg(0x004f, (GDISP_SCREEN_HEIGHT-1-y) & 0x01FF);
break;
case GDISP_ROTATE_0:
lld_lcdWriteReg(0x004e, x & 0x00FF);
lld_lcdWriteReg(0x004f, y & 0x01FF);
break;
case GDISP_ROTATE_270:
lld_lcdWriteReg(0x004e, y & 0x00FF);
lld_lcdWriteReg(0x004f, x & 0x01FF);
break;
case GDISP_ROTATE_90:
lld_lcdWriteReg(0x004e, (GDISP_SCREEN_WIDTH - y - 1) & 0x00FF);
lld_lcdWriteReg(0x004f, (GDISP_SCREEN_HEIGHT - x - 1) & 0x01FF);
break;
}
}
static void lld_lcdSetViewPort(uint16_t x, uint16_t y, uint16_t cx, uint16_t cy) {
lld_lcdSetCursor(x, y);
/* Reg 0x44 - Horizontal RAM address position
* Upper Byte - HEA
* Lower Byte - HSA
* 0 <= HSA <= HEA <= 0xEF
* Reg 0x45,0x46 - Vertical RAM address position
* Lower 9 bits gives 0-511 range in each value
* 0 <= Reg(0x45) <= Reg(0x46) <= 0x13F
*/
switch(GDISP.Orientation) {
case GDISP_ROTATE_0:
lld_lcdWriteReg(0x44, (((x+cx-1) << 8) & 0xFF00 ) | (x & 0x00FF));
lld_lcdWriteReg(0x45, y & 0x01FF);
lld_lcdWriteReg(0x46, (y+cy-1) & 0x01FF);
break;
case GDISP_ROTATE_270:
lld_lcdWriteReg(0x44, (((x+cx-1) << 8) & 0xFF00 ) | (y & 0x00FF));
lld_lcdWriteReg(0x45, x & 0x01FF);
lld_lcdWriteReg(0x46, (x+cx-1) & 0x01FF);
break;
case GDISP_ROTATE_180:
lld_lcdWriteReg(0x44, (((GDISP_SCREEN_WIDTH-x-1) & 0x00FF) << 8) | ((GDISP_SCREEN_WIDTH - (x+cx)) & 0x00FF));
lld_lcdWriteReg(0x45, (GDISP_SCREEN_HEIGHT-(y+cy)) & 0x01FF);
lld_lcdWriteReg(0x46, (GDISP_SCREEN_HEIGHT-y-1) & 0x01FF);
break;
case GDISP_ROTATE_90:
lld_lcdWriteReg(0x44, (((GDISP_SCREEN_WIDTH - y - 1) & 0x00FF) << 8) | ((GDISP_SCREEN_WIDTH - (y+cy)) & 0x00FF));
lld_lcdWriteReg(0x45, (GDISP_SCREEN_HEIGHT - (x+cx)) & 0x01FF);
lld_lcdWriteReg(0x46, (GDISP_SCREEN_HEIGHT - x - 1) & 0x01FF);
break;
}
lld_lcdSetCursor(x, y);
}
static __inline void lld_lcdResetViewPort(void) {
/* ToDo */
}
#endif /* SSD1289_H */