hw/ssd0323.c

   1 /*
   2  * SSD0323 OLED controller with OSRAM Pictiva 128x64 display.
   3  *
   4  * Copyright (c) 2006-2007 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the GPL.
   8  */
   9
  10 /* The controller can support a variety of different displays, but we only
  11    implement one.  Most of the commends relating to brightness and geometry
  12    setup are ignored. */
  13 #include "vl.h"
  14
  15 //#define DEBUG_SSD0323 1
  16
  17 #ifdef DEBUG_SSD0323
  18 #define DPRINTF(fmt, args...) \
  19 do { printf("ssd0323: " fmt , ##args); } while (0)
  20 #define BADF(fmt, args...) \
  21 do { fprintf(stderr, "ssd0323: error: " fmt , ##args); exit(1);} while (0)
  22 #else
  23 #define DPRINTF(fmt, args...) do {} while(0)
  24 #define BADF(fmt, args...) \
  25 do { fprintf(stderr, "ssd0323: error: " fmt , ##args);} while (0)
  26 #endif
  27
  28 /* Scaling factor for pixels.  */
  29 #define MAGNIFY 4
  30
  31 enum ssd0323_mode
  32 {
  33     SSD0323_CMD,
  34     SSD0323_DATA
  35 };
  36
  37 typedef struct {
  38     DisplayState *ds;
  39
  40     int cmd_len;
  41     int cmd;
  42     int cmd_data[8];
  43     int row;
  44     int row_start;
  45     int row_end;
  46     int col;
  47     int col_start;
  48     int col_end;
  49     int redraw;
  50     enum ssd0323_mode mode;
  51     uint8_t framebuffer[128 * 80 / 2];
  52 } ssd0323_state;
  53
  54 int ssd0323_xfer_ssi(void *opaque, int data)
  55 {
  56     ssd0323_state *s = (ssd0323_state *)opaque;
  57     switch (s->mode) {
  58     case SSD0323_DATA:
  59         DPRINTF("data 0x%02x\n", data);
  60         s->framebuffer[s->col + s->row * 64] = data;
  61         s->col++;
  62         if (s->col > s->col_end) {
  63             s->row++;
  64             s->col = s->col_start;
  65         }
  66         if (s->row > s->row_end) {
  67             s->row = s->row_start;
  68         }
  69         s->redraw = 1;
  70         break;
  71     case SSD0323_CMD:
  72         DPRINTF("cmd 0x%02x\n", data);
  73         if (s->cmd_len == 0) {
  74             s->cmd = data;
  75         } else {
  76             s->cmd_data[s->cmd_len - 1] = data;
  77         }
  78         s->cmd_len++;
  79         switch (s->cmd) {
  80 #define DATA(x) if (s->cmd_len <= (x)) return 0
  81         case 0x15: /* Set column.  */
  82             DATA(2);
  83             s->col_start = s->cmd_data[0] % 64;
  84             s->col_end = s->cmd_data[1] % 64;
  85             break;
  86         case 0x75: /* Set row.  */
  87             DATA(2);
  88             s->row_start = s->cmd_data[0] % 80;
  89             s->row_end = s->cmd_data[1] % 80;
  90             break;
  91         case 0x81: /* Set contrast */
  92             DATA(1);
  93             break;
  94         case 0x84: case 0x85: case 0x86: /* Max current.  */
  95             DATA(0);
  96             break;
  97         case 0xa0: /* Set remapping.  */
  98             /* FIXME: Implement this.  */
  99             DATA(1);
 100             break;
 101         case 0xa1: /* Set display start line.  */
 102         case 0xa2: /* Set display offset.  */
 103             /* FIXME: Implement these.  */
 104             DATA(1);
 105             break;
 106         case 0xa4: /* Normal mode.  */
 107         case 0xa5: /* All on.  */
 108         case 0xa6: /* All off.  */
 109         case 0xa7: /* Inverse.  */
 110             /* FIXME: Implement these.  */
 111             DATA(0);
 112             break;
 113         case 0xa8: /* Set multiplex ratio.  */
 114         case 0xad: /* Set DC-DC converter.  */
 115             DATA(1);
 116             /* Ignored.  Don't care.  */
 117             break;
 118         case 0xae: /* Display off.  */
 119         case 0xaf: /* Display on.  */
 120             DATA(0);
 121             /* TODO: Implement power control.  */
 122             break;
 123         case 0xb1: /* Set phase length.  */
 124         case 0xb2: /* Set row period.  */
 125         case 0xb3: /* Set clock rate.  */
 126         case 0xbc: /* Set precharge.  */
 127         case 0xbe: /* Set VCOMH.  */
 128         case 0xbf: /* Set segment low.  */
 129             DATA(1);
 130             /* Ignored.  Don't care.  */
 131             break;
 132         case 0xb8: /* Set grey scale table.  */
 133             /* FIXME: Implement this.  */
 134             DATA(8);
 135             break;
 136         case 0xe3: /* NOP.  */
 137             DATA(0);
 138             break;
 139         default:
 140             BADF("Unknown command: 0x%x\n", data);
 141         }
 142         s->cmd_len = 0;
 143         return 0;
 144     }
 145     return 0;
 146 }
 147
 148 static void ssd0323_update_display(void *opaque)
 149 {
 150     ssd0323_state *s = (ssd0323_state *)opaque;
 151     uint8_t *dest;
 152     uint8_t *src;
 153     int x;
 154     int y;
 155     int i;
 156     int line;
 157     char *colors[16];
 158     char colortab[MAGNIFY * 64];
 159     char *p;
 160     int dest_width;
 161
 162     if (s->redraw) {
 163         switch (s->ds->depth) {
 164         case 0:
 165             return;
 166         case 15:
 167             dest_width = 2;
 168             break;
 169         case 16:
 170             dest_width = 2;
 171             break;
 172         case 24:
 173             dest_width = 3;
 174             break;
 175         case 32:
 176             dest_width = 4;
 177             break;
 178         default:
 179             BADF("Bad color depth\n");
 180             return;
 181         }
 182         p = colortab;
 183         for (i = 0; i < 16; i++) {
 184             int n;
 185             colors[i] = p;
 186             switch (s->ds->depth) {
 187             case 15:
 188                 n = i * 2 + (i >> 3);
 189                 p[0] = n | (n << 5);
 190                 p[1] = (n << 2) | (n >> 3);
 191                 break;
 192             case 16:
 193                 n = i * 2 + (i >> 3);
 194                 p[0] = n | (n << 6) | ((n << 1) & 0x20);
 195                 p[1] = (n << 3) | (n >> 2);
 196                 break;
 197             case 24:
 198             case 32:
 199                 n = (i << 4) | i;
 200                 p[0] = p[1] = p[2] = n;
 201                 break;
 202             default:
 203                 BADF("Bad color depth\n");
 204                 return;
 205             }
 206             p += dest_width;
 207         }
 208         dest = s->ds->data;
 209         for (y = 0; y < 64; y++) {
 210             line = y;
 211             src = s->framebuffer + 64 * line;
 212             for (x = 0; x < 64; x++) {
 213                 int val;
 214                 val = *src >> 4;
 215                 for (i = 0; i < MAGNIFY; i++) {
 216                     memcpy(dest, colors[val], dest_width);
 217                     dest += dest_width;
 218                 }
 219                 val = *src & 0xf;
 220                 for (i = 0; i < MAGNIFY; i++) {
 221                     memcpy(dest, colors[val], dest_width);
 222                     dest += dest_width;
 223                 }
 224                 src++;
 225             }
 226             for (i = 1; i < MAGNIFY; i++) {
 227                 memcpy(dest, dest - dest_width * MAGNIFY * 128,
 228                        dest_width * 128 * MAGNIFY);
 229                 dest += dest_width * 128 * MAGNIFY;
 230             }
 231         }
 232     }
 233     dpy_update(s->ds, 0, 0, 128 * MAGNIFY, 64 * MAGNIFY);
 234 }
 235
 236 static void ssd0323_invalidate_display(void * opaque)
 237 {
 238     ssd0323_state *s = (ssd0323_state *)opaque;
 239     s->redraw = 1;
 240 }
 241
 242 /* Command/data input.  */
 243 static void ssd0323_cd(void *opaque, int n, int level)
 244 {
 245     ssd0323_state *s = (ssd0323_state *)opaque;
 246     DPRINTF("%s mode\n", level ? "Data" : "Command");
 247     s->mode = level ? SSD0323_DATA : SSD0323_CMD;
 248 }
 249
 250 void *ssd0323_init(DisplayState *ds, qemu_irq *cmd_p)
 251 {
 252     ssd0323_state *s;
 253     qemu_irq *cmd;
 254
 255     s = (ssd0323_state *)qemu_mallocz(sizeof(ssd0323_state));
 256     s->ds = ds;
 257     graphic_console_init(ds, ssd0323_update_display, ssd0323_invalidate_display,
 258                          NULL, s);
 259     dpy_resize(s->ds, 128 * MAGNIFY, 64 * MAGNIFY);
 260     s->col_end = 63;
 261     s->row_end = 79;
 262
 263     cmd = qemu_allocate_irqs(ssd0323_cd, s, 1);
 264     *cmd_p = *cmd;
 265
 266     return s;
 267 }