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

Convert Nokia6610GE8 driver to the new format.

Browse source
This commit is contained in:
inmarket 2013-10-19 16:33:56 +10:00
parent ad416c32b3
commit b6986f5b16
7 changed files with 463 additions and 526 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

195
drivers/gdisp/Nokia6610GE8/board_Nokia6610GE8_olimexsam7ex256.h Normal file
View file

@ -0,0 +1,195 @@
/*
* This file is subject to the terms of the GFX License. If a copy of
* the license was not distributed with this file, you can obtain one at:
*
* http://ugfx.org/license.html
*/
/**
* @file drivers/gdisp/Nokia6610GE8/board_Nokia6610GE8_olimexsam7ex256.h
* @brief GDISP Graphic Driver subsystem board interface for the Olimex SAM7-EX256 board.
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
/*
* Set various display properties. These properties mostly depend on the exact controller chip you get.
* The defaults should work for most controllers.
*/
//#define GDISP_GE8_BROKEN_CONTROLLER FALSE // Uncomment this out if you have a controller thats not window wrap broken.
//#define GDISP_SCREEN_HEIGHT 130 // The visible display height
//#define GDISP_SCREEN_WIDTH 130 // The visible display width
//#define GDISP_RAM_X_OFFSET 0 // The x offset of the visible area
//#define GDISP_RAM_Y_OFFSET 2 // The y offset of the visible area
//#define GDISP_SLEEP_SIZE 32 // The size of the sleep mode partial display
//#define GDISP_SLEEP_POS 50 // The position of the sleep mode partial display
//#define GDISP_INITIAL_CONTRAST 38 // The initial contrast percentage
//#define GDISP_INITIAL_BACKLIGHT 100 // The initial backlight percentage
// For a multiple display configuration we would put all this in a structure and then
// set g->priv to that structure.
// ******************************************************
// Pointers to AT91SAM7X256 peripheral data structures
// ******************************************************
static volatile AT91PS_PIO pPIOA = AT91C_BASE_PIOA;
static volatile AT91PS_PIO pPIOB = AT91C_BASE_PIOB;
static volatile AT91PS_SPI pSPI = AT91C_BASE_SPI0;
static volatile AT91PS_PMC pPMC = AT91C_BASE_PMC;
static volatile AT91PS_PDC pPDC = AT91C_BASE_PDC_SPI0;
/* The PWM backlight control is non-linear on this board.
* We pick values here that make it look a bit more linear.
*/
#define PWM_TOP_VALUE 500
#define PWM_BOTTOM_VALUE 200
#define PWM_VALUE(x) (PWM_BOTTOM_VALUE+(PWM_TOP_VALUE-PWM_BOTTOM_VALUE)*(x)/100)
/* PWM configuration structure. The LCD Backlight is on PWM1/PB20 ie PWM2/PIN1 in ChibiOS speak */
static const PWMConfig pwmcfg = {
1000000, /* 1 MHz PWM clock frequency. Ignored as we are using PWM_MCK_DIV_n */
1000, /* PWM period is 1000 cycles. */
NULL,
{
{PWM_MCK_DIV_1 | PWM_OUTPUT_ACTIVE_HIGH | PWM_OUTPUT_PIN1 | PWM_DISABLEPULLUP_PIN1, NULL},
},
};
static bool_t pwmRunning = FALSE;
/**
* @brief Initialise the board for the display.
* @notes Performs the following functions:
* 1. initialise the spi 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(GDisplay *g) {
// As we are not using multiple displays we set g->priv to NULL as we don't use it.
g->priv = 0;
switch(g->controllerdisplay) {
case 0: // Set up for Display 0
// *********************************************************************************************
// InitSpi( )
//
// Sets up SPI channel 0 for communications to Nokia 6610 LCD Display
//
// I/O ports used: PA2 = LCD Reset (set to low to reset)
// PA12 = LCD chip select (set to low to select the LCD chip)
// PA16 = SPI0_MISO Master In - Slave Out (not used in LCD interface)
// PA17 = SPI0_MOSI Master Out - Slave In pin (Serial Data to LCD slave)
// PA18 = SPI0_SPCK Serial Clock (to LCD slave)
// PB20 = backlight control (normally PWM control, 1 = full on)
//
// *********************************************************************************************}
/* This code should really use the ChibiOS driver for these functions */
// Pin for backlight
pPIOB->PIO_CODR = PIOB_LCD_BL_MASK; // Set PB20 to LOW
pPIOB->PIO_OER = PIOB_LCD_BL_MASK; // Configure PB20 as output
// Reset pin
pPIOA->PIO_SODR = PIOA_LCD_RESET_MASK; // Set PA2 to HIGH
pPIOA->PIO_OER = PIOA_LCD_RESET_MASK; // Configure PA2 as output
// CS pin - this seems to be ignored
// 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)
// BIT12 = PA12 -> SPI0_NPCS0 chip select
// 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 = (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
pPMC->PMC_PCER = 1 << AT91C_ID_SPI0;
// Fixed mode
pSPI->SPI_CR = 0x81; //SPI Enable, Software reset
pSPI->SPI_CR = 0x01; //SPI Enable
pSPI->SPI_MR = 0xE0011; //Master mode, fixed select, disable decoder, PCS=1110
pSPI->SPI_CSR[0] = 0x01010311; //9bit, CPOL=1, ClockPhase=0, SCLK = 48Mhz/3 = 16MHz
/* Display backlight control at 100% */
pwmRunning = FALSE;
palSetPad(IOPORT2, PIOB_LCD_BL);
break;
}
}
static inline void post_init_board(GDisplay *g) {
(void) g;
}
static inline void setpin_reset(GDisplay *g, bool_t state) {
(void) g;
if (state)
palClearPad(IOPORT1, PIOA_LCD_RESET);
else
palSetPad(IOPORT1, PIOA_LCD_RESET);
}
static inline void set_backlight(GDisplay *g, uint8_t percent) {
(void) g;
if (percent == 100) {
/* Turn the pin on - No PWM */
if (pwmRunning) {
pwmStop(&PWMD2);
pwmRunning = FALSE;
}
palSetPad(IOPORT2, PIOB_LCD_BL);
} else if (percent == 0) {
/* Turn the pin off - No PWM */
if (pwmRunning) {
pwmStop(&PWMD2);
pwmRunning = FALSE;
}
palClearPad(IOPORT2, PIOB_LCD_BL);
} else {
/* Use the PWM */
if (!pwmRunning) {
pwmStart(&PWMD2, &pwmcfg);
pwmRunning = TRUE;
}
pwmEnableChannel(&PWMD2, 0, PWM_VALUE(percent));
}
}
static inline void acquire_bus(GDisplay *g) {
(void) g;
}
static inline void release_bus(GDisplay *g) {
(void) g;
}
static inline void write_index(GDisplay *g, uint16_t index) {
(void) g;
// wait for the previous transfer to complete
while((pSPI->SPI_SR & AT91C_SPI_TXEMPTY) == 0);
// send the command
pSPI->SPI_TDR = index & 0xFF;
}
static inline void write_data(GDisplay *g, uint16_t data) {
(void) g;
// wait for the previous transfer to complete
while((pSPI->SPI_SR & AT91C_SPI_TXEMPTY) == 0);
// send the data
pSPI->SPI_TDR = data | 0x0100;
}
#endif /* _GDISP_LLD_BOARD_H */

