serial.c 30.6 KB
Newer Older
B
bellard 已提交
1
/*
2
 * QEMU 16550A UART emulation
3
 *
B
bellard 已提交
4
 * Copyright (c) 2003-2004 Fabrice Bellard
5
 * Copyright (c) 2008 Citrix Systems, Inc.
6
 *
B
bellard 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 * 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.
 */
G
Gerd Hoffmann 已提交
25

P
Peter Maydell 已提交
26
#include "qemu/osdep.h"
P
Paolo Bonzini 已提交
27
#include "hw/char/serial.h"
28
#include "sysemu/char.h"
29
#include "qapi/error.h"
30
#include "qemu/timer.h"
31
#include "exec/address-spaces.h"
32
#include "qemu/error-report.h"
B
bellard 已提交
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

//#define DEBUG_SERIAL

#define UART_LCR_DLAB	0x80	/* Divisor latch access bit */

#define UART_IER_MSI	0x08	/* Enable Modem status interrupt */
#define UART_IER_RLSI	0x04	/* Enable receiver line status interrupt */
#define UART_IER_THRI	0x02	/* Enable Transmitter holding register int. */
#define UART_IER_RDI	0x01	/* Enable receiver data interrupt */

#define UART_IIR_NO_INT	0x01	/* No interrupts pending */
#define UART_IIR_ID	0x06	/* Mask for the interrupt ID */

#define UART_IIR_MSI	0x00	/* Modem status interrupt */
#define UART_IIR_THRI	0x02	/* Transmitter holding register empty */
#define UART_IIR_RDI	0x04	/* Receiver data interrupt */
#define UART_IIR_RLSI	0x06	/* Receiver line status interrupt */
50 51 52 53
#define UART_IIR_CTI    0x0C    /* Character Timeout Indication */

#define UART_IIR_FENF   0x80    /* Fifo enabled, but not functionning */
#define UART_IIR_FE     0xC0    /* Fifo enabled */
B
bellard 已提交
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

/*
 * These are the definitions for the Modem Control Register
 */
#define UART_MCR_LOOP	0x10	/* Enable loopback test mode */
#define UART_MCR_OUT2	0x08	/* Out2 complement */
#define UART_MCR_OUT1	0x04	/* Out1 complement */
#define UART_MCR_RTS	0x02	/* RTS complement */
#define UART_MCR_DTR	0x01	/* DTR complement */

/*
 * These are the definitions for the Modem Status Register
 */
#define UART_MSR_DCD	0x80	/* Data Carrier Detect */
#define UART_MSR_RI	0x40	/* Ring Indicator */
#define UART_MSR_DSR	0x20	/* Data Set Ready */
#define UART_MSR_CTS	0x10	/* Clear to Send */
#define UART_MSR_DDCD	0x08	/* Delta DCD */
#define UART_MSR_TERI	0x04	/* Trailing edge ring indicator */
#define UART_MSR_DDSR	0x02	/* Delta DSR */
#define UART_MSR_DCTS	0x01	/* Delta CTS */
#define UART_MSR_ANY_DELTA 0x0F	/* Any of the delta bits! */

#define UART_LSR_TEMT	0x40	/* Transmitter empty */
#define UART_LSR_THRE	0x20	/* Transmit-hold-register empty */
#define UART_LSR_BI	0x10	/* Break interrupt indicator */
#define UART_LSR_FE	0x08	/* Frame error indicator */
#define UART_LSR_PE	0x04	/* Parity error indicator */
#define UART_LSR_OE	0x02	/* Overrun error indicator */
#define UART_LSR_DR	0x01	/* Receiver data ready */
84
#define UART_LSR_INT_ANY 0x1E	/* Any of the lsr-interrupt-triggering status bits */
B
bellard 已提交
85

86 87 88 89 90 91 92 93 94 95 96 97 98 99
/* Interrupt trigger levels. The byte-counts are for 16550A - in newer UARTs the byte-count for each ITL is higher. */

#define UART_FCR_ITL_1      0x00 /* 1 byte ITL */
#define UART_FCR_ITL_2      0x40 /* 4 bytes ITL */
#define UART_FCR_ITL_3      0x80 /* 8 bytes ITL */
#define UART_FCR_ITL_4      0xC0 /* 14 bytes ITL */

#define UART_FCR_DMS        0x08    /* DMA Mode Select */
#define UART_FCR_XFR        0x04    /* XMIT Fifo Reset */
#define UART_FCR_RFR        0x02    /* RCVR Fifo Reset */
#define UART_FCR_FE         0x01    /* FIFO Enable */

#define MAX_XMIT_RETRY      4

