← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/linaro/0040-serial-omap_uart-Add-support-for-fifo-level-regs.patch/hw/char/serial.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

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