]> git.donarmstrong.com Git - qmk_firmware.git/blob - keyboards/ergodox/infinity/drivers/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c
Merge pull request #1283 from TerryMathews/master
[qmk_firmware.git] / keyboards / ergodox / infinity / 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_ERGODOX
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 100
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_ON);
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 = powerOn;
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                         PRIV(g)->write_buffer[get_led_address(g, x, y)]=CIE1931_CURVE[*src];
208                         ++src;
209                     }
210                 }
211         write_ram(g, PRIV(g)->page, IS31_PWM_REG, IS31_PWM_SIZE);
212         gfxSleepMilliseconds(1);
213         write_register(g, IS31_FUNCTIONREG, IS31_REG_PICTDISP, PRIV(g)->page);
214
215                 g->flags &= ~GDISP_FLG_NEEDFLUSH;
216         }
217 #endif
218
219 #if GDISP_HARDWARE_DRAWPIXEL
220         LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
221                 coord_t         x, y;
222
223                 switch(g->g.Orientation) {
224                 default:
225                 case GDISP_ROTATE_0:
226                         x = g->p.x;
227                         y = g->p.y;
228                         break;
229                 case GDISP_ROTATE_180:
230                         x = GDISP_SCREEN_WIDTH-1 - g->p.x;
231                         y = g->p.y;
232                         break;
233                 }
234                 PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x] = gdispColor2Native(g->p.color);
235                 g->flags |= GDISP_FLG_NEEDFLUSH;
236         }
237 #endif
238
239 #if GDISP_HARDWARE_PIXELREAD
240         LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
241                 coord_t         x, y;
242
243                 switch(g->g.Orientation) {
244                 default:
245                 case GDISP_ROTATE_0:
246                         x = g->p.x;
247                         y = g->p.y;
248                         break;
249                 case GDISP_ROTATE_180:
250                         x = GDISP_SCREEN_WIDTH-1 - g->p.x;
251                         y = g->p.y;
252                         break;
253                 }
254                 return gdispNative2Color(PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x]);
255         }
256 #endif
257
258 #if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
259         LLDSPEC void gdisp_lld_control(GDisplay *g) {
260                 switch(g->p.x) {
261                 case GDISP_CONTROL_POWER:
262                         if (g->g.Powermode == (powermode_t)g->p.ptr)
263                                 return;
264                         switch((powermode_t)g->p.ptr) {
265                         case powerOff:
266                         case powerSleep:
267                         case powerDeepSleep:
268                 write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
269                                 break;
270                         case powerOn:
271                 write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_ON);
272                                 break;
273                         default:
274                                 return;
275                         }
276                         g->g.Powermode = (powermode_t)g->p.ptr;
277                         return;
278
279                 case GDISP_CONTROL_ORIENTATION:
280                         if (g->g.Orientation == (orientation_t)g->p.ptr)
281                                 return;
282                         switch((orientation_t)g->p.ptr) {
283                         /* Rotation is handled by the drawing routines */
284                         case GDISP_ROTATE_0:
285                         case GDISP_ROTATE_180:
286                                 g->g.Height = GDISP_SCREEN_HEIGHT;
287                                 g->g.Width = GDISP_SCREEN_WIDTH;
288                                 break;
289                         case GDISP_ROTATE_90:
290                         case GDISP_ROTATE_270:
291                                 g->g.Height = GDISP_SCREEN_WIDTH;
292                                 g->g.Width = GDISP_SCREEN_HEIGHT;
293                                 break;
294                         default:
295                                 return;
296                         }
297                         g->g.Orientation = (orientation_t)g->p.ptr;
298                         return;
299
300                 case GDISP_CONTROL_CONTRAST:
301                         return;
302                 }
303         }
304 #endif // GDISP_NEED_CONTROL
305
306 #endif // GFX_USE_GDISP