2 * QEMU JAZZ LED emulator.
4 * Copyright (c) 2007 Hervé 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
28 #include "pixel_ops.h"
33 REDRAW_NONE
= 0, REDRAW_SEGMENTS
= 1, REDRAW_BACKGROUND
= 2,
36 typedef struct LedState
{
42 static uint32_t led_readb(void *opaque
, target_phys_addr_t addr
)
53 printf("jazz led: invalid read [0x%x]\n", relative_addr
);
61 static uint32_t led_readw(void *opaque
, target_phys_addr_t addr
)
64 #ifdef TARGET_WORDS_BIGENDIAN
65 v
= led_readb(opaque
, addr
) << 8;
66 v
|= led_readb(opaque
, addr
+ 1);
68 v
= led_readb(opaque
, addr
);
69 v
|= led_readb(opaque
, addr
+ 1) << 8;
74 static uint32_t led_readl(void *opaque
, target_phys_addr_t addr
)
77 #ifdef TARGET_WORDS_BIGENDIAN
78 v
= led_readb(opaque
, addr
) << 24;
79 v
|= led_readb(opaque
, addr
+ 1) << 16;
80 v
|= led_readb(opaque
, addr
+ 2) << 8;
81 v
|= led_readb(opaque
, addr
+ 3);
83 v
= led_readb(opaque
, addr
);
84 v
|= led_readb(opaque
, addr
+ 1) << 8;
85 v
|= led_readb(opaque
, addr
+ 2) << 16;
86 v
|= led_readb(opaque
, addr
+ 3) << 24;
91 static void led_writeb(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
98 s
->state
|= REDRAW_SEGMENTS
;
102 printf("jazz led: invalid write of 0x%02x at [0x%x]\n", val
, relative_addr
);
108 static void led_writew(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
110 #ifdef TARGET_WORDS_BIGENDIAN
111 led_writeb(opaque
, addr
, (val
>> 8) & 0xff);
112 led_writeb(opaque
, addr
+ 1, val
& 0xff);
114 led_writeb(opaque
, addr
, val
& 0xff);
115 led_writeb(opaque
, addr
+ 1, (val
>> 8) & 0xff);
119 static void led_writel(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
121 #ifdef TARGET_WORDS_BIGENDIAN
122 led_writeb(opaque
, addr
, (val
>> 24) & 0xff);
123 led_writeb(opaque
, addr
+ 1, (val
>> 16) & 0xff);
124 led_writeb(opaque
, addr
+ 2, (val
>> 8) & 0xff);
125 led_writeb(opaque
, addr
+ 3, val
& 0xff);
127 led_writeb(opaque
, addr
, val
& 0xff);
128 led_writeb(opaque
, addr
+ 1, (val
>> 8) & 0xff);
129 led_writeb(opaque
, addr
+ 2, (val
>> 16) & 0xff);
130 led_writeb(opaque
, addr
+ 3, (val
>> 24) & 0xff);
134 static CPUReadMemoryFunc
* const led_read
[3] = {
140 static CPUWriteMemoryFunc
* const led_write
[3] = {
146 /***********************************************************/
147 /* jazz_led display */
149 static void draw_horizontal_line(DisplayState
*ds
, int posy
, int posx1
, int posx2
, uint32_t color
)
154 bpp
= (ds_get_bits_per_pixel(ds
) + 7) >> 3;
155 d
= ds_get_data(ds
) + ds_get_linesize(ds
) * posy
+ bpp
* posx1
;
158 for (x
= posx1
; x
<= posx2
; x
++) {
159 *((uint8_t *)d
) = color
;
164 for (x
= posx1
; x
<= posx2
; x
++) {
165 *((uint16_t *)d
) = color
;
170 for (x
= posx1
; x
<= posx2
; x
++) {
171 *((uint32_t *)d
) = color
;
178 static void draw_vertical_line(DisplayState
*ds
, int posx
, int posy1
, int posy2
, uint32_t color
)
183 bpp
= (ds_get_bits_per_pixel(ds
) + 7) >> 3;
184 d
= ds_get_data(ds
) + ds_get_linesize(ds
) * posy1
+ bpp
* posx
;
187 for (y
= posy1
; y
<= posy2
; y
++) {
188 *((uint8_t *)d
) = color
;
189 d
+= ds_get_linesize(ds
);
193 for (y
= posy1
; y
<= posy2
; y
++) {
194 *((uint16_t *)d
) = color
;
195 d
+= ds_get_linesize(ds
);
199 for (y
= posy1
; y
<= posy2
; y
++) {
200 *((uint32_t *)d
) = color
;
201 d
+= ds_get_linesize(ds
);
207 static void jazz_led_update_display(void *opaque
)
209 LedState
*s
= opaque
;
210 DisplayState
*ds
= s
->ds
;
212 uint32_t color_segment
, color_led
;
215 if (s
->state
& REDRAW_BACKGROUND
) {
217 bpp
= (ds_get_bits_per_pixel(ds
) + 7) >> 3;
218 d1
= ds_get_data(ds
);
219 for (y
= 0; y
< ds_get_height(ds
); y
++) {
220 memset(d1
, 0x00, ds_get_width(ds
) * bpp
);
221 d1
+= ds_get_linesize(ds
);
225 if (s
->state
& REDRAW_SEGMENTS
) {
226 /* set colors according to bpp */
227 switch (ds_get_bits_per_pixel(ds
)) {
229 color_segment
= rgb_to_pixel8(0xaa, 0xaa, 0xaa);
230 color_led
= rgb_to_pixel8(0x00, 0xff, 0x00);
233 color_segment
= rgb_to_pixel15(0xaa, 0xaa, 0xaa);
234 color_led
= rgb_to_pixel15(0x00, 0xff, 0x00);
237 color_segment
= rgb_to_pixel16(0xaa, 0xaa, 0xaa);
238 color_led
= rgb_to_pixel16(0x00, 0xff, 0x00);
240 color_segment
= rgb_to_pixel24(0xaa, 0xaa, 0xaa);
241 color_led
= rgb_to_pixel24(0x00, 0xff, 0x00);
244 color_segment
= rgb_to_pixel32(0xaa, 0xaa, 0xaa);
245 color_led
= rgb_to_pixel32(0x00, 0xff, 0x00);
251 /* display segments */
252 draw_horizontal_line(ds
, 40, 10, 40, (s
->segments
& 0x02) ? color_segment
: 0);
253 draw_vertical_line(ds
, 10, 10, 40, (s
->segments
& 0x04) ? color_segment
: 0);
254 draw_vertical_line(ds
, 10, 40, 70, (s
->segments
& 0x08) ? color_segment
: 0);
255 draw_horizontal_line(ds
, 70, 10, 40, (s
->segments
& 0x10) ? color_segment
: 0);
256 draw_vertical_line(ds
, 40, 40, 70, (s
->segments
& 0x20) ? color_segment
: 0);
257 draw_vertical_line(ds
, 40, 10, 40, (s
->segments
& 0x40) ? color_segment
: 0);
258 draw_horizontal_line(ds
, 10, 10, 40, (s
->segments
& 0x80) ? color_segment
: 0);
261 if (!(s
->segments
& 0x01))
262 color_led
= 0; /* black */
263 draw_horizontal_line(ds
, 68, 50, 50, color_led
);
264 draw_horizontal_line(ds
, 69, 49, 51, color_led
);
265 draw_horizontal_line(ds
, 70, 48, 52, color_led
);
266 draw_horizontal_line(ds
, 71, 49, 51, color_led
);
267 draw_horizontal_line(ds
, 72, 50, 50, color_led
);
270 s
->state
= REDRAW_NONE
;
271 dpy_update(ds
, 0, 0, ds_get_width(ds
), ds_get_height(ds
));
274 static void jazz_led_invalidate_display(void *opaque
)
276 LedState
*s
= opaque
;
277 s
->state
|= REDRAW_SEGMENTS
| REDRAW_BACKGROUND
;
280 static void jazz_led_screen_dump(void *opaque
, const char *filename
)
282 printf("jazz_led_screen_dump() not implemented\n");
285 static void jazz_led_text_update(void *opaque
, console_ch_t
*chardata
)
287 LedState
*s
= opaque
;
290 dpy_cursor(s
->ds
, -1, -1);
291 qemu_console_resize(s
->ds
, 2, 1);
293 /* TODO: draw the segments */
294 snprintf(buf
, 2, "%02hhx\n", s
->segments
);
295 console_write_ch(chardata
++, 0x00200100 | buf
[0]);
296 console_write_ch(chardata
++, 0x00200100 | buf
[1]);
298 dpy_update(s
->ds
, 0, 0, 2, 1);
301 void jazz_led_init(target_phys_addr_t base
)
306 s
= qemu_mallocz(sizeof(LedState
));
308 s
->state
= REDRAW_SEGMENTS
| REDRAW_BACKGROUND
;
310 io
= cpu_register_io_memory(led_read
, led_write
, s
);
311 cpu_register_physical_memory(base
, 1, io
);
313 s
->ds
= graphic_console_init(jazz_led_update_display
,
314 jazz_led_invalidate_display
,
315 jazz_led_screen_dump
,
316 jazz_led_text_update
, s
);
317 qemu_console_resize(s
->ds
, 60, 80);