131
drivers/gdisp/Nokia6610GE8/board_Nokia6610GE8_template.h Normal file
View file

@ -0,0 +1,131 @@
/*
* This file is subject to the terms of the GFX License. If a copy of
* the license was not distributed with this file, you can obtain one at:
*
* http://ugfx.org/license.html
*/
/**
* @file drivers/gdisp/Nokia6610GE8/board_Nokia6610GE8_template.h
* @brief GDISP Graphic Driver subsystem board interface for the Nokia6610 GE12 display.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
/*
* Set various display properties. These properties mostly depend on the exact controller chip you get.
* The defaults should work for most controllers.
*/
//#define GDISP_SCREEN_HEIGHT 130 // The visible display height
//#define GDISP_SCREEN_WIDTH 130 // The visible display width
//#define GDISP_RAM_X_OFFSET 0 // The x offset of the visible area
//#define GDISP_RAM_Y_OFFSET 2 // The y offset of the visible area
//#define GDISP_SLEEP_POS 50 // The position of the sleep mode partial display
//#define GDISP_INITIAL_CONTRAST 50 // The initial contrast percentage
//#define GDISP_INITIAL_BACKLIGHT 100 // The initial backlight percentage
/**
* @brief Initialise the board for the display.
*
* @param[in] g The GDisplay structure
*
* @note Set the g->priv member to whatever is appropriate. For multiple
* displays this might be a pointer to the appropriate register set.
*
* @notapi
*/
static inline void init_board(GDisplay *g) {
(void) g;
}
/**
* @brief After the initialisation.
*
* @param[in] g The GDisplay structure
*
* @notapi
*/
static inline void post_init_board(GDisplay *g) {
(void) g;
}
/**
* @brief Set or clear the lcd reset pin.
*
* @param[in] g The GDisplay structure
* @param[in] state TRUE = lcd in reset, FALSE = normal operation
*
* @notapi
*/
static inline void setpin_reset(GDisplay *g, bool_t state) {
(void) g;
(void) state;
}
/**
* @brief Set the lcd back-light level.
*
* @param[in] g The GDisplay structure
* @param[in] percent 0 to 100%
*
* @notapi
*/
static inline void set_backlight(GDisplay *g, uint8_t percent) {
(void) g;
(void) percent;
}
/**
* @brief Take exclusive control of the bus
*
* @param[in] g The GDisplay structure
*
* @notapi
*/
static inline void acquire_bus(GDisplay *g) {
(void) g;
}
/**
* @brief Release exclusive control of the bus
*
* @param[in] g The GDisplay structure
*
* @notapi
*/
static inline void release_bus(GDisplay *g) {
(void) g;
}
/**
* @brief Send data to the index register.
*
* @param[in] g The GDisplay structure
* @param[in] index The index register to set
*
* @notapi
*/
static inline void write_index(GDisplay *g, uint16_t index) {
(void) g;
(void) index;
}
/**
* @brief Send data to the lcd.
*
* @param[in] g The GDisplay structure
* @param[in] data The data to send
*
* @notapi
*/
static inline void write_data(GDisplay *g, uint16_t data) {
(void) g;
(void) data;
}
#endif /* _GDISP_LLD_BOARD_H */
/** @} */

282
drivers/gdisp/Nokia6610GE8/gdisp_lld.c
View file

