keyboards/ergodox/infinity/drivers/gdisp/st7565ergodox/gdisp_lld_ST7565.c

   1 /*
   2  * This file is subject to the terms of the GFX License. If a copy of
   3  * the license was not distributed with this file, you can obtain one at:
   4  *
   5  *              http://ugfx.org/license.html
   6  */
   7
   8 #include "gfx.h"
   9
  10 #if GFX_USE_GDISP
  11
  12 #define GDISP_DRIVER_VMT                        GDISPVMT_ST7565_ERGODOX
  13 #include "drivers/gdisp/st7565ergodox/gdisp_lld_config.h"
  14 #include "src/gdisp/gdisp_driver.h"
  15
  16 #include "board_ST7565.h"
  17
  18 /*===========================================================================*/
  19 /* Driver local definitions.                                                 */
  20 /*===========================================================================*/
  21
  22 #ifndef GDISP_SCREEN_HEIGHT
  23 #define GDISP_SCREEN_HEIGHT             32
  24 #endif
  25 #ifndef GDISP_SCREEN_WIDTH
  26 #define GDISP_SCREEN_WIDTH              128
  27 #endif
  28 #ifndef GDISP_INITIAL_CONTRAST
  29 #define GDISP_INITIAL_CONTRAST  0
  30 #endif
  31 #ifndef GDISP_INITIAL_BACKLIGHT
  32 #define GDISP_INITIAL_BACKLIGHT 100
  33 #endif
  34
  35 #define GDISP_FLG_NEEDFLUSH                     (GDISP_FLG_DRIVER<<0)
  36
  37 #include "drivers/gdisp/st7565ergodox/st7565.h"
  38
  39 /*===========================================================================*/
  40 /* Driver config defaults for backward compatibility.                        */
  41 /*===========================================================================*/
  42 #ifndef ST7565_LCD_BIAS
  43 #define ST7565_LCD_BIAS         ST7565_LCD_BIAS_7
  44 #endif
  45 #ifndef ST7565_ADC
  46 #define ST7565_ADC              ST7565_ADC_NORMAL
  47 #endif
  48 #ifndef ST7565_COM_SCAN
  49 #define ST7565_COM_SCAN         ST7565_COM_SCAN_INC
  50 #endif
  51 #ifndef ST7565_PAGE_ORDER
  52 #define ST7565_PAGE_ORDER       0,1,2,3
  53 #endif
  54
  55 /*===========================================================================*/
  56 /* Driver local functions.                                                   */
  57 /*===========================================================================*/
  58
  59 typedef struct{
  60     bool_t buffer2;
  61     uint8_t data_pos;
  62     uint8_t data[16];
  63     uint8_t ram[GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH / 8];
  64 }PrivData;
  65
  66 // Some common routines and macros
  67 #define PRIV(g)                         ((PrivData*)g->priv)
  68 #define RAM(g)                                                  (PRIV(g)->ram)
  69
  70 static GFXINLINE void write_cmd(GDisplay* g, uint8_t cmd) {
  71     PRIV(g)->data[PRIV(g)->data_pos++] = cmd;
  72 }
  73
  74 static GFXINLINE void flush_cmd(GDisplay* g) {
  75     write_data(g, PRIV(g)->data, PRIV(g)->data_pos);
  76     PRIV(g)->data_pos = 0;
  77 }
  78
  79 #define write_cmd2(g, cmd1, cmd2)               { write_cmd(g, cmd1); write_cmd(g, cmd2); }
  80 #define write_cmd3(g, cmd1, cmd2, cmd3) { write_cmd(g, cmd1); write_cmd(g, cmd2); write_cmd(g, cmd3); }
  81
  82 // Some common routines and macros
  83 #define delay(us)                       gfxSleepMicroseconds(us)
  84 #define delay_ms(ms)            gfxSleepMilliseconds(ms)
  85
  86 #define xyaddr(x, y)            ((x) + ((y)>>3)*GDISP_SCREEN_WIDTH)
  87 #define xybit(y)                        (1<<((y)&7))
  88
  89 /*===========================================================================*/
  90 /* Driver exported functions.                                                */
  91 /*===========================================================================*/
  92
  93 /*
  94  * As this controller can't update on a pixel boundary we need to maintain the
  95  * the entire display surface in memory so that we can do the necessary bit
  96  * operations. Fortunately it is a small display in monochrome.
  97  * 64 * 128 / 8 = 1024 bytes.
  98  */
  99
 100 LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 101     // The private area is the display surface.
 102     g->priv = gfxAlloc(sizeof(PrivData));
 103     PRIV(g)->buffer2 = false;
 104     PRIV(g)->data_pos = 0;
 105
 106     // Initialise the board interface
 107     init_board(g);
 108
 109     // Hardware reset
 110     setpin_reset(g, TRUE);
 111     gfxSleepMilliseconds(20);
 112     setpin_reset(g, FALSE);
 113     gfxSleepMilliseconds(20);
 114
 115     acquire_bus(g);
 116     enter_cmd_mode(g);
 117     write_cmd(g, ST7565_DISPLAY_OFF);
 118     write_cmd(g, ST7565_LCD_BIAS);
 119     write_cmd(g, ST7565_ADC);
 120     write_cmd(g, ST7565_COM_SCAN);
 121
 122     write_cmd(g, ST7565_START_LINE | 0);
 123
 124     write_cmd(g, ST7565_RESISTOR_RATIO | 0x6);
 125
 126     // turn on voltage converter (VC=1, VR=0, VF=0)
 127     write_cmd(g, ST7565_POWER_CONTROL | 0x04);
 128     flush_cmd(g);
 129     delay_ms(50);
 130
 131     // turn on voltage regulator (VC=1, VR=1, VF=0)
 132     write_cmd(g, ST7565_POWER_CONTROL | 0x06);
 133     flush_cmd(g);
 134     delay_ms(50);
 135
 136     // turn on voltage follower (VC=1, VR=1, VF=1)
 137     write_cmd(g, ST7565_POWER_CONTROL | 0x07);
 138     flush_cmd(g);
 139     delay_ms(50);
 140
 141     write_cmd(g, 0xE2);
 142     write_cmd(g, ST7565_COM_SCAN);
 143     write_cmd2(g, ST7565_CONTRAST, GDISP_INITIAL_CONTRAST*64/101);
 144     //write_cmd2(g, ST7565_CONTRAST, 0);
 145     write_cmd(g, ST7565_DISPLAY_ON);
 146     write_cmd(g, ST7565_ALLON_NORMAL);
 147     write_cmd(g, ST7565_INVERT_DISPLAY);
 148
 149     write_cmd(g, ST7565_RMW);
 150     flush_cmd(g);
 151
 152     // Finish Init
 153     post_init_board(g);
 154
 155     // Release the bus
 156     release_bus(g);
 157
 158     /* Initialise the GDISP structure */
 159     g->g.Width = GDISP_SCREEN_WIDTH;
 160     g->g.Height = GDISP_SCREEN_HEIGHT;
 161     g->g.Orientation = GDISP_ROTATE_0;
 162     g->g.Powermode = powerOn;
 163     g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
 164     g->g.Contrast = GDISP_INITIAL_CONTRAST;
 165     return TRUE;
 166 }
 167
 168 #if GDISP_HARDWARE_FLUSH
 169 LLDSPEC void gdisp_lld_flush(GDisplay *g) {
 170     unsigned    p;
 171
 172     // Don't flush if we don't need it.
 173     if (!(g->flags & GDISP_FLG_NEEDFLUSH))
 174         return;
 175
 176     acquire_bus(g);
 177     enter_cmd_mode(g);
 178     unsigned dstOffset = (PRIV(g)->buffer2 ? 4 : 0);
 179     for (p = 0; p < 4; p++) {
 180         write_cmd(g, ST7565_PAGE | (p + dstOffset));
 181         write_cmd(g, ST7565_COLUMN_MSB | 0);
 182         write_cmd(g, ST7565_COLUMN_LSB | 0);
 183         write_cmd(g, ST7565_RMW);
 184         flush_cmd(g);
 185         enter_data_mode(g);
 186         write_data(g, RAM(g) + (p*GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH);
 187         enter_cmd_mode(g);
 188     }
 189     unsigned line = (PRIV(g)->buffer2 ? 32 : 0);
 190     write_cmd(g, ST7565_START_LINE | line);
 191     flush_cmd(g);
 192     PRIV(g)->buffer2 = !PRIV(g)->buffer2;
 193     release_bus(g);
 194
 195     g->flags &= ~GDISP_FLG_NEEDFLUSH;
 196 }
 197 #endif
 198
 199 #if GDISP_HARDWARE_DRAWPIXEL
 200 LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
 201     coord_t             x, y;
 202
 203     switch(g->g.Orientation) {
 204     default:
 205     case GDISP_ROTATE_0:
 206         x = g->p.x;
 207         y = g->p.y;
 208         break;
 209     case GDISP_ROTATE_90:
 210         x = g->p.y;
 211         y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
 212         break;
 213     case GDISP_ROTATE_180:
 214         x = GDISP_SCREEN_WIDTH-1 - g->p.x;
 215         y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
 216         break;
 217     case GDISP_ROTATE_270:
 218         x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
 219         y = g->p.x;
 220         break;
 221     }
 222     if (gdispColor2Native(g->p.color) != Black)
 223         RAM(g)[xyaddr(x, y)] |= xybit(y);
 224     else
 225         RAM(g)[xyaddr(x, y)] &= ~xybit(y);
 226     g->flags |= GDISP_FLG_NEEDFLUSH;
 227 }
 228 #endif
 229
 230 #if GDISP_HARDWARE_PIXELREAD
 231 LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
 232     coord_t             x, y;
 233
 234     switch(g->g.Orientation) {
 235     default:
 236     case GDISP_ROTATE_0:
 237         x = g->p.x;
 238         y = g->p.y;
 239         break;
 240     case GDISP_ROTATE_90:
 241         x = g->p.y;
 242         y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
 243         break;
 244     case GDISP_ROTATE_180:
 245         x = GDISP_SCREEN_WIDTH-1 - g->p.x;
 246         y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
 247         break;
 248     case GDISP_ROTATE_270:
 249         x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
 250         y = g->p.x;
 251         break;
 252     }
 253     return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black;
 254 }
 255 #endif
 256
 257 LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
 258     uint8_t* buffer = (uint8_t*)g->p.ptr;
 259     int linelength = g->p.cx;
 260     for (int i = 0; i < g->p.cy; i++) {
 261         unsigned dstx = g->p.x;
 262         unsigned dsty = g->p.y + i;
 263         unsigned srcx = g->p.x1;
 264         unsigned srcy = g->p.y1 + i;
 265         unsigned srcbit = srcy * g->p.x2 + srcx;
 266         for(int j=0; j < linelength; j++) {
 267             uint8_t src = buffer[srcbit / 8];
 268             uint8_t bit = 7-(srcbit % 8);
 269             uint8_t bitset = (src >> bit) & 1;
 270             uint8_t* dst = &(RAM(g)[xyaddr(dstx, dsty)]);
 271             if (bitset) {
 272                 *dst |= xybit(dsty);
 273             }
 274             else {
 275                 *dst &= ~xybit(dsty);
 276             }
 277                         dstx++;
 278             srcbit++;
 279         }
 280     }
 281 }
 282
 283 #if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
 284 LLDSPEC void gdisp_lld_control(GDisplay *g) {
 285     switch(g->p.x) {
 286     case GDISP_CONTROL_POWER:
 287         if (g->g.Powermode == (powermode_t)g->p.ptr)
 288             return;
 289         switch((powermode_t)g->p.ptr) {
 290         case powerOff:
 291         case powerSleep:
 292         case powerDeepSleep:
 293             acquire_bus(g);
 294             enter_cmd_mode(g);
 295             write_cmd(g, ST7565_DISPLAY_OFF);
 296             flush_cmd(g);
 297             release_bus(g);
 298             break;
 299         case powerOn:
 300             acquire_bus(g);
 301             enter_cmd_mode(g);
 302             write_cmd(g, ST7565_DISPLAY_ON);
 303             flush_cmd(g);
 304             release_bus(g);
 305             break;
 306         default:
 307             return;
 308         }
 309         g->g.Powermode = (powermode_t)g->p.ptr;
 310         return;
 311
 312         case GDISP_CONTROL_ORIENTATION:
 313             if (g->g.Orientation == (orientation_t)g->p.ptr)
 314                 return;
 315             switch((orientation_t)g->p.ptr) {
 316             /* Rotation is handled by the drawing routines */
 317             case GDISP_ROTATE_0:
 318             case GDISP_ROTATE_180:
 319                 g->g.Height = GDISP_SCREEN_HEIGHT;
 320                 g->g.Width = GDISP_SCREEN_WIDTH;
 321                 break;
 322             case GDISP_ROTATE_90:
 323             case GDISP_ROTATE_270:
 324                 g->g.Height = GDISP_SCREEN_WIDTH;
 325                 g->g.Width = GDISP_SCREEN_HEIGHT;
 326                 break;
 327             default:
 328                 return;
 329             }
 330             g->g.Orientation = (orientation_t)g->p.ptr;
 331             return;
 332
 333             case GDISP_CONTROL_CONTRAST:
 334                 if ((unsigned)g->p.ptr > 100)
 335                     g->p.ptr = (void *)100;
 336                 acquire_bus(g);
 337                 enter_cmd_mode(g);
 338                 write_cmd2(g, ST7565_CONTRAST, ((((unsigned)g->p.ptr)<<6)/101) & 0x3F);
 339                 flush_cmd(g);
 340                 release_bus(g);
 341                 g->g.Contrast = (unsigned)g->p.ptr;
 342                 return;
 343     }
 344 }
 345 #endif // GDISP_NEED_CONTROL
 346
 347 #endif // GFX_USE_GDISP