[qemu.git] / hw / jazz_led.c

/*
 * QEMU JAZZ LED emulator.
 *
 * Copyright (c) 2007-2012 Herve Poussineau
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "console.h"
#include "pixel_ops.h"
#include "trace.h"
#include "sysbus.h"

typedef enum {
    REDRAW_NONE = 0, REDRAW_SEGMENTS = 1, REDRAW_BACKGROUND = 2,
} screen_state_t;

typedef struct LedState {
    SysBusDevice busdev;
    MemoryRegion iomem;
    uint8_t segments;
    DisplayState *ds;
    screen_state_t state;
} LedState;

static uint64_t jazz_led_read(void *opaque, target_phys_addr_t addr,
                              unsigned int size)
{
    LedState *s = opaque;
    uint8_t val;

    val = s->segments;
    trace_jazz_led_read(addr, val);

    return val;
}

static void jazz_led_write(void *opaque, target_phys_addr_t addr,
                           uint64_t val, unsigned int size)
{
    LedState *s = opaque;
    uint8_t new_val = val & 0xff;

    trace_jazz_led_write(addr, new_val);

    s->segments = new_val;
    s->state |= REDRAW_SEGMENTS;
}

static const MemoryRegionOps led_ops = {
    .read = jazz_led_read,
    .write = jazz_led_write,
    .endianness = DEVICE_NATIVE_ENDIAN,
    .impl.min_access_size = 1,
    .impl.max_access_size = 1,
};

/***********************************************************/
/* jazz_led display */

static void draw_horizontal_line(DisplayState *ds, int posy, int posx1, int posx2, uint32_t color)
{
    uint8_t *d;
    int x, bpp;

    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
    d = ds_get_data(ds) + ds_get_linesize(ds) * posy + bpp * posx1;
    switch(bpp) {
        case 1:
            for (x = posx1; x <= posx2; x++) {
                *((uint8_t *)d) = color;
                d++;
            }
            break;
        case 2:
            for (x = posx1; x <= posx2; x++) {
                *((uint16_t *)d) = color;
                d += 2;
            }
            break;
        case 4:
            for (x = posx1; x <= posx2; x++) {
                *((uint32_t *)d) = color;
                d += 4;
            }
            break;
    }
}

static void draw_vertical_line(DisplayState *ds, int posx, int posy1, int posy2, uint32_t color)
{
    uint8_t *d;
    int y, bpp;

    bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
    d = ds_get_data(ds) + ds_get_linesize(ds) * posy1 + bpp * posx;
    switch(bpp) {
        case 1:
            for (y = posy1; y <= posy2; y++) {
                *((uint8_t *)d) = color;
                d += ds_get_linesize(ds);
            }
            break;
        case 2:
            for (y = posy1; y <= posy2; y++) {
                *((uint16_t *)d) = color;
                d += ds_get_linesize(ds);
            }
            break;
        case 4:
            for (y = posy1; y <= posy2; y++) {
                *((uint32_t *)d) = color;
                d += ds_get_linesize(ds);
            }
            break;
    }
}

