You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

308 lines
9.6 KiB

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