drivers/ugfx/gdisp/is31fl3731c/gdisp_is31fl3731c.c

   1 /*
   2 Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include "gfx.h"
  19
  20 #if GFX_USE_GDISP
  21
  22 #define GDISP_DRIVER_VMT            GDISPVMT_IS31FL3731C_QMK
  23 #include "gdisp_lld_config.h"
  24 #include "src/gdisp/gdisp_driver.h"
  25
  26 #include "board_IS31FL3731C.h"
  27
  28
  29 // Can't include led_tables from here
  30 extern const uint8_t CIE1931_CURVE[];
  31
  32 /*===========================================================================*/
  33 /* Driver local definitions.                                                 */
  34 /*===========================================================================*/
  35
  36 #ifndef GDISP_SCREEN_HEIGHT
  37     #define GDISP_SCREEN_HEIGHT       9
  38 #endif
  39 #ifndef GDISP_SCREEN_WIDTH
  40     #define GDISP_SCREEN_WIDTH        16
  41 #endif
  42 #ifndef GDISP_INITIAL_CONTRAST
  43     #define GDISP_INITIAL_CONTRAST    0
  44 #endif
  45 #ifndef GDISP_INITIAL_BACKLIGHT
  46     #define GDISP_INITIAL_BACKLIGHT   0
  47 #endif
  48
  49 #define GDISP_FLG_NEEDFLUSH           (GDISP_FLG_DRIVER<<0)
  50
  51 #define IS31_ADDR_DEFAULT 0x74
  52
  53 #define IS31_REG_CONFIG   0x00
  54 // bits in reg
  55 #define IS31_REG_CONFIG_PICTUREMODE   0x00
  56 #define IS31_REG_CONFIG_AUTOPLAYMODE  0x08
  57 #define IS31_REG_CONFIG_AUDIOPLAYMODE 0x18
  58 // D2:D0 bits are starting frame for autoplay mode
  59
  60 #define IS31_REG_PICTDISP 0x01 // D2:D0 frame select for picture mode
  61
  62 #define IS31_REG_AUTOPLAYCTRL1 0x02
  63 // D6:D4 number of loops (000=infty)
  64 // D2:D0 number of frames to be used
  65
  66 #define IS31_REG_AUTOPLAYCTRL2 0x03 // D5:D0 delay time (*11ms)
  67
  68 #define IS31_REG_DISPLAYOPT 0x05
  69 #define IS31_REG_DISPLAYOPT_INTENSITY_SAME 0x20 // same intensity for all frames
  70 #define IS31_REG_DISPLAYOPT_BLINK_ENABLE 0x8
  71 // D2:D0 bits blink period time (*0.27s)
  72
  73 #define IS31_REG_AUDIOSYNC 0x06
  74 #define IS31_REG_AUDIOSYNC_ENABLE 0x1
  75
  76 #define IS31_REG_FRAMESTATE 0x07
  77
  78 #define IS31_REG_BREATHCTRL1 0x08
  79 // D6:D4 fade out time (26ms*2^i)
  80 // D2:D0 fade in time (26ms*2^i)
  81
  82 #define IS31_REG_BREATHCTRL2 0x09
  83 #define IS31_REG_BREATHCTRL2_ENABLE 0x10
  84 // D2:D0 extinguish time (3.5ms*2^i)
  85
  86 #define IS31_REG_SHUTDOWN 0x0A
  87 #define IS31_REG_SHUTDOWN_OFF 0x0
  88 #define IS31_REG_SHUTDOWN_ON 0x1
  89
  90 #define IS31_REG_AGCCTRL 0x0B
  91 #define IS31_REG_ADCRATE 0x0C
  92
  93 #define IS31_COMMANDREGISTER 0xFD
  94 #define IS31_FUNCTIONREG 0x0B    // helpfully called 'page nine'
  95 #define IS31_FUNCTIONREG_SIZE 0xD
  96
  97 #define IS31_FRAME_SIZE 0xB4
  98
  99 #define IS31_PWM_REG 0x24
 100 #define IS31_PWM_SIZE 0x90
 101
 102 #define IS31_LED_MASK_SIZE 0x12
 103 #define IS31_SCREEN_WIDTH 16
 104
 105 #define IS31
 106
 107 /*===========================================================================*/
 108 /* Driver local functions.                                                   */
 109 /*===========================================================================*/
 110
 111 typedef struct{
 112     uint8_t write_buffer_offset;
 113     uint8_t write_buffer[IS31_FRAME_SIZE];
 114     uint8_t frame_buffer[GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH];
 115     uint8_t page;
 116 }__attribute__((__packed__)) PrivData;
 117
 118 // Some common routines and macros
 119 #define PRIV(g)                         ((PrivData*)g->priv)
 120
 121 /*===========================================================================*/
 122 /* Driver exported functions.                                                */
 123 /*===========================================================================*/
 124
 125 static GFXINLINE void write_page(GDisplay* g, uint8_t page) {
 126     uint8_t tx[2] __attribute__((aligned(2)));
 127     tx[0] = IS31_COMMANDREGISTER;
 128     tx[1] = page;
 129     write_data(g, tx, 2);
 130 }
 131
 132 static GFXINLINE void write_register(GDisplay* g, uint8_t page, uint8_t reg, uint8_t data) {
 133     uint8_t tx[2] __attribute__((aligned(2)));
 134     tx[0] = reg;
 135     tx[1] = data;
 136     write_page(g, page);
 137     write_data(g, tx, 2);
 138 }
 139
 140 static GFXINLINE void write_ram(GDisplay *g, uint8_t page, uint16_t offset, uint16_t length) {
 141     PRIV(g)->write_buffer_offset = offset;
 142     write_page(g, page);
 143     write_data(g, (uint8_t*)PRIV(g), length + 1);
 144 }
 145
 146 LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 147     // The private area is the display surface.
 148     g->priv = gfxAlloc(sizeof(PrivData));
 149     __builtin_memset(PRIV(g), 0, sizeof(PrivData));
 150     PRIV(g)->page = 0;
 151
 152     // Initialise the board interface
 153     init_board(g);
 154     gfxSleepMilliseconds(10);
 155
 156     // zero function page, all registers (assuming full_page is all zeroes)
 157     write_ram(g, IS31_FUNCTIONREG, 0, IS31_FUNCTIONREG_SIZE);
 158     set_hardware_shutdown(g, false);
 159     gfxSleepMilliseconds(10);
 160     // software shutdown
 161     write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
 162     gfxSleepMilliseconds(10);
 163     // zero function page, all registers
 164     write_ram(g, IS31_FUNCTIONREG, 0, IS31_FUNCTIONREG_SIZE);
 165     gfxSleepMilliseconds(10);
 166
 167
 168     // zero all LED registers on all 8 pages, and enable the mask
 169     __builtin_memcpy(PRIV(g)->write_buffer, get_led_mask(g), IS31_LED_MASK_SIZE);
 170     for(uint8_t i=0; i<8; i++) {
 171         write_ram(g, i, 0, IS31_FRAME_SIZE);
 172         gfxSleepMilliseconds(1);
 173     }
 174
 175     // software shutdown disable (i.e. turn stuff on)
 176     write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
 177     gfxSleepMilliseconds(10);
 178
 179     // Finish Init
 180     post_init_board(g);
 181
 182     /* Initialise the GDISP structure */
 183     g->g.Width = GDISP_SCREEN_WIDTH;
 184     g->g.Height = GDISP_SCREEN_HEIGHT;
 185     g->g.Orientation = GDISP_ROTATE_0;
 186     g->g.Powermode = powerOff;
 187     g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
 188     g->g.Contrast = GDISP_INITIAL_CONTRAST;
 189     return TRUE;
 190 }
 191
 192 #if GDISP_HARDWARE_FLUSH
 193     LLDSPEC void gdisp_lld_flush(GDisplay *g) {
 194         // Don't flush if we don't need it.
 195         if (!(g->flags & GDISP_FLG_NEEDFLUSH))
 196             return;
 197
 198         PRIV(g)->page++;
 199         PRIV(g)->page %= 2;
 200         // TODO: some smarter algorithm for this
 201         // We should run only one physical page at a time
 202         // This way we don't need to send so much data, and
 203         // we could use slightly less memory
 204         uint8_t* src = PRIV(g)->frame_buffer;
 205         for (int y=0;y<GDISP_SCREEN_HEIGHT;y++) {
 206             for (int x=0;x<GDISP_SCREEN_WIDTH;x++) {
 207                 uint8_t val = (uint16_t)*src * g->g.Backlight / 100;
 208                 PRIV(g)->write_buffer[get_led_address(g, x, y)]=CIE1931_CURVE[val];
 209                 ++src;
 210             }
 211         }
 212         write_ram(g, PRIV(g)->page, IS31_PWM_REG, IS31_PWM_SIZE);
 213         gfxSleepMilliseconds(1);
 214         write_register(g, IS31_FUNCTIONREG, IS31_REG_PICTDISP, PRIV(g)->page);
 215
 216         g->flags &= ~GDISP_FLG_NEEDFLUSH;
 217     }
 218 #endif
 219
 220 #if GDISP_HARDWARE_DRAWPIXEL
 221     LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
 222         coord_t        x, y;
 223
 224         switch(g->g.Orientation) {
 225         default:
 226         case GDISP_ROTATE_0:
 227             x = g->p.x;
 228             y = g->p.y;
 229             break;
 230         case GDISP_ROTATE_180:
 231             x = GDISP_SCREEN_WIDTH-1 - g->p.x;
 232             y = g->p.y;
 233             break;
 234         }
 235         PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x] = gdispColor2Native(g->p.color);
 236         g->flags |= GDISP_FLG_NEEDFLUSH;
 237     }
 238 #endif
 239
 240 #if GDISP_HARDWARE_PIXELREAD
 241     LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
 242         coord_t        x, y;
 243
 244         switch(g->g.Orientation) {
 245         default:
 246         case GDISP_ROTATE_0:
 247             x = g->p.x;
 248             y = g->p.y;
 249             break;
 250         case GDISP_ROTATE_180:
 251             x = GDISP_SCREEN_WIDTH-1 - g->p.x;
 252             y = g->p.y;
 253             break;
 254         }
 255         return gdispNative2Color(PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x]);
 256     }
 257 #endif
 258
 259 #if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
 260     LLDSPEC void gdisp_lld_control(GDisplay *g) {
 261         switch(g->p.x) {
 262         case GDISP_CONTROL_POWER:
 263             if (g->g.Powermode == (powermode_t)g->p.ptr)
 264                 return;
 265             switch((powermode_t)g->p.ptr) {
 266             case powerOff:
 267             case powerSleep:
 268             case powerDeepSleep:
 269                 write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
 270                 break;
 271             case powerOn:
 272                 write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_ON);
 273                 break;
 274             default:
 275                 return;
 276             }
 277             g->g.Powermode = (powermode_t)g->p.ptr;
 278             return;
 279
 280         case GDISP_CONTROL_ORIENTATION:
 281             if (g->g.Orientation == (orientation_t)g->p.ptr)
 282                 return;
 283             switch((orientation_t)g->p.ptr) {
 284             /* Rotation is handled by the drawing routines */
 285             case GDISP_ROTATE_0:
 286             case GDISP_ROTATE_180:
 287                 g->g.Height = GDISP_SCREEN_HEIGHT;
 288                 g->g.Width = GDISP_SCREEN_WIDTH;
 289                 break;
 290             case GDISP_ROTATE_90:
 291             case GDISP_ROTATE_270:
 292                 g->g.Height = GDISP_SCREEN_WIDTH;
 293                 g->g.Width = GDISP_SCREEN_HEIGHT;
 294                 break;
 295             default:
 296                 return;
 297             }
 298             g->g.Orientation = (orientation_t)g->p.ptr;
 299             return;
 300
 301         case GDISP_CONTROL_BACKLIGHT:
 302             if (g->g.Backlight == (unsigned)g->p.ptr)
 303                 return;
 304             unsigned val = (unsigned)g->p.ptr;
 305             g->g.Backlight = val > 100 ? 100 : val;
 306             g->flags |= GDISP_FLG_NEEDFLUSH;
 307             return;
 308         }
 309     }
 310 #endif // GDISP_NEED_CONTROL
 311
 312 #endif // GFX_USE_GDISP