static void jazz_led_update_display(void *opaque)
{
    LedState *s = opaque;
    DisplayState *ds = s->ds;
    uint8_t *d1;
    uint32_t color_segment, color_led;
    int y, bpp;

    if (s->state & REDRAW_BACKGROUND) {
        /* clear screen */
        bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
        d1 = ds_get_data(ds);
        for (y = 0; y < ds_get_height(ds); y++) {
            memset(d1, 0x00, ds_get_width(ds) * bpp);
            d1 += ds_get_linesize(ds);
        }
    }

    if (s->state & REDRAW_SEGMENTS) {
        /* set colors according to bpp */
        switch (ds_get_bits_per_pixel(ds)) {
            case 8:
                color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);
                color_led = rgb_to_pixel8(0x00, 0xff, 0x00);
                break;
            case 15:
                color_segment = rgb_to_pixel15(0xaa, 0xaa, 0xaa);
                color_led = rgb_to_pixel15(0x00, 0xff, 0x00);
                break;
            case 16:
                color_segment = rgb_to_pixel16(0xaa, 0xaa, 0xaa);
                color_led = rgb_to_pixel16(0x00, 0xff, 0x00);
            case 24:
                color_segment = rgb_to_pixel24(0xaa, 0xaa, 0xaa);
                color_led = rgb_to_pixel24(0x00, 0xff, 0x00);
                break;
            case 32:
                color_segment = rgb_to_pixel32(0xaa, 0xaa, 0xaa);
                color_led = rgb_to_pixel32(0x00, 0xff, 0x00);
                break;
            default:
                return;
        }

        /* display segments */
        draw_horizontal_line(ds, 40, 10, 40, (s->segments & 0x02) ? color_segment : 0);
        draw_vertical_line(ds, 10, 10, 40, (s->segments & 0x04) ? color_segment : 0);
        draw_vertical_line(ds, 10, 40, 70, (s->segments & 0x08) ? color_segment : 0);
        draw_horizontal_line(ds, 70, 10, 40, (s->segments & 0x10) ? color_segment : 0);
        draw_vertical_line(ds, 40, 40, 70, (s->segments & 0x20) ? color_segment : 0);
        draw_vertical_line(ds, 40, 10, 40, (s->segments & 0x40) ? color_segment : 0);
        draw_horizontal_line(ds, 10, 10, 40, (s->segments & 0x80) ? color_segment : 0);

        /* display led */
        if (!(s->segments & 0x01))
            color_led = 0; /* black */
        draw_horizontal_line(ds, 68, 50, 50, color_led);
        draw_horizontal_line(ds, 69, 49, 51, color_led);
        draw_horizontal_line(ds, 70, 48, 52, color_led);
        draw_horizontal_line(ds, 71, 49, 51, color_led);
        draw_horizontal_line(ds, 72, 50, 50, color_led);
    }

    s->state = REDRAW_NONE;
    dpy_update(ds, 0, 0, ds_get_width(ds), ds_get_height(ds));
}

static void jazz_led_invalidate_display(void *opaque)
{
    LedState *s = opaque;
    s->state |= REDRAW_SEGMENTS | REDRAW_BACKGROUND;
}

static void jazz_led_text_update(void *opaque, console_ch_t *chardata)
{
    LedState *s = opaque;
    char buf[2];

    dpy_cursor(s->ds, -1, -1);
    qemu_console_resize(s->ds, 2, 1);

    /* TODO: draw the segments */
    snprintf(buf, 2, "%02hhx\n", s->segments);
    console_write_ch(chardata++, 0x00200100 | buf[0]);
    console_write_ch(chardata++, 0x00200100 | buf[1]);

    dpy_update(s->ds, 0, 0, 2, 1);
}

static int jazz_led_post_load(void *opaque, int version_id)
{
    /* force refresh */
    jazz_led_invalidate_display(opaque);

    return 0;
}

static const VMStateDescription vmstate_jazz_led = {
    .name = "jazz-led",
    .version_id = 0,
    .minimum_version_id = 0,
    .minimum_version_id_old = 0,
    .post_load = jazz_led_post_load,
    .fields = (VMStateField[]) {
        VMSTATE_UINT8(segments, LedState),
        VMSTATE_END_OF_LIST()
    }
};

static int jazz_led_init(SysBusDevice *dev)
{
    LedState *s = FROM_SYSBUS(LedState, dev);

    memory_region_init_io(&s->iomem, &led_ops, s, "led", 1);
    sysbus_init_mmio(dev, &s->iomem);

    s->ds = graphic_console_init(jazz_led_update_display,
                                 jazz_led_invalidate_display,
                                 NULL,
                                 jazz_led_text_update, s);

    return 0;
}

static void jazz_led_reset(DeviceState *d)
{
    LedState *s = DO_UPCAST(LedState, busdev.qdev, d);

    s->segments = 0;
    s->state = REDRAW_SEGMENTS | REDRAW_BACKGROUND;
    qemu_console_resize(s->ds, 60, 80);
}

static void jazz_led_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);

    k->init = jazz_led_init;
    dc->desc = "Jazz LED display",
    dc->vmsd = &vmstate_jazz_led;
    dc->reset = jazz_led_reset;
}

static TypeInfo jazz_led_info = {
    .name          = "jazz-led",
    .parent        = TYPE_SYS_BUS_DEVICE,
    .instance_size = sizeof(LedState),
    .class_init    = jazz_led_class_init,
};

