2 * QEMU JAZZ LED emulator.
4 * Copyright (c) 2007-2012 Herve Poussineau
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "qemu/module.h"
27 #include "ui/console.h"
28 #include "ui/pixel_ops.h"
30 #include "hw/sysbus.h"
31 #include "migration/vmstate.h"
32 #include "qom/object.h"
35 REDRAW_NONE
= 0, REDRAW_SEGMENTS
= 1, REDRAW_BACKGROUND
= 2,
38 #define TYPE_JAZZ_LED "jazz-led"
39 typedef struct LedState LedState
;
40 DECLARE_INSTANCE_CHECKER(LedState
, JAZZ_LED
,
44 SysBusDevice parent_obj
;
52 static uint64_t jazz_led_read(void *opaque
, hwaddr addr
,
59 trace_jazz_led_read(addr
, val
);
64 static void jazz_led_write(void *opaque
, hwaddr addr
,
65 uint64_t val
, unsigned int size
)
68 uint8_t new_val
= val
& 0xff;
70 trace_jazz_led_write(addr
, new_val
);
72 s
->segments
= new_val
;
73 s
->state
|= REDRAW_SEGMENTS
;
76 static const MemoryRegionOps led_ops
= {
77 .read
= jazz_led_read
,
78 .write
= jazz_led_write
,
79 .endianness
= DEVICE_NATIVE_ENDIAN
,
80 .impl
.min_access_size
= 1,
81 .impl
.max_access_size
= 1,
84 /***********************************************************/
85 /* jazz_led display */
87 static void draw_horizontal_line(DisplaySurface
*ds
,
88 int posy
, int posx1
, int posx2
,
94 bpp
= (surface_bits_per_pixel(ds
) + 7) >> 3;
95 d
= surface_data(ds
) + surface_stride(ds
) * posy
+ bpp
* posx1
;
98 for (x
= posx1
; x
<= posx2
; x
++) {
99 *((uint8_t *)d
) = color
;
104 for (x
= posx1
; x
<= posx2
; x
++) {
105 *((uint16_t *)d
) = color
;
110 for (x
= posx1
; x
<= posx2
; x
++) {
111 *((uint32_t *)d
) = color
;
118 static void draw_vertical_line(DisplaySurface
*ds
,
119 int posx
, int posy1
, int posy2
,
125 bpp
= (surface_bits_per_pixel(ds
) + 7) >> 3;
126 d
= surface_data(ds
) + surface_stride(ds
) * posy1
+ bpp
* posx
;
129 for (y
= posy1
; y
<= posy2
; y
++) {
130 *((uint8_t *)d
) = color
;
131 d
+= surface_stride(ds
);
135 for (y
= posy1
; y
<= posy2
; y
++) {
136 *((uint16_t *)d
) = color
;
137 d
+= surface_stride(ds
);
141 for (y
= posy1
; y
<= posy2
; y
++) {
142 *((uint32_t *)d
) = color
;
143 d
+= surface_stride(ds
);
149 static void jazz_led_update_display(void *opaque
)
151 LedState
*s
= opaque
;
152 DisplaySurface
*surface
= qemu_console_surface(s
->con
);
154 uint32_t color_segment
, color_led
;
157 if (s
->state
& REDRAW_BACKGROUND
) {
159 bpp
= (surface_bits_per_pixel(surface
) + 7) >> 3;
160 d1
= surface_data(surface
);
161 for (y
= 0; y
< surface_height(surface
); y
++) {
162 memset(d1
, 0x00, surface_width(surface
) * bpp
);
163 d1
+= surface_stride(surface
);
167 if (s
->state
& REDRAW_SEGMENTS
) {
168 /* set colors according to bpp */
169 switch (surface_bits_per_pixel(surface
)) {
171 color_segment
= rgb_to_pixel8(0xaa, 0xaa, 0xaa);
172 color_led
= rgb_to_pixel8(0x00, 0xff, 0x00);
175 color_segment
= rgb_to_pixel15(0xaa, 0xaa, 0xaa);
176 color_led
= rgb_to_pixel15(0x00, 0xff, 0x00);
179 color_segment
= rgb_to_pixel16(0xaa, 0xaa, 0xaa);
180 color_led
= rgb_to_pixel16(0x00, 0xff, 0x00);
183 color_segment
= rgb_to_pixel24(0xaa, 0xaa, 0xaa);
184 color_led
= rgb_to_pixel24(0x00, 0xff, 0x00);
187 color_segment
= rgb_to_pixel32(0xaa, 0xaa, 0xaa);
188 color_led
= rgb_to_pixel32(0x00, 0xff, 0x00);
194 /* display segments */
195 draw_horizontal_line(surface
, 40, 10, 40,
196 (s
->segments
& 0x02) ? color_segment
: 0);
197 draw_vertical_line(surface
, 10, 10, 40,
198 (s
->segments
& 0x04) ? color_segment
: 0);
199 draw_vertical_line(surface
, 10, 40, 70,
200 (s
->segments
& 0x08) ? color_segment
: 0);
201 draw_horizontal_line(surface
, 70, 10, 40,
202 (s
->segments
& 0x10) ? color_segment
: 0);
203 draw_vertical_line(surface
, 40, 40, 70,
204 (s
->segments
& 0x20) ? color_segment
: 0);
205 draw_vertical_line(surface
, 40, 10, 40,
206 (s
->segments
& 0x40) ? color_segment
: 0);
207 draw_horizontal_line(surface
, 10, 10, 40,
208 (s
->segments
& 0x80) ? color_segment
: 0);
211 if (!(s
->segments
& 0x01)) {
212 color_led
= 0; /* black */
214 draw_horizontal_line(surface
, 68, 50, 50, color_led
);
215 draw_horizontal_line(surface
, 69, 49, 51, color_led
);
216 draw_horizontal_line(surface
, 70, 48, 52, color_led
);
217 draw_horizontal_line(surface
, 71, 49, 51, color_led
);
218 draw_horizontal_line(surface
, 72, 50, 50, color_led
);
221 s
->state
= REDRAW_NONE
;
222 dpy_gfx_update_full(s
->con
);
225 static void jazz_led_invalidate_display(void *opaque
)
227 LedState
*s
= opaque
;
228 s
->state
|= REDRAW_SEGMENTS
| REDRAW_BACKGROUND
;
231 static void jazz_led_text_update(void *opaque
, console_ch_t
*chardata
)
233 LedState
*s
= opaque
;
236 dpy_text_cursor(s
->con
, -1, -1);
237 qemu_console_resize(s
->con
, 2, 1);
239 /* TODO: draw the segments */
240 snprintf(buf
, 3, "%02hhx", s
->segments
);
241 console_write_ch(chardata
++, ATTR2CHTYPE(buf
[0], QEMU_COLOR_BLUE
,
242 QEMU_COLOR_BLACK
, 1));
243 console_write_ch(chardata
++, ATTR2CHTYPE(buf
[1], QEMU_COLOR_BLUE
,
244 QEMU_COLOR_BLACK
, 1));
246 dpy_text_update(s
->con
, 0, 0, 2, 1);
249 static int jazz_led_post_load(void *opaque
, int version_id
)
252 jazz_led_invalidate_display(opaque
);
257 static const VMStateDescription vmstate_jazz_led
= {
260 .minimum_version_id
= 0,
261 .post_load
= jazz_led_post_load
,
262 .fields
= (VMStateField
[]) {
263 VMSTATE_UINT8(segments
, LedState
),
264 VMSTATE_END_OF_LIST()
268 static const GraphicHwOps jazz_led_ops
= {
269 .invalidate
= jazz_led_invalidate_display
,
270 .gfx_update
= jazz_led_update_display
,
271 .text_update
= jazz_led_text_update
,
274 static void jazz_led_init(Object
*obj
)
276 LedState
*s
= JAZZ_LED(obj
);
277 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
279 memory_region_init_io(&s
->iomem
, obj
, &led_ops
, s
, "led", 1);
280 sysbus_init_mmio(dev
, &s
->iomem
);
283 static void jazz_led_realize(DeviceState
*dev
, Error
**errp
)
285 LedState
*s
= JAZZ_LED(dev
);
287 s
->con
= graphic_console_init(dev
, 0, &jazz_led_ops
, s
);
290 static void jazz_led_reset(DeviceState
*d
)
292 LedState
*s
= JAZZ_LED(d
);
295 s
->state
= REDRAW_SEGMENTS
| REDRAW_BACKGROUND
;
296 qemu_console_resize(s
->con
, 60, 80);
299 static void jazz_led_class_init(ObjectClass
*klass
, void *data
)
301 DeviceClass
*dc
= DEVICE_CLASS(klass
);
303 dc
->desc
= "Jazz LED display",
304 dc
->vmsd
= &vmstate_jazz_led
;
305 dc
->reset
= jazz_led_reset
;
306 dc
->realize
= jazz_led_realize
;
309 static const TypeInfo jazz_led_info
= {
310 .name
= TYPE_JAZZ_LED
,
311 .parent
= TYPE_SYS_BUS_DEVICE
,
312 .instance_size
= sizeof(LedState
),
313 .instance_init
= jazz_led_init
,
314 .class_init
= jazz_led_class_init
,
317 static void jazz_led_register(void)
319 type_register_static(&jazz_led_info
);
322 type_init(jazz_led_register
);