@ -58,9 +58,11 @@
#undef GDISP_SCREEN_WIDTH #undef GDISP_SCREEN_WIDTH
#endif #endif
#define GDISP_LLD_DECLARATIONS #define GDISP_DRIVER_VMT GDISPVMT_Nokia6610GE8
#include "../drivers/gdisp/Nokia6610GE8/gdisp_lld_config.h"
#include "gdisp/lld/gdisp_lld.h" #include "gdisp/lld/gdisp_lld.h"
#include "gdisp_lld_board.h"
#include "board_Nokia6610GE8.h"
/*===========================================================================*/ /*===========================================================================*/
/* Driver local definitions. */ /* Driver local definitions. */
@ -108,9 +110,9 @@
/*===========================================================================*/ /*===========================================================================*/
#if GDISP_HARDWARE_STREAM_WRITE #if GDISP_HARDWARE_STREAM_WRITE
static color_t savecolor; static color_t savecolor[GDISP_TOTAL_DISPLAYS];
#if GDISP_GE8_BROKEN_CONTROLLER #if GDISP_GE8_BROKEN_CONTROLLER
static color_t firstcolor; static color_t firstcolor[GDISP_TOTAL_DISPLAYS];
#endif #endif
#endif #endif
@ -122,57 +124,86 @@
/*===========================================================================*/ /*===========================================================================*/
// Some macros just to make reading the code easier // Some macros just to make reading the code easier
#define delayms(ms) gfxSleepMilliseconds(ms) #define delayms(ms) gfxSleepMilliseconds(ms)
#define write_data2(d1, d2) { write_data(d1); write_data(d2); } #define write_data2(g, d1, d2) { write_data(g, d1); write_data(g, d2); }
#define write_data3(d1, d2, d3) { write_data(d1); write_data(d2); write_data(d3); } #define write_data3(g, d1, d2, d3) { write_data(g, d1); write_data(g, d2); write_data(g, d3); }
#define write_data4(d1, d2, d3, d4) { write_data(d1); write_data(d2); write_data(d3); write_data(d4); } #define write_data4(g, d1, d2, d3, d4) { write_data(g, d1); write_data(g, d2); write_data(g, d3); write_data(g, d4); }
#define write_cmd1(cmd, d1) { write_cmd(cmd); write_data(d1); } #define write_cmd1(g, cmd, d1) { write_index(g, cmd); write_data(g, d1); }
#define write_cmd2(cmd, d1, d2) { write_cmd(cmd); write_data2(d1, d2); } #define write_cmd2(g, cmd, d1, d2) { write_index(g, cmd); write_data2(g, d1, d2); }
#define write_cmd3(cmd, d1, d2, d3) { write_cmd(cmd); write_data3(d1, d2, d3); } #define write_cmd3(g, cmd, d1, d2, d3) { write_index(g, cmd); write_data3(g, d1, d2, d3); }
#define write_cmd4(cmd, d1, d2, d3, d4) { write_cmd(cmd); write_data4(d1, d2, d3, d4); } #define write_cmd4(g, cmd, d1, d2, d3, d4) { write_index(g, cmd); write_data4(g, d1, d2, d3, d4); }
static inline void set_viewport(GDisplay* g) {
#if GDISP_NOKIA_ORIENTATION && GDISP_NEED_CONTROL
switch(g->g.Orientation) {
case GDISP_ROTATE_0:
write_cmd2(g, CASET, GDISP_RAM_X_OFFSET+g->p.x, GDISP_RAM_X_OFFSET+g->p.x); // Column address set
write_cmd2(g, PASET, GDISP_RAM_Y_OFFSET+g->p.y, GDISP_RAM_Y_OFFSET+g->p.y); // Page address set
break;
case GDISP_ROTATE_90:
write_cmd2(g, CASET, GDISP_RAM_X_OFFSET+g->p.y, GDISP_RAM_X_OFFSET+g->p.y);
write_cmd2(g, PASET, GDISP_RAM_Y_OFFSET-1+g->g.Width-g->p.x, GDISP_RAM_Y_OFFSET-1+g->g.Width-g->p.x);
break;
case GDISP_ROTATE_180:
write_cmd2(g, CASET, GDISP_RAM_X_OFFSET-1+g->g.Width-g->p.x, GDISP_RAM_X_OFFSET-1+g->g.Width-g->p.x);
write_cmd2(g, PASET, GDISP_RAM_Y_OFFSET-1+g->g.Height-g->p.y, GDISP_RAM_Y_OFFSET-1+g->g.Height-g->p.y);
break;
case GDISP_ROTATE_270:
write_cmd2(g, CASET, GDISP_RAM_X_OFFSET-1+g->g.Height-g->p.y, GDISP_RAM_X_OFFSET-1+g->g.Height-g->p.y);
write_cmd2(g, PASET, GDISP_RAM_Y_OFFSET+g->p.x, GDISP_RAM_Y_OFFSET+g->p.x);
break;
}
#else
write_cmd2(g, CASET, GDISP_RAM_X_OFFSET+g->p.x, GDISP_RAM_X_OFFSET+g->p.x+g->p.cx-1); // Column address set
write_cmd2(g, PASET, GDISP_RAM_Y_OFFSET+g->p.y, GDISP_RAM_Y_OFFSET+g->p.y+g->p.cy-1); // Page address set
#endif
write_index(g, RAMWR);
}
/*===========================================================================*/ /*===========================================================================*/
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) { LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
/* Initialise your display */ /* Initialise your display */
init_board(); init_board(g);
// Hardware reset // Hardware reset
setpin_reset(TRUE); setpin_reset(g, TRUE);
delayms(20); delayms(20);
setpin_reset(FALSE); setpin_reset(g, FALSE);
delayms(20); delayms(20);
// Get the bus for the following initialisation commands // Get the bus for the following initialisation commands
acquire_bus(); acquire_bus(g);
write_cmd4(DISCTL, 0x00, GDISP_SCAN_LINES/4-1, 0x0A, 0x00); // Display control - How the controller drives the LCD write_cmd4(g, DISCTL, 0x00, GDISP_SCAN_LINES/4-1, 0x0A, 0x00); // Display control - How the controller drives the LCD
// P1: 0x00 = 2 divisions, switching period=8 (default) // P1: 0x00 = 2 divisions, switching period=8 (default)
// P2: 0x20 = nlines/4 - 1 = 132/4 - 1 = 32) // P2: 0x20 = nlines/4 - 1 = 132/4 - 1 = 32)
// P3: 0x0A = standard inverse highlight, inversion every frame // P3: 0x0A = standard inverse highlight, inversion every frame
// P4: 0x00 = dispersion on // P4: 0x00 = dispersion on
write_cmd1(COMSCN, 0x01); // COM scan - How the LCD is connected to the controller write_cmd1(g, COMSCN, 0x01); // COM scan - How the LCD is connected to the controller
// P1: 0x01 = Scan 1->80, 160<-81 // P1: 0x01 = Scan 1->80, 160<-81
write_cmd(OSCON); // Internal oscillator ON write_index(g, OSCON); // Internal oscillator ON
write_cmd(SLPOUT); // Sleep out write_index(g, SLPOUT); // Sleep out
write_cmd1(PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON write_cmd1(g, PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON
write_cmd3(DATCTL, 0x00, 0x00, 0x02); // Data control write_cmd3(g, DATCTL, 0x00, 0x00, 0x02); // Data control
// P1: 0x00 = page address normal, column address normal, address scan in column direction // P1: 0x00 = page address normal, column address normal, address scan in column direction
// P2: 0x00 = RGB sequence (default value) // P2: 0x00 = RGB sequence (default value)
// P3: 0x02 = 4 bits per colour (Type A) // P3: 0x02 = 4 bits per colour (Type A)
write_cmd2(VOLCTR, 63*GDISP_INITIAL_CONTRAST/100, 0x03); // Voltage control (contrast setting) write_cmd2(g, VOLCTR, 63*GDISP_INITIAL_CONTRAST/100, 0x03); // Voltage control (contrast setting)
// P1 = Contrast (0..63) // P1 = Contrast (0..63)
// P2 = 3 resistance ratio (only value that works) // P2 = 3 resistance ratio (only value that works)
delayms(100); // Allow power supply to stabilise delayms(100); // Allow power supply to stabilise
write_cmd(DISON); // Turn on the display write_index(g, DISON); // Turn on the display
// Finish Init
post_init_board(g);
// Release the bus // Release the bus
release_bus(); release_bus(g);
/* Turn on the back-light */ /* Turn on the back-light */
set_backlight(GDISP_INITIAL_BACKLIGHT); set_backlight(g, GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure to match */ /* Initialise the GDISP structure to match */
g->g.Orientation = GDISP_ROTATE_0; g->g.Orientation = GDISP_ROTATE_0;
@ -185,30 +216,30 @@ LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) {
} }
#if GDISP_HARDWARE_STREAM_WRITE #if GDISP_HARDWARE_STREAM_WRITE
LLDSPEC void gdisp_lld_write_start(GDISPDriver *g) { LLDSPEC void gdisp_lld_write_start(GDisplay *g) {
acquire_bus(); acquire_bus(g);
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.x, GDISP_RAM_X_OFFSET+g->p.x+g->p.cx-1); // Column address set set_viewport(g);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.y, GDISP_RAM_Y_OFFSET+g->p.y+g->p.cy-1); // Page address set
write_cmd(RAMWR);
g->flags &= ~(GDISP_FLG_ODDBYTE|GDISP_FLG_RUNBYTE); g->flags &= ~(GDISP_FLG_ODDBYTE|GDISP_FLG_RUNBYTE);
} }
LLDSPEC void gdisp_lld_write_color(GDISPDriver *g) { LLDSPEC void gdisp_lld_write_color(GDisplay *g) {
#if GDISP_GE8_BROKEN_CONTROLLER #if GDISP_GE8_BROKEN_CONTROLLER
if (!(g->flags & GDISP_FLG_RUNBYTE)) { if (!(g->flags & GDISP_FLG_RUNBYTE)) {
firstcolor = g->p.color; firstcolor[g->controllerdisplay] = g->p.color;
g->flags |= GDISP_FLG_RUNBYTE; g->flags |= GDISP_FLG_RUNBYTE;
} }
#endif #endif
if ((g->flags & GDISP_FLG_ODDBYTE)) { if ((g->flags & GDISP_FLG_ODDBYTE)) {
// Write the pair of pixels to the display // Write the pair of pixels to the display
write_data3(((savecolor >> 4) & 0xFF), (((savecolor << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)), (g->p.color & 0xFF)); write_data3(g, ((savecolor[g->controllerdisplay] >> 4) & 0xFF),
(((savecolor[g->controllerdisplay] << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)),
(g->p.color & 0xFF));
g->flags &= ~GDISP_FLG_ODDBYTE; g->flags &= ~GDISP_FLG_ODDBYTE;
} else { } else {
savecolor = g->p.color; savecolor[g->controllerdisplay] = g->p.color;
g->flags |= GDISP_FLG_ODDBYTE; g->flags |= GDISP_FLG_ODDBYTE;
} }
} }
LLDSPEC void gdisp_lld_write_stop(GDISPDriver *g) { LLDSPEC void gdisp_lld_write_stop(GDisplay *g) {
if ((g->flags & GDISP_FLG_ODDBYTE)) { if ((g->flags & GDISP_FLG_ODDBYTE)) {
#if GDISP_GE8_BROKEN_CONTROLLER #if GDISP_GE8_BROKEN_CONTROLLER
/** /**
@ -229,80 +260,47 @@ LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) {
* user application uses the streaming calls and then terminates the stream early or after buffer wrap. * user application uses the streaming calls and then terminates the stream early or after buffer wrap.
* Since this is such an unlikely situation we just don't handle it. * Since this is such an unlikely situation we just don't handle it.
*/ */
write_data3(((savecolor >> 4) & 0xFF), (((savecolor << 4) & 0xF0)|((firstcolor >> 8) & 0x0F)), (firstcolor & 0xFF)); write_data3(g, ((savecolor[g->controllerdisplay] >> 4) & 0xFF),
(((savecolor[g->controllerdisplay] << 4) & 0xF0)|((firstcolor[g->controllerdisplay] >> 8) & 0x0F)),
(firstcolor[g->controllerdisplay] & 0xFF));
#else #else
write_data2(((savecolor >> 4) & 0xFF), ((savecolor << 4) & 0xF0)); write_data2(g, ((savecolor[g->controllerdisplay] >> 4) & 0xFF), ((savecolor[g->controllerdisplay] << 4) & 0xF0));
write_cmd(NOP); write_index(g, NOP);
#endif #endif
} }
release_bus(); release_bus(g);
} }
#endif #endif
#if GDISP_HARDWARE_DRAWPIXEL #if GDISP_HARDWARE_DRAWPIXEL
LLDSPEC void gdisp_lld_draw_pixel(GDISPDriver *g) { LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
acquire_bus(); acquire_bus(g);
switch(g->g.Orientation) { set_viewport(g);
case GDISP_ROTATE_0: write_data3(g, 0, (g->p.color>>8) & 0x0F, g->p.color & 0xFF);
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.x, GDISP_RAM_X_OFFSET+g->p.x); // Column address set release_bus(g);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.y, GDISP_RAM_Y_OFFSET+g->p.y); // Page address set
break;
case GDISP_ROTATE_90:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.y, GDISP_RAM_X_OFFSET+g->p.y);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET-1+g->g.Width-g->p.x, GDISP_RAM_Y_OFFSET-1+g->g.Width-g->p.x);
break;
case GDISP_ROTATE_180:
write_cmd2(CASET, GDISP_RAM_X_OFFSET-1+g->g.Width-g->p.x, GDISP_RAM_X_OFFSET-1+g->g.Width-g->p.x);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET-1+g->g.Height-g->p.y, GDISP_RAM_Y_OFFSET-1+g->g.Height-g->p.y);
break;
case GDISP_ROTATE_270:
write_cmd2(CASET, GDISP_RAM_X_OFFSET-1+g->g.Height-g->p.y, GDISP_RAM_X_OFFSET-1+g->g.Height-g->p.y);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.x, GDISP_RAM_Y_OFFSET+g->p.x);
break;
}
write_cmd3(RAMWR, 0, (g->p.color>>8) & 0x0F, g->p.color & 0xFF);
release_bus();
} }
#endif #endif
/* ---- Optional Routines ---- */ /* ---- Optional Routines ---- */
#if GDISP_HARDWARE_FILLS #if GDISP_HARDWARE_FILLS
LLDSPEC void gdisp_lld_fill_area(GDISPDriver *g) { LLDSPEC void gdisp_lld_fill_area(GDisplay *g) {
unsigned tuples; unsigned tuples;
tuples = (g->p.cx*g->p.cy+1)>>1; // With an odd sized area we over-print by one pixel. tuples = (g->p.cx*g->p.cy+1)>>1; // With an odd sized area we over-print by one pixel.
// This extra pixel overwrites the first pixel (harmless as it is the same colour) // This extra pixel overwrites the first pixel (harmless as it is the same colour)
acquire_bus(); acquire_bus(g);
switch(g->g.Orientation) { set_viewport(g);
case GDISP_ROTATE_0:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.x, GDISP_RAM_X_OFFSET+g->p.x+g->p.cx-1); // Column address set
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.y, GDISP_RAM_Y_OFFSET+g->p.y+g->p.cy-1); // Page address set
break;
case GDISP_ROTATE_90:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.y, GDISP_RAM_X_OFFSET+g->p.y+g->p.cy-1);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->g.Width-g->p.x-g->p.cx, GDISP_RAM_Y_OFFSET+g->g.Width-g->p.x-1);
break;
case GDISP_ROTATE_180:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->g.Width-g->p.x-g->p.cx, GDISP_RAM_X_OFFSET+g->g.Width-g->p.x-1);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->g.Height-g->p.y-g->p.cy, GDISP_RAM_Y_OFFSET+g->g.Height-g->p.y-1);
break;
case GDISP_ROTATE_270:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->g.Height-g->p.y-g->p.cy, GDISP_RAM_X_OFFSET+g->g.Height-g->p.y-1);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.x, GDISP_RAM_Y_OFFSET+g->p.x+g->p.cx-1);
break;
}
write_cmd(RAMWR);
while(tuples--) while(tuples--)
write_data3(((g->p.color >> 4) & 0xFF), (((g->p.color << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)), (g->p.color & 0xFF)); write_data3(g, ((g->p.color >> 4) & 0xFF), (((g->p.color << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)), (g->p.color & 0xFF));
release_bus(); release_bus(g);
} }
#endif #endif
#if GDISP_HARDWARE_BITFILLS #if GDISP_HARDWARE_BITFILLS
LLDSPEC void gdisp_lld_blit_area(GDISPDriver *g) { LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
coord_t lg, x, y; coord_t lg, x, y;
color_t c1, c2; color_t c1, c2;
unsigned tuples; unsigned tuples;
@ -318,26 +316,8 @@ LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) {
buffer = (const pixel_t *)g->p.ptr; buffer = (const pixel_t *)g->p.ptr;
/* Set up the data window to transfer */ /* Set up the data window to transfer */
acquire_bus(); acquire_bus(g);
switch(g->g.Orientation) { set_viewport(g);
case GDISP_ROTATE_0:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.x, GDISP_RAM_X_OFFSET+g->p.x+g->p.cx-1); // Column address set
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.y, GDISP_RAM_Y_OFFSET+g->p.y+g->p.cy-1); // Page address set
break;
case GDISP_ROTATE_90:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->p.y, GDISP_RAM_X_OFFSET+g->p.y+g->p.cy-1);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->g.Width-g->p.x-g->p.cx, GDISP_RAM_Y_OFFSET+g->g.Width-g->p.x-1);
break;
case GDISP_ROTATE_180:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->g.Width-g->p.x-g->p.cx, GDISP_RAM_X_OFFSET+g->g.Width-g->p.x-1);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->g.Height-g->p.y-g->p.cy, GDISP_RAM_Y_OFFSET+g->g.Height-g->p.y-1);
break;
case GDISP_ROTATE_270:
write_cmd2(CASET, GDISP_RAM_X_OFFSET+g->g.Height-g->p.y-g->p.cy, GDISP_RAM_X_OFFSET+g->g.Height-g->p.y-1);
write_cmd2(PASET, GDISP_RAM_Y_OFFSET+g->p.x, GDISP_RAM_Y_OFFSET+g->p.x+g->p.cx-1);
break;
}
write_cmd(RAMWR);
/* /*
* Due to the way the Nokia6610 handles a decrementing column or page, * Due to the way the Nokia6610 handles a decrementing column or page,
@ -389,7 +369,7 @@ LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) {
} }
/* Write the pair of pixels to the display */ /* Write the pair of pixels to the display */
write_data3(((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF)); write_data3(g, ((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF));
} }
#else #else
@ -445,17 +425,17 @@ LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) {
} }
/* Write the pair of pixels to the display */ /* Write the pair of pixels to the display */
write_data3(((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF)); write_data3(g, ((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF));
} }
#endif #endif
/* All done */ /* All done */
release_bus(); release_bus(g);
} }
#endif #endif
#if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL #if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
LLDSPEC void gdisp_lld_control(GDISPDriver *g) { LLDSPEC void gdisp_lld_control(GDisplay *g) {
/* The hardware is capable of supporting... /* The hardware is capable of supporting...
* GDISP_CONTROL_POWER - supported * GDISP_CONTROL_POWER - supported
* GDISP_CONTROL_ORIENTATION - supported * GDISP_CONTROL_ORIENTATION - supported
@ -466,96 +446,96 @@ LLDSPEC bool_t gdisp_lld_init(GDISPDriver *g) {
case GDISP_CONTROL_POWER: case GDISP_CONTROL_POWER:
if (g->g.Powermode == (powermode_t)g->p.ptr) if (g->g.Powermode == (powermode_t)g->p.ptr)
return; return;
acquire_bus(); acquire_bus(g);
switch((powermode_t)g->p.ptr) { switch((powermode_t)g->p.ptr) {
case powerOff: case powerOff:
set_backlight(0); // Turn off the backlight set_backlight(g, 0); // Turn off the backlight
write_cmd(DISOFF); // Turn off the display write_index(g, DISOFF); // Turn off the display
write_cmd1(PWRCTR, 0x00); // Power control - all off write_cmd1(g, PWRCTR, 0x00); // Power control - all off
write_cmd(SLPIN); // Sleep in write_index(g, SLPIN); // Sleep in
write_cmd(OSCOFF); // Internal oscillator off write_index(g, OSCOFF); // Internal oscillator off
break; break;
case powerOn: case powerOn:
write_cmd(OSCON); // Internal oscillator on write_index(g, OSCON); // Internal oscillator on
write_cmd(SLPOUT); // Sleep out write_index(g, SLPOUT); // Sleep out
write_cmd1(PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON write_cmd1(g, PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON
write_cmd2(VOLCTR, g->g.Contrast, 0x03); // Voltage control (contrast setting) write_cmd2(g, VOLCTR, g->g.Contrast, 0x03); // Voltage control (contrast setting)
delayms(100); // Allow power supply to stabilise delayms(100); // Allow power supply to stabilise
write_cmd(DISON); // Turn on the display write_index(g, DISON); // Turn on the display
write_cmd(PTLOUT); // Remove sleep window write_index(g, PTLOUT); // Remove sleep window
set_backlight(g->g.Backlight); // Turn on the backlight set_backlight(g, g->g.Backlight); // Turn on the backlight
break; break;
case powerSleep: case powerSleep:
write_cmd(OSCON); // Internal oscillator on write_index(g, OSCON); // Internal oscillator on
write_cmd(SLPOUT); // Sleep out write_index(g, SLPOUT); // Sleep out
write_cmd1(PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON write_cmd1(g, PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON
write_cmd2(VOLCTR, g->g.Contrast, 0x03); // Voltage control (contrast setting) write_cmd2(g, VOLCTR, g->g.Contrast, 0x03); // Voltage control (contrast setting)
delayms(100); // Allow power supply to stabilise delayms(100); // Allow power supply to stabilise
write_cmd(DISON); // Turn on the display write_index(g, DISON); // Turn on the display
write_cmd2(PTLIN, GDISP_SLEEP_POS/4, (GDISP_SLEEP_POS+GDISP_SLEEP_SIZE)/4); // Sleep Window write_cmd2(g, PTLIN, GDISP_SLEEP_POS/4, (GDISP_SLEEP_POS+GDISP_SLEEP_SIZE)/4); // Sleep Window
set_backlight(g->g.Backlight); // Turn on the backlight set_backlight(g, g->g.Backlight); // Turn on the backlight
break; break;
case powerDeepSleep: case powerDeepSleep:
write_cmd(OSCON); // Internal oscillator on write_index(g, OSCON); // Internal oscillator on
write_cmd(SLPOUT); // Sleep out write_index(g, SLPOUT); // Sleep out
write_cmd1(PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON write_cmd1(g, PWRCTR, 0x0F); // Power control - reference voltage regulator on, circuit voltage follower on, BOOST ON
write_cmd2(VOLCTR, g->g.Contrast, 0x03); // Voltage control (contrast setting) write_cmd2(g, VOLCTR, g->g.Contrast, 0x03); // Voltage control (contrast setting)
delayms(100); // Allow power supply to stabilise delayms(100); // Allow power supply to stabilise
write_cmd(DISON); // Turn on the display write_index(g, DISON); // Turn on the display
write_cmd2(PTLIN, GDISP_SLEEP_POS/4, (GDISP_SLEEP_POS+GDISP_SLEEP_SIZE)/4); // Sleep Window write_cmd2(g, PTLIN, GDISP_SLEEP_POS/4, (GDISP_SLEEP_POS+GDISP_SLEEP_SIZE)/4); // Sleep Window
set_backlight(0); // Turn off the backlight set_backlight(g, 0); // Turn off the backlight
break; break;
default: default:
release_bus(); release_bus(g);
return; return;
} }
release_bus(); release_bus(g);
g->g.Powermode = (powermode_t)g->p.ptr; g->g.Powermode = (powermode_t)g->p.ptr;
return; return;
#if GDISP_NOKIA_ORIENTATION #if GDISP_NOKIA_ORIENTATION
case GDISP_CONTROL_ORIENTATION: case GDISP_CONTROL_ORIENTATION:
if (g->g.Orientation == (orientation_t)g->p.ptr) if (g->g.Orientation == (orientation_t)g->p.ptr)
return; return;
acquire_bus(); acquire_bus(g);
switch((orientation_t)g->p.ptr) { switch((orientation_t)g->p.ptr) {
case GDISP_ROTATE_0: case GDISP_ROTATE_0:
write_cmd3(DATCTL, 0x00, 0x00, 0x02); // P1: page normal, column normal, scan in column direction write_cmd3(g, DATCTL, 0x00, 0x00, 0x02); // P1: page normal, column normal, scan in column direction
g->g.Height = GDISP_SCREEN_HEIGHT; g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH; g->g.Width = GDISP_SCREEN_WIDTH;
break; break;
case GDISP_ROTATE_90: case GDISP_ROTATE_90:
write_cmd3(DATCTL, 0x05, 0x00, 0x02); // P1: page reverse, column normal, scan in page direction write_cmd3(g, DATCTL, 0x05, 0x00, 0x02); // P1: page reverse, column normal, scan in page direction
g->g.Height = GDISP_SCREEN_WIDTH; g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT; g->g.Width = GDISP_SCREEN_HEIGHT;
break; break;
case GDISP_ROTATE_180: case GDISP_ROTATE_180:
write_cmd3(DATCTL, 0x03, 0x00, 0x02); // P1: page reverse, column reverse, scan in column direction write_cmd3(g, DATCTL, 0x03, 0x00, 0x02); // P1: page reverse, column reverse, scan in column direction
g->g.Height = GDISP_SCREEN_HEIGHT; g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH; g->g.Width = GDISP_SCREEN_WIDTH;
break; break;
case GDISP_ROTATE_270: case GDISP_ROTATE_270:
write_cmd3(DATCTL, 0x06, 0x00, 0x02); // P1: page normal, column reverse, scan in page direction write_cmd3(g, DATCTL, 0x06, 0x00, 0x02); // P1: page normal, column reverse, scan in page direction
g->g.Height = GDISP_SCREEN_WIDTH; g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT; g->g.Width = GDISP_SCREEN_HEIGHT;
break; break;
default: default:
release_bus(); release_bus(g);
return; return;
} }
release_bus(); release_bus(g);
g->g.Orientation = (orientation_t)g->p.ptr; g->g.Orientation = (orientation_t)g->p.ptr;
return; return;
#endif #endif
case GDISP_CONTROL_BACKLIGHT: case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100; if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
set_backlight((unsigned)g->p.ptr); set_backlight(g, (unsigned)g->p.ptr);
g->g.Backlight = (unsigned)g->p.ptr; g->g.Backlight = (unsigned)g->p.ptr;
return; return;
case GDISP_CONTROL_CONTRAST: case GDISP_CONTROL_CONTRAST:
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100; if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
acquire_bus(); acquire_bus(g);
write_cmd2(VOLCTR, 63*(unsigned)g->p.ptr/100, 0x03); write_cmd2(g, VOLCTR, 63*(unsigned)g->p.ptr/100, 0x03);
release_bus(); release_bus(g);
g->g.Contrast = (unsigned)g->p.ptr; g->g.Contrast = (unsigned)g->p.ptr;
return; return;
} }

5
drivers/gdisp/Nokia6610GE8/gdisp_lld.mk
View file

@ -1,5 +1,2 @@
# List the required driver.
GFXSRC += $(GFXLIB)/drivers/gdisp/Nokia6610GE8/gdisp_lld.c
# Required include directories
GFXINC += $(GFXLIB)/drivers/gdisp/Nokia6610GE8 GFXINC += $(GFXLIB)/drivers/gdisp/Nokia6610GE8
GFXSRC += $(GFXLIB)/drivers/gdisp/Nokia6610GE8/gdisp_lld.c

235
drivers/gdisp/Nokia6610GE8/gdisp_lld_board_olimexsam7ex256.h
View file

@ -1,235 +0,0 @@
/*
* This file is subject to the terms of the GFX License. If a copy of
* the license was not distributed with this file, you can obtain one at:
*
* http://ugfx.org/license.html
*/
/**
* @file drivers/gdisp/Nokia6610GE8/gdisp_lld_board_olimexsam7ex256.h
* @brief GDISP Graphic Driver subsystem board interface for the Olimex SAM7-EX256 board.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
/*
* Set various display properties. These properties mostly depend on the exact controller chip you get.
* The defaults should work for most controllers.
*/
//#define GDISP_GE8_BROKEN_CONTROLLER FALSE // Uncomment this out if you have a controller thats not window wrap broken.
//#define GDISP_SCREEN_HEIGHT 130 // The visible display height
//#define GDISP_SCREEN_WIDTH 130 // The visible display width
//#define GDISP_RAM_X_OFFSET 0 // The x offset of the visible area
//#define GDISP_RAM_Y_OFFSET 2 // The y offset of the visible area
//#define GDISP_SLEEP_SIZE 32 // The size of the sleep mode partial display
//#define GDISP_SLEEP_POS 50 // The position of the sleep mode partial display
//#define GDISP_INITIAL_CONTRAST 38 // The initial contrast percentage
//#define GDISP_INITIAL_BACKLIGHT 100 // The initial backlight percentage
// ******************************************************
// Pointers to AT91SAM7X256 peripheral data structures
// ******************************************************
static volatile AT91PS_PIO pPIOA = AT91C_BASE_PIOA;
static volatile AT91PS_PIO pPIOB = AT91C_BASE_PIOB;
static volatile AT91PS_SPI pSPI = AT91C_BASE_SPI0;
static volatile AT91PS_PMC pPMC = AT91C_BASE_PMC;
static volatile AT91PS_PDC pPDC = AT91C_BASE_PDC_SPI0;
/* The PWM backlight control is non-linear on this board.
* We pick values here that make it look a bit more linear.
*/
#define PWM_TOP_VALUE 500
#define PWM_BOTTOM_VALUE 200
#define PWM_VALUE(x) (PWM_BOTTOM_VALUE+(PWM_TOP_VALUE-PWM_BOTTOM_VALUE)*(x)/100)
/* PWM configuration structure. The LCD Backlight is on PWM1/PB20 ie PWM2/PIN1 in ChibiOS speak */
static const PWMConfig pwmcfg = {
1000000, /* 1 MHz PWM clock frequency. Ignored as we are using PWM_MCK_DIV_n */
1000, /* PWM period is 1000 cycles. */
NULL,
{
{PWM_MCK_DIV_1 | PWM_OUTPUT_ACTIVE_HIGH | PWM_OUTPUT_PIN1 | PWM_DISABLEPULLUP_PIN1, NULL},
},
};
static bool_t pwmRunning = FALSE;
/**
* @brief Initialise the board for the display.
* @notes Performs the following functions:
* 1. initialise the spi 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) {
// *********************************************************************************************
// InitSpi( )
//
// Sets up SPI channel 0 for communications to Nokia 6610 LCD Display
//
// I/O ports used: PA2 = LCD Reset (set to low to reset)
// PA12 = LCD chip select (set to low to select the LCD chip)
// PA16 = SPI0_MISO Master In - Slave Out (not used in LCD interface)
// PA17 = SPI0_MOSI Master Out - Slave In pin (Serial Data to LCD slave)
// PA18 = SPI0_SPCK Serial Clock (to LCD slave)
// PB20 = backlight control (normally PWM control, 1 = full on)
//
// *********************************************************************************************}
/* This code should really use the ChibiOS driver for these functions */
// Pin for backlight
pPIOB->PIO_CODR = PIOB_LCD_BL_MASK; // Set PB20 to LOW
pPIOB->PIO_OER = PIOB_LCD_BL_MASK; // Configure PB20 as output
// Reset pin
pPIOA->PIO_SODR = PIOA_LCD_RESET_MASK; // Set PA2 to HIGH
pPIOA->PIO_OER = PIOA_LCD_RESET_MASK; // Configure PA2 as output
// CS pin - this seems to be ignored
// 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)
// BIT12 = PA12 -> SPI0_NPCS0 chip select
// 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 = (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
pPMC->PMC_PCER = 1 << AT91C_ID_SPI0;
// Fixed mode
pSPI->SPI_CR = 0x81; //SPI Enable, Software reset
pSPI->SPI_CR = 0x01; //SPI Enable
pSPI->SPI_MR = 0xE0011; //Master mode, fixed select, disable decoder, PCS=1110
pSPI->SPI_CSR[0] = 0x01010311; //9bit, CPOL=1, ClockPhase=0, SCLK = 48Mhz/3 = 16MHz
/* Display backlight control at 100% */
pwmRunning = FALSE;
palSetPad(IOPORT2, PIOB_LCD_BL);
}
/**
* @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) {
if (state)
palClearPad(IOPORT1, PIOA_LCD_RESET);
else
palSetPad(IOPORT1, PIOA_LCD_RESET);
}
/**
* @brief Set the lcd back-light level.
* @note For now 0% turns the backlight off, anything else the backlight is on.
* While the hardware supports PWM backlight control, we are not using it
* yet.
*
* @param[in] percent 0 to 100%
*
* @notapi
*/
static inline void set_backlight(uint8_t percent) {
if (percent == 100) {
/* Turn the pin on - No PWM */
if (pwmRunning) {
pwmStop(&PWMD2);
pwmRunning = FALSE;
}
palSetPad(IOPORT2, PIOB_LCD_BL);
} else if (percent == 0) {
/* Turn the pin off - No PWM */
if (pwmRunning) {
pwmStop(&PWMD2);
pwmRunning = FALSE;
}
palClearPad(IOPORT2, PIOB_LCD_BL);
} else {
/* Use the PWM */
if (!pwmRunning) {
pwmStart(&PWMD2, &pwmcfg);
pwmRunning = TRUE;
}
pwmEnableChannel(&PWMD2, 0, PWM_VALUE(percent));
}
}
/**
* @brief Take exclusive control of the bus
*
* @notapi
*/
static inline void acquire_bus(void) {
/* Nothing to do for this board as the LCD is the only device on the SPI port */
}
/**
* @brief Release exclusive control of the bus
*
* @notapi
*/
static inline void release_bus(void) {
// Nothing to do for this board as the LCD is the only device on the SPI port
}
/**
* @brief Send an 8 bit command to the lcd.
*
* @param[in] cmd The command to send
*
* @notapi
*/
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 = cmd & 0xFF;
}
/**
* @brief Send an 8 bit data to the lcd.
*
* @param[in] data The data to send
*
* @notapi
*/
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
pSPI->SPI_TDR = data | 0x0100;
}
#if GDISP_HARDWARE_READPIXEL || GDISP_HARDWARE_SCROLL || defined(__DOXYGEN__)
/**
* @brief Read data from the lcd.
*
* @return The data from the lcd
*
* @notapi
*/
static inline uint16_t read_data(void) {
#error "gdispNokia6610GE8: GDISP_HARDWARE_READPIXEL and GDISP_HARDWARE_SCROLL are not supported on this board"
return pSPI->SPI_RDR;
}
#endif
#endif /* _GDISP_LLD_BOARD_H */
/** @} */

