1
2
3
4
5
6
7
8
9
10
11
12
13
14#include "qemu/osdep.h"
15#include "hw/i2c/i2c.h"
16#include "qemu/module.h"
17#include "ui/console.h"
18
19
20
21#ifdef DEBUG_SSD0303
22#define DPRINTF(fmt, ...) \
23do { printf("ssd0303: " fmt , ## __VA_ARGS__); } while (0)
24#define BADF(fmt, ...) \
25do { fprintf(stderr, "ssd0303: error: " fmt , ## __VA_ARGS__); exit(1);} while (0)
26#else
27#define DPRINTF(fmt, ...) do {} while(0)
28#define BADF(fmt, ...) \
29do { fprintf(stderr, "ssd0303: error: " fmt , ## __VA_ARGS__);} while (0)
30#endif
31
32
33#define MAGNIFY 4
34
35enum ssd0303_mode
36{
37 SSD0303_IDLE,
38 SSD0303_DATA,
39 SSD0303_CMD
40};
41
42enum ssd0303_cmd {
43 SSD0303_CMD_NONE,
44 SSD0303_CMD_SKIP1
45};
46
47#define TYPE_SSD0303 "ssd0303"
48#define SSD0303(obj) OBJECT_CHECK(ssd0303_state, (obj), TYPE_SSD0303)
49
50typedef struct {
51 I2CSlave parent_obj;
52
53 QemuConsole *con;
54 int row;
55 int col;
56 int start_line;
57 int mirror;
58 int flash;
59 int enabled;
60 int inverse;
61 int redraw;
62 enum ssd0303_mode mode;
63 enum ssd0303_cmd cmd_state;
64 uint8_t framebuffer[132*8];
65} ssd0303_state;
66
67static uint8_t ssd0303_recv(I2CSlave *i2c)
68{
69 BADF("Reads not implemented\n");
70 return 0xff;
71}
72
73static int ssd0303_send(I2CSlave *i2c, uint8_t data)
74{
75 ssd0303_state *s = SSD0303(i2c);
76 enum ssd0303_cmd old_cmd_state;
77
78 switch (s->mode) {
79 case SSD0303_IDLE:
80 DPRINTF("byte 0x%02x\n", data);
81 if (data == 0x80)
82 s->mode = SSD0303_CMD;
83 else if (data == 0x40)
84 s->mode = SSD0303_DATA;
85 else
86 BADF("Unexpected byte 0x%x\n", data);
87 break;
88 case SSD0303_DATA:
89 DPRINTF("data 0x%02x\n", data);
90 if (s->col < 132) {
91 s->framebuffer[s->col + s->row * 132] = data;
92 s->col++;
93 s->redraw = 1;
94 }
95 break;
96 case SSD0303_CMD:
97 old_cmd_state = s->cmd_state;
98 s->cmd_state = SSD0303_CMD_NONE;
99 switch (old_cmd_state) {
100 case SSD0303_CMD_NONE:
101 DPRINTF("cmd 0x%02x\n", data);
102 s->mode = SSD0303_IDLE;
103 switch (data) {
104 case 0x00 ... 0x0f:
105 s->col = (s->col & 0xf0) | (data & 0xf);
106 break;
107 case 0x10 ... 0x20:
108 s->col = (s->col & 0x0f) | ((data & 0xf) << 4);
109 break;
110 case 0x40 ... 0x7f:
111 s->start_line = 0;
112 break;
113 case 0x81:
114 s->cmd_state = SSD0303_CMD_SKIP1;
115 break;
116 case 0xa0:
117 s->mirror = 0;
118 break;
119 case 0xa1:
120 s->mirror = 1;
121 break;
122 case 0xa4:
123 s->flash = 0;
124 break;
125 case 0xa5:
126 s->flash = 1;
127 break;
128 case 0xa6:
129 s->inverse = 0;
130 break;
131 case 0xa7:
132 s->inverse = 1;
133 break;
134 case 0xa8:
135 s->cmd_state = SSD0303_CMD_SKIP1;
136 break;
137 case 0xad:
138 s->cmd_state = SSD0303_CMD_SKIP1;
139 break;
140 case 0xae:
141 s->enabled = 0;
142 break;
143 case 0xaf:
144 s->enabled = 1;
145 break;
146 case 0xb0 ... 0xbf:
147 s->row = data & 7;
148 break;
149 case 0xc0 ... 0xc8:
150 break;
151 case 0xd3:
152 s->cmd_state = SSD0303_CMD_SKIP1;
153 break;
154 case 0xd5:
155 s->cmd_state = SSD0303_CMD_SKIP1;
156 break;
157 case 0xd8:
158 s->cmd_state = SSD0303_CMD_SKIP1;
159 break;
160 case 0xd9:
161 s->cmd_state = SSD0303_CMD_SKIP1;
162 break;
163 case 0xda:
164 s->cmd_state = SSD0303_CMD_SKIP1;
165 break;
166 case 0xdb:
167 s->cmd_state = SSD0303_CMD_SKIP1;
168 break;
169 case 0xe3:
170 break;
171 default:
172 BADF("Unknown command: 0x%x\n", data);
173 }
174 break;
175 case SSD0303_CMD_SKIP1:
176 DPRINTF("skip 0x%02x\n", data);
177 break;
178 }
179 break;
180 }
181 return 0;
182}
183
184static int ssd0303_event(I2CSlave *i2c, enum i2c_event event)
185{
186 ssd0303_state *s = SSD0303(i2c);
187
188 switch (event) {
189 case I2C_FINISH:
190 s->mode = SSD0303_IDLE;
191 break;
192 case I2C_START_RECV:
193 case I2C_START_SEND:
194 case I2C_NACK:
195
196 break;
197 }
198
199 return 0;
200}
201
202static void ssd0303_update_display(void *opaque)
203{
204 ssd0303_state *s = (ssd0303_state *)opaque;
205 DisplaySurface *surface = qemu_console_surface(s->con);
206 uint8_t *dest;
207 uint8_t *src;
208 int x;
209 int y;
210 int line;
211 char *colors[2];
212 char colortab[MAGNIFY * 8];
213 int dest_width;
214 uint8_t mask;
215
216 if (!s->redraw)
217 return;
218
219 switch (surface_bits_per_pixel(surface)) {
220 case 0:
221 return;
222 case 15:
223 dest_width = 2;
224 break;
225 case 16:
226 dest_width = 2;
227 break;
228 case 24:
229 dest_width = 3;
230 break;
231 case 32:
232 dest_width = 4;
233 break;
234 default:
235 BADF("Bad color depth\n");
236 return;
237 }
238 dest_width *= MAGNIFY;
239 memset(colortab, 0xff, dest_width);
240 memset(colortab + dest_width, 0, dest_width);
241 if (s->flash) {
242 colors[0] = colortab;
243 colors[1] = colortab;
244 } else if (s->inverse) {
245 colors[0] = colortab;
246 colors[1] = colortab + dest_width;
247 } else {
248 colors[0] = colortab + dest_width;
249 colors[1] = colortab;
250 }
251 dest = surface_data(surface);
252 for (y = 0; y < 16; y++) {
253 line = (y + s->start_line) & 63;
254 src = s->framebuffer + 132 * (line >> 3) + 36;
255 mask = 1 << (line & 7);
256 for (x = 0; x < 96; x++) {
257 memcpy(dest, colors[(*src & mask) != 0], dest_width);
258 dest += dest_width;
259 src++;
260 }
261 for (x = 1; x < MAGNIFY; x++) {
262 memcpy(dest, dest - dest_width * 96, dest_width * 96);
263 dest += dest_width * 96;
264 }
265 }
266 s->redraw = 0;
267 dpy_gfx_update(s->con, 0, 0, 96 * MAGNIFY, 16 * MAGNIFY);
268}
269
270static void ssd0303_invalidate_display(void * opaque)
271{
272 ssd0303_state *s = (ssd0303_state *)opaque;
273 s->redraw = 1;
274}
275
276static const VMStateDescription vmstate_ssd0303 = {
277 .name = "ssd0303_oled",
278 .version_id = 1,
279 .minimum_version_id = 1,
280 .fields = (VMStateField[]) {
281 VMSTATE_INT32(row, ssd0303_state),
282 VMSTATE_INT32(col, ssd0303_state),
283 VMSTATE_INT32(start_line, ssd0303_state),
284 VMSTATE_INT32(mirror, ssd0303_state),
285 VMSTATE_INT32(flash, ssd0303_state),
286 VMSTATE_INT32(enabled, ssd0303_state),
287 VMSTATE_INT32(inverse, ssd0303_state),
288 VMSTATE_INT32(redraw, ssd0303_state),
289 VMSTATE_UINT32(mode, ssd0303_state),
290 VMSTATE_UINT32(cmd_state, ssd0303_state),
291 VMSTATE_BUFFER(framebuffer, ssd0303_state),
292 VMSTATE_I2C_SLAVE(parent_obj, ssd0303_state),
293 VMSTATE_END_OF_LIST()
294 }
295};
296
297static const GraphicHwOps ssd0303_ops = {
298 .invalidate = ssd0303_invalidate_display,
299 .gfx_update = ssd0303_update_display,
300};
301
302static void ssd0303_realize(DeviceState *dev, Error **errp)
303{
304 ssd0303_state *s = SSD0303(dev);
305
306 s->con = graphic_console_init(dev, 0, &ssd0303_ops, s);
307 qemu_console_resize(s->con, 96 * MAGNIFY, 16 * MAGNIFY);
308}
309
310static void ssd0303_class_init(ObjectClass *klass, void *data)
311{
312 DeviceClass *dc = DEVICE_CLASS(klass);
313 I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
314
315 dc->realize = ssd0303_realize;
316 k->event = ssd0303_event;
317 k->recv = ssd0303_recv;
318 k->send = ssd0303_send;
319 dc->vmsd = &vmstate_ssd0303;
320}
321
322static const TypeInfo ssd0303_info = {
323 .name = TYPE_SSD0303,
324 .parent = TYPE_I2C_SLAVE,
325 .instance_size = sizeof(ssd0303_state),
326 .class_init = ssd0303_class_init,
327};
328
329static void ssd0303_register_types(void)
330{
331 type_register_static(&ssd0303_info);
332}
333
334type_init(ssd0303_register_types)
335
