keyboards/whitefox/drivers/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_WHITEFOX
  23 #include "drivers/gdisp/IS31FL3731C/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