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