128
drivers/gdisp/Nokia6610GE8/gdisp_lld_board_template.h
View file

@ -1,128 +0,0 @@
/*
* This file is subject to the terms of the GFX License. If a copy of
* the license was not distributed with this file, you can obtain one at:
*
* http://ugfx.org/license.html
*/
/**
* @file drivers/gdisp/Nokia6610GE8/gdisp_lld_board_template.h
* @brief GDISP Graphic Driver subsystem board interface for the Nokia6610 GE8 display.
*
* @addtogroup GDISP
* @{
*/
#ifndef _GDISP_LLD_BOARD_H
#define _GDISP_LLD_BOARD_H
/*
* Set various display properties. These properties mostly depend on the exact controller chip you get.
* The defaults should work for most controllers.
*/
//#define GDISP_GE8_BROKEN_CONTROLLER FALSE // Uncomment this out if you have a controller thats not window wrap broken.
//#define GDISP_SCREEN_HEIGHT 130 // The visible display height
//#define GDISP_SCREEN_WIDTH 130 // The visible display width
//#define GDISP_RAM_X_OFFSET 0 // The x offset of the visible area
//#define GDISP_RAM_Y_OFFSET 2 // The y offset of the visible area
//#define GDISP_SLEEP_SIZE 32 // The size of the sleep mode partial display
//#define GDISP_SLEEP_POS 50 // The position of the sleep mode partial display
//#define GDISP_INITIAL_CONTRAST 38 // The initial contrast percentage
//#define GDISP_INITIAL_BACKLIGHT 100 // The initial backlight percentage
/**
* @brief Initialise the board for the display.
* @notes Performs the following functions:
* 1. initialise the spi 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) {
}
/**
* @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) {
}
/**
* @brief Set the lcd back-light level.
* @note For now 0% turns the backlight off, anything else the backlight is on.
* While the hardware supports PWM backlight control, we are not using it
* yet.
*
* @param[in] percent 0 to 100%
*
* @notapi
*/
static inline void set_backlight(uint8_t percent) {
}
/**
* @brief Take exclusive control of the bus
*
* @notapi
*/
static inline void acquire_bus(void) {
}
/**
* @brief Release exclusive control of the bus
*
* @notapi
*/
static inline void release_bus(void) {
}
/**
* @brief Send an 8 bit command to the lcd.
*
* @param[in] cmd The command to send
*
* @notapi
*/
static inline void write_cmd(uint16_t cmd) {
}
/**
* @brief Send an 8 bit data to the lcd.
*
* @param[in] data The data to send
*
* @notapi
*/
static inline void write_data(uint16_t 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) {
}
#endif
#endif /* _GDISP_LLD_BOARD_H */
/** @} */

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

@ -22,9 +22,11 @@
/* Driver hardware support. */ /* Driver hardware support. */
/*===========================================================================*/ /*===========================================================================*/
#define GDISP_DRIVER_NAME "Nokia6610GE8" /* This driver has problems with other orientations and requires significantly
#define GDISP_DRIVER_STRUCT GDISP_Nokia6610GE8 * extra code to handle them. By default we turn this on (only if the GDISP_NEED_CONTROL
* is turned on). If you are worried about code size and don't need orientation support
* define GDISP_NOKIA_ORIENTATION as false.
*/
#ifndef GDISP_NOKIA_ORIENTATION #ifndef GDISP_NOKIA_ORIENTATION
#define GDISP_NOKIA_ORIENTATION TRUE #define GDISP_NOKIA_ORIENTATION TRUE
#endif #endif
@ -40,11 +42,6 @@
#endif #endif
#define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB444 #define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB444
/* This driver supports both packed and unpacked pixel formats and line formats.
* By default we leave these as FALSE.
*/
#define GDISP_PACKED_PIXELS FALSE
#define GDISP_PACKED_LINES FALSE
#endif /* GFX_USE_GDISP */ #endif /* GFX_USE_GDISP */