hw/serial.c

   1 /*
   2  * QEMU 16550A UART emulation
   3  *
   4  * Copyright (c) 2003-2004 Fabrice Bellard
   5  * Copyright (c) 2008 Citrix Systems, Inc.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include "serial.h"
  27 #include "qemu-char.h"
  28 #include "qemu-timer.h"
  29
  30 //#define DEBUG_SERIAL
  31
  32 #define UART_LCR_DLAB   0x80    /* Divisor latch access bit */
  33
  34 #define UART_IER_MSI    0x08    /* Enable Modem status interrupt */
  35 #define UART_IER_RLSI   0x04    /* Enable receiver line status interrupt */
  36 #define UART_IER_THRI   0x02    /* Enable Transmitter holding register int. */
  37 #define UART_IER_RDI    0x01    /* Enable receiver data interrupt */
  38
  39 #define UART_IIR_NO_INT 0x01    /* No interrupts pending */
  40 #define UART_IIR_ID     0x06    /* Mask for the interrupt ID */
  41
  42 #define UART_IIR_MSI    0x00    /* Modem status interrupt */
  43 #define UART_IIR_THRI   0x02    /* Transmitter holding register empty */
  44 #define UART_IIR_RDI    0x04    /* Receiver data interrupt */
  45 #define UART_IIR_RLSI   0x06    /* Receiver line status interrupt */
  46 #define UART_IIR_CTI    0x0C    /* Character Timeout Indication */
  47
  48 #define UART_IIR_FENF   0x80    /* Fifo enabled, but not functionning */
  49 #define UART_IIR_FE     0xC0    /* Fifo enabled */
  50
  51 /*
  52  * These are the definitions for the Modem Control Register
  53  */
  54 #define UART_MCR_LOOP   0x10    /* Enable loopback test mode */
  55 #define UART_MCR_OUT2   0x08    /* Out2 complement */
  56 #define UART_MCR_OUT1   0x04    /* Out1 complement */
  57 #define UART_MCR_RTS    0x02    /* RTS complement */
  58 #define UART_MCR_DTR    0x01    /* DTR complement */
  59
  60 /*
  61  * These are the definitions for the Modem Status Register
  62  */
  63 #define UART_MSR_DCD    0x80    /* Data Carrier Detect */
  64 #define UART_MSR_RI     0x40    /* Ring Indicator */
  65 #define UART_MSR_DSR    0x20    /* Data Set Ready */
  66 #define UART_MSR_CTS    0x10    /* Clear to Send */
  67 #define UART_MSR_DDCD   0x08    /* Delta DCD */
  68 #define UART_MSR_TERI   0x04    /* Trailing edge ring indicator */
  69 #define UART_MSR_DDSR   0x02    /* Delta DSR */
  70 #define UART_MSR_DCTS   0x01    /* Delta CTS */
  71 #define UART_MSR_ANY_DELTA 0x0F /* Any of the delta bits! */
  72
  73 #define UART_LSR_TEMT   0x40    /* Transmitter empty */
  74 #define UART_LSR_THRE   0x20    /* Transmit-hold-register empty */
  75 #define UART_LSR_BI     0x10    /* Break interrupt indicator */
  76 #define UART_LSR_FE     0x08    /* Frame error indicator */
  77 #define UART_LSR_PE     0x04    /* Parity error indicator */
  78 #define UART_LSR_OE     0x02    /* Overrun error indicator */
  79 #define UART_LSR_DR     0x01    /* Receiver data ready */
  80 #define UART_LSR_INT_ANY 0x1E   /* Any of the lsr-interrupt-triggering status bits */
  81
  82 /* Interrupt trigger levels. The byte-counts are for 16550A - in newer UARTs the byte-count for each ITL is higher. */
  83
  84 #define UART_FCR_ITL_1      0x00 /* 1 byte ITL */
  85 #define UART_FCR_ITL_2      0x40 /* 4 bytes ITL */
  86 #define UART_FCR_ITL_3      0x80 /* 8 bytes ITL */
  87 #define UART_FCR_ITL_4      0xC0 /* 14 bytes ITL */
  88
  89 #define UART_FCR_DMS        0x08    /* DMA Mode Select */
  90 #define UART_FCR_XFR        0x04    /* XMIT Fifo Reset */
  91 #define UART_FCR_RFR        0x02    /* RCVR Fifo Reset */
  92 #define UART_FCR_FE         0x01    /* FIFO Enable */
  93
  94 #define XMIT_FIFO           0
  95 #define RECV_FIFO           1
  96 #define MAX_XMIT_RETRY      4
  97
  98 #ifdef DEBUG_SERIAL
  99 #define DPRINTF(fmt, ...) \
 100 do { fprintf(stderr, "serial: " fmt , ## __VA_ARGS__); } while (0)
 101 #else
 102 #define DPRINTF(fmt, ...) \
 103 do {} while (0)
 104 #endif
 105
 106 static void serial_receive1(void *opaque, const uint8_t *buf, int size);
 107
 108 static void fifo_clear(SerialState *s, int fifo)
 109 {
 110     SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo;
 111     memset(f->data, 0, UART_FIFO_LENGTH);
 112     f->count = 0;
 113     f->head = 0;
 114     f->tail = 0;
 115 }
 116
 117 static int fifo_put(SerialState *s, int fifo, uint8_t chr)
 118 {
 119     SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo;
 120
 121     /* Receive overruns do not overwrite FIFO contents. */
 122     if (fifo == XMIT_FIFO || f->count < UART_FIFO_LENGTH) {
 123
 124         f->data[f->head++] = chr;
 125
 126         if (f->head == UART_FIFO_LENGTH)
 127             f->head = 0;
 128     }
 129
 130     if (f->count < UART_FIFO_LENGTH)
 131         f->count++;
 132     else if (fifo == RECV_FIFO)
 133         s->lsr |= UART_LSR_OE;
 134
 135     return 1;
 136 }
 137
 138 static uint8_t fifo_get(SerialState *s, int fifo)
 139 {
 140     SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo;
 141     uint8_t c;
 142
 143     if(f->count == 0)
 144         return 0;
 145
 146     c = f->data[f->tail++];
 147     if (f->tail == UART_FIFO_LENGTH)
 148         f->tail = 0;
 149     f->count--;
 150
 151     return c;
 152 }
 153
 154 static void serial_update_irq(SerialState *s)
 155 {
 156     uint8_t tmp_iir = UART_IIR_NO_INT;
 157
 158     if ((s->ier & UART_IER_RLSI) && (s->lsr & UART_LSR_INT_ANY)) {
 159         tmp_iir = UART_IIR_RLSI;
 160     } else if ((s->ier & UART_IER_RDI) && s->timeout_ipending) {
 161         /* Note that(s->ier & UART_IER_RDI) can mask this interrupt,
 162          * this is not in the specification but is observed on existing
 163          * hardware.  */
 164         tmp_iir = UART_IIR_CTI;
 165     } else if ((s->ier & UART_IER_RDI) && (s->lsr & UART_LSR_DR) &&
 166                (!(s->fcr & UART_FCR_FE) ||
 167                 s->recv_fifo.count >= s->recv_fifo.itl)) {
 168         tmp_iir = UART_IIR_RDI;
 169     } else if ((s->ier & UART_IER_THRI) && s->thr_ipending) {
 170         tmp_iir = UART_IIR_THRI;
 171     } else if ((s->ier & UART_IER_MSI) && (s->msr & UART_MSR_ANY_DELTA)) {
 172         tmp_iir = UART_IIR_MSI;
 173     }
 174
 175     s->iir = tmp_iir | (s->iir & 0xF0);
 176
 177     if (tmp_iir != UART_IIR_NO_INT) {
 178         qemu_irq_raise(s->irq);
 179     } else {
 180         qemu_irq_lower(s->irq);
 181     }
 182 }
 183
 184 static void serial_update_parameters(SerialState *s)
 185 {
 186     int speed, parity, data_bits, stop_bits, frame_size;
 187     QEMUSerialSetParams ssp;
 188
 189     if (s->divider == 0)
 190         return;
 191
 192     /* Start bit. */
 193     frame_size = 1;
 194     if (s->lcr & 0x08) {
 195         /* Parity bit. */
 196         frame_size++;
 197         if (s->lcr & 0x10)
 198             parity = 'E';
 199         else
 200             parity = 'O';
 201     } else {
 202             parity = 'N';
 203     }
 204     if (s->lcr & 0x04)
 205         stop_bits = 2;
 206     else
 207         stop_bits = 1;
 208
 209     data_bits = (s->lcr & 0x03) + 5;
 210     frame_size += data_bits + stop_bits;
 211     speed = s->baudbase / s->divider;
 212     ssp.speed = speed;
 213     ssp.parity = parity;
 214     ssp.data_bits = data_bits;
 215     ssp.stop_bits = stop_bits;
 216     s->char_transmit_time =  (get_ticks_per_sec() / speed) * frame_size;
 217     qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
 218
 219     DPRINTF("speed=%d parity=%c data=%d stop=%d\n",
 220            speed, parity, data_bits, stop_bits);
 221 }
 222
 223 static void serial_update_msl(SerialState *s)
 224 {
 225     uint8_t omsr;
 226     int flags;
 227
 228     qemu_del_timer(s->modem_status_poll);
 229
 230     if (qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &flags) == -ENOTSUP) {
 231         s->poll_msl = -1;
 232         return;
 233     }
 234
 235     omsr = s->msr;
 236
 237     s->msr = (flags & CHR_TIOCM_CTS) ? s->msr | UART_MSR_CTS : s->msr & ~UART_MSR_CTS;
 238     s->msr = (flags & CHR_TIOCM_DSR) ? s->msr | UART_MSR_DSR : s->msr & ~UART_MSR_DSR;
 239     s->msr = (flags & CHR_TIOCM_CAR) ? s->msr | UART_MSR_DCD : s->msr & ~UART_MSR_DCD;
 240     s->msr = (flags & CHR_TIOCM_RI) ? s->msr | UART_MSR_RI : s->msr & ~UART_MSR_RI;
 241
 242     if (s->msr != omsr) {
 243          /* Set delta bits */
 244          s->msr = s->msr | ((s->msr >> 4) ^ (omsr >> 4));
 245          /* UART_MSR_TERI only if change was from 1 -> 0 */
 246          if ((s->msr & UART_MSR_TERI) && !(omsr & UART_MSR_RI))
 247              s->msr &= ~UART_MSR_TERI;
 248          serial_update_irq(s);
 249     }
 250
 251     /* The real 16550A apparently has a 250ns response latency to line status changes.
 252        We'll be lazy and poll only every 10ms, and only poll it at all if MSI interrupts are turned on */
 253
 254     if (s->poll_msl)
 255         qemu_mod_timer(s->modem_status_poll, qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 100);
 256 }
 257
 258 static void serial_xmit(void *opaque)
 259 {
 260     SerialState *s = opaque;
 261     uint64_t new_xmit_ts = qemu_get_clock_ns(vm_clock);
 262
 263     if (s->tsr_retry <= 0) {
 264         if (s->fcr & UART_FCR_FE) {
 265             s->tsr = fifo_get(s,XMIT_FIFO);
 266             if (!s->xmit_fifo.count)
 267                 s->lsr |= UART_LSR_THRE;
 268         } else if ((s->lsr & UART_LSR_THRE)) {
 269             return;
 270         } else {
 271             s->tsr = s->thr;
 272             s->lsr |= UART_LSR_THRE;
 273             s->lsr &= ~UART_LSR_TEMT;
 274         }
 275     }
 276
 277     if (s->mcr & UART_MCR_LOOP) {
 278         /* in loopback mode, say that we just received a char */
 279         serial_receive1(s, &s->tsr, 1);
 280     } else if (qemu_chr_fe_write(s->chr, &s->tsr, 1) != 1) {
 281         if ((s->tsr_retry >= 0) && (s->tsr_retry <= MAX_XMIT_RETRY)) {
 282             s->tsr_retry++;
 283             qemu_mod_timer(s->transmit_timer,  new_xmit_ts + s->char_transmit_time);
 284             return;
 285         } else if (s->poll_msl < 0) {
 286             /* If we exceed MAX_XMIT_RETRY and the backend is not a real serial port, then
 287             drop any further failed writes instantly, until we get one that goes through.
 288             This is to prevent guests that log to unconnected pipes or pty's from stalling. */
 289             s->tsr_retry = -1;
 290         }
 291     }
 292     else {
 293         s->tsr_retry = 0;
 294     }
 295
 296     s->last_xmit_ts = qemu_get_clock_ns(vm_clock);
 297     if (!(s->lsr & UART_LSR_THRE))
 298         qemu_mod_timer(s->transmit_timer, s->last_xmit_ts + s->char_transmit_time);
 299
 300     if (s->lsr & UART_LSR_THRE) {
 301         s->lsr |= UART_LSR_TEMT;
 302         s->thr_ipending = 1;
 303         serial_update_irq(s);
 304     }
 305 }
 306
 307
 308 static void serial_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 309 {
 310     SerialState *s = opaque;
 311
 312     addr &= 7;
 313     DPRINTF("write addr=0x%02x val=0x%02x\n", addr, val);
 314     switch(addr) {
 315     default:
 316     case 0:
 317         if (s->lcr & UART_LCR_DLAB) {
 318             s->divider = (s->divider & 0xff00) | val;
 319             serial_update_parameters(s);
 320         } else {
 321             s->thr = (uint8_t) val;
 322             if(s->fcr & UART_FCR_FE) {
 323                 fifo_put(s, XMIT_FIFO, s->thr);
 324                 s->thr_ipending = 0;
 325                 s->lsr &= ~UART_LSR_TEMT;
 326                 s->lsr &= ~UART_LSR_THRE;
 327                 serial_update_irq(s);
 328             } else {
 329                 s->thr_ipending = 0;
 330                 s->lsr &= ~UART_LSR_THRE;
 331                 serial_update_irq(s);
 332             }
 333             serial_xmit(s);
 334         }
 335         break;
 336     case 1:
 337         if (s->lcr & UART_LCR_DLAB) {
 338             s->divider = (s->divider & 0x00ff) | (val << 8);
 339             serial_update_parameters(s);
 340         } else {
 341             s->ier = val & 0x0f;
 342             /* If the backend device is a real serial port, turn polling of the modem
 343                status lines on physical port on or off depending on UART_IER_MSI state */
 344             if (s->poll_msl >= 0) {
 345                 if (s->ier & UART_IER_MSI) {
 346                      s->poll_msl = 1;
 347                      serial_update_msl(s);
 348                 } else {
 349                      qemu_del_timer(s->modem_status_poll);
 350                      s->poll_msl = 0;
 351                 }
 352             }
 353             if (s->lsr & UART_LSR_THRE) {
 354                 s->thr_ipending = 1;
 355                 serial_update_irq(s);
 356             }
 357         }
 358         break;
 359     case 2:
 360         val = val & 0xFF;
 361
 362         if (s->fcr == val)
 363             break;
 364
 365         /* Did the enable/disable flag change? If so, make sure FIFOs get flushed */
 366         if ((val ^ s->fcr) & UART_FCR_FE)
 367             val |= UART_FCR_XFR | UART_FCR_RFR;
 368
 369         /* FIFO clear */
 370
 371         if (val & UART_FCR_RFR) {
 372             qemu_del_timer(s->fifo_timeout_timer);
 373             s->timeout_ipending=0;
 374             fifo_clear(s,RECV_FIFO);
 375         }
 376
 377         if (val & UART_FCR_XFR) {
 378             fifo_clear(s,XMIT_FIFO);
 379         }
 380
 381         if (val & UART_FCR_FE) {
 382             s->iir |= UART_IIR_FE;
 383             /* Set RECV_FIFO trigger Level */
 384             switch (val & 0xC0) {
 385             case UART_FCR_ITL_1:
 386                 s->recv_fifo.itl = 1;
 387                 break;
 388             case UART_FCR_ITL_2:
 389                 s->recv_fifo.itl = 4;
 390                 break;
 391             case UART_FCR_ITL_3:
 392                 s->recv_fifo.itl = 8;
 393                 break;
 394             case UART_FCR_ITL_4:
 395                 s->recv_fifo.itl = 14;
 396                 break;
 397             }
 398         } else
 399             s->iir &= ~UART_IIR_FE;
 400
 401         /* Set fcr - or at least the bits in it that are supposed to "stick" */
 402         s->fcr = val & 0xC9;
 403         serial_update_irq(s);
 404         break;
 405     case 3:
 406         {
 407             int break_enable;
 408             s->lcr = val;
 409             serial_update_parameters(s);
 410             break_enable = (val >> 6) & 1;
 411             if (break_enable != s->last_break_enable) {
 412                 s->last_break_enable = break_enable;
 413                 qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_BREAK,
 414                                &break_enable);
 415             }
 416         }
 417         break;
 418     case 4:
 419         {
 420             int flags;
 421             int old_mcr = s->mcr;
 422             s->mcr = val & 0x1f;
 423             if (val & UART_MCR_LOOP)
 424                 break;
 425
 426             if (s->poll_msl >= 0 && old_mcr != s->mcr) {
 427
 428                 qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &flags);
 429
 430                 flags &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);
 431
 432                 if (val & UART_MCR_RTS)
 433                     flags |= CHR_TIOCM_RTS;
 434                 if (val & UART_MCR_DTR)
 435                     flags |= CHR_TIOCM_DTR;
 436
 437                 qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_SET_TIOCM, &flags);
 438                 /* Update the modem status after a one-character-send wait-time, since there may be a response
 439                    from the device/computer at the other end of the serial line */
 440                 qemu_mod_timer(s->modem_status_poll, qemu_get_clock_ns(vm_clock) + s->char_transmit_time);
 441             }
 442         }
 443         break;
 444     case 5:
 445         break;
 446     case 6:
 447         break;
 448     case 7:
 449         s->scr = val;
 450         break;
 451     }
 452 }
 453
 454 static uint32_t serial_ioport_read(void *opaque, uint32_t addr)
 455 {
 456     SerialState *s = opaque;
 457     uint32_t ret;
 458
 459     addr &= 7;
 460     switch(addr) {
 461     default:
 462     case 0:
 463         if (s->lcr & UART_LCR_DLAB) {
 464             ret = s->divider & 0xff;
 465         } else {
 466             if(s->fcr & UART_FCR_FE) {
 467                 ret = fifo_get(s,RECV_FIFO);
 468                 if (s->recv_fifo.count == 0)
 469                     s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
 470                 else
 471                     qemu_mod_timer(s->fifo_timeout_timer, qemu_get_clock_ns (vm_clock) + s->char_transmit_time * 4);
 472                 s->timeout_ipending = 0;
 473             } else {
 474                 ret = s->rbr;
 475                 s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
 476             }
 477             serial_update_irq(s);
 478             if (!(s->mcr & UART_MCR_LOOP)) {
 479                 /* in loopback mode, don't receive any data */
 480                 qemu_chr_accept_input(s->chr);
 481             }
 482         }
 483         break;
 484     case 1:
 485         if (s->lcr & UART_LCR_DLAB) {
 486             ret = (s->divider >> 8) & 0xff;
 487         } else {
 488             ret = s->ier;
 489         }
 490         break;
 491     case 2:
 492         ret = s->iir;
 493         if ((ret & UART_IIR_ID) == UART_IIR_THRI) {
 494             s->thr_ipending = 0;
 495             serial_update_irq(s);
 496         }
 497         break;
 498     case 3:
 499         ret = s->lcr;
 500         break;
 501     case 4:
 502         ret = s->mcr;
 503         break;
 504     case 5:
 505         ret = s->lsr;
 506         /* Clear break and overrun interrupts */
 507         if (s->lsr & (UART_LSR_BI|UART_LSR_OE)) {
 508             s->lsr &= ~(UART_LSR_BI|UART_LSR_OE);
 509             serial_update_irq(s);
 510         }
 511         break;
 512     case 6:
 513         if (s->mcr & UART_MCR_LOOP) {
 514             /* in loopback, the modem output pins are connected to the
 515                inputs */
 516             ret = (s->mcr & 0x0c) << 4;
 517             ret |= (s->mcr & 0x02) << 3;
 518             ret |= (s->mcr & 0x01) << 5;
 519         } else {
 520             if (s->poll_msl >= 0)
 521                 serial_update_msl(s);
 522             ret = s->msr;
 523             /* Clear delta bits & msr int after read, if they were set */
 524             if (s->msr & UART_MSR_ANY_DELTA) {
 525                 s->msr &= 0xF0;
 526                 serial_update_irq(s);
 527             }
 528         }
 529         break;
 530     case 7:
 531         ret = s->scr;
 532         break;
 533     }
 534     DPRINTF("read addr=0x%02x val=0x%02x\n", addr, ret);
 535     return ret;
 536 }
 537
 538 static int serial_can_receive(SerialState *s)
 539 {
 540     if(s->fcr & UART_FCR_FE) {
 541         if(s->recv_fifo.count < UART_FIFO_LENGTH)
 542         /* Advertise (fifo.itl - fifo.count) bytes when count < ITL, and 1 if above. If UART_FIFO_LENGTH - fifo.count is
 543         advertised the effect will be to almost always fill the fifo completely before the guest has a chance to respond,
 544         effectively overriding the ITL that the guest has set. */
 545              return (s->recv_fifo.count <= s->recv_fifo.itl) ? s->recv_fifo.itl - s->recv_fifo.count : 1;
 546         else
 547              return 0;
 548     } else {
 549     return !(s->lsr & UART_LSR_DR);
 550     }
 551 }
 552
 553 static void serial_receive_break(SerialState *s)
 554 {
 555     s->rbr = 0;
 556     /* When the LSR_DR is set a null byte is pushed into the fifo */
 557     fifo_put(s, RECV_FIFO, '\0');
 558     s->lsr |= UART_LSR_BI | UART_LSR_DR;
 559     serial_update_irq(s);
 560 }
 561
 562 /* There's data in recv_fifo and s->rbr has not been read for 4 char transmit times */
 563 static void fifo_timeout_int (void *opaque) {
 564     SerialState *s = opaque;
 565     if (s->recv_fifo.count) {
 566         s->timeout_ipending = 1;
 567         serial_update_irq(s);
 568     }
 569 }
 570
 571 static int serial_can_receive1(void *opaque)
 572 {
 573     SerialState *s = opaque;
 574     return serial_can_receive(s);
 575 }
 576
 577 static void serial_receive1(void *opaque, const uint8_t *buf, int size)
 578 {
 579     SerialState *s = opaque;
 580
 581     if (s->wakeup) {
 582         qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
 583     }
 584     if(s->fcr & UART_FCR_FE) {
 585         int i;
 586         for (i = 0; i < size; i++) {
 587             fifo_put(s, RECV_FIFO, buf[i]);
 588         }
 589         s->lsr |= UART_LSR_DR;
 590         /* call the timeout receive callback in 4 char transmit time */
 591         qemu_mod_timer(s->fifo_timeout_timer, qemu_get_clock_ns (vm_clock) + s->char_transmit_time * 4);
 592     } else {
 593         if (s->lsr & UART_LSR_DR)
 594             s->lsr |= UART_LSR_OE;
 595         s->rbr = buf[0];
 596         s->lsr |= UART_LSR_DR;
 597     }
 598     serial_update_irq(s);
 599 }
 600
 601 static void serial_event(void *opaque, int event)
 602 {
 603     SerialState *s = opaque;
 604     DPRINTF("event %x\n", event);
 605     if (event == CHR_EVENT_BREAK)
 606         serial_receive_break(s);
 607 }
 608
 609 static void serial_pre_save(void *opaque)
 610 {
 611     SerialState *s = opaque;
 612     s->fcr_vmstate = s->fcr;
 613 }
 614
 615 static int serial_post_load(void *opaque, int version_id)
 616 {
 617     SerialState *s = opaque;
 618
 619     if (version_id < 3) {
 620         s->fcr_vmstate = 0;
 621     }
 622     /* Initialize fcr via setter to perform essential side-effects */
 623     serial_ioport_write(s, 0x02, s->fcr_vmstate);
 624     serial_update_parameters(s);
 625     return 0;
 626 }
 627
 628 const VMStateDescription vmstate_serial = {
 629     .name = "serial",
 630     .version_id = 3,
 631     .minimum_version_id = 2,
 632     .pre_save = serial_pre_save,
 633     .post_load = serial_post_load,
 634     .fields      = (VMStateField []) {
 635         VMSTATE_UINT16_V(divider, SerialState, 2),
 636         VMSTATE_UINT8(rbr, SerialState),
 637         VMSTATE_UINT8(ier, SerialState),
 638         VMSTATE_UINT8(iir, SerialState),
 639         VMSTATE_UINT8(lcr, SerialState),
 640         VMSTATE_UINT8(mcr, SerialState),
 641         VMSTATE_UINT8(lsr, SerialState),
 642         VMSTATE_UINT8(msr, SerialState),
 643         VMSTATE_UINT8(scr, SerialState),
 644         VMSTATE_UINT8_V(fcr_vmstate, SerialState, 3),
 645         VMSTATE_END_OF_LIST()
 646     }
 647 };
 648
 649 static void serial_reset(void *opaque)
 650 {
 651     SerialState *s = opaque;
 652
 653     s->rbr = 0;
 654     s->ier = 0;
 655     s->iir = UART_IIR_NO_INT;
 656     s->lcr = 0;
 657     s->lsr = UART_LSR_TEMT | UART_LSR_THRE;
 658     s->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
 659     /* Default to 9600 baud, 1 start bit, 8 data bits, 1 stop bit, no parity. */
 660     s->divider = 0x0C;
 661     s->mcr = UART_MCR_OUT2;
 662     s->scr = 0;
 663     s->tsr_retry = 0;
 664     s->char_transmit_time = (get_ticks_per_sec() / 9600) * 10;
 665     s->poll_msl = 0;
 666
 667     fifo_clear(s,RECV_FIFO);
 668     fifo_clear(s,XMIT_FIFO);
 669
 670     s->last_xmit_ts = qemu_get_clock_ns(vm_clock);
 671
 672     s->thr_ipending = 0;
 673     s->last_break_enable = 0;
 674     qemu_irq_lower(s->irq);
 675 }
 676
 677 void serial_init_core(SerialState *s)
 678 {
 679     if (!s->chr) {
 680         fprintf(stderr, "Can't create serial device, empty char device\n");
 681         exit(1);
 682     }
 683
 684     s->modem_status_poll = qemu_new_timer_ns(vm_clock, (QEMUTimerCB *) serial_update_msl, s);
 685
 686     s->fifo_timeout_timer = qemu_new_timer_ns(vm_clock, (QEMUTimerCB *) fifo_timeout_int, s);
 687     s->transmit_timer = qemu_new_timer_ns(vm_clock, (QEMUTimerCB *) serial_xmit, s);
 688
 689     qemu_register_reset(serial_reset, s);
 690
 691     qemu_chr_add_handlers(s->chr, serial_can_receive1, serial_receive1,
 692                           serial_event, s);
 693 }
 694
 695 void serial_exit_core(SerialState *s)
 696 {
 697     qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL);
 698     qemu_unregister_reset(serial_reset, s);
 699 }
 700
 701 /* Change the main reference oscillator frequency. */
 702 void serial_set_frequency(SerialState *s, uint32_t frequency)
 703 {
 704     s->baudbase = frequency;
 705     serial_update_parameters(s);
 706 }
 707
 708 static const MemoryRegionPortio serial_portio[] = {
 709     { 0, 8, 1, .read = serial_ioport_read, .write = serial_ioport_write },
 710     PORTIO_END_OF_LIST()
 711 };
 712
 713 const MemoryRegionOps serial_io_ops = {
 714     .old_portio = serial_portio
 715 };
 716
 717 SerialState *serial_init(int base, qemu_irq irq, int baudbase,
 718                          CharDriverState *chr)
 719 {
 720     SerialState *s;
 721
 722     s = g_malloc0(sizeof(SerialState));
 723
 724     s->irq = irq;
 725     s->baudbase = baudbase;
 726     s->chr = chr;
 727     serial_init_core(s);
 728
 729     vmstate_register(NULL, base, &vmstate_serial, s);
 730
 731     register_ioport_write(base, 8, 1, serial_ioport_write, s);
 732     register_ioport_read(base, 8, 1, serial_ioport_read, s);
 733     return s;
 734 }
 735
 736 /* Memory mapped interface */
 737 static uint64_t serial_mm_read(void *opaque, hwaddr addr,
 738                                unsigned size)
 739 {
 740     SerialState *s = opaque;
 741     return serial_ioport_read(s, addr >> s->it_shift);
 742 }
 743
 744 static void serial_mm_write(void *opaque, hwaddr addr,
 745                             uint64_t value, unsigned size)
 746 {
 747     SerialState *s = opaque;
 748     value &= ~0u >> (32 - (size * 8));
 749     serial_ioport_write(s, addr >> s->it_shift, value);
 750 }
 751
 752 static const MemoryRegionOps serial_mm_ops[3] = {
 753     [DEVICE_NATIVE_ENDIAN] = {
 754         .read = serial_mm_read,
 755         .write = serial_mm_write,
 756         .endianness = DEVICE_NATIVE_ENDIAN,
 757     },
 758     [DEVICE_LITTLE_ENDIAN] = {
 759         .read = serial_mm_read,
 760         .write = serial_mm_write,
 761         .endianness = DEVICE_LITTLE_ENDIAN,
 762     },
 763     [DEVICE_BIG_ENDIAN] = {
 764         .read = serial_mm_read,
 765         .write = serial_mm_write,
 766         .endianness = DEVICE_BIG_ENDIAN,
 767     },
 768 };
 769
 770 SerialState *serial_mm_init(MemoryRegion *address_space,
 771                             hwaddr base, int it_shift,
 772                             qemu_irq irq, int baudbase,
 773                             CharDriverState *chr, enum device_endian end)
 774 {
 775     SerialState *s;
 776
 777     s = g_malloc0(sizeof(SerialState));
 778
 779     s->it_shift = it_shift;
 780     s->irq = irq;
 781     s->baudbase = baudbase;
 782     s->chr = chr;
 783
 784     serial_init_core(s);
 785     vmstate_register(NULL, base, &vmstate_serial, s);
 786
 787     memory_region_init_io(&s->io, &serial_mm_ops[end], s,
 788                           "serial", 8 << it_shift);
 789     memory_region_add_subregion(address_space, base, &s->io);
 790
 791     serial_update_msl(s);
 792     return s;
 793 }