static void jazz_led_register(void)
{
    type_register_static(&jazz_led_info);
}

type_init(jazz_led_register);
Commit	Line	Data
31211df1 TS	1	/*
31211df1 TS	2	* QEMU JAZZ LED emulator.
5fafdf24	3	*
b39506e4	4	* Copyright (c) 2007-2012 Herve 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	25	#include "console.h"
31211df1	26	#include "pixel_ops.h"
63b9932d	27	#include "trace.h"
b39506e4	28	#include "sysbus.h"
14414da4	29
31211df1 TS	30	typedef enum {
31211df1 TS	31	REDRAW_NONE = 0, REDRAW_SEGMENTS = 1, REDRAW_BACKGROUND = 2,
c227f099	32	} screen_state_t;
31211df1 TS	33
31211df1 TS	34	typedef struct LedState {
b39506e4	35	SysBusDevice busdev;
c6017850	36	MemoryRegion iomem;
31211df1 TS	37	uint8_t segments;
31211df1 TS	38	DisplayState *ds;
c227f099	39	screen_state_t state;
31211df1 TS	40	} LedState;
31211df1 TS	41
b39506e4 HP	42	static uint64_t jazz_led_read(void *opaque, target_phys_addr_t addr,
b39506e4 HP	43	unsigned int size)
31211df1 TS	44	{
31211df1 TS	45	LedState *s = opaque;
63b9932d	46	uint8_t val;
31211df1	47
b39506e4	48	val = s->segments;
63b9932d	49	trace_jazz_led_read(addr, val);
14414da4	50
31211df1 TS	51	return val;
	52	}
	53
b39506e4 HP	54	static void jazz_led_write(void *opaque, target_phys_addr_t addr,
b39506e4 HP	55	uint64_t val, unsigned int size)
31211df1 TS	56	{
31211df1 TS	57	LedState *s = opaque;
63b9932d	58	uint8_t new_val = val & 0xff;
31211df1	59
63b9932d	60	trace_jazz_led_write(addr, new_val);
14414da4	61
b39506e4 HP	62	s->segments = new_val;
b39506e4 HP	63	s->state \|= REDRAW_SEGMENTS;
31211df1 TS	64	}
31211df1 TS	65
c6017850	66	static const MemoryRegionOps led_ops = {
b39506e4 HP	67	.read = jazz_led_read,
b39506e4 HP	68	.write = jazz_led_write,
c6017850	69	.endianness = DEVICE_NATIVE_ENDIAN,
b39506e4 HP	70	.impl.min_access_size = 1,
b39506e4 HP	71	.impl.max_access_size = 1,
31211df1 TS	72	};
	73
	74	/***********************************************************/
	75	/* jazz_led display */
	76
	77	static void draw_horizontal_line(DisplayState *ds, int posy, int posx1, int posx2, uint32_t color)
	78	{
	79	uint8_t *d;
	80	int x, bpp;
	81
0e1f5a0c AL	82	bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
0e1f5a0c AL	83	d = ds_get_data(ds) + ds_get_linesize(ds) * posy + bpp * posx1;
31211df1 TS	84	switch(bpp) {
	85	case 1:
	86	for (x = posx1; x <= posx2; x++) {
	87	((uint8_t )d) = color;
	88	d++;
	89	}
	90	break;
	91	case 2:
	92	for (x = posx1; x <= posx2; x++) {
	93	((uint16_t )d) = color;
	94	d += 2;
	95	}
	96	break;
	97	case 4:
	98	for (x = posx1; x <= posx2; x++) {
	99	((uint32_t )d) = color;
	100	d += 4;
	101	}
	102	break;
	103	}
	104	}
	105
	106	static void draw_vertical_line(DisplayState *ds, int posx, int posy1, int posy2, uint32_t color)
	107	{
	108	uint8_t *d;
	109	int y, bpp;
	110
0e1f5a0c AL	111	bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
0e1f5a0c AL	112	d = ds_get_data(ds) + ds_get_linesize(ds) * posy1 + bpp * posx;
31211df1 TS	113	switch(bpp) {
	114	case 1:
	115	for (y = posy1; y <= posy2; y++) {
	116	((uint8_t )d) = color;
0e1f5a0c	117	d += ds_get_linesize(ds);
31211df1 TS	118	}
	119	break;
	120	case 2:
	121	for (y = posy1; y <= posy2; y++) {
	122	((uint16_t )d) = color;
0e1f5a0c	123	d += ds_get_linesize(ds);
31211df1 TS	124	}
	125	break;
	126	case 4:
	127	for (y = posy1; y <= posy2; y++) {
	128	((uint32_t )d) = color;
0e1f5a0c	129	d += ds_get_linesize(ds);
31211df1 TS	130	}
	131	break;
	132	}
	133	}
	134
	135	static void jazz_led_update_display(void *opaque)
	136	{
	137	LedState *s = opaque;
	138	DisplayState *ds = s->ds;
	139	uint8_t *d1;
	140	uint32_t color_segment, color_led;
	141	int y, bpp;
	142
	143	if (s->state & REDRAW_BACKGROUND) {
	144	/* clear screen */
0e1f5a0c AL	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);
31211df1 TS	150	}
	151	}
	152
	153	if (s->state & REDRAW_SEGMENTS) {
	154	/* set colors according to bpp */
0e1f5a0c	155	switch (ds_get_bits_per_pixel(ds)) {
31211df1 TS	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;
	177	}
	178
	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);
	187
	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);
	196	}
	197
	198	s->state = REDRAW_NONE;
0e1f5a0c	199	dpy_update(ds, 0, 0, ds_get_width(ds), ds_get_height(ds));
31211df1 TS	200	}
	201
	202	static void jazz_led_invalidate_display(void *opaque)
	203	{
	204	LedState *s = opaque;
	205	s->state \|= REDRAW_SEGMENTS \| REDRAW_BACKGROUND;
	206	}
	207
c227f099	208	static void jazz_led_text_update(void opaque, console_ch_t chardata)
4d3b6f6e AZ	209	{
	210	LedState *s = opaque;
	211	char buf[2];
	212
	213	dpy_cursor(s->ds, -1, -1);
3023f332	214	qemu_console_resize(s->ds, 2, 1);
4d3b6f6e AZ	215
	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]);
	220
	221	dpy_update(s->ds, 0, 0, 2, 1);
	222	}
	223
b39506e4	224	static int jazz_led_post_load(void *opaque, int version_id)
31211df1	225	{
b39506e4 HP	226	/* force refresh */
b39506e4 HP	227	jazz_led_invalidate_display(opaque);
31211df1	228
b39506e4 HP	229	return 0;
b39506e4 HP	230	}
31211df1	231
b39506e4 HP	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()
	241	}
	242	};
	243
	244	static int jazz_led_init(SysBusDevice *dev)
	245	{
	246	LedState *s = FROM_SYSBUS(LedState, dev);
31211df1	247
c6017850	248	memory_region_init_io(&s->iomem, &led_ops, s, "led", 1);
b39506e4	249	sysbus_init_mmio(dev, &s->iomem);
31211df1	250
3023f332 AL	251	s->ds = graphic_console_init(jazz_led_update_display,
3023f332 AL	252	jazz_led_invalidate_display,
16735102	253	NULL,
3023f332	254	jazz_led_text_update, s);
b39506e4 HP	255
	256	return 0;
	257	}
	258
	259	static void jazz_led_reset(DeviceState *d)
	260	{
	261	LedState *s = DO_UPCAST(LedState, busdev.qdev, d);
	262
	263	s->segments = 0;
	264	s->state = REDRAW_SEGMENTS \| REDRAW_BACKGROUND;
3023f332	265	qemu_console_resize(s->ds, 60, 80);
31211df1	266	}
b39506e4 HP	267
	268	static void jazz_led_class_init(ObjectClass klass, void data)
	269	{
	270	DeviceClass *dc = DEVICE_CLASS(klass);
	271	SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
	272
	273	k->init = jazz_led_init;
	274	dc->desc = "Jazz LED display",
	275	dc->vmsd = &vmstate_jazz_led;
	276	dc->reset = jazz_led_reset;
	277	}
	278
	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,
	284	};
	285
	286	static void jazz_led_register(void)
	287	{
	288	type_register_static(&jazz_led_info);
	289	}
	290
	291	type_init(jazz_led_register);