Bug Summary

File:hw/display/jazz_led.c
Location:line 175, column 17
Description:Value stored to 'color_led' is never read

Annotated Source Code

1/*
2 * QEMU JAZZ LED emulator.
3 *
4 * Copyright (c) 2007-2012 Herve Poussineau
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
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" "jazz-led"
36#define JAZZ_LED(obj)((LedState *)object_dynamic_cast_assert(((Object *)((obj))), (
"jazz-led"), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 36, __func__)) OBJECT_CHECK(LedState, (obj), TYPE_JAZZ_LED)((LedState *)object_dynamic_cast_assert(((Object *)((obj))), (
"jazz-led"), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 36, __func__))
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/* jazz_led display */
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 /* clear screen */
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 /* set colors according to bpp */
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);
Value stored to 'color_led' is never read
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 /* display segments */
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 /* display led */
205 if (!(s->segments & 0x01))
206 color_led = 0; /* black */
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 /* TODO: draw the segments */
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 /* force refresh */
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){ .name = ("segments"), .version_id = (0), .field_exists = ((
(void*)0)), .size = sizeof(uint8_t), .info = &(vmstate_info_uint8
), .flags = VMS_SINGLE, .offset = (__builtin_offsetof(LedState
, segments) + ((uint8_t*)0 - (typeof(((LedState *)0)->segments
)*)0)), },
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)((LedState *)object_dynamic_cast_assert(((Object *)((dev))), (
"jazz-led"), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 269, __func__));
270
271 memory_region_init_io(&s->iomem, OBJECT(s)((Object *)(s)), &led_ops, s, "led", 1);
272 sysbus_init_mmio(dev, &s->iomem);
273
274 s->con = graphic_console_init(DEVICE(dev)((DeviceState *)object_dynamic_cast_assert(((Object *)((dev))
), ("device"), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 274, __func__)), &jazz_led_ops, s);
275
276 return 0;
277}
278
279static void jazz_led_reset(DeviceState *d)
280{
281 LedState *s = JAZZ_LED(d)((LedState *)object_dynamic_cast_assert(((Object *)((d))), ("jazz-led"
), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 281, __func__));
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)((DeviceClass *)object_class_dynamic_cast_assert(((ObjectClass
*)((klass))), ("device"), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 290, __func__));
291 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass)((SysBusDeviceClass *)object_class_dynamic_cast_assert(((ObjectClass
*)((klass))), ("sys-bus-device"), "/home/stefan/src/qemu/qemu.org/qemu/hw/display/jazz_led.c"
, 291, __func__));
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"jazz-led",
301 .parent = TYPE_SYS_BUS_DEVICE"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)static void __attribute__((constructor)) do_qemu_init_jazz_led_register
(void) { register_module_init(jazz_led_register, MODULE_INIT_QOM
); };