]> git.proxmox.com Git - mirror_qemu.git/blame - hw/jazz_led.c
isa: always use provided ISA bus when creating an isa device
[mirror_qemu.git] / hw / jazz_led.c
CommitLineData
31211df1
TS
1/*
2 * QEMU JAZZ LED emulator.
5fafdf24 3 *
bcc4e41f 4 * Copyright (c) 2007 Hervé Poussineau
5fafdf24 5 *
31211df1
TS
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
87ecb68b
PB
25#include "hw.h"
26#include "mips.h"
27#include "console.h"
31211df1
TS
28#include "pixel_ops.h"
29
30//#define DEBUG_LED
31
14414da4
HP
32#ifdef DEBUG_LED
33#define DPRINTF(fmt, ...) \
34do { printf("jazz led: " fmt , ## __VA_ARGS__); } while (0)
35#else
36#define DPRINTF(fmt, ...) do {} while (0)
37#endif
38#define BADF(fmt, ...) \
39do { fprintf(stderr, "jazz led ERROR: " fmt , ## __VA_ARGS__);} while (0)
40
31211df1
TS
41typedef enum {
42 REDRAW_NONE = 0, REDRAW_SEGMENTS = 1, REDRAW_BACKGROUND = 2,
c227f099 43} screen_state_t;
31211df1
TS
44
45typedef struct LedState {
c6017850 46 MemoryRegion iomem;
31211df1
TS
47 uint8_t segments;
48 DisplayState *ds;
c227f099 49 screen_state_t state;
31211df1
TS
50} LedState;
51
c227f099 52static uint32_t led_readb(void *opaque, target_phys_addr_t addr)
31211df1
TS
53{
54 LedState *s = opaque;
31211df1
TS
55 uint32_t val;
56
8da3ff18 57 switch (addr) {
31211df1
TS
58 case 0:
59 val = s->segments;
60 break;
61 default:
14414da4 62 BADF("invalid read at [" TARGET_FMT_plx "]\n", addr);
31211df1
TS
63 val = 0;
64 }
65
14414da4
HP
66 DPRINTF("read addr=" TARGET_FMT_plx " val=0x%02x\n", addr, val);
67
31211df1
TS
68 return val;
69}
70
c227f099 71static uint32_t led_readw(void *opaque, target_phys_addr_t addr)
31211df1
TS
72{
73 uint32_t v;
74#ifdef TARGET_WORDS_BIGENDIAN
75 v = led_readb(opaque, addr) << 8;
76 v |= led_readb(opaque, addr + 1);
77#else
78 v = led_readb(opaque, addr);
79 v |= led_readb(opaque, addr + 1) << 8;
80#endif
81 return v;
82}
83
c227f099 84static uint32_t led_readl(void *opaque, target_phys_addr_t addr)
31211df1
TS
85{
86 uint32_t v;
87#ifdef TARGET_WORDS_BIGENDIAN
88 v = led_readb(opaque, addr) << 24;
89 v |= led_readb(opaque, addr + 1) << 16;
90 v |= led_readb(opaque, addr + 2) << 8;
91 v |= led_readb(opaque, addr + 3);
92#else
93 v = led_readb(opaque, addr);
94 v |= led_readb(opaque, addr + 1) << 8;
95 v |= led_readb(opaque, addr + 2) << 16;
96 v |= led_readb(opaque, addr + 3) << 24;
97#endif
98 return v;
99}
100
c227f099 101static void led_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
31211df1
TS
102{
103 LedState *s = opaque;
31211df1 104
14414da4
HP
105 DPRINTF("write addr=" TARGET_FMT_plx " val=0x%02x\n", addr, val);
106
8da3ff18 107 switch (addr) {
31211df1
TS
108 case 0:
109 s->segments = val;
110 s->state |= REDRAW_SEGMENTS;
111 break;
112 default:
14414da4 113 BADF("invalid write of 0x%08x at [" TARGET_FMT_plx "]\n", val, addr);
31211df1
TS
114 break;
115 }
116}
117
c227f099 118static void led_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
31211df1
TS
119{
120#ifdef TARGET_WORDS_BIGENDIAN
121 led_writeb(opaque, addr, (val >> 8) & 0xff);
122 led_writeb(opaque, addr + 1, val & 0xff);
123#else
124 led_writeb(opaque, addr, val & 0xff);
125 led_writeb(opaque, addr + 1, (val >> 8) & 0xff);
126#endif
127}
128
c227f099 129static void led_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
31211df1
TS
130{
131#ifdef TARGET_WORDS_BIGENDIAN
132 led_writeb(opaque, addr, (val >> 24) & 0xff);
133 led_writeb(opaque, addr + 1, (val >> 16) & 0xff);
134 led_writeb(opaque, addr + 2, (val >> 8) & 0xff);
135 led_writeb(opaque, addr + 3, val & 0xff);
136#else
137 led_writeb(opaque, addr, val & 0xff);
138 led_writeb(opaque, addr + 1, (val >> 8) & 0xff);
139 led_writeb(opaque, addr + 2, (val >> 16) & 0xff);
140 led_writeb(opaque, addr + 3, (val >> 24) & 0xff);
141#endif
142}
143
c6017850
AK
144static const MemoryRegionOps led_ops = {
145 .old_mmio = {
146 .read = { led_readb, led_readw, led_readl, },
147 .write = { led_writeb, led_writew, led_writel, },
148 },
149 .endianness = DEVICE_NATIVE_ENDIAN,
31211df1
TS
150};
151
152/***********************************************************/
153/* jazz_led display */
154
155static void draw_horizontal_line(DisplayState *ds, int posy, int posx1, int posx2, uint32_t color)
156{
157 uint8_t *d;
158 int x, bpp;
159
0e1f5a0c
AL
160 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
161 d = ds_get_data(ds) + ds_get_linesize(ds) * posy + bpp * posx1;
31211df1
TS
162 switch(bpp) {
163 case 1:
164 for (x = posx1; x <= posx2; x++) {
165 *((uint8_t *)d) = color;
166 d++;
167 }
168 break;
169 case 2:
170 for (x = posx1; x <= posx2; x++) {
171 *((uint16_t *)d) = color;
172 d += 2;
173 }
174 break;
175 case 4:
176 for (x = posx1; x <= posx2; x++) {
177 *((uint32_t *)d) = color;
178 d += 4;
179 }
180 break;
181 }
182}
183
184static void draw_vertical_line(DisplayState *ds, int posx, int posy1, int posy2, uint32_t color)
185{
186 uint8_t *d;
187 int y, bpp;
188
0e1f5a0c
AL
189 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
190 d = ds_get_data(ds) + ds_get_linesize(ds) * posy1 + bpp * posx;
31211df1
TS
191 switch(bpp) {
192 case 1:
193 for (y = posy1; y <= posy2; y++) {
194 *((uint8_t *)d) = color;
0e1f5a0c 195 d += ds_get_linesize(ds);
31211df1
TS
196 }
197 break;
198 case 2:
199 for (y = posy1; y <= posy2; y++) {
200 *((uint16_t *)d) = color;
0e1f5a0c 201 d += ds_get_linesize(ds);
31211df1
TS
202 }
203 break;
204 case 4:
205 for (y = posy1; y <= posy2; y++) {
206 *((uint32_t *)d) = color;
0e1f5a0c 207 d += ds_get_linesize(ds);
31211df1
TS
208 }
209 break;
210 }
211}
212
213static void jazz_led_update_display(void *opaque)
214{
215 LedState *s = opaque;
216 DisplayState *ds = s->ds;
217 uint8_t *d1;
218 uint32_t color_segment, color_led;
219 int y, bpp;
220
221 if (s->state & REDRAW_BACKGROUND) {
222 /* clear screen */
0e1f5a0c
AL
223 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
224 d1 = ds_get_data(ds);
225 for (y = 0; y < ds_get_height(ds); y++) {
226 memset(d1, 0x00, ds_get_width(ds) * bpp);
227 d1 += ds_get_linesize(ds);
31211df1
TS
228 }
229 }
230
231 if (s->state & REDRAW_SEGMENTS) {
232 /* set colors according to bpp */
0e1f5a0c 233 switch (ds_get_bits_per_pixel(ds)) {
31211df1
TS
234 case 8:
235 color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);
236 color_led = rgb_to_pixel8(0x00, 0xff, 0x00);
237 break;
238 case 15:
239 color_segment = rgb_to_pixel15(0xaa, 0xaa, 0xaa);
240 color_led = rgb_to_pixel15(0x00, 0xff, 0x00);
241 break;
242 case 16:
243 color_segment = rgb_to_pixel16(0xaa, 0xaa, 0xaa);
244 color_led = rgb_to_pixel16(0x00, 0xff, 0x00);
245 case 24:
246 color_segment = rgb_to_pixel24(0xaa, 0xaa, 0xaa);
247 color_led = rgb_to_pixel24(0x00, 0xff, 0x00);
248 break;
249 case 32:
250 color_segment = rgb_to_pixel32(0xaa, 0xaa, 0xaa);
251 color_led = rgb_to_pixel32(0x00, 0xff, 0x00);
252 break;
253 default:
254 return;
255 }
256
257 /* display segments */
258 draw_horizontal_line(ds, 40, 10, 40, (s->segments & 0x02) ? color_segment : 0);
259 draw_vertical_line(ds, 10, 10, 40, (s->segments & 0x04) ? color_segment : 0);
260 draw_vertical_line(ds, 10, 40, 70, (s->segments & 0x08) ? color_segment : 0);
261 draw_horizontal_line(ds, 70, 10, 40, (s->segments & 0x10) ? color_segment : 0);
262 draw_vertical_line(ds, 40, 40, 70, (s->segments & 0x20) ? color_segment : 0);
263 draw_vertical_line(ds, 40, 10, 40, (s->segments & 0x40) ? color_segment : 0);
264 draw_horizontal_line(ds, 10, 10, 40, (s->segments & 0x80) ? color_segment : 0);
265
266 /* display led */
267 if (!(s->segments & 0x01))
268 color_led = 0; /* black */
269 draw_horizontal_line(ds, 68, 50, 50, color_led);
270 draw_horizontal_line(ds, 69, 49, 51, color_led);
271 draw_horizontal_line(ds, 70, 48, 52, color_led);
272 draw_horizontal_line(ds, 71, 49, 51, color_led);
273 draw_horizontal_line(ds, 72, 50, 50, color_led);
274 }
275
276 s->state = REDRAW_NONE;
0e1f5a0c 277 dpy_update(ds, 0, 0, ds_get_width(ds), ds_get_height(ds));
31211df1
TS
278}
279
280static void jazz_led_invalidate_display(void *opaque)
281{
282 LedState *s = opaque;
283 s->state |= REDRAW_SEGMENTS | REDRAW_BACKGROUND;
284}
285
286static void jazz_led_screen_dump(void *opaque, const char *filename)
287{
288 printf("jazz_led_screen_dump() not implemented\n");
289}
290
c227f099 291static void jazz_led_text_update(void *opaque, console_ch_t *chardata)
4d3b6f6e
AZ
292{
293 LedState *s = opaque;
294 char buf[2];
295
296 dpy_cursor(s->ds, -1, -1);
3023f332 297 qemu_console_resize(s->ds, 2, 1);
4d3b6f6e
AZ
298
299 /* TODO: draw the segments */
300 snprintf(buf, 2, "%02hhx\n", s->segments);
301 console_write_ch(chardata++, 0x00200100 | buf[0]);
302 console_write_ch(chardata++, 0x00200100 | buf[1]);
303
304 dpy_update(s->ds, 0, 0, 2, 1);
305}
306
c6017850 307void jazz_led_init(MemoryRegion *address_space, target_phys_addr_t base)
31211df1
TS
308{
309 LedState *s;
31211df1 310
7267c094 311 s = g_malloc0(sizeof(LedState));
31211df1 312
31211df1
TS
313 s->state = REDRAW_SEGMENTS | REDRAW_BACKGROUND;
314
c6017850
AK
315 memory_region_init_io(&s->iomem, &led_ops, s, "led", 1);
316 memory_region_add_subregion(address_space, base, &s->iomem);
31211df1 317
3023f332
AL
318 s->ds = graphic_console_init(jazz_led_update_display,
319 jazz_led_invalidate_display,
320 jazz_led_screen_dump,
321 jazz_led_text_update, s);
322 qemu_console_resize(s->ds, 60, 80);
31211df1 323}