vcs.maemo.org Git - qemu/blob - hw/pl011.c

   1 /*
   2  * Arm PrimeCell PL011 UART
   3  *
   4  * Copyright (c) 2006 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the GPL.
   8  */
   9
  10 #include "vl.h"
  11
  12 typedef struct {
  13     uint32_t base;
  14     uint32_t readbuff;
  15     uint32_t flags;
  16     uint32_t lcr;
  17     uint32_t cr;
  18     uint32_t dmacr;
  19     uint32_t int_enabled;
  20     uint32_t int_level;
  21     uint32_t read_fifo[16];
  22     uint32_t ilpr;
  23     uint32_t ibrd;
  24     uint32_t fbrd;
  25     uint32_t ifl;
  26     int read_pos;
  27     int read_count;
  28     int read_trigger;
  29     CharDriverState *chr;
  30     void *pic;
  31     int irq;
  32 } pl011_state;
  33
  34 #define PL011_INT_TX 0x20
  35 #define PL011_INT_RX 0x10
  36
  37 #define PL011_FLAG_TXFE 0x80
  38 #define PL011_FLAG_RXFF 0x40
  39 #define PL011_FLAG_TXFF 0x20
  40 #define PL011_FLAG_RXFE 0x10
  41
  42 static const unsigned char pl011_id[] =
  43 { 0x11, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1 };
  44
  45 static void pl011_update(pl011_state *s)
  46 {
  47     uint32_t flags;
  48
  49     flags = s->int_level & s->int_enabled;
  50     pic_set_irq_new(s->pic, s->irq, flags != 0);
  51 }
  52
  53 static uint32_t pl011_read(void *opaque, target_phys_addr_t offset)
  54 {
  55     pl011_state *s = (pl011_state *)opaque;
  56     uint32_t c;
  57
  58     offset -= s->base;
  59     if (offset >= 0xfe0 && offset < 0x1000) {
  60         return pl011_id[(offset - 0xfe0) >> 2];
  61     }
  62     switch (offset >> 2) {
  63     case 0: /* UARTDR */
  64         s->flags &= ~PL011_FLAG_RXFF;
  65         c = s->read_fifo[s->read_pos];
  66         if (s->read_count > 0) {
  67             s->read_count--;
  68             if (++s->read_pos == 16)
  69                 s->read_pos = 0;
  70         }
  71         if (s->read_count == 0) {
  72             s->flags |= PL011_FLAG_RXFE;
  73         }
  74         if (s->read_count == s->read_trigger - 1)
  75             s->int_level &= ~ PL011_INT_RX;
  76         pl011_update(s);
  77         return c;
  78     case 1: /* UARTCR */
  79         return 0;
  80     case 6: /* UARTFR */
  81         return s->flags;
  82     case 8: /* UARTILPR */
  83         return s->ilpr;
  84     case 9: /* UARTIBRD */
  85         return s->ibrd;
  86     case 10: /* UARTFBRD */
  87         return s->fbrd;
  88     case 11: /* UARTLCR_H */
  89         return s->lcr;
  90     case 12: /* UARTCR */
  91         return s->cr;
  92     case 13: /* UARTIFLS */
  93         return s->ifl;
  94     case 14: /* UARTIMSC */
  95         return s->int_enabled;
  96     case 15: /* UARTRIS */
  97         return s->int_level;
  98     case 16: /* UARTMIS */
  99         return s->int_level & s->int_enabled;
 100     case 18: /* UARTDMACR */
 101         return s->dmacr;
 102     default:
 103         cpu_abort (cpu_single_env, "pl011_read: Bad offset %x\n", offset);
 104         return 0;
 105     }
 106 }
 107
 108 static void pl011_set_read_trigger(pl011_state *s)
 109 {
 110 #if 0
 111     /* The docs say the RX interrupt is triggered when the FIFO exceeds
 112        the threshold.  However linux only reads the FIFO in response to an
 113        interrupt.  Triggering the interrupt when the FIFO is non-empty seems
 114        to make things work.  */
 115     if (s->lcr & 0x10)
 116         s->read_trigger = (s->ifl >> 1) & 0x1c;
 117     else
 118 #endif
 119         s->read_trigger = 1;
 120 }
 121
 122 static void pl011_write(void *opaque, target_phys_addr_t offset,
 123                           uint32_t value)
 124 {
 125     pl011_state *s = (pl011_state *)opaque;
 126     unsigned char ch;
 127
 128     offset -= s->base;
 129     switch (offset >> 2) {
 130     case 0: /* UARTDR */
 131         /* ??? Check if transmitter is enabled.  */
 132         ch = value;
 133         if (s->chr)
 134             qemu_chr_write(s->chr, &ch, 1);
 135         s->int_level |= PL011_INT_TX;
 136         pl011_update(s);
 137         break;
 138     case 1: /* UARTCR */
 139         s->cr = value;
 140         break;
 141     case 8: /* UARTUARTILPR */
 142         s->ilpr = value;
 143         break;
 144     case 9: /* UARTIBRD */
 145         s->ibrd = value;
 146         break;
 147     case 10: /* UARTFBRD */
 148         s->fbrd = value;
 149         break;
 150     case 11: /* UARTLCR_H */
 151         s->lcr = value;
 152         pl011_set_read_trigger(s);
 153         break;
 154     case 12: /* UARTCR */
 155         /* ??? Need to implement the enable and loopback bits.  */
 156         s->cr = value;
 157         break;
 158     case 13: /* UARTIFS */
 159         s->ifl = value;
 160         pl011_set_read_trigger(s);
 161         break;
 162     case 14: /* UARTIMSC */
 163         s->int_enabled = value;
 164         pl011_update(s);
 165         break;
 166     case 17: /* UARTICR */
 167         s->int_level &= ~value;
 168         pl011_update(s);
 169         break;
 170     case 18: /* UARTDMACR */
 171         s->dmacr = value;
 172         if (value & 3)
 173             cpu_abort(cpu_single_env, "PL011: DMA not implemented\n");
 174         break;
 175     default:
 176         cpu_abort (cpu_single_env, "pl011_write: Bad offset %x\n", offset);
 177     }
 178 }
 179
 180 static int pl011_can_recieve(void *opaque)
 181 {
 182     pl011_state *s = (pl011_state *)opaque;
 183
 184     if (s->lcr & 0x10)
 185         return s->read_count < 16;
 186     else
 187         return s->read_count < 1;
 188 }
 189
 190 static void pl011_recieve(void *opaque, const uint8_t *buf, int size)
 191 {
 192     pl011_state *s = (pl011_state *)opaque;
 193     int slot;
 194
 195     slot = s->read_pos + s->read_count;
 196     if (slot >= 16)
 197         slot -= 16;
 198     s->read_fifo[slot] = *buf;
 199     s->read_count++;
 200     s->flags &= ~PL011_FLAG_RXFE;
 201     if (s->cr & 0x10 || s->read_count == 16) {
 202         s->flags |= PL011_FLAG_RXFF;
 203     }
 204     if (s->read_count == s->read_trigger) {
 205         s->int_level |= PL011_INT_RX;
 206         pl011_update(s);
 207     }
 208 }
 209
 210 static void pl011_event(void *opaque, int event)
 211 {
 212     /* ??? Should probably implement break.  */
 213 }
 214
 215 static CPUReadMemoryFunc *pl011_readfn[] = {
 216    pl011_read,
 217    pl011_read,
 218    pl011_read
 219 };
 220
 221 static CPUWriteMemoryFunc *pl011_writefn[] = {
 222    pl011_write,
 223    pl011_write,
 224    pl011_write
 225 };
 226
 227 void pl011_init(uint32_t base, void *pic, int irq,
 228                 CharDriverState *chr)
 229 {
 230     int iomemtype;
 231     pl011_state *s;
 232
 233     s = (pl011_state *)qemu_mallocz(sizeof(pl011_state));
 234     iomemtype = cpu_register_io_memory(0, pl011_readfn,
 235                                        pl011_writefn, s);
 236     cpu_register_physical_memory(base, 0x00000fff, iomemtype);
 237     s->base = base;
 238     s->pic = pic;
 239     s->irq = irq;
 240     s->chr = chr;
 241     s->read_trigger = 1;
 242     s->ifl = 0x12;
 243     s->cr = 0x300;
 244     s->flags = 0x90;
 245     if (chr){
 246         qemu_chr_add_read_handler(chr, pl011_can_recieve, pl011_recieve, s);
 247         qemu_chr_add_event_handler(chr, pl011_event);
 248     }
 249     /* ??? Save/restore.  */
 250 }
 251