aboutsummaryrefslogtreecommitdiff
path: root/drivers/ugfx/gdisp
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/ugfx/gdisp')
-rw-r--r--drivers/ugfx/gdisp/IS31FL3731C/driver.mk2
-rw-r--r--drivers/ugfx/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c312
-rw-r--r--drivers/ugfx/gdisp/IS31FL3731C/gdisp_lld_config.h36
-rw-r--r--drivers/ugfx/gdisp/st7565ergodox/driver.mk2
-rw-r--r--drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_ST7565.c329
-rw-r--r--drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_config.h27
-rw-r--r--drivers/ugfx/gdisp/st7565ergodox/st7565.h39
7 files changed, 747 insertions, 0 deletions
diff --git a/drivers/ugfx/gdisp/IS31FL3731C/driver.mk b/drivers/ugfx/gdisp/IS31FL3731C/driver.mk
new file mode 100644
index 000000000..58a16d209
--- /dev/null
+++ b/drivers/ugfx/gdisp/IS31FL3731C/driver.mk
@@ -0,0 +1,2 @@
1GFXINC += drivers/ugfx/gdisp/IS31FL3731C
2GFXSRC += drivers/ugfx/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c
diff --git a/drivers/ugfx/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c b/drivers/ugfx/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c
new file mode 100644
index 000000000..2d78a5533
--- /dev/null
+++ b/drivers/ugfx/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c
@@ -0,0 +1,312 @@
1/*
2Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
3
4This program is free software: you can redistribute it and/or modify
5it under the terms of the GNU General Public License as published by
6the Free Software Foundation, either version 2 of the License, or
7(at your option) any later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along 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 "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
30extern 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
111typedef 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
125static 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
132static 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
140static 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
146LLDSPEC 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
diff --git a/drivers/ugfx/gdisp/IS31FL3731C/gdisp_lld_config.h b/drivers/ugfx/gdisp/IS31FL3731C/gdisp_lld_config.h
new file mode 100644
index 000000000..bb28ad775
--- /dev/null
+++ b/drivers/ugfx/gdisp/IS31FL3731C/gdisp_lld_config.h
@@ -0,0 +1,36 @@
1/*
2Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
3
4This program is free software: you can redistribute it and/or modify
5it under the terms of the GNU General Public License as published by
6the Free Software Foundation, either version 2 of the License, or
7(at your option) any later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program. If not, see <http://www.gnu.org/licenses/>.
16*/
17
18#ifndef _GDISP_LLD_CONFIG_H
19#define _GDISP_LLD_CONFIG_H
20
21#if GFX_USE_GDISP
22
23/*===========================================================================*/
24/* Driver hardware support. */
25/*===========================================================================*/
26
27#define GDISP_HARDWARE_FLUSH TRUE // This controller requires flushing
28#define GDISP_HARDWARE_DRAWPIXEL TRUE
29#define GDISP_HARDWARE_PIXELREAD TRUE
30#define GDISP_HARDWARE_CONTROL TRUE
31
32#define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_GRAY256
33
34#endif /* GFX_USE_GDISP */
35
36#endif /* _GDISP_LLD_CONFIG_H */
diff --git a/drivers/ugfx/gdisp/st7565ergodox/driver.mk b/drivers/ugfx/gdisp/st7565ergodox/driver.mk
new file mode 100644
index 000000000..401e15e69
--- /dev/null
+++ b/drivers/ugfx/gdisp/st7565ergodox/driver.mk
@@ -0,0 +1,2 @@
1GFXINC += drivers/ugfx/gdisp/st7565ergodox
2GFXSRC += drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_ST7565.c
diff --git a/drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_ST7565.c b/drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_ST7565.c
new file mode 100644
index 000000000..c576280a1
--- /dev/null
+++ b/drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_ST7565.c
@@ -0,0 +1,329 @@
1/*
2 * This file is subject to the terms of the GFX License. If a copy of
3 * the license was not distributed with this file, you can obtain one at:
4 *
5 * http://ugfx.org/license.html
6 */
7
8#include "gfx.h"
9
10#if GFX_USE_GDISP
11
12#define GDISP_DRIVER_VMT GDISPVMT_ST7565_ERGODOX
13#include "gdisp_lld_config.h"
14#include "src/gdisp/gdisp_driver.h"
15
16#include "board_ST7565.h"
17
18/*===========================================================================*/
19/* Driver local definitions. */
20/*===========================================================================*/
21
22#ifndef GDISP_SCREEN_HEIGHT
23#define GDISP_SCREEN_HEIGHT 32
24#endif
25#ifndef GDISP_SCREEN_WIDTH
26#define GDISP_SCREEN_WIDTH 128
27#endif
28#ifndef GDISP_INITIAL_CONTRAST
29#define GDISP_INITIAL_CONTRAST 35
30#endif
31#ifndef GDISP_INITIAL_BACKLIGHT
32#define GDISP_INITIAL_BACKLIGHT 100
33#endif
34
35#define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER<<0)
36
37#include "st7565.h"
38
39/*===========================================================================*/
40/* Driver config defaults for backward compatibility. */
41/*===========================================================================*/
42#ifndef ST7565_LCD_BIAS
43#define ST7565_LCD_BIAS ST7565_LCD_BIAS_7
44#endif
45#ifndef ST7565_ADC
46#define ST7565_ADC ST7565_ADC_NORMAL
47#endif
48#ifndef ST7565_COM_SCAN
49#define ST7565_COM_SCAN ST7565_COM_SCAN_INC
50#endif
51#ifndef ST7565_PAGE_ORDER
52#define ST7565_PAGE_ORDER 0,1,2,3
53#endif
54
55/*===========================================================================*/
56/* Driver local functions. */
57/*===========================================================================*/
58
59typedef struct{
60 bool_t buffer2;
61 uint8_t data_pos;
62 uint8_t data[16];
63 uint8_t ram[GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH / 8];
64}PrivData;
65
66// Some common routines and macros
67#define PRIV(g) ((PrivData*)g->priv)
68#define RAM(g) (PRIV(g)->ram)
69
70static GFXINLINE void write_cmd(GDisplay* g, uint8_t cmd) {
71 PRIV(g)->data[PRIV(g)->data_pos++] = cmd;
72}
73
74static GFXINLINE void flush_cmd(GDisplay* g) {
75 write_data(g, PRIV(g)->data, PRIV(g)->data_pos);
76 PRIV(g)->data_pos = 0;
77}
78
79#define write_cmd2(g, cmd1, cmd2) { write_cmd(g, cmd1); write_cmd(g, cmd2); }
80#define write_cmd3(g, cmd1, cmd2, cmd3) { write_cmd(g, cmd1); write_cmd(g, cmd2); write_cmd(g, cmd3); }
81
82// Some common routines and macros
83#define delay(us) gfxSleepMicroseconds(us)
84#define delay_ms(ms) gfxSleepMilliseconds(ms)
85
86#define xyaddr(x, y) ((x) + ((y)>>3)*GDISP_SCREEN_WIDTH)
87#define xybit(y) (1<<((y)&7))
88
89/*===========================================================================*/
90/* Driver exported functions. */
91/*===========================================================================*/
92
93/*
94 * As this controller can't update on a pixel boundary we need to maintain the
95 * the entire display surface in memory so that we can do the necessary bit
96 * operations. Fortunately it is a small display in monochrome.
97 * 64 * 128 / 8 = 1024 bytes.
98 */
99
100LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
101 // The private area is the display surface.
102 g->priv = gfxAlloc(sizeof(PrivData));
103 PRIV(g)->buffer2 = false;
104 PRIV(g)->data_pos = 0;
105
106 // Initialise the board interface
107 init_board(g);
108
109 // Hardware reset
110 setpin_reset(g, TRUE);
111 gfxSleepMilliseconds(20);
112 setpin_reset(g, FALSE);
113 gfxSleepMilliseconds(20);
114 acquire_bus(g);
115 enter_cmd_mode(g);
116
117 write_cmd(g, ST7565_RESET);
118 write_cmd(g, ST7565_LCD_BIAS);
119 write_cmd(g, ST7565_ADC);
120 write_cmd(g, ST7565_COM_SCAN);
121
122 write_cmd(g, ST7565_RESISTOR_RATIO | 0x1);
123 write_cmd2(g, ST7565_CONTRAST, GDISP_INITIAL_CONTRAST);
124
125 // turn on internal power supply (VC=1, VR=1, VF=1)
126 write_cmd(g, ST7565_POWER_CONTROL | 0x07);
127
128 write_cmd(g, ST7565_INVERT_DISPLAY);
129 write_cmd(g, ST7565_ALLON_NORMAL);
130
131 write_cmd(g, ST7565_START_LINE | 0);
132 write_cmd(g, ST7565_RMW);
133 flush_cmd(g);
134
135 // Finish Init
136 post_init_board(g);
137
138 // Release the bus
139 release_bus(g);
140
141 /* Initialise the GDISP structure */
142 g->g.Width = GDISP_SCREEN_WIDTH;
143 g->g.Height = GDISP_SCREEN_HEIGHT;
144 g->g.Orientation = GDISP_ROTATE_0;
145 g->g.Powermode = powerOff;
146 g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
147 g->g.Contrast = GDISP_INITIAL_CONTRAST;
148 return TRUE;
149}
150
151#if GDISP_HARDWARE_FLUSH
152LLDSPEC void gdisp_lld_flush(GDisplay *g) {
153 unsigned p;
154
155 // Don't flush if we don't need it.
156 if (!(g->flags & GDISP_FLG_NEEDFLUSH))
157 return;
158
159 acquire_bus(g);
160 enter_cmd_mode(g);
161 unsigned dstOffset = (PRIV(g)->buffer2 ? 4 : 0);
162 for (p = 0; p < 4; p++) {
163 write_cmd(g, ST7565_PAGE | (p + dstOffset));
164 write_cmd(g, ST7565_COLUMN_MSB | 0);
165 write_cmd(g, ST7565_COLUMN_LSB | 0);
166 write_cmd(g, ST7565_RMW);
167 flush_cmd(g);
168 enter_data_mode(g);
169 write_data(g, RAM(g) + (p*GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH);
170 enter_cmd_mode(g);
171 }
172 unsigned line = (PRIV(g)->buffer2 ? 32 : 0);
173 write_cmd(g, ST7565_START_LINE | line);
174 flush_cmd(g);
175 PRIV(g)->buffer2 = !PRIV(g)->buffer2;
176 release_bus(g);
177
178 g->flags &= ~GDISP_FLG_NEEDFLUSH;
179}
180#endif
181
182#if GDISP_HARDWARE_DRAWPIXEL
183LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
184 coord_t x, y;
185
186 switch(g->g.Orientation) {
187 default:
188 case GDISP_ROTATE_0:
189 x = g->p.x;
190 y = g->p.y;
191 break;
192 case GDISP_ROTATE_90:
193 x = g->p.y;
194 y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
195 break;
196 case GDISP_ROTATE_180:
197 x = GDISP_SCREEN_WIDTH-1 - g->p.x;
198 y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
199 break;
200 case GDISP_ROTATE_270:
201 x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
202 y = g->p.x;
203 break;
204 }
205 if (gdispColor2Native(g->p.color) != Black)
206 RAM(g)[xyaddr(x, y)] |= xybit(y);
207 else
208 RAM(g)[xyaddr(x, y)] &= ~xybit(y);
209 g->flags |= GDISP_FLG_NEEDFLUSH;
210}
211#endif
212
213#if GDISP_HARDWARE_PIXELREAD
214LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
215 coord_t x, y;
216
217 switch(g->g.Orientation) {
218 default:
219 case GDISP_ROTATE_0:
220 x = g->p.x;
221 y = g->p.y;
222 break;
223 case GDISP_ROTATE_90:
224 x = g->p.y;
225 y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
226 break;
227 case GDISP_ROTATE_180:
228 x = GDISP_SCREEN_WIDTH-1 - g->p.x;
229 y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
230 break;
231 case GDISP_ROTATE_270:
232 x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
233 y = g->p.x;
234 break;
235 }
236 return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black;
237}
238#endif
239
240LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
241 uint8_t* buffer = (uint8_t*)g->p.ptr;
242 int linelength = g->p.cx;
243 for (int i = 0; i < g->p.cy; i++) {
244 unsigned dstx = g->p.x;
245 unsigned dsty = g->p.y + i;
246 unsigned srcx = g->p.x1;
247 unsigned srcy = g->p.y1 + i;
248 unsigned srcbit = srcy * g->p.x2 + srcx;
249 for(int j=0; j < linelength; j++) {
250 uint8_t src = buffer[srcbit / 8];
251 uint8_t bit = 7-(srcbit % 8);
252 uint8_t bitset = (src >> bit) & 1;
253 uint8_t* dst = &(RAM(g)[xyaddr(dstx, dsty)]);
254 if (bitset) {
255 *dst |= xybit(dsty);
256 }
257 else {
258 *dst &= ~xybit(dsty);
259 }
260 dstx++;
261 srcbit++;
262 }
263 }
264 g->flags |= GDISP_FLG_NEEDFLUSH;
265}
266
267#if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
268LLDSPEC void gdisp_lld_control(GDisplay *g) {
269 switch(g->p.x) {
270 case GDISP_CONTROL_POWER:
271 if (g->g.Powermode == (powermode_t)g->p.ptr)
272 return;
273 switch((powermode_t)g->p.ptr) {
274 case powerOff:
275 case powerSleep:
276 case powerDeepSleep:
277 acquire_bus(g);
278 enter_cmd_mode(g);
279 write_cmd(g, ST7565_DISPLAY_OFF);
280 flush_cmd(g);
281 release_bus(g);
282 break;
283 case powerOn:
284 acquire_bus(g);
285 enter_cmd_mode(g);
286 write_cmd(g, ST7565_DISPLAY_ON);
287 flush_cmd(g);
288 release_bus(g);
289 break;
290 default:
291 return;
292 }
293 g->g.Powermode = (powermode_t)g->p.ptr;
294 return;
295
296 case GDISP_CONTROL_ORIENTATION:
297 if (g->g.Orientation == (orientation_t)g->p.ptr)
298 return;
299 switch((orientation_t)g->p.ptr) {
300 /* Rotation is handled by the drawing routines */
301 case GDISP_ROTATE_0:
302 case GDISP_ROTATE_180:
303 g->g.Height = GDISP_SCREEN_HEIGHT;
304 g->g.Width = GDISP_SCREEN_WIDTH;
305 break;
306 case GDISP_ROTATE_90:
307 case GDISP_ROTATE_270:
308 g->g.Height = GDISP_SCREEN_WIDTH;
309 g->g.Width = GDISP_SCREEN_HEIGHT;
310 break;
311 default:
312 return;
313 }
314 g->g.Orientation = (orientation_t)g->p.ptr;
315 return;
316
317 case GDISP_CONTROL_CONTRAST:
318 g->g.Contrast = (unsigned)g->p.ptr & 63;
319 acquire_bus(g);
320 enter_cmd_mode(g);
321 write_cmd2(g, ST7565_CONTRAST, g->g.Contrast);
322 flush_cmd(g);
323 release_bus(g);
324 return;
325 }
326}
327#endif // GDISP_NEED_CONTROL
328
329#endif // GFX_USE_GDISP
diff --git a/drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_config.h b/drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_config.h
new file mode 100644
index 000000000..2b66a877c
--- /dev/null
+++ b/drivers/ugfx/gdisp/st7565ergodox/gdisp_lld_config.h
@@ -0,0 +1,27 @@
1/*
2 * This file is subject to the terms of the GFX License. If a copy of
3 * the license was not distributed with this file, you can obtain one at:
4 *
5 * http://ugfx.org/license.html
6 */
7
8#ifndef _GDISP_LLD_CONFIG_H
9#define _GDISP_LLD_CONFIG_H
10
11#if GFX_USE_GDISP
12
13/*===========================================================================*/
14/* Driver hardware support. */
15/*===========================================================================*/
16
17#define GDISP_HARDWARE_FLUSH TRUE // This controller requires flushing
18#define GDISP_HARDWARE_DRAWPIXEL TRUE
19#define GDISP_HARDWARE_PIXELREAD TRUE
20#define GDISP_HARDWARE_CONTROL TRUE
21#define GDISP_HARDWARE_BITFILLS TRUE
22
23#define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_MONO
24
25#endif /* GFX_USE_GDISP */
26
27#endif /* _GDISP_LLD_CONFIG_H */
diff --git a/drivers/ugfx/gdisp/st7565ergodox/st7565.h b/drivers/ugfx/gdisp/st7565ergodox/st7565.h
new file mode 100644
index 000000000..24924ff05
--- /dev/null
+++ b/drivers/ugfx/gdisp/st7565ergodox/st7565.h
@@ -0,0 +1,39 @@
1/*
2 * This file is subject to the terms of the GFX License. If a copy of
3 * the license was not distributed with this file, you can obtain one at:
4 *
5 * http://ugfx.org/license.html
6 */
7
8#ifndef _ST7565_H
9#define _ST7565_H
10
11#define ST7565_CONTRAST 0x81
12#define ST7565_ALLON_NORMAL 0xA4
13#define ST7565_ALLON 0xA5
14#define ST7565_POSITIVE_DISPLAY 0xA6
15#define ST7565_INVERT_DISPLAY 0xA7
16#define ST7565_DISPLAY_OFF 0xAE
17#define ST7565_DISPLAY_ON 0xAF
18
19#define ST7565_LCD_BIAS_7 0xA3
20#define ST7565_LCD_BIAS_9 0xA2
21
22#define ST7565_ADC_NORMAL 0xA0
23#define ST7565_ADC_REVERSE 0xA1
24
25#define ST7565_COM_SCAN_INC 0xC0
26#define ST7565_COM_SCAN_DEC 0xC8
27
28#define ST7565_START_LINE 0x40
29#define ST7565_PAGE 0xB0
30#define ST7565_COLUMN_MSB 0x10
31#define ST7565_COLUMN_LSB 0x00
32#define ST7565_RMW 0xE0
33
34#define ST7565_RESISTOR_RATIO 0x20
35#define ST7565_POWER_CONTROL 0x28
36
37#define ST7565_RESET 0xE2
38
39#endif /* _ST7565_H */
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-29 07:32:14 +0000