1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu-common.h"
26#include "ui/console.h"
27#include "ui/pixel_ops.h"
28#include "trace.h"
29#include "hw/sysbus.h"
30
31typedef enum {
32 REDRAW_NONE = 0, REDRAW_SEGMENTS = 1, REDRAW_BACKGROUND = 2,
33} screen_state_t;
34
35#define TYPE_JAZZ_LED "jazz-led"
36#define JAZZ_LED(obj) OBJECT_CHECK(LedState, (obj), TYPE_JAZZ_LED)
37
38typedef struct LedState {
39 SysBusDevice parent_obj;
40
41 MemoryRegion iomem;
42 uint8_t segments;
43 QemuConsole *con;
44 screen_state_t state;
45} LedState;
46
47static uint64_t jazz_led_read(void *opaque, hwaddr addr,
48 unsigned int size)
49{
50 LedState *s = opaque;
51 uint8_t val;
52
53 val = s->segments;
54 trace_jazz_led_read(addr, val);
55
56 return val;
57}
58
59static void jazz_led_write(void *opaque, hwaddr addr,
60 uint64_t val, unsigned int size)
61{
62 LedState *s = opaque;
63 uint8_t new_val = val & 0xff;
64
65 trace_jazz_led_write(addr, new_val);
66
67 s->segments = new_val;
68 s->state |= REDRAW_SEGMENTS;
69}
70
71static const MemoryRegionOps led_ops = {
72 .read = jazz_led_read,
73 .write = jazz_led_write,
74 .endianness = DEVICE_NATIVE_ENDIAN,
75 .impl.min_access_size = 1,
76 .impl.max_access_size = 1,
77};
78
79
80
81
82static void draw_horizontal_line(DisplaySurface *ds,
83 int posy, int posx1, int posx2,
84 uint32_t color)
85{
86 uint8_t *d;
87 int x, bpp;
88
89 bpp = (surface_bits_per_pixel(ds) + 7) >> 3;
90 d = surface_data(ds) + surface_stride(ds) * posy + bpp * posx1;
91 switch(bpp) {
92 case 1:
93 for (x = posx1; x <= posx2; x++) {
94 *((uint8_t *)d) = color;
95 d++;
96 }
97 break;
98 case 2:
99 for (x = posx1; x <= posx2; x++) {
100 *((uint16_t *)d) = color;
101 d += 2;
102 }
103 break;
104 case 4:
105 for (x = posx1; x <= posx2; x++) {
106 *((uint32_t *)d) = color;
107 d += 4;
108 }
109 break;
110 }
111}
112
113static void draw_vertical_line(DisplaySurface *ds,
114 int posx, int posy1, int posy2,
115 uint32_t color)
116{
117 uint8_t *d;
118 int y, bpp;
119
120 bpp = (surface_bits_per_pixel(ds) + 7) >> 3;
121 d = surface_data(ds) + surface_stride(ds) * posy1 + bpp * posx;
122 switch(bpp) {
123 case 1:
124 for (y = posy1; y <= posy2; y++) {
125 *((uint8_t *)d) = color;
126 d += surface_stride(ds);
127 }
128 break;
129 case 2:
130 for (y = posy1; y <= posy2; y++) {
131 *((uint16_t *)d) = color;
132 d += surface_stride(ds);
133 }
134 break;
135 case 4:
136 for (y = posy1; y <= posy2; y++) {
137 *((uint32_t *)d) = color;
138 d += surface_stride(ds);
139 }
140 break;
141 }
142}
143
144static void jazz_led_update_display(void *opaque)
145{
146 LedState *s = opaque;
147 DisplaySurface *surface = qemu_console_surface(s->con);
148 uint8_t *d1;
149 uint32_t color_segment, color_led;
150 int y, bpp;
151
152 if (s->state & REDRAW_BACKGROUND) {
153
154 bpp = (surface_bits_per_pixel(surface) + 7) >> 3;
155 d1 = surface_data(surface);
156 for (y = 0; y < surface_height(surface); y++) {
157 memset(d1, 0x00, surface_width(surface) * bpp);
158 d1 += surface_stride(surface);
159 }
160 }
161
162 if (s->state & REDRAW_SEGMENTS) {
163
164 switch (surface_bits_per_pixel(surface)) {
165 case 8:
166 color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);
167 color_led = rgb_to_pixel8(0x00, 0xff, 0x00);
168 break;
169 case 15:
170 color_segment = rgb_to_pixel15(0xaa, 0xaa, 0xaa);
171 color_led = rgb_to_pixel15(0x00, 0xff, 0x00);
172 break;
173 case 16:
174 color_segment = rgb_to_pixel16(0xaa, 0xaa, 0xaa);
175 color_led = rgb_to_pixel16(0x00, 0xff, 0x00);
176 case 24:
177 color_segment = rgb_to_pixel24(0xaa, 0xaa, 0xaa);
178 color_led = rgb_to_pixel24(0x00, 0xff, 0x00);
179 break;
180 case 32:
181 color_segment = rgb_to_pixel32(0xaa, 0xaa, 0xaa);
182 color_led = rgb_to_pixel32(0x00, 0xff, 0x00);
183 break;
184 default:
185 return;
186 }
187
188
189 draw_horizontal_line(surface, 40, 10, 40,
190 (s->segments & 0x02) ? color_segment : 0);
191 draw_vertical_line(surface, 10, 10, 40,
192 (s->segments & 0x04) ? color_segment : 0);
193 draw_vertical_line(surface, 10, 40, 70,
194 (s->segments & 0x08) ? color_segment : 0);
195 draw_horizontal_line(surface, 70, 10, 40,
196 (s->segments & 0x10) ? color_segment : 0);
197 draw_vertical_line(surface, 40, 40, 70,
198 (s->segments & 0x20) ? color_segment : 0);
199 draw_vertical_line(surface, 40, 10, 40,
200 (s->segments & 0x40) ? color_segment : 0);
201 draw_horizontal_line(surface, 10, 10, 40,
202 (s->segments & 0x80) ? color_segment : 0);
203
204
205 if (!(s->segments & 0x01))
206 color_led = 0;
207 draw_horizontal_line(surface, 68, 50, 50, color_led);
208 draw_horizontal_line(surface, 69, 49, 51, color_led);
209 draw_horizontal_line(surface, 70, 48, 52, color_led);
210 draw_horizontal_line(surface, 71, 49, 51, color_led);
211 draw_horizontal_line(surface, 72, 50, 50, color_led);
212 }
213
214 s->state = REDRAW_NONE;
215 dpy_gfx_update(s->con, 0, 0,
216 surface_width(surface), surface_height(surface));
217}
218
219static void jazz_led_invalidate_display(void *opaque)
220{
221 LedState *s = opaque;
222 s->state |= REDRAW_SEGMENTS | REDRAW_BACKGROUND;
223}
224
225static void jazz_led_text_update(void *opaque, console_ch_t *chardata)
226{
227 LedState *s = opaque;
228 char buf[2];
229
230 dpy_text_cursor(s->con, -1, -1);
231 qemu_console_resize(s->con, 2, 1);
232
233
234 snprintf(buf, 2, "%02hhx\n", s->segments);
235 console_write_ch(chardata++, 0x00200100 | buf[0]);
236 console_write_ch(chardata++, 0x00200100 | buf[1]);
237
238 dpy_text_update(s->con, 0, 0, 2, 1);
239}
240
241static int jazz_led_post_load(void *opaque, int version_id)
242{
243
244 jazz_led_invalidate_display(opaque);
245
246 return 0;
247}
248
249static const VMStateDescription vmstate_jazz_led = {
250 .name = "jazz-led",
251 .version_id = 0,
252 .minimum_version_id = 0,
253 .minimum_version_id_old = 0,
254 .post_load = jazz_led_post_load,
255 .fields = (VMStateField[]) {
256 VMSTATE_UINT8(segments, LedState),
257 VMSTATE_END_OF_LIST()
258 }
259};
260
261static const GraphicHwOps jazz_led_ops = {
262 .invalidate = jazz_led_invalidate_display,
263 .gfx_update = jazz_led_update_display,
264 .text_update = jazz_led_text_update,
265};
266
267static int jazz_led_init(SysBusDevice *dev)
268{
269 LedState *s = JAZZ_LED(dev);
270
271 memory_region_init_io(&s->iomem, OBJECT(s), &led_ops, s, "led", 1);
272 sysbus_init_mmio(dev, &s->iomem);
273
274 s->con = graphic_console_init(DEVICE(dev), &jazz_led_ops, s);
275
276 return 0;
277}
278
279static void jazz_led_reset(DeviceState *d)
280{
281 LedState *s = JAZZ_LED(d);
282
283 s->segments = 0;
284 s->state = REDRAW_SEGMENTS | REDRAW_BACKGROUND;
285 qemu_console_resize(s->con, 60, 80);
286}
287
288static void jazz_led_class_init(ObjectClass *klass, void *data)
289{
290 DeviceClass *dc = DEVICE_CLASS(klass);
291 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
292
293 k->init = jazz_led_init;
294 dc->desc = "Jazz LED display",
295 dc->vmsd = &vmstate_jazz_led;
296 dc->reset = jazz_led_reset;
297}
298
299static const TypeInfo jazz_led_info = {
300 .name = TYPE_JAZZ_LED,
301 .parent = TYPE_SYS_BUS_DEVICE,
302 .instance_size = sizeof(LedState),
303 .class_init = jazz_led_class_init,
304};
305
306static void jazz_led_register(void)
307{
308 type_register_static(&jazz_led_info);
309}
310
311type_init(jazz_led_register);
312
