Merge remote-tracking branch 'bonzini/nbd-next' into staging
[qemu/kevin.git] / hw / jazz_led.c
blob648652302a0d73ed6df5443b46f8aacedd186151
1 /*
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
22 * THE SOFTWARE.
25 #include "console.h"
26 #include "pixel_ops.h"
27 #include "trace.h"
28 #include "sysbus.h"
30 typedef enum {
31 REDRAW_NONE = 0, REDRAW_SEGMENTS = 1, REDRAW_BACKGROUND = 2,
32 } screen_state_t;
34 typedef struct LedState {
35 SysBusDevice busdev;
36 MemoryRegion iomem;
37 uint8_t segments;
38 DisplayState *ds;
39 screen_state_t state;
40 } LedState;
42 static uint64_t jazz_led_read(void *opaque, target_phys_addr_t addr,
43 unsigned int size)
45 LedState *s = opaque;
46 uint8_t val;
48 val = s->segments;
49 trace_jazz_led_read(addr, val);
51 return val;
54 static void jazz_led_write(void *opaque, target_phys_addr_t addr,
55 uint64_t val, unsigned int size)
57 LedState *s = opaque;
58 uint8_t new_val = val & 0xff;
60 trace_jazz_led_write(addr, new_val);
62 s->segments = new_val;
63 s->state |= REDRAW_SEGMENTS;
66 static const MemoryRegionOps led_ops = {
67 .read = jazz_led_read,
68 .write = jazz_led_write,
69 .endianness = DEVICE_NATIVE_ENDIAN,
70 .impl.min_access_size = 1,
71 .impl.max_access_size = 1,
74 /***********************************************************/
75 /* jazz_led display */
77 static void draw_horizontal_line(DisplayState *ds, int posy, int posx1, int posx2, uint32_t color)
79 uint8_t *d;
80 int x, bpp;
82 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
83 d = ds_get_data(ds) + ds_get_linesize(ds) * posy + bpp * posx1;
84 switch(bpp) {
85 case 1:
86 for (x = posx1; x <= posx2; x++) {
87 *((uint8_t *)d) = color;
88 d++;
90 break;
91 case 2:
92 for (x = posx1; x <= posx2; x++) {
93 *((uint16_t *)d) = color;
94 d += 2;
96 break;
97 case 4:
98 for (x = posx1; x <= posx2; x++) {
99 *((uint32_t *)d) = color;
100 d += 4;
102 break;
106 static void draw_vertical_line(DisplayState *ds, int posx, int posy1, int posy2, uint32_t color)
108 uint8_t *d;
109 int y, bpp;
111 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
112 d = ds_get_data(ds) + ds_get_linesize(ds) * posy1 + bpp * posx;
113 switch(bpp) {
114 case 1:
115 for (y = posy1; y <= posy2; y++) {
116 *((uint8_t *)d) = color;
117 d += ds_get_linesize(ds);
119 break;
120 case 2:
121 for (y = posy1; y <= posy2; y++) {
122 *((uint16_t *)d) = color;
123 d += ds_get_linesize(ds);
125 break;
126 case 4:
127 for (y = posy1; y <= posy2; y++) {
128 *((uint32_t *)d) = color;
129 d += ds_get_linesize(ds);
131 break;
135 static void jazz_led_update_display(void *opaque)
137 LedState *s = opaque;
138 DisplayState *ds = s->ds;
139 uint8_t *d1;
140 uint32_t color_segment, color_led;
141 int y, bpp;
143 if (s->state & REDRAW_BACKGROUND) {
144 /* clear screen */
145 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
146 d1 = ds_get_data(ds);
147 for (y = 0; y < ds_get_height(ds); y++) {
148 memset(d1, 0x00, ds_get_width(ds) * bpp);
149 d1 += ds_get_linesize(ds);
153 if (s->state & REDRAW_SEGMENTS) {
154 /* set colors according to bpp */
155 switch (ds_get_bits_per_pixel(ds)) {
156 case 8:
157 color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);
158 color_led = rgb_to_pixel8(0x00, 0xff, 0x00);
159 break;
160 case 15:
161 color_segment = rgb_to_pixel15(0xaa, 0xaa, 0xaa);
162 color_led = rgb_to_pixel15(0x00, 0xff, 0x00);
163 break;
164 case 16:
165 color_segment = rgb_to_pixel16(0xaa, 0xaa, 0xaa);
166 color_led = rgb_to_pixel16(0x00, 0xff, 0x00);
167 case 24:
168 color_segment = rgb_to_pixel24(0xaa, 0xaa, 0xaa);
169 color_led = rgb_to_pixel24(0x00, 0xff, 0x00);
170 break;
171 case 32:
172 color_segment = rgb_to_pixel32(0xaa, 0xaa, 0xaa);
173 color_led = rgb_to_pixel32(0x00, 0xff, 0x00);
174 break;
175 default:
176 return;
179 /* display segments */
180 draw_horizontal_line(ds, 40, 10, 40, (s->segments & 0x02) ? color_segment : 0);
181 draw_vertical_line(ds, 10, 10, 40, (s->segments & 0x04) ? color_segment : 0);
182 draw_vertical_line(ds, 10, 40, 70, (s->segments & 0x08) ? color_segment : 0);
183 draw_horizontal_line(ds, 70, 10, 40, (s->segments & 0x10) ? color_segment : 0);
184 draw_vertical_line(ds, 40, 40, 70, (s->segments & 0x20) ? color_segment : 0);
185 draw_vertical_line(ds, 40, 10, 40, (s->segments & 0x40) ? color_segment : 0);
186 draw_horizontal_line(ds, 10, 10, 40, (s->segments & 0x80) ? color_segment : 0);
188 /* display led */
189 if (!(s->segments & 0x01))
190 color_led = 0; /* black */
191 draw_horizontal_line(ds, 68, 50, 50, color_led);
192 draw_horizontal_line(ds, 69, 49, 51, color_led);
193 draw_horizontal_line(ds, 70, 48, 52, color_led);
194 draw_horizontal_line(ds, 71, 49, 51, color_led);
195 draw_horizontal_line(ds, 72, 50, 50, color_led);
198 s->state = REDRAW_NONE;
199 dpy_update(ds, 0, 0, ds_get_width(ds), ds_get_height(ds));
202 static void jazz_led_invalidate_display(void *opaque)
204 LedState *s = opaque;
205 s->state |= REDRAW_SEGMENTS | REDRAW_BACKGROUND;
208 static void jazz_led_text_update(void *opaque, console_ch_t *chardata)
210 LedState *s = opaque;
211 char buf[2];
213 dpy_cursor(s->ds, -1, -1);
214 qemu_console_resize(s->ds, 2, 1);
216 /* TODO: draw the segments */
217 snprintf(buf, 2, "%02hhx\n", s->segments);
218 console_write_ch(chardata++, 0x00200100 | buf[0]);
219 console_write_ch(chardata++, 0x00200100 | buf[1]);
221 dpy_update(s->ds, 0, 0, 2, 1);
224 static int jazz_led_post_load(void *opaque, int version_id)
226 /* force refresh */
227 jazz_led_invalidate_display(opaque);
229 return 0;
232 static const VMStateDescription vmstate_jazz_led = {
233 .name = "jazz-led",
234 .version_id = 0,
235 .minimum_version_id = 0,
236 .minimum_version_id_old = 0,
237 .post_load = jazz_led_post_load,
238 .fields = (VMStateField[]) {
239 VMSTATE_UINT8(segments, LedState),
240 VMSTATE_END_OF_LIST()
244 static int jazz_led_init(SysBusDevice *dev)
246 LedState *s = FROM_SYSBUS(LedState, dev);
248 memory_region_init_io(&s->iomem, &led_ops, s, "led", 1);
249 sysbus_init_mmio(dev, &s->iomem);
251 s->ds = graphic_console_init(jazz_led_update_display,
252 jazz_led_invalidate_display,
253 NULL,
254 jazz_led_text_update, s);
256 return 0;
259 static void jazz_led_reset(DeviceState *d)
261 LedState *s = DO_UPCAST(LedState, busdev.qdev, d);
263 s->segments = 0;
264 s->state = REDRAW_SEGMENTS | REDRAW_BACKGROUND;
265 qemu_console_resize(s->ds, 60, 80);
268 static void jazz_led_class_init(ObjectClass *klass, void *data)
270 DeviceClass *dc = DEVICE_CLASS(klass);
271 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
273 k->init = jazz_led_init;
274 dc->desc = "Jazz LED display",
275 dc->vmsd = &vmstate_jazz_led;
276 dc->reset = jazz_led_reset;
279 static TypeInfo jazz_led_info = {
280 .name = "jazz-led",
281 .parent = TYPE_SYS_BUS_DEVICE,
282 .instance_size = sizeof(LedState),
283 .class_init = jazz_led_class_init,
286 static void jazz_led_register(void)
288 type_register_static(&jazz_led_info);
291 type_init(jazz_led_register);