diff --git a/drivers/gdisp/SSD1312/.gdisp_lld_SSD1312.c.swp b/drivers/gdisp/SSD1312/.gdisp_lld_SSD1312.c.swp new file mode 100644 index 00000000..4de69047 Binary files /dev/null and b/drivers/gdisp/SSD1312/.gdisp_lld_SSD1312.c.swp differ diff --git a/drivers/gdisp/SSD1312/SSD1312.h b/drivers/gdisp/SSD1312/SSD1312.h new file mode 100644 index 00000000..3559fa37 --- /dev/null +++ b/drivers/gdisp/SSD1312/SSD1312.h @@ -0,0 +1,28 @@ +/* + * 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.io/license.html + */ + +#ifndef _SSD1322_H +#define _SSD1322_H + +#define CMD_DISPLAY_START_LINE 0x40 +#define CMD_CONTRAST_CONTROL 0x81 +#define CMD_CHARGE_PUMP 0x8D +#define CMD_SEGMENT_REMAP 0xA1 +#define CMD_MULTIPLEX_RATIO 0xA8 +#define CMD_REFERENCE 0xAD +#define CMD_DISPLAY_OFF 0xAE +#define CMD_DISPLAY_ON 0xAF +#define CMD_COM_OUTPUT_SCAN_DIR 0xC0 +#define CMD_DISPLAY_OFFSET 0xD3 +#define CMD_CLOCK_DIVIDER 0xD5 +#define CMD_PRECHARGE_PERIOD 0xD9 +#define CMD_COM_HARDWARE_CFG 0xDA +#define CMD_VCOMH_SELECT_LEVEL 0xDB +#define CMD_LOCK 0xFD + +#endif /* _SSD1322_H */ + diff --git a/drivers/gdisp/SSD1312/board_SSD1312_template.h b/drivers/gdisp/SSD1312/board_SSD1312_template.h new file mode 100644 index 00000000..754701ed --- /dev/null +++ b/drivers/gdisp/SSD1312/board_SSD1312_template.h @@ -0,0 +1,51 @@ +/* + * 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.io/license.html + */ + +#ifndef _GDISP_LLD_BOARD_H +#define _GDISP_LLD_BOARD_H + +static GFXINLINE void init_board(GDisplay *g) +{ + (void) g; +} + +static GFXINLINE void post_init_board(GDisplay *g) +{ + (void) g; +} + +static GFXINLINE void setpin_reset(GDisplay *g, gBool state) +{ + (void) g; + (void) state; +} + +static GFXINLINE void acquire_bus(GDisplay *g) +{ + (void) g; +} + +static GFXINLINE void release_bus(GDisplay *g) +{ + (void) g; +} + + +static GFXINLINE void write_cmd(GDisplay *g, gU8 cmd) +{ + (void) g; + (void) cmd; +} + +static GFXINLINE void write_data(GDisplay *g, gU8 data) +{ + (void) g; + (void) data; +} + +#endif // _GDISP_LLD_BOARD_H + diff --git a/drivers/gdisp/SSD1312/driver.mk b/drivers/gdisp/SSD1312/driver.mk new file mode 100644 index 00000000..e091a878 --- /dev/null +++ b/drivers/gdisp/SSD1312/driver.mk @@ -0,0 +1,3 @@ +GFXINC += $(GFXLIB)/drivers/gdisp/SSD1312 +GFXSRC += $(GFXLIB)/drivers/gdisp/SSD1312/gdisp_lld_SSD1312.c + diff --git a/drivers/gdisp/SSD1312/gdisp_lld_SSD1312.c b/drivers/gdisp/SSD1312/gdisp_lld_SSD1312.c new file mode 100644 index 00000000..d8fff4f4 --- /dev/null +++ b/drivers/gdisp/SSD1312/gdisp_lld_SSD1312.c @@ -0,0 +1,366 @@ +/* + * 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.io/license.html + */ + +#include "gfx.h" + +#if GFX_USE_GDISP + +#define GDISP_DRIVER_VMT GDISPVMT_SSD1312 +#include "gdisp_lld_config.h" +#include "../../../src/gdisp/gdisp_driver.h" + +#include "board_SSD1312.h" + +/*===========================================================================*/ +/* Driver local definitions. */ +/*===========================================================================*/ + +#ifndef GDISP_SCREEN_HEIGHT + #define GDISP_SCREEN_HEIGHT 32 // This controller should also support 64 (untested) +#endif +#ifndef GDISP_SCREEN_WIDTH + #define GDISP_SCREEN_WIDTH 128 +#endif +#ifndef GDISP_INITIAL_CONTRAST + #define GDISP_INITIAL_CONTRAST 100 +#endif +#ifndef GDISP_INITIAL_BACKLIGHT + #define GDISP_INITIAL_BACKLIGHT 100 +#endif +#ifdef SSD1312_PAGE_PREFIX + #define SSD1312_PAGE_WIDTH (GDISP_SCREEN_WIDTH+1) + #define SSD1312_PAGE_OFFSET 1 +#else + #define SSD1312_PAGE_WIDTH GDISP_SCREEN_WIDTH + #define SSD1312_PAGE_OFFSET 0 +#endif + +#define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER<<0) + +#include "SSD1312.h" + +/*===========================================================================*/ +/* Driver local functions. */ +/*===========================================================================*/ + +// Some common routines and macros +#define RAM(g) ((gU8 *)g->priv) +#define xyaddr(x, y) (SSD1312_PAGE_OFFSET + (x) + ((y)>>3)*SSD1312_PAGE_WIDTH) +#define xybit(y) (1<<((y)&7)) + +/*===========================================================================*/ +/* Driver exported functions. */ +/*===========================================================================*/ + +/** + * As this controller can't update on a pixel boundary we need to maintain the + * the entire display surface in memory so that we can do the necessary bit + * operations. Fortunately it is a small display in 4 bit grayscale. + * 64 * 128 / 2 = 4096 bytes. + */ + +LLDSPEC gBool gdisp_lld_init(GDisplay *g) +{ + // The private area is the display surface. + g->priv = gfxAlloc(GDISP_SCREEN_HEIGHT/8 * SSD1312_PAGE_WIDTH); + + // Fill in the prefix command byte on each page line of the display buffer + // We can do it during initialisation as this byte is never overwritten. + #ifdef SSD1312_PAGE_PREFIX + for (unsigned i = 0; i < GDISP_SCREEN_HEIGHT/8 * SSD1312_PAGE_WIDTH; i += SSD1312_PAGE_WIDTH) + RAM(g)[i] = SSD1312_PAGE_PREFIX; + #endif + + // Initialise the board interface + init_board(g); + + // Hardware reset + setpin_reset(g, gTrue); + gfxSleepMilliseconds(20); + setpin_reset(g, gFalse); + gfxSleepMilliseconds(200); + + // Display off + write_cmd(g, 0xAE); + + // Clock divider + write_cmd2(g, 0xD5, 0x80); + + // Multiplex ratio + write_cmd2(g, 0xA8, 0x1F); + + // Display offset + write_cmd2(g, 0xD3, 0x30); + + // Display start line + write_cmd(g, 0x40); + + // Charge pump + write_cmd2(g, 0x8D, 0x72); // 0x10 if Vcc externally supplied + + // Segment re-map + write_cmd(g, 0xA1); + + // COM output scan direction + write_cmd(g, 0xC0); + + // COM pin hardware configuration + write_cmd2(g, 0xDA, 0x10); + + // Set internal/external current reference + write_cmd2(g, 0xAD, 0x50); + + // Set contract + // ToDo: Also add to GDISP control interface below + write_cmd2(g, 0x81, 0x17); + + // Set pre-charge period + write_cmd2(g, 0xD9, 0xF1); + + // Set VCOMH select level + write_cmd2(g, 0xDB, 0x30); + + // Set entire display on/off + write_cmd(g, 0xA4); + + // Set normal/inverse display + write_cmd(g, 0xA6); + + // Display on + write_cmd(g, 0xAF); + + // Finish Init + post_init_board(g); + + // Initialise the GDISP structure + g->g.Width = GDISP_SCREEN_WIDTH; + g->g.Height = GDISP_SCREEN_HEIGHT; + g->g.Orientation = gOrientation0; + g->g.Powermode = gPowerOn; + g->g.Backlight = GDISP_INITIAL_BACKLIGHT; + g->g.Contrast = GDISP_INITIAL_CONTRAST; + + return gTrue; +} + +#if GDISP_HARDWARE_FLUSH + LLDSPEC void gdisp_lld_flush(GDisplay *g) { + gU8 * ram; + unsigned pages; + + // Don't flush if we don't need it. + if (!(g->flags & GDISP_FLG_NEEDFLUSH)) + return; + + ram = RAM(g); + pages = GDISP_SCREEN_HEIGHT/8; + + acquire_bus(g); + write_cmd(g, CMD_DISPLAY_START_LINE); + while (pages--) { + write_data(g, ram, SSD1312_PAGE_WIDTH); + ram += SSD1312_PAGE_WIDTH; + } + release_bus(g); + + g->flags &= ~GDISP_FLG_NEEDFLUSH; + } +#endif + +#if GDISP_HARDWARE_FILLS + LLDSPEC void gdisp_lld_fill_area(GDisplay *g) { + gCoord sy, ey; + gCoord sx, ex; + gCoord col; + unsigned spage, zpages; + gU8 * base; + gU8 mask; + + switch(g->g.Orientation) { + default: + case gOrientation0: + sx = g->p.x; + ex = g->p.x + g->p.cx - 1; + sy = g->p.y; + ey = sy + g->p.cy - 1; + break; + case gOrientation90: + sx = g->p.y; + ex = g->p.y + g->p.cy - 1; + sy = GDISP_SCREEN_HEIGHT - g->p.x - g->p.cx; + ey = GDISP_SCREEN_HEIGHT-1 - g->p.x; + break; + case gOrientation180: + sx = GDISP_SCREEN_WIDTH - g->p.x - g->p.cx; + ex = GDISP_SCREEN_WIDTH-1 - g->p.x; + sy = GDISP_SCREEN_HEIGHT - g->p.y - g->p.cy; + ey = GDISP_SCREEN_HEIGHT-1 - g->p.y; + break; + case gOrientation270: + sx = GDISP_SCREEN_WIDTH - g->p.y - g->p.cy; + ex = GDISP_SCREEN_WIDTH-1 - g->p.y; + sy = g->p.x; + ey = g->p.x + g->p.cx - 1; + break; + } + + spage = sy / 8; + base = RAM(g) + SSD1312_PAGE_OFFSET + SSD1312_PAGE_WIDTH * spage; + mask = 0xff << (sy&7); + zpages = (ey / 8) - spage; + + if (gdispColor2Native(g->p.color) == gdispColor2Native(GFX_BLACK)) { + while (zpages--) { + for (col = sx; col <= ex; col++) + base[col] &= ~mask; + mask = 0xff; + base += SSD1312_PAGE_WIDTH; + } + mask &= (0xff >> (7 - (ey&7))); + for (col = sx; col <= ex; col++) + base[col] &= ~mask; + } else { + while (zpages--) { + for (col = sx; col <= ex; col++) + base[col] |= mask; + mask = 0xff; + base += SSD1312_PAGE_WIDTH; + } + mask &= (0xff >> (7 - (ey&7))); + for (col = sx; col <= ex; col++) + base[col] |= mask; + } + g->flags |= GDISP_FLG_NEEDFLUSH; + } +#endif + +#if GDISP_HARDWARE_DRAWPIXEL + LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) { + gCoord x, y; + + switch(g->g.Orientation) { + default: + case gOrientation0: + x = g->p.x; + y = g->p.y; + break; + case gOrientation90: + x = g->p.y; + y = GDISP_SCREEN_HEIGHT-1 - g->p.x; + break; + case gOrientation180: + x = GDISP_SCREEN_WIDTH-1 - g->p.x; + y = GDISP_SCREEN_HEIGHT-1 - g->p.y; + break; + case gOrientation270: + x = GDISP_SCREEN_WIDTH-1 - g->p.y; + y = g->p.x; + break; + } + if (gdispColor2Native(g->p.color) != gdispColor2Native(GFX_BLACK)) + RAM(g)[xyaddr(x, y)] |= xybit(y); + else + RAM(g)[xyaddr(x, y)] &= ~xybit(y); + g->flags |= GDISP_FLG_NEEDFLUSH; + } +#endif + +#if GDISP_HARDWARE_PIXELREAD + LLDSPEC gColor gdisp_lld_get_pixel_color(GDisplay *g) { + gCoord x, y; + + switch(g->g.Orientation) { + default: + case gOrientation0: + x = g->p.x; + y = g->p.y; + break; + case gOrientation90: + x = g->p.y; + y = GDISP_SCREEN_HEIGHT-1 - g->p.x; + break; + case gOrientation180: + x = GDISP_SCREEN_WIDTH-1 - g->p.x; + y = GDISP_SCREEN_HEIGHT-1 - g->p.y; + break; + case gOrientation270: + x = GDISP_SCREEN_WIDTH-1 - g->p.y; + y = g->p.x; + break; + } + return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? GFX_WHITE : GFX_BLACK; + } +#endif + +#if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL + LLDSPEC void gdisp_lld_control(GDisplay *g) { + switch(g->p.x) { + case GDISP_CONTROL_POWER: + if (g->g.Powermode == (gPowermode)g->p.ptr) + return; + switch((gPowermode)g->p.ptr) { + case gPowerOff: + case gPowerSleep: + case gPowerDeepSleep: + acquire_bus(g); + write_cmd(g, SSD1312_DISPLAYOFF); + release_bus(g); + break; + case gPowerOn: + acquire_bus(g); + write_cmd(g, SSD1312_DISPLAYON); + release_bus(g); + break; + default: + return; + } + g->g.Powermode = (gPowermode)g->p.ptr; + return; + + case GDISP_CONTROL_ORIENTATION: + if (g->g.Orientation == (gOrientation)g->p.ptr) + return; + switch((gOrientation)g->p.ptr) { + /* Rotation is handled by the drawing routines */ + case gOrientation0: + case gOrientation180: + g->g.Height = GDISP_SCREEN_HEIGHT; + g->g.Width = GDISP_SCREEN_WIDTH; + break; + case gOrientation90: + case gOrientation270: + g->g.Height = GDISP_SCREEN_WIDTH; + g->g.Width = GDISP_SCREEN_HEIGHT; + break; + default: + return; + } + g->g.Orientation = (gOrientation)g->p.ptr; + return; + + case GDISP_CONTROL_CONTRAST: + if ((unsigned)g->p.ptr > 100) + g->p.ptr = (void *)100; + acquire_bus(g); + write_cmd2(g, SSD1312_SETCONTRAST, (((unsigned)g->p.ptr)<<8)/101); + release_bus(g); + g->g.Contrast = (unsigned)g->p.ptr; + return; + + // Our own special controller code to inverse the display + // 0 = normal, 1 = inverse + case GDISP_CONTROL_INVERSE: + acquire_bus(g); + write_cmd(g, g->p.ptr ? SSD1312_INVERTDISPLAY : SSD1312_NORMALDISPLAY); + release_bus(g); + return; + } + } +#endif // GDISP_NEED_CONTROL + +#endif // GFX_USE_GDISP + diff --git a/drivers/gdisp/SSD1312/gdisp_lld_config.h b/drivers/gdisp/SSD1312/gdisp_lld_config.h new file mode 100644 index 00000000..2e9bfed3 --- /dev/null +++ b/drivers/gdisp/SSD1312/gdisp_lld_config.h @@ -0,0 +1,27 @@ +/* + * 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.io/license.html + */ + +#ifndef _GDISP_LLD_CONFIG_H +#define _GDISP_LLD_CONFIG_H + +#if GFX_USE_GDISP + +/*===========================================================================*/ +/* Driver hardware support. */ +/*===========================================================================*/ + +#define GDISP_HARDWARE_FLUSH GFXON // This controller requires flushing +#define GDISP_HARDWARE_DRAWPIXEL GFXON +#define GDISP_HARDWARE_PIXELREAD GFXON +#define GDISP_HARDWARE_CONTROL GFXON +#define GDISP_HARDWARE_FILLS GFXON + +#define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_MONO + +#endif /* GFX_USE_GDISP */ + +#endif /* _GDISP_LLD_CONFIG_H */