File:  [Qemu by Fabrice Bellard] / qemu / hw / jazz_led.c
Revision 1.1.1.7 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:46:42 2018 UTC (2 years, 2 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu1101, HEAD
qemu 1.1.1

    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 "console.h"
   26: #include "pixel_ops.h"
   27: #include "trace.h"
   28: #include "sysbus.h"
   29: 
   30: typedef enum {
   31:     REDRAW_NONE = 0, REDRAW_SEGMENTS = 1, REDRAW_BACKGROUND = 2,
   32: } screen_state_t;
   33: 
   34: typedef struct LedState {
   35:     SysBusDevice busdev;
   36:     MemoryRegion iomem;
   37:     uint8_t segments;
   38:     DisplayState *ds;
   39:     screen_state_t state;
   40: } LedState;
   41: 
   42: static uint64_t jazz_led_read(void *opaque, target_phys_addr_t addr,
   43:                               unsigned int size)
   44: {
   45:     LedState *s = opaque;
   46:     uint8_t val;
   47: 
   48:     val = s->segments;
   49:     trace_jazz_led_read(addr, val);
   50: 
   51:     return val;
   52: }
   53: 
   54: static void jazz_led_write(void *opaque, target_phys_addr_t addr,
   55:                            uint64_t val, unsigned int size)
   56: {
   57:     LedState *s = opaque;
   58:     uint8_t new_val = val & 0xff;
   59: 
   60:     trace_jazz_led_write(addr, new_val);
   61: 
   62:     s->segments = new_val;
   63:     s->state |= REDRAW_SEGMENTS;
   64: }
   65: 
   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,
   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: 
   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++;
   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: 
  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);
  118:             }
  119:             break;
  120:         case 2:
  121:             for (y = posy1; y <= posy2; y++) {
  122:                 *((uint16_t *)d) = color;
  123:                 d += ds_get_linesize(ds);
  124:             }
  125:             break;
  126:         case 4:
  127:             for (y = posy1; y <= posy2; y++) {
  128:                 *((uint32_t *)d) = color;
  129:                 d += ds_get_linesize(ds);
  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 */
  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);
  150:         }
  151:     }
  152: 
  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;
  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;
  199:     dpy_update(ds, 0, 0, ds_get_width(ds), ds_get_height(ds));
  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: 
  208: static void jazz_led_text_update(void *opaque, console_ch_t *chardata)
  209: {
  210:     LedState *s = opaque;
  211:     char buf[2];
  212: 
  213:     dpy_cursor(s->ds, -1, -1);
  214:     qemu_console_resize(s->ds, 2, 1);
  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: 
  224: static int jazz_led_post_load(void *opaque, int version_id)
  225: {
  226:     /* force refresh */
  227:     jazz_led_invalidate_display(opaque);
  228: 
  229:     return 0;
  230: }
  231: 
  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);
  247: 
  248:     memory_region_init_io(&s->iomem, &led_ops, s, "led", 1);
  249:     sysbus_init_mmio(dev, &s->iomem);
  250: 
  251:     s->ds = graphic_console_init(jazz_led_update_display,
  252:                                  jazz_led_invalidate_display,
  253:                                  NULL,
  254:                                  jazz_led_text_update, s);
  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;
  265:     qemu_console_resize(s->ds, 60, 80);
  266: }
  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);

unix.superglobalmegacorp.com