100 101
#ifdef DEBUG_SERIAL
#define DPRINTF(fmt, ...) \
102
do { fprintf(stderr, "serial: " fmt , ## __VA_ARGS__); } while (0)
103 104
#else
#define DPRINTF(fmt, ...) \
105
do {} while (0)
106 107
#endif

108
static void serial_receive1(void *opaque, const uint8_t *buf, int size);
109
static void serial_xmit(SerialState *s);
110

111
static inline void recv_fifo_put(SerialState *s, uint8_t chr)
B
bellard 已提交
112
{
113
    /* Receive overruns do not overwrite FIFO contents. */
114 115 116
    if (!fifo8_is_full(&s->recv_fifo)) {
        fifo8_push(&s->recv_fifo, chr);
    } else {
117
        s->lsr |= UART_LSR_OE;
118
    }
119
}
A
aurel32 已提交
120

121 122 123 124 125 126
static void serial_update_irq(SerialState *s)
{
    uint8_t tmp_iir = UART_IIR_NO_INT;

    if ((s->ier & UART_IER_RLSI) && (s->lsr & UART_LSR_INT_ANY)) {
        tmp_iir = UART_IIR_RLSI;
127
    } else if ((s->ier & UART_IER_RDI) && s->timeout_ipending) {
128 129 130
        /* Note that(s->ier & UART_IER_RDI) can mask this interrupt,
         * this is not in the specification but is observed on existing
         * hardware.  */
131
        tmp_iir = UART_IIR_CTI;
132 133
    } else if ((s->ier & UART_IER_RDI) && (s->lsr & UART_LSR_DR) &&
               (!(s->fcr & UART_FCR_FE) ||
134
                s->recv_fifo.num >= s->recv_fifo_itl)) {
135
        tmp_iir = UART_IIR_RDI;
136 137 138 139 140 141 142 143 144 145 146 147
    } else if ((s->ier & UART_IER_THRI) && s->thr_ipending) {
        tmp_iir = UART_IIR_THRI;
    } else if ((s->ier & UART_IER_MSI) && (s->msr & UART_MSR_ANY_DELTA)) {
        tmp_iir = UART_IIR_MSI;
    }

    s->iir = tmp_iir | (s->iir & 0xF0);

    if (tmp_iir != UART_IIR_NO_INT) {
        qemu_irq_raise(s->irq);
    } else {
        qemu_irq_lower(s->irq);
A
aurel32 已提交
148 149 150
    }
}

B
bellard 已提交
151 152
static void serial_update_parameters(SerialState *s)
{
153
    int speed, parity, data_bits, stop_bits, frame_size;
B
bellard 已提交
154
    QEMUSerialSetParams ssp;
B
bellard 已提交
155

156
    if (s->divider == 0 || s->divider > s->baudbase) {
157
        return;
158
    }
159

S
Stefan Weil 已提交
160
    /* Start bit. */
161
    frame_size = 1;
B
bellard 已提交
162
    if (s->lcr & 0x08) {
S
Stefan Weil 已提交
163 164
        /* Parity bit. */
        frame_size++;
B
bellard 已提交
165 166 167 168 169 170 171
        if (s->lcr & 0x10)
            parity = 'E';
        else
            parity = 'O';
    } else {
            parity = 'N';
    }
172
    if (s->lcr & 0x04)
B
bellard 已提交
173 174 175
        stop_bits = 2;
    else
        stop_bits = 1;
176

B
bellard 已提交
177
    data_bits = (s->lcr & 0x03) + 5;
178
    frame_size += data_bits + stop_bits;
A
aurel32 已提交
179
    speed = s->baudbase / s->divider;
B
bellard 已提交
180 181 182 183
    ssp.speed = speed;
    ssp.parity = parity;
    ssp.data_bits = data_bits;
    ssp.stop_bits = stop_bits;
184
    s->char_transmit_time =  (NANOSECONDS_PER_SECOND / speed) * frame_size;
185
    qemu_chr_fe_ioctl(s->chr.chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
186 187

    DPRINTF("speed=%d parity=%c data=%d stop=%d\n",
B
bellard 已提交
188 189 190
           speed, parity, data_bits, stop_bits);
}

191 192 193 194 195
static void serial_update_msl(SerialState *s)
{
    uint8_t omsr;
    int flags;

196
    timer_del(s->modem_status_poll);
197

198 199
    if (qemu_chr_fe_ioctl(s->chr.chr, CHR_IOCTL_SERIAL_GET_TIOCM,
                          &flags) == -ENOTSUP) {
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
        s->poll_msl = -1;
        return;
    }

    omsr = s->msr;

    s->msr = (flags & CHR_TIOCM_CTS) ? s->msr | UART_MSR_CTS : s->msr & ~UART_MSR_CTS;
    s->msr = (flags & CHR_TIOCM_DSR) ? s->msr | UART_MSR_DSR : s->msr & ~UART_MSR_DSR;
    s->msr = (flags & CHR_TIOCM_CAR) ? s->msr | UART_MSR_DCD : s->msr & ~UART_MSR_DCD;
    s->msr = (flags & CHR_TIOCM_RI) ? s->msr | UART_MSR_RI : s->msr & ~UART_MSR_RI;

    if (s->msr != omsr) {
         /* Set delta bits */
         s->msr = s->msr | ((s->msr >> 4) ^ (omsr >> 4));
         /* UART_MSR_TERI only if change was from 1 -> 0 */
         if ((s->msr & UART_MSR_TERI) && !(omsr & UART_MSR_RI))
             s->msr &= ~UART_MSR_TERI;
         serial_update_irq(s);
    }

    /* The real 16550A apparently has a 250ns response latency to line status changes.
       We'll be lazy and poll only every 10ms, and only poll it at all if MSI interrupts are turned on */

223 224 225 226
    if (s->poll_msl) {
        timer_mod(s->modem_status_poll, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
                  NANOSECONDS_PER_SECOND / 100);
    }
227 228
}

229 230
static gboolean serial_watch_cb(GIOChannel *chan, GIOCondition cond,
                                void *opaque)
231 232
{
    SerialState *s = opaque;
P
Paolo Bonzini 已提交
233
    s->watch_tag = 0;
234 235 236
    serial_xmit(s);
    return FALSE;
}
237

238 239
static void serial_xmit(SerialState *s)
{
240
    do {
241
        assert(!(s->lsr & UART_LSR_TEMT));
P
Paolo Bonzini 已提交
242
        if (s->tsr_retry == 0) {
243 244
            assert(!(s->lsr & UART_LSR_THRE));

245
            if (s->fcr & UART_FCR_FE) {
246
                assert(!fifo8_is_empty(&s->xmit_fifo));
247 248 249 250 251 252
                s->tsr = fifo8_pop(&s->xmit_fifo);
                if (!s->xmit_fifo.num) {
                    s->lsr |= UART_LSR_THRE;
                }
            } else {
                s->tsr = s->thr;
253
                s->lsr |= UART_LSR_THRE;
254 255 256 257
            }
            if ((s->lsr & UART_LSR_THRE) && !s->thr_ipending) {
                s->thr_ipending = 1;
                serial_update_irq(s);
P
Peter Crosthwaite 已提交
258
            }
259 260
        }

261 262 263
        if (s->mcr & UART_MCR_LOOP) {
            /* in loopback mode, say that we just received a char */
            serial_receive1(s, &s->tsr, 1);
264
        } else if (qemu_chr_fe_write(s->chr.chr, &s->tsr, 1) != 1 &&
P
Paolo Bonzini 已提交
265 266
                   s->tsr_retry < MAX_XMIT_RETRY) {
            assert(s->watch_tag == 0);
267 268 269
            s->watch_tag =
                qemu_chr_fe_add_watch(s->chr.chr, G_IO_OUT | G_IO_HUP,
                                      serial_watch_cb, s);
P
Paolo Bonzini 已提交
270
            if (s->watch_tag > 0) {
271
                s->tsr_retry++;
272
                return;
273
            }
274
        }
P
Paolo Bonzini 已提交
275
        s->tsr_retry = 0;
276

277 278
        /* Transmit another byte if it is already available. It is only
           possible when FIFO is enabled and not empty. */
279
    } while (!(s->lsr & UART_LSR_THRE));
280

281
    s->last_xmit_ts = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
282
    s->lsr |= UART_LSR_TEMT;
283 284
}

285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
/* Setter for FCR.
   is_load flag means, that value is set while loading VM state
   and interrupt should not be invoked */
static void serial_write_fcr(SerialState *s, uint8_t val)
{
    /* Set fcr - val only has the bits that are supposed to "stick" */
    s->fcr = val;

    if (val & UART_FCR_FE) {
        s->iir |= UART_IIR_FE;
        /* Set recv_fifo trigger Level */
        switch (val & 0xC0) {
        case UART_FCR_ITL_1:
            s->recv_fifo_itl = 1;
            break;
        case UART_FCR_ITL_2:
            s->recv_fifo_itl = 4;
            break;
        case UART_FCR_ITL_3:
            s->recv_fifo_itl = 8;
            break;
        case UART_FCR_ITL_4:
            s->recv_fifo_itl = 14;
            break;
        }
    } else {
        s->iir &= ~UART_IIR_FE;
    }
}

315 316
static void serial_ioport_write(void *opaque, hwaddr addr, uint64_t val,
                                unsigned size)
B
bellard 已提交
317
{
B
bellard 已提交
318
    SerialState *s = opaque;
319

B
bellard 已提交
320
    addr &= 7;
K
Kevin Wolf 已提交
321
    DPRINTF("write addr=0x%" HWADDR_PRIx " val=0x%" PRIx64 "\n", addr, val);
B
bellard 已提交
322 323 324 325 326
    switch(addr) {
    default:
    case 0:
        if (s->lcr & UART_LCR_DLAB) {
            s->divider = (s->divider & 0xff00) | val;
B
bellard 已提交
327
            serial_update_parameters(s);
B
bellard 已提交
328
        } else {
329 330
            s->thr = (uint8_t) val;
            if(s->fcr & UART_FCR_FE) {
331 332 333 334 335
                /* xmit overruns overwrite data, so make space if needed */
                if (fifo8_is_full(&s->xmit_fifo)) {
                    fifo8_pop(&s->xmit_fifo);
                }
                fifo8_push(&s->xmit_fifo, s->thr);
A
aurel32 已提交
336
            }
337 338
            s->thr_ipending = 0;
            s->lsr &= ~UART_LSR_THRE;
339
            s->lsr &= ~UART_LSR_TEMT;
340
            serial_update_irq(s);
P
Paolo Bonzini 已提交
341
            if (s->tsr_retry == 0) {
342
                serial_xmit(s);
343
            }
B
bellard 已提交
344 345 346 347 348
        }
        break;
    case 1:
        if (s->lcr & UART_LCR_DLAB) {
            s->divider = (s->divider & 0x00ff) | (val << 8);
B
bellard 已提交
349
            serial_update_parameters(s);
B
bellard 已提交
350
        } else {
351
            uint8_t changed = (s->ier ^ val) & 0x0f;
B
bellard 已提交
352
            s->ier = val & 0x0f;
353
            /* If the backend device is a real serial port, turn polling of the modem
354 355 356
             * status lines on physical port on or off depending on UART_IER_MSI state.
             */
            if ((changed & UART_IER_MSI) && s->poll_msl >= 0) {
357 358 359 360
                if (s->ier & UART_IER_MSI) {
                     s->poll_msl = 1;
                     serial_update_msl(s);
                } else {
361
                     timer_del(s->modem_status_poll);
362 363 364
                     s->poll_msl = 0;
                }
            }
365 366 367 368 369 370

            /* Turning on the THRE interrupt on IER can trigger the interrupt
             * if LSR.THRE=1, even if it had been masked before by reading IIR.
             * This is not in the datasheet, but Windows relies on it.  It is
             * unclear if THRE has to be resampled every time THRI becomes
             * 1, or only on the rising edge.  Bochs does the latter, and Windows
371 372
             * always toggles IER to all zeroes and back to all ones, so do the
             * same.
373 374 375 376
             *
             * If IER.THRI is zero, thr_ipending is not used.  Set it to zero
             * so that the thr_ipending subsection is not migrated.
             */
377 378 379 380 381 382 383 384 385 386
            if (changed & UART_IER_THRI) {
                if ((s->ier & UART_IER_THRI) && (s->lsr & UART_LSR_THRE)) {
                    s->thr_ipending = 1;
                } else {
                    s->thr_ipending = 0;
                }
            }

            if (changed) {
                serial_update_irq(s);
B
bellard 已提交
387
            }
B
bellard 已提交
388 389 390
        }
        break;
    case 2:
391
        /* Did the enable/disable flag change? If so, make sure FIFOs get flushed */
392
        if ((val ^ s->fcr) & UART_FCR_FE) {
393
            val |= UART_FCR_XFR | UART_FCR_RFR;
394
        }
395 396 397 398

        /* FIFO clear */

        if (val & UART_FCR_RFR) {
399
            s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
400
            timer_del(s->fifo_timeout_timer);
401
            s->timeout_ipending = 0;
402
            fifo8_reset(&s->recv_fifo);
403 404 405
        }

        if (val & UART_FCR_XFR) {
406 407
            s->lsr |= UART_LSR_THRE;
            s->thr_ipending = 1;
408
            fifo8_reset(&s->xmit_fifo);
409 410
        }

411
        serial_write_fcr(s, val & 0xC9);
412
        serial_update_irq(s);
B
bellard 已提交
413 414
        break;
    case 3:
B
bellard 已提交
415 416 417 418 419 420 421
        {
            int break_enable;
            s->lcr = val;
            serial_update_parameters(s);
            break_enable = (val >> 6) & 1;
            if (break_enable != s->last_break_enable) {
                s->last_break_enable = break_enable;
422
                qemu_chr_fe_ioctl(s->chr.chr, CHR_IOCTL_SERIAL_SET_BREAK,
B
bellard 已提交
423
                               &break_enable);
B
bellard 已提交
424 425
            }
        }
B
bellard 已提交
426 427
        break;
    case 4:
428 429 430 431 432 433 434 435 436
        {
            int flags;
            int old_mcr = s->mcr;
            s->mcr = val & 0x1f;
            if (val & UART_MCR_LOOP)
                break;

            if (s->poll_msl >= 0 && old_mcr != s->mcr) {

437 438
                qemu_chr_fe_ioctl(s->chr.chr,
                                  CHR_IOCTL_SERIAL_GET_TIOCM, &flags);
439 440 441 442 443 444 445 446

                flags &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);

                if (val & UART_MCR_RTS)
                    flags |= CHR_TIOCM_RTS;
                if (val & UART_MCR_DTR)
                    flags |= CHR_TIOCM_DTR;

447 448
                qemu_chr_fe_ioctl(s->chr.chr,
                                  CHR_IOCTL_SERIAL_SET_TIOCM, &flags);
449 450
                /* Update the modem status after a one-character-send wait-time, since there may be a response
                   from the device/computer at the other end of the serial line */
451
                timer_mod(s->modem_status_poll, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time);
452 453
            }
        }
B
bellard 已提交
454 455 456 457 458 459 460 461 462 463 464
        break;
    case 5:
        break;
    case 6:
        break;
    case 7:
        s->scr = val;
        break;
    }
}

465
static uint64_t serial_ioport_read(void *opaque, hwaddr addr, unsigned size)
B
bellard 已提交
466
{
B
bellard 已提交
467
    SerialState *s = opaque;
B
bellard 已提交
468 469 470 471 472 473 474
    uint32_t ret;

    addr &= 7;
    switch(addr) {
    default:
    case 0:
        if (s->lcr & UART_LCR_DLAB) {
475
            ret = s->divider & 0xff;
B
bellard 已提交
476
        } else {
477
            if(s->fcr & UART_FCR_FE) {
478
                ret = fifo8_is_empty(&s->recv_fifo) ?
479 480
                            0 : fifo8_pop(&s->recv_fifo);
                if (s->recv_fifo.num == 0) {
481
                    s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
P
Peter Crosthwaite 已提交
482
                } else {
483
                    timer_mod(s->fifo_timeout_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time * 4);
P
Peter Crosthwaite 已提交
484
                }
485 486 487 488 489
                s->timeout_ipending = 0;
            } else {
                ret = s->rbr;
                s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
            }
B
bellard 已提交
490
            serial_update_irq(s);
491 492
            if (!(s->mcr & UART_MCR_LOOP)) {
                /* in loopback mode, don't receive any data */
493
                qemu_chr_fe_accept_input(s->chr.chr);
494
            }
B
bellard 已提交
495 496 497 498 499 500 501 502 503 504 505
        }
        break;
    case 1:
        if (s->lcr & UART_LCR_DLAB) {
            ret = (s->divider >> 8) & 0xff;
        } else {
            ret = s->ier;
        }
        break;
    case 2:
        ret = s->iir;
506
        if ((ret & UART_IIR_ID) == UART_IIR_THRI) {
B
bellard 已提交
507
            s->thr_ipending = 0;
508 509
            serial_update_irq(s);
        }
B
bellard 已提交
510 511 512 513 514 515 516 517 518
        break;
    case 3:
        ret = s->lcr;
        break;
    case 4:
        ret = s->mcr;
        break;
    case 5:
        ret = s->lsr;
519 520 521
        /* Clear break and overrun interrupts */
        if (s->lsr & (UART_LSR_BI|UART_LSR_OE)) {
            s->lsr &= ~(UART_LSR_BI|UART_LSR_OE);
522 523
            serial_update_irq(s);
        }
B
bellard 已提交
524 525 526 527 528 529 530 531 532
        break;
    case 6:
        if (s->mcr & UART_MCR_LOOP) {
            /* in loopback, the modem output pins are connected to the
               inputs */
            ret = (s->mcr & 0x0c) << 4;
            ret |= (s->mcr & 0x02) << 3;
            ret |= (s->mcr & 0x01) << 5;
        } else {
533 534
            if (s->poll_msl >= 0)
                serial_update_msl(s);
B
bellard 已提交
535
            ret = s->msr;
536 537 538 539 540
            /* Clear delta bits & msr int after read, if they were set */
            if (s->msr & UART_MSR_ANY_DELTA) {
                s->msr &= 0xF0;
                serial_update_irq(s);
            }
B
bellard 已提交
541 542 543 544 545 546
        }
        break;
    case 7:
        ret = s->scr;
        break;
    }
K
Kevin Wolf 已提交
547
    DPRINTF("read addr=0x%" HWADDR_PRIx " val=0x%02x\n", addr, ret);
B
bellard 已提交
548 549 550
    return ret;
}

B
bellard 已提交
551
static int serial_can_receive(SerialState *s)
B
bellard 已提交
552
{
553
    if(s->fcr & UART_FCR_FE) {
554
        if (s->recv_fifo.num < UART_FIFO_LENGTH) {
P
Peter Crosthwaite 已提交
555 556 557 558 559 560 561
            /*
             * Advertise (fifo.itl - fifo.count) bytes when count < ITL, and 1
             * if above. If UART_FIFO_LENGTH - fifo.count is advertised the
             * effect will be to almost always fill the fifo completely before
             * the guest has a chance to respond, effectively overriding the ITL
             * that the guest has set.
             */
562 563
            return (s->recv_fifo.num <= s->recv_fifo_itl) ?
                        s->recv_fifo_itl - s->recv_fifo.num : 1;
P
Peter Crosthwaite 已提交
564 565 566
        } else {
            return 0;
        }
567
    } else {
P
Peter Crosthwaite 已提交
568
        return !(s->lsr & UART_LSR_DR);
569
    }
B
bellard 已提交
570 571
}

B
bellard 已提交
572
static void serial_receive_break(SerialState *s)
B
bellard 已提交
573 574
{
    s->rbr = 0;
575
    /* When the LSR_DR is set a null byte is pushed into the fifo */
576
    recv_fifo_put(s, '\0');
B
bellard 已提交
577
    s->lsr |= UART_LSR_BI | UART_LSR_DR;
B
bellard 已提交
578
    serial_update_irq(s);
B
bellard 已提交
579 580
}

581 582 583
/* There's data in recv_fifo and s->rbr has not been read for 4 char transmit times */
static void fifo_timeout_int (void *opaque) {
    SerialState *s = opaque;
584
    if (s->recv_fifo.num) {
585 586 587 588 589
        s->timeout_ipending = 1;
        serial_update_irq(s);
    }
}

B
bellard 已提交
590
static int serial_can_receive1(void *opaque)
B
bellard 已提交
591
{
B
bellard 已提交
592 593 594 595 596 597 598
    SerialState *s = opaque;
    return serial_can_receive(s);
}

static void serial_receive1(void *opaque, const uint8_t *buf, int size)
{
    SerialState *s = opaque;
599 600 601 602

    if (s->wakeup) {
        qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
    }
603 604 605
    if(s->fcr & UART_FCR_FE) {
        int i;
        for (i = 0; i < size; i++) {
606
            recv_fifo_put(s, buf[i]);
607 608 609
        }
        s->lsr |= UART_LSR_DR;
        /* call the timeout receive callback in 4 char transmit time */
610
        timer_mod(s->fifo_timeout_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time * 4);
611
    } else {
612 613
        if (s->lsr & UART_LSR_DR)
            s->lsr |= UART_LSR_OE;
614 615 616 617
        s->rbr = buf[0];
        s->lsr |= UART_LSR_DR;
    }
    serial_update_irq(s);
B
bellard 已提交
618
}
B
bellard 已提交
619

B
bellard 已提交
620 621 622
static void serial_event(void *opaque, int event)
{
    SerialState *s = opaque;
623
    DPRINTF("event %x\n", event);
B
bellard 已提交
624 625 626 627
    if (event == CHR_EVENT_BREAK)
        serial_receive_break(s);
}

628
static void serial_pre_save(void *opaque)
629
{
630
    SerialState *s = opaque;
J
Juan Quintela 已提交
631
    s->fcr_vmstate = s->fcr;
632 633
}

634 635 636 637 638 639 640 641
static int serial_pre_load(void *opaque)
{
    SerialState *s = opaque;
    s->thr_ipending = -1;
    s->poll_msl = -1;
    return 0;
}

642
static int serial_post_load(void *opaque, int version_id)
J
Juan Quintela 已提交
643 644
{
    SerialState *s = opaque;
645

646 647 648
    if (version_id < 3) {
        s->fcr_vmstate = 0;
    }
649 650 651
    if (s->thr_ipending == -1) {
        s->thr_ipending = ((s->iir & UART_IIR_ID) == UART_IIR_THRI);
    }
652 653 654 655 656 657 658 659 660 661 662 663 664 665

    if (s->tsr_retry > 0) {
        /* tsr_retry > 0 implies LSR.TEMT = 0 (transmitter not empty).  */
        if (s->lsr & UART_LSR_TEMT) {
            error_report("inconsistent state in serial device "
                         "(tsr empty, tsr_retry=%d", s->tsr_retry);
            return -1;
        }

        if (s->tsr_retry > MAX_XMIT_RETRY) {
            s->tsr_retry = MAX_XMIT_RETRY;
        }

        assert(s->watch_tag == 0);
666
        s->watch_tag = qemu_chr_fe_add_watch(s->chr.chr, G_IO_OUT | G_IO_HUP,
667 668 669 670 671 672 673 674
                                             serial_watch_cb, s);
    } else {
        /* tsr_retry == 0 implies LSR.TEMT = 1 (transmitter empty).  */
        if (!(s->lsr & UART_LSR_TEMT)) {
            error_report("inconsistent state in serial device "
                         "(tsr not empty, tsr_retry=0");
            return -1;
        }
P
Paolo Bonzini 已提交
675 676
    }

677
    s->last_break_enable = (s->lcr >> 6) & 1;
678
    /* Initialize fcr via setter to perform essential side-effects */
679
    serial_write_fcr(s, s->fcr_vmstate);
680
    serial_update_parameters(s);
681 682 683
    return 0;
}

684 685 686
static bool serial_thr_ipending_needed(void *opaque)
{
    SerialState *s = opaque;
687 688 689 690 691 692 693 694 695 696 697

    if (s->ier & UART_IER_THRI) {
        bool expected_value = ((s->iir & UART_IIR_ID) == UART_IIR_THRI);
        return s->thr_ipending != expected_value;
    } else {
        /* LSR.THRE will be sampled again when the interrupt is
         * enabled.  thr_ipending is not used in this case, do
         * not migrate it.
         */
        return false;
    }
698 699
}

700
static const VMStateDescription vmstate_serial_thr_ipending = {
701 702 703
    .name = "serial/thr_ipending",
    .version_id = 1,
    .minimum_version_id = 1,
704
    .needed = serial_thr_ipending_needed,
705 706 707 708 709 710 711 712 713 714 715 716
    .fields = (VMStateField[]) {
        VMSTATE_INT32(thr_ipending, SerialState),
        VMSTATE_END_OF_LIST()
    }
};

static bool serial_tsr_needed(void *opaque)
{
    SerialState *s = (SerialState *)opaque;
    return s->tsr_retry != 0;
}

717
static const VMStateDescription vmstate_serial_tsr = {
718 719 720
    .name = "serial/tsr",
    .version_id = 1,
    .minimum_version_id = 1,
721
    .needed = serial_tsr_needed,
722
    .fields = (VMStateField[]) {
P
Paolo Bonzini 已提交
723
        VMSTATE_UINT32(tsr_retry, SerialState),
724 725 726 727 728 729 730 731 732 733 734 735 736
        VMSTATE_UINT8(thr, SerialState),
        VMSTATE_UINT8(tsr, SerialState),
        VMSTATE_END_OF_LIST()
    }
};

static bool serial_recv_fifo_needed(void *opaque)
{
    SerialState *s = (SerialState *)opaque;
    return !fifo8_is_empty(&s->recv_fifo);

}

737
static const VMStateDescription vmstate_serial_recv_fifo = {
738 739 740
    .name = "serial/recv_fifo",
    .version_id = 1,
    .minimum_version_id = 1,
741
    .needed = serial_recv_fifo_needed,
742 743 744 745 746 747 748 749 750 751 752 753
    .fields = (VMStateField[]) {
        VMSTATE_STRUCT(recv_fifo, SerialState, 1, vmstate_fifo8, Fifo8),
        VMSTATE_END_OF_LIST()
    }
};

static bool serial_xmit_fifo_needed(void *opaque)
{
    SerialState *s = (SerialState *)opaque;
    return !fifo8_is_empty(&s->xmit_fifo);
}

754
static const VMStateDescription vmstate_serial_xmit_fifo = {
755 756 757
    .name = "serial/xmit_fifo",
    .version_id = 1,
    .minimum_version_id = 1,
758
    .needed = serial_xmit_fifo_needed,
759 760 761 762 763 764 765 766 767 768 769 770
    .fields = (VMStateField[]) {
        VMSTATE_STRUCT(xmit_fifo, SerialState, 1, vmstate_fifo8, Fifo8),
        VMSTATE_END_OF_LIST()
    }
};

static bool serial_fifo_timeout_timer_needed(void *opaque)
{
    SerialState *s = (SerialState *)opaque;
    return timer_pending(s->fifo_timeout_timer);
}

771
static const VMStateDescription vmstate_serial_fifo_timeout_timer = {
772 773 774
    .name = "serial/fifo_timeout_timer",
    .version_id = 1,
    .minimum_version_id = 1,
775
    .needed = serial_fifo_timeout_timer_needed,
776
    .fields = (VMStateField[]) {
777
        VMSTATE_TIMER_PTR(fifo_timeout_timer, SerialState),
778 779 780 781 782 783 784 785 786 787
        VMSTATE_END_OF_LIST()
    }
};

static bool serial_timeout_ipending_needed(void *opaque)
{
    SerialState *s = (SerialState *)opaque;
    return s->timeout_ipending != 0;
}

788
static const VMStateDescription vmstate_serial_timeout_ipending = {
789 790 791
    .name = "serial/timeout_ipending",
    .version_id = 1,
    .minimum_version_id = 1,
792
    .needed = serial_timeout_ipending_needed,
793 794 795 796 797 798 799 800 801 802 803 804
    .fields = (VMStateField[]) {
        VMSTATE_INT32(timeout_ipending, SerialState),
        VMSTATE_END_OF_LIST()
    }
};

static bool serial_poll_needed(void *opaque)
{
    SerialState *s = (SerialState *)opaque;
    return s->poll_msl >= 0;
}

805
static const VMStateDescription vmstate_serial_poll = {
806 807
    .name = "serial/poll",
    .version_id = 1,
808
    .needed = serial_poll_needed,
809 810 811
    .minimum_version_id = 1,
    .fields = (VMStateField[]) {
        VMSTATE_INT32(poll_msl, SerialState),
812
        VMSTATE_TIMER_PTR(modem_status_poll, SerialState),
813 814 815 816
        VMSTATE_END_OF_LIST()
    }
};

G
Gerd Hoffmann 已提交
817
const VMStateDescription vmstate_serial = {
J
Juan Quintela 已提交
818 819 820 821
    .name = "serial",
    .version_id = 3,
    .minimum_version_id = 2,
    .pre_save = serial_pre_save,
822
    .pre_load = serial_pre_load,
J
Juan Quintela 已提交
823
    .post_load = serial_post_load,
824
    .fields = (VMStateField[]) {
J
Juan Quintela 已提交
825 826 827 828 829 830 831 832 833 834 835
        VMSTATE_UINT16_V(divider, SerialState, 2),
        VMSTATE_UINT8(rbr, SerialState),
        VMSTATE_UINT8(ier, SerialState),
        VMSTATE_UINT8(iir, SerialState),
        VMSTATE_UINT8(lcr, SerialState),
        VMSTATE_UINT8(mcr, SerialState),
        VMSTATE_UINT8(lsr, SerialState),
        VMSTATE_UINT8(msr, SerialState),
        VMSTATE_UINT8(scr, SerialState),
        VMSTATE_UINT8_V(fcr_vmstate, SerialState, 3),
        VMSTATE_END_OF_LIST()
836
    },
837 838 839 840 841 842 843 844 845
    .subsections = (const VMStateDescription*[]) {
        &vmstate_serial_thr_ipending,
        &vmstate_serial_tsr,
        &vmstate_serial_recv_fifo,
        &vmstate_serial_xmit_fifo,
        &vmstate_serial_fifo_timeout_timer,
        &vmstate_serial_timeout_ipending,
        &vmstate_serial_poll,
        NULL
J
Juan Quintela 已提交
846 847 848
    }
};

849 850 851 852
static void serial_reset(void *opaque)
{
    SerialState *s = opaque;

P
Paolo Bonzini 已提交
853 854 855 856 857
    if (s->watch_tag > 0) {
        g_source_remove(s->watch_tag);
        s->watch_tag = 0;
    }

858 859 860 861 862 863
    s->rbr = 0;
    s->ier = 0;
    s->iir = UART_IIR_NO_INT;
    s->lcr = 0;
    s->lsr = UART_LSR_TEMT | UART_LSR_THRE;
    s->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
S
Stefan Weil 已提交
864
    /* Default to 9600 baud, 1 start bit, 8 data bits, 1 stop bit, no parity. */
865 866
    s->divider = 0x0C;
    s->mcr = UART_MCR_OUT2;
867
    s->scr = 0;
868
    s->tsr_retry = 0;
869
    s->char_transmit_time = (NANOSECONDS_PER_SECOND / 9600) * 10;
870 871
    s->poll_msl = 0;

872 873 874 875
    s->timeout_ipending = 0;
    timer_del(s->fifo_timeout_timer);
    timer_del(s->modem_status_poll);

876 877
    fifo8_reset(&s->recv_fifo);
    fifo8_reset(&s->xmit_fifo);
878

879
    s->last_xmit_ts = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
880 881 882 883

    s->thr_ipending = 0;
    s->last_break_enable = 0;
    qemu_irq_lower(s->irq);
884 885 886

    serial_update_msl(s);
    s->msr &= ~UART_MSR_ANY_DELTA;
887 888
}

889
void serial_realize_core(SerialState *s, Error **errp)
890
{
891
    if (!s->chr.chr) {
892 893
        error_setg(errp, "Can't create serial device, empty char device");
        return;
894 895
    }

896
    s->modem_status_poll = timer_new_ns(QEMU_CLOCK_VIRTUAL, (QEMUTimerCB *) serial_update_msl, s);
897

898
    s->fifo_timeout_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, (QEMUTimerCB *) fifo_timeout_int, s);
899
    qemu_register_reset(serial_reset, s);
900

901
    qemu_chr_add_handlers(s->chr.chr, serial_can_receive1, serial_receive1,
902
                          serial_event, s);
903 904
    fifo8_create(&s->recv_fifo, UART_FIFO_LENGTH);
    fifo8_create(&s->xmit_fifo, UART_FIFO_LENGTH);
P
Paolo Bonzini 已提交
905
    serial_reset(s);
906 907
}

G
Gerd Hoffmann 已提交
908 909
void serial_exit_core(SerialState *s)
{
910
    qemu_chr_add_handlers(s->chr.chr, NULL, NULL, NULL, NULL);
G
Gerd Hoffmann 已提交
911 912 913
    qemu_unregister_reset(serial_reset, s);
}

914 915 916 917 918 919 920
/* Change the main reference oscillator frequency. */
void serial_set_frequency(SerialState *s, uint32_t frequency)
{
    s->baudbase = frequency;
    serial_update_parameters(s);
}

G
Gerd Hoffmann 已提交
921
const MemoryRegionOps serial_io_ops = {
922 923 924 925 926 927 928
    .read = serial_ioport_read,
    .write = serial_ioport_write,
    .impl = {
        .min_access_size = 1,
        .max_access_size = 1,
    },
    .endianness = DEVICE_LITTLE_ENDIAN,
929 930
};

A
aurel32 已提交
931
SerialState *serial_init(int base, qemu_irq irq, int baudbase,
J
Julien Grall 已提交
932
                         CharDriverState *chr, MemoryRegion *system_io)
B
bellard 已提交
933 934 935
{
    SerialState *s;

936
    s = g_malloc0(sizeof(SerialState));
A
aurel32 已提交
937

G
Gerd Hoffmann 已提交
938 939
    s->irq = irq;
    s->baudbase = baudbase;
940
    qemu_chr_fe_init(&s->chr, chr, &error_abort);
941
    serial_realize_core(s, &error_fatal);
B
bellard 已提交
942

A
Alex Williamson 已提交
943
    vmstate_register(NULL, base, &vmstate_serial, s);
944

945
    memory_region_init_io(&s->io, NULL, &serial_io_ops, s, "serial", 8);
J
Julien Grall 已提交
946
    memory_region_add_subregion(system_io, base, &s->io);
947

B
bellard 已提交
948
    return s;
B
bellard 已提交
949
}
950 951

/* Memory mapped interface */
A
Avi Kivity 已提交
952
static uint64_t serial_mm_read(void *opaque, hwaddr addr,
953
                               unsigned size)
954 955
{
    SerialState *s = opaque;
956
    return serial_ioport_read(s, addr >> s->it_shift, 1);
957 958
}

A
Avi Kivity 已提交
959
static void serial_mm_write(void *opaque, hwaddr addr,
960
                            uint64_t value, unsigned size)
B
Blue Swirl 已提交
961 962
{
    SerialState *s = opaque;
963
    value &= ~0u >> (32 - (size * 8));
964
    serial_ioport_write(s, addr >> s->it_shift, value, 1);
B
Blue Swirl 已提交
965 966
}

967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
static const MemoryRegionOps serial_mm_ops[3] = {
    [DEVICE_NATIVE_ENDIAN] = {
        .read = serial_mm_read,
        .write = serial_mm_write,
        .endianness = DEVICE_NATIVE_ENDIAN,
    },
    [DEVICE_LITTLE_ENDIAN] = {
        .read = serial_mm_read,
        .write = serial_mm_write,
        .endianness = DEVICE_LITTLE_ENDIAN,
    },
    [DEVICE_BIG_ENDIAN] = {
        .read = serial_mm_read,
        .write = serial_mm_write,
        .endianness = DEVICE_BIG_ENDIAN,
    },
983 984
};

985
SerialState *serial_mm_init(MemoryRegion *address_space,
A
Avi Kivity 已提交
986
                            hwaddr base, int it_shift,
987 988
                            qemu_irq irq, int baudbase,
                            CharDriverState *chr, enum device_endian end)
989 990 991
{
    SerialState *s;

992
    s = g_malloc0(sizeof(SerialState));
993

994
    s->it_shift = it_shift;
G
Gerd Hoffmann 已提交
995 996
    s->irq = irq;
    s->baudbase = baudbase;
997
    qemu_chr_fe_init(&s->chr, chr, &error_abort);
998

999
    serial_realize_core(s, &error_fatal);
A
Alex Williamson 已提交
1000
    vmstate_register(NULL, base, &vmstate_serial, s);
1001

1002
    memory_region_init_io(&s->io, NULL, &serial_mm_ops[end], s,
1003
                          "serial", 8 << it_shift);
1004
    memory_region_add_subregion(address_space, base, &s->io);
1005 1006
    return s;
}