← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to hw/serial.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/serial.c
1
1
/*
2
 
 * QEMU 16450 UART emulation
 
2
 * QEMU 16550A UART emulation
3
3
 *
4
4
 * Copyright (c) 2003-2004 Fabrice Bellard
 
5
 * Copyright (c) 2008 Citrix Systems, Inc.
5
6
 *
6
7
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
8
 * of this software and associated documentation files (the "Software"), to deal
25
26
#include "qemu-char.h"
26
27
#include "isa.h"
27
28
#include "pc.h"
 
29
#include "qemu-timer.h"
28
30
 
29
31
//#define DEBUG_SERIAL
30
32
 
42
44
#define UART_IIR_THRI   0x02    /* Transmitter holding register empty */
43
45
#define UART_IIR_RDI    0x04    /* Receiver data interrupt */
44
46
#define UART_IIR_RLSI   0x06    /* Receiver line status interrupt */
 
47
#define UART_IIR_CTI    0x0C    /* Character Timeout Indication */
 
48
 
 
49
#define UART_IIR_FENF   0x80    /* Fifo enabled, but not functionning */
 
50
#define UART_IIR_FE     0xC0    /* Fifo enabled */
45
51
 
46
52
/*
47
53
 * These are the definitions for the Modem Control Register
72
78
#define UART_LSR_PE     0x04    /* Parity error indicator */
73
79
#define UART_LSR_OE     0x02    /* Overrun error indicator */
74
80
#define UART_LSR_DR     0x01    /* Receiver data ready */
 
81
#define UART_LSR_INT_ANY 0x1E   /* Any of the lsr-interrupt-triggering status bits */
 
82
 
 
83
/* Interrupt trigger levels. The byte-counts are for 16550A - in newer UARTs the byte-count for each ITL is higher. */
 
84
 
 
85
#define UART_FCR_ITL_1      0x00 /* 1 byte ITL */
 
86
#define UART_FCR_ITL_2      0x40 /* 4 bytes ITL */
 
87
#define UART_FCR_ITL_3      0x80 /* 8 bytes ITL */
 
88
#define UART_FCR_ITL_4      0xC0 /* 14 bytes ITL */
 
89
 
 
90
#define UART_FCR_DMS        0x08    /* DMA Mode Select */
 
91
#define UART_FCR_XFR        0x04    /* XMIT Fifo Reset */
 
92
#define UART_FCR_RFR        0x02    /* RCVR Fifo Reset */
 
93
#define UART_FCR_FE         0x01    /* FIFO Enable */
 
94
 
 
95
#define UART_FIFO_LENGTH    16      /* 16550A Fifo Length */
 
96
 
 
97
#define XMIT_FIFO           0
 
98
#define RECV_FIFO           1
 
99
#define MAX_XMIT_RETRY      4
 
100
 
 
101
struct SerialFIFO {
 
102
    uint8_t data[UART_FIFO_LENGTH];
 
103
    uint8_t count;
 
104
    uint8_t itl;                        /* Interrupt Trigger Level */
 
105
    uint8_t tail;
 
106
    uint8_t head;
 
107
} typedef SerialFIFO;
75
108
 
76
109
struct SerialState {
77
110
    uint16_t divider;
78
111
    uint8_t rbr; /* receive register */
 
112
    uint8_t thr; /* transmit holding register */
 
113
    uint8_t tsr; /* transmit shift register */
79
114
    uint8_t ier;
80
115
    uint8_t iir; /* read only */
81
116
    uint8_t lcr;
83
118
    uint8_t lsr; /* read only */
84
119
    uint8_t msr; /* read only */
85
120
    uint8_t scr;
 
121
    uint8_t fcr;
86
122
    /* NOTE: this hidden state is necessary for tx irq generation as
87
123
       it can be reset while reading iir */
88
124
    int thr_ipending;
89
125
    qemu_irq irq;
90
126
    CharDriverState *chr;
91
127
    int last_break_enable;
92
 
    target_phys_addr_t base;
93
128
    int it_shift;
 
129
    int baudbase;
 
130
    int tsr_retry;
 
131
 
 
132
    uint64_t last_xmit_ts;              /* Time when the last byte was successfully sent out of the tsr */
 
133
    SerialFIFO recv_fifo;
 
134
    SerialFIFO xmit_fifo;
 
135
 
 
136
    struct QEMUTimer *fifo_timeout_timer;
 
137
    int timeout_ipending;                   /* timeout interrupt pending state */
 
138
    struct QEMUTimer *transmit_timer;
 
139
 
 
140
 
 
141
    uint64_t char_transmit_time;               /* time to transmit a char in ticks*/
 
142
    int poll_msl;
 
143
 
 
144
    struct QEMUTimer *modem_status_poll;
94
145
};
95
146
 
 
147
static void serial_receive1(void *opaque, const uint8_t *buf, int size);
 
148
 
 
149
static void fifo_clear(SerialState *s, int fifo)
 
150
{
 
151
    SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo;
 
152
    memset(f->data, 0, UART_FIFO_LENGTH);
 
153
    f->count = 0;
 
154
    f->head = 0;
 
155
    f->tail = 0;
 
156
}
 
157
 
 
158
static int fifo_put(SerialState *s, int fifo, uint8_t chr)
 
159
{
 
160
    SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo;
 
161
 
 
162
    f->data[f->head++] = chr;
 
163
 
 
164
    if (f->head == UART_FIFO_LENGTH)
 
165
        f->head = 0;
 
166
    f->count++;
 
167
 
 
168
    return 1;
 
169
}
 
170
 
 
171
static uint8_t fifo_get(SerialState *s, int fifo)
 
172
{
 
173
    SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo;
 
174
    uint8_t c;
 
175
 
 
176
    if(f->count == 0)
 
177
        return 0;
 
178
 
 
179
    c = f->data[f->tail++];
 
180
    if (f->tail == UART_FIFO_LENGTH)
 
181
        f->tail = 0;
 
182
    f->count--;
 
183
 
 
184
    return c;
 
185
}
 
186
 
96
187
static void serial_update_irq(SerialState *s)
97
188
{
98
 
    if ((s->lsr & UART_LSR_DR) && (s->ier & UART_IER_RDI)) {
99
 
        s->iir = UART_IIR_RDI;
100
 
    } else if (s->thr_ipending && (s->ier & UART_IER_THRI)) {
101
 
        s->iir = UART_IIR_THRI;
102
 
    } else {
103
 
        s->iir = UART_IIR_NO_INT;
 
189
    uint8_t tmp_iir = UART_IIR_NO_INT;
 
190
 
 
191
    if ((s->ier & UART_IER_RLSI) && (s->lsr & UART_LSR_INT_ANY)) {
 
192
        tmp_iir = UART_IIR_RLSI;
 
193
    } else if ((s->ier & UART_IER_RDI) && s->timeout_ipending) {
 
194
        /* Note that(s->ier & UART_IER_RDI) can mask this interrupt,
 
195
         * this is not in the specification but is observed on existing
 
196
         * hardware.  */
 
197
        tmp_iir = UART_IIR_CTI;
 
198
    } else if ((s->ier & UART_IER_RDI) && (s->lsr & UART_LSR_DR)) {
 
199
        if (!(s->fcr & UART_FCR_FE)) {
 
200
           tmp_iir = UART_IIR_RDI;
 
201
        } else if (s->recv_fifo.count >= s->recv_fifo.itl) {
 
202
           tmp_iir = UART_IIR_RDI;
 
203
        }
 
204
    } else if ((s->ier & UART_IER_THRI) && s->thr_ipending) {
 
205
        tmp_iir = UART_IIR_THRI;
 
206
    } else if ((s->ier & UART_IER_MSI) && (s->msr & UART_MSR_ANY_DELTA)) {
 
207
        tmp_iir = UART_IIR_MSI;
104
208
    }
105
 
    if (s->iir != UART_IIR_NO_INT) {
 
209
 
 
210
    s->iir = tmp_iir | (s->iir & 0xF0);
 
211
 
 
212
    if (tmp_iir != UART_IIR_NO_INT) {
106
213
        qemu_irq_raise(s->irq);
107
214
    } else {
108
215
        qemu_irq_lower(s->irq);
111
218
 
112
219
static void serial_update_parameters(SerialState *s)
113
220
{
114
 
    int speed, parity, data_bits, stop_bits;
 
221
    int speed, parity, data_bits, stop_bits, frame_size;
115
222
    QEMUSerialSetParams ssp;
116
223
 
 
224
    if (s->divider == 0)
 
225
        return;
 
226
 
 
227
    frame_size = 1;
117
228
    if (s->lcr & 0x08) {
118
229
        if (s->lcr & 0x10)
119
230
            parity = 'E';
121
232
            parity = 'O';
122
233
    } else {
123
234
            parity = 'N';
 
235
            frame_size = 0;
124
236
    }
125
237
    if (s->lcr & 0x04)
126
238
        stop_bits = 2;
127
239
    else
128
240
        stop_bits = 1;
 
241
 
129
242
    data_bits = (s->lcr & 0x03) + 5;
130
 
    if (s->divider == 0)
131
 
        return;
132
 
    speed = 115200 / s->divider;
 
243
    frame_size += data_bits + stop_bits;
 
244
    speed = s->baudbase / s->divider;
133
245
    ssp.speed = speed;
134
246
    ssp.parity = parity;
135
247
    ssp.data_bits = data_bits;
136
248
    ssp.stop_bits = stop_bits;
 
249
    s->char_transmit_time =  (ticks_per_sec / speed) * frame_size;
137
250
    qemu_chr_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
138
251
#if 0
139
252
    printf("speed=%d parity=%c data=%d stop=%d\n",
141
254
#endif
142
255
}
143
256
 
 
257
static void serial_update_msl(SerialState *s)
 
258
{
 
259
    uint8_t omsr;
 
260
    int flags;
 
261
 
 
262
    qemu_del_timer(s->modem_status_poll);
 
263
 
 
264
    if (qemu_chr_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &flags) == -ENOTSUP) {
 
265
        s->poll_msl = -1;
 
266
        return;
 
267
    }
 
268
 
 
269
    omsr = s->msr;
 
270
 
 
271
    s->msr = (flags & CHR_TIOCM_CTS) ? s->msr | UART_MSR_CTS : s->msr & ~UART_MSR_CTS;
 
272
    s->msr = (flags & CHR_TIOCM_DSR) ? s->msr | UART_MSR_DSR : s->msr & ~UART_MSR_DSR;
 
273
    s->msr = (flags & CHR_TIOCM_CAR) ? s->msr | UART_MSR_DCD : s->msr & ~UART_MSR_DCD;
 
274
    s->msr = (flags & CHR_TIOCM_RI) ? s->msr | UART_MSR_RI : s->msr & ~UART_MSR_RI;
 
275
 
 
276
    if (s->msr != omsr) {
 
277
         /* Set delta bits */
 
278
         s->msr = s->msr | ((s->msr >> 4) ^ (omsr >> 4));
 
279
         /* UART_MSR_TERI only if change was from 1 -> 0 */
 
280
         if ((s->msr & UART_MSR_TERI) && !(omsr & UART_MSR_RI))
 
281
             s->msr &= ~UART_MSR_TERI;
 
282
         serial_update_irq(s);
 
283
    }
 
284
 
 
285
    /* The real 16550A apparently has a 250ns response latency to line status changes.
 
286
       We'll be lazy and poll only every 10ms, and only poll it at all if MSI interrupts are turned on */
 
287
 
 
288
    if (s->poll_msl)
 
289
        qemu_mod_timer(s->modem_status_poll, qemu_get_clock(vm_clock) + ticks_per_sec / 100);
 
290
}
 
291
 
 
292
static void serial_xmit(void *opaque)
 
293
{
 
294
    SerialState *s = opaque;
 
295
    uint64_t new_xmit_ts = qemu_get_clock(vm_clock);
 
296
 
 
297
    if (s->tsr_retry <= 0) {
 
298
        if (s->fcr & UART_FCR_FE) {
 
299
            s->tsr = fifo_get(s,XMIT_FIFO);
 
300
            if (!s->xmit_fifo.count)
 
301
                s->lsr |= UART_LSR_THRE;
 
302
        } else {
 
303
            s->tsr = s->thr;
 
304
            s->lsr |= UART_LSR_THRE;
 
305
        }
 
306
    }
 
307
 
 
308
    if (s->mcr & UART_MCR_LOOP) {
 
309
        /* in loopback mode, say that we just received a char */
 
310
        serial_receive1(s, &s->tsr, 1);
 
311
    } else if (qemu_chr_write(s->chr, &s->tsr, 1) != 1) {
 
312
        if ((s->tsr_retry > 0) && (s->tsr_retry <= MAX_XMIT_RETRY)) {
 
313
            s->tsr_retry++;
 
314
            qemu_mod_timer(s->transmit_timer,  new_xmit_ts + s->char_transmit_time);
 
315
            return;
 
316
        } else if (s->poll_msl < 0) {
 
317
            /* If we exceed MAX_XMIT_RETRY and the backend is not a real serial port, then
 
318
            drop any further failed writes instantly, until we get one that goes through.
 
319
            This is to prevent guests that log to unconnected pipes or pty's from stalling. */
 
320
            s->tsr_retry = -1;
 
321
        }
 
322
    }
 
323
    else {
 
324
        s->tsr_retry = 0;
 
325
    }
 
326
 
 
327
    s->last_xmit_ts = qemu_get_clock(vm_clock);
 
328
    if (!(s->lsr & UART_LSR_THRE))
 
329
        qemu_mod_timer(s->transmit_timer, s->last_xmit_ts + s->char_transmit_time);
 
330
 
 
331
    if (s->lsr & UART_LSR_THRE) {
 
332
        s->lsr |= UART_LSR_TEMT;
 
333
        s->thr_ipending = 1;
 
334
        serial_update_irq(s);
 
335
    }
 
336
}
 
337
 
 
338
 
144
339
static void serial_ioport_write(void *opaque, uint32_t addr, uint32_t val)
145
340
{
146
341
    SerialState *s = opaque;
147
 
    unsigned char ch;
148
342
 
149
343
    addr &= 7;
150
344
#ifdef DEBUG_SERIAL
157
351
            s->divider = (s->divider & 0xff00) | val;
158
352
            serial_update_parameters(s);
159
353
        } else {
 
354
            s->thr = (uint8_t) val;
 
355
            if(s->fcr & UART_FCR_FE) {
 
356
                  fifo_put(s, XMIT_FIFO, s->thr);
160
357
            s->thr_ipending = 0;
 
358
                  s->lsr &= ~UART_LSR_TEMT;
161
359
            s->lsr &= ~UART_LSR_THRE;
162
360
            serial_update_irq(s);
163
 
            ch = val;
164
 
            qemu_chr_write(s->chr, &ch, 1);
165
 
            s->thr_ipending = 1;
166
 
            s->lsr |= UART_LSR_THRE;
167
 
            s->lsr |= UART_LSR_TEMT;
168
 
            serial_update_irq(s);
 
361
            } else {
 
362
                  s->thr_ipending = 0;
 
363
                  s->lsr &= ~UART_LSR_THRE;
 
364
                  serial_update_irq(s);
 
365
            }
 
366
            serial_xmit(s);
169
367
        }
170
368
        break;
171
369
    case 1:
174
372
            serial_update_parameters(s);
175
373
        } else {
176
374
            s->ier = val & 0x0f;
 
375
            /* If the backend device is a real serial port, turn polling of the modem
 
376
               status lines on physical port on or off depending on UART_IER_MSI state */
 
377
            if (s->poll_msl >= 0) {
 
378
                if (s->ier & UART_IER_MSI) {
 
379
                     s->poll_msl = 1;
 
380
                     serial_update_msl(s);
 
381
                } else {
 
382
                     qemu_del_timer(s->modem_status_poll);
 
383
                     s->poll_msl = 0;
 
384
                }
 
385
            }
177
386
            if (s->lsr & UART_LSR_THRE) {
178
387
                s->thr_ipending = 1;
 
388
                serial_update_irq(s);
179
389
            }
180
 
            serial_update_irq(s);
181
390
        }
182
391
        break;
183
392
    case 2:
 
393
        val = val & 0xFF;
 
394
 
 
395
        if (s->fcr == val)
 
396
            break;
 
397
 
 
398
        /* Did the enable/disable flag change? If so, make sure FIFOs get flushed */
 
399
        if ((val ^ s->fcr) & UART_FCR_FE)
 
400
            val |= UART_FCR_XFR | UART_FCR_RFR;
 
401
 
 
402
        /* FIFO clear */
 
403
 
 
404
        if (val & UART_FCR_RFR) {
 
405
            qemu_del_timer(s->fifo_timeout_timer);
 
406
            s->timeout_ipending=0;
 
407
            fifo_clear(s,RECV_FIFO);
 
408
        }
 
409
 
 
410
        if (val & UART_FCR_XFR) {
 
411
            fifo_clear(s,XMIT_FIFO);
 
412
        }
 
413
 
 
414
        if (val & UART_FCR_FE) {
 
415
            s->iir |= UART_IIR_FE;
 
416
            /* Set RECV_FIFO trigger Level */
 
417
            switch (val & 0xC0) {
 
418
            case UART_FCR_ITL_1:
 
419
                s->recv_fifo.itl = 1;
 
420
                break;
 
421
            case UART_FCR_ITL_2:
 
422
                s->recv_fifo.itl = 4;
 
423
                break;
 
424
            case UART_FCR_ITL_3:
 
425
                s->recv_fifo.itl = 8;
 
426
                break;
 
427
            case UART_FCR_ITL_4:
 
428
                s->recv_fifo.itl = 14;
 
429
                break;
 
430
            }
 
431
        } else
 
432
            s->iir &= ~UART_IIR_FE;
 
433
 
 
434
        /* Set fcr - or at least the bits in it that are supposed to "stick" */
 
435
        s->fcr = val & 0xC9;
 
436
        serial_update_irq(s);
184
437
        break;
185
438
    case 3:
186
439
        {
196
449
        }
197
450
        break;
198
451
    case 4:
199
 
        s->mcr = val & 0x1f;
 
452
        {
 
453
            int flags;
 
454
            int old_mcr = s->mcr;
 
455
            s->mcr = val & 0x1f;
 
456
            if (val & UART_MCR_LOOP)
 
457
                break;
 
458
 
 
459
            if (s->poll_msl >= 0 && old_mcr != s->mcr) {
 
460
 
 
461
                qemu_chr_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &flags);
 
462
 
 
463
                flags &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);
 
464
 
 
465
                if (val & UART_MCR_RTS)
 
466
                    flags |= CHR_TIOCM_RTS;
 
467
                if (val & UART_MCR_DTR)
 
468
                    flags |= CHR_TIOCM_DTR;
 
469
 
 
470
                qemu_chr_ioctl(s->chr,CHR_IOCTL_SERIAL_SET_TIOCM, &flags);
 
471
                /* Update the modem status after a one-character-send wait-time, since there may be a response
 
472
                   from the device/computer at the other end of the serial line */
 
473
                qemu_mod_timer(s->modem_status_poll, qemu_get_clock(vm_clock) + s->char_transmit_time);
 
474
            }
 
475
        }
200
476
        break;
201
477
    case 5:
202
478
        break;
220
496
        if (s->lcr & UART_LCR_DLAB) {
221
497
            ret = s->divider & 0xff;
222
498
        } else {
223
 
            ret = s->rbr;
224
 
            s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
 
499
            if(s->fcr & UART_FCR_FE) {
 
500
                ret = fifo_get(s,RECV_FIFO);
 
501
                if (s->recv_fifo.count == 0)
 
502
                    s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
 
503
                else
 
504
                    qemu_mod_timer(s->fifo_timeout_timer, qemu_get_clock (vm_clock) + s->char_transmit_time * 4);
 
505
                s->timeout_ipending = 0;
 
506
            } else {
 
507
                ret = s->rbr;
 
508
                s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
 
509
            }
225
510
            serial_update_irq(s);
226
 
            qemu_chr_accept_input(s->chr);
 
511
            if (!(s->mcr & UART_MCR_LOOP)) {
 
512
                /* in loopback mode, don't receive any data */
 
513
                qemu_chr_accept_input(s->chr);
 
514
            }
227
515
        }
228
516
        break;
229
517
    case 1:
235
523
        break;
236
524
    case 2:
237
525
        ret = s->iir;
238
 
        /* reset THR pending bit */
239
 
        if ((ret & 0x7) == UART_IIR_THRI)
240
526
            s->thr_ipending = 0;
241
527
        serial_update_irq(s);
242
528
        break;
248
534
        break;
249
535
    case 5:
250
536
        ret = s->lsr;
 
537
        /* Clear break interrupt */
 
538
        if (s->lsr & UART_LSR_BI) {
 
539
            s->lsr &= ~UART_LSR_BI;
 
540
            serial_update_irq(s);
 
541
        }
251
542
        break;
252
543
    case 6:
253
544
        if (s->mcr & UART_MCR_LOOP) {
257
548
            ret |= (s->mcr & 0x02) << 3;
258
549
            ret |= (s->mcr & 0x01) << 5;
259
550
        } else {
 
551
            if (s->poll_msl >= 0)
 
552
                serial_update_msl(s);
260
553
            ret = s->msr;
 
554
            /* Clear delta bits & msr int after read, if they were set */
 
555
            if (s->msr & UART_MSR_ANY_DELTA) {
 
556
                s->msr &= 0xF0;
 
557
                serial_update_irq(s);
 
558
            }
261
559
        }
262
560
        break;
263
561
    case 7:
272
570
 
273
571
static int serial_can_receive(SerialState *s)
274
572
{
 
573
    if(s->fcr & UART_FCR_FE) {
 
574
        if(s->recv_fifo.count < UART_FIFO_LENGTH)
 
575
        /* Advertise (fifo.itl - fifo.count) bytes when count < ITL, and 1 if above. If UART_FIFO_LENGTH - fifo.count is
 
576
        advertised the effect will be to almost always fill the fifo completely before the guest has a chance to respond,
 
577
        effectively overriding the ITL that the guest has set. */
 
578
             return (s->recv_fifo.count <= s->recv_fifo.itl) ? s->recv_fifo.itl - s->recv_fifo.count : 1;
 
579
        else
 
580
             return 0;
 
581
    } else {
275
582
    return !(s->lsr & UART_LSR_DR);
276
 
}
277
 
 
278
 
static void serial_receive_byte(SerialState *s, int ch)
279
 
{
280
 
    s->rbr = ch;
281
 
    s->lsr |= UART_LSR_DR;
282
 
    serial_update_irq(s);
 
583
    }
283
584
}
284
585
 
285
586
static void serial_receive_break(SerialState *s)
289
590
    serial_update_irq(s);
290
591
}
291
592
 
 
593
/* There's data in recv_fifo and s->rbr has not been read for 4 char transmit times */
 
594
static void fifo_timeout_int (void *opaque) {
 
595
    SerialState *s = opaque;
 
596
    if (s->recv_fifo.count) {
 
597
        s->timeout_ipending = 1;
 
598
        serial_update_irq(s);
 
599
    }
 
600
}
 
601
 
292
602
static int serial_can_receive1(void *opaque)
293
603
{
294
604
    SerialState *s = opaque;
298
608
static void serial_receive1(void *opaque, const uint8_t *buf, int size)
299
609
{
300
610
    SerialState *s = opaque;
301
 
    serial_receive_byte(s, buf[0]);
 
611
    if(s->fcr & UART_FCR_FE) {
 
612
        int i;
 
613
        for (i = 0; i < size; i++) {
 
614
            fifo_put(s, RECV_FIFO, buf[i]);
 
615
        }
 
616
        s->lsr |= UART_LSR_DR;
 
617
        /* call the timeout receive callback in 4 char transmit time */
 
618
        qemu_mod_timer(s->fifo_timeout_timer, qemu_get_clock (vm_clock) + s->char_transmit_time * 4);
 
619
    } else {
 
620
        s->rbr = buf[0];
 
621
        s->lsr |= UART_LSR_DR;
 
622
    }
 
623
    serial_update_irq(s);
302
624
}
303
625
 
304
626
static void serial_event(void *opaque, int event)
305
627
{
306
628
    SerialState *s = opaque;
 
629
#ifdef DEBUG_SERIAL
 
630
    printf("serial: event %x\n", event);
 
631
#endif
307
632
    if (event == CHR_EVENT_BREAK)
308
633
        serial_receive_break(s);
309
634
}
321
646
    qemu_put_8s(f,&s->lsr);
322
647
    qemu_put_8s(f,&s->msr);
323
648
    qemu_put_8s(f,&s->scr);
 
649
    qemu_put_8s(f,&s->fcr);
324
650
}
325
651
 
326
652
static int serial_load(QEMUFile *f, void *opaque, int version_id)
327
653
{
328
654
    SerialState *s = opaque;
 
655
    uint8_t fcr = 0;
329
656
 
330
 
    if(version_id > 2)
 
657
    if(version_id > 3)
331
658
        return -EINVAL;
332
659
 
333
660
    if (version_id >= 2)
343
670
    qemu_get_8s(f,&s->msr);
344
671
    qemu_get_8s(f,&s->scr);
345
672
 
 
673
    if (version_id >= 3)
 
674
        qemu_get_8s(f,&fcr);
 
675
 
 
676
    /* Initialize fcr via setter to perform essential side-effects */
 
677
    serial_ioport_write(s, 0x02, fcr);
346
678
    return 0;
347
679
}
348
680
 
 
681
static void serial_reset(void *opaque)
 
682
{
 
683
    SerialState *s = opaque;
 
684
 
 
685
    s->rbr = 0;
 
686
    s->ier = 0;
 
687
    s->iir = UART_IIR_NO_INT;
 
688
    s->lcr = 0;
 
689
    s->lsr = UART_LSR_TEMT | UART_LSR_THRE;
 
690
    s->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
 
691
    /* Default to 9600 baud, no parity, one stop bit */
 
692
    s->divider = 0x0C;
 
693
    s->mcr = UART_MCR_OUT2;
 
694
    s->scr = 0;
 
695
    s->tsr_retry = 0;
 
696
    s->char_transmit_time = (ticks_per_sec / 9600) * 9;
 
697
    s->poll_msl = 0;
 
698
 
 
699
    fifo_clear(s,RECV_FIFO);
 
700
    fifo_clear(s,XMIT_FIFO);
 
701
 
 
702
    s->last_xmit_ts = qemu_get_clock(vm_clock);
 
703
 
 
704
    s->thr_ipending = 0;
 
705
    s->last_break_enable = 0;
 
706
    qemu_irq_lower(s->irq);
 
707
}
 
708
 
 
709
static void serial_init_core(SerialState *s, qemu_irq irq, int baudbase,
 
710
                             CharDriverState *chr)
 
711
{
 
712
    s->irq = irq;
 
713
    s->baudbase = baudbase;
 
714
    s->chr = chr ?: qemu_chr_open("null", "null", NULL);
 
715
 
 
716
    s->modem_status_poll = qemu_new_timer(vm_clock, (QEMUTimerCB *) serial_update_msl, s);
 
717
 
 
718
    s->fifo_timeout_timer = qemu_new_timer(vm_clock, (QEMUTimerCB *) fifo_timeout_int, s);
 
719
    s->transmit_timer = qemu_new_timer(vm_clock, (QEMUTimerCB *) serial_xmit, s);
 
720
 
 
721
    qemu_register_reset(serial_reset, s);
 
722
    serial_reset(s);
 
723
 
 
724
    qemu_chr_add_handlers(s->chr, serial_can_receive1, serial_receive1,
 
725
                          serial_event, s);
 
726
}
 
727
 
349
728
/* If fd is zero, it means that the serial device uses the console */
350
 
SerialState *serial_init(int base, qemu_irq irq, CharDriverState *chr)
 
729
SerialState *serial_init(int base, qemu_irq irq, int baudbase,
 
730
                         CharDriverState *chr)
351
731
{
352
732
    SerialState *s;
353
733
 
354
734
    s = qemu_mallocz(sizeof(SerialState));
355
 
    if (!s)
356
 
        return NULL;
357
 
    s->irq = irq;
358
 
    s->lsr = UART_LSR_TEMT | UART_LSR_THRE;
359
 
    s->iir = UART_IIR_NO_INT;
360
 
    s->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
361
 
 
362
 
    register_savevm("serial", base, 2, serial_save, serial_load, s);
 
735
 
 
736
    serial_init_core(s, irq, baudbase, chr);
 
737
 
 
738
    register_savevm("serial", base, 3, serial_save, serial_load, s);
363
739
 
364
740
    register_ioport_write(base, 8, 1, serial_ioport_write, s);
365
741
    register_ioport_read(base, 8, 1, serial_ioport_read, s);
366
 
    s->chr = chr;
367
 
    qemu_chr_add_handlers(chr, serial_can_receive1, serial_receive1,
368
 
                          serial_event, s);
369
742
    return s;
370
743
}
371
744
 
374
747
{
375
748
    SerialState *s = opaque;
376
749
 
377
 
    return serial_ioport_read(s, (addr - s->base) >> s->it_shift) & 0xFF;
 
750
    return serial_ioport_read(s, addr >> s->it_shift) & 0xFF;
378
751
}
379
752
 
380
753
void serial_mm_writeb (void *opaque,
382
755
{
383
756
    SerialState *s = opaque;
384
757
 
385
 
    serial_ioport_write(s, (addr - s->base) >> s->it_shift, value & 0xFF);
 
758
    serial_ioport_write(s, addr >> s->it_shift, value & 0xFF);
386
759
}
387
760
 
388
761
uint32_t serial_mm_readw (void *opaque, target_phys_addr_t addr)
390
763
    SerialState *s = opaque;
391
764
    uint32_t val;
392
765
 
393
 
    val = serial_ioport_read(s, (addr - s->base) >> s->it_shift) & 0xFFFF;
 
766
    val = serial_ioport_read(s, addr >> s->it_shift) & 0xFFFF;
394
767
#ifdef TARGET_WORDS_BIGENDIAN
395
768
    val = bswap16(val);
396
769
#endif
404
777
#ifdef TARGET_WORDS_BIGENDIAN
405
778
    value = bswap16(value);
406
779
#endif
407
 
    serial_ioport_write(s, (addr - s->base) >> s->it_shift, value & 0xFFFF);
 
780
    serial_ioport_write(s, addr >> s->it_shift, value & 0xFFFF);
408
781
}
409
782
 
410
783
uint32_t serial_mm_readl (void *opaque, target_phys_addr_t addr)
412
785
    SerialState *s = opaque;
413
786
    uint32_t val;
414
787
 
415
 
    val = serial_ioport_read(s, (addr - s->base) >> s->it_shift);
 
788
    val = serial_ioport_read(s, addr >> s->it_shift);
416
789
#ifdef TARGET_WORDS_BIGENDIAN
417
790
    val = bswap32(val);
418
791
#endif
426
799
#ifdef TARGET_WORDS_BIGENDIAN
427
800
    value = bswap32(value);
428
801
#endif
429
 
    serial_ioport_write(s, (addr - s->base) >> s->it_shift, value);
 
802
    serial_ioport_write(s, addr >> s->it_shift, value);
430
803
}
431
804
 
432
805
static CPUReadMemoryFunc *serial_mm_read[] = {
442
815
};
443
816
 
444
817
SerialState *serial_mm_init (target_phys_addr_t base, int it_shift,
445
 
                             qemu_irq irq, CharDriverState *chr,
446
 
                             int ioregister)
 
818
                             qemu_irq irq, int baudbase,
 
819
                             CharDriverState *chr, int ioregister)
447
820
{
448
821
    SerialState *s;
449
822
    int s_io_memory;
450
823
 
451
824
    s = qemu_mallocz(sizeof(SerialState));
452
 
    if (!s)
453
 
        return NULL;
454
 
    s->irq = irq;
455
 
    s->lsr = UART_LSR_TEMT | UART_LSR_THRE;
456
 
    s->iir = UART_IIR_NO_INT;
457
 
    s->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
458
 
    s->base = base;
 
825
 
459
826
    s->it_shift = it_shift;
460
827
 
461
 
    register_savevm("serial", base, 2, serial_save, serial_load, s);
 
828
    serial_init_core(s, irq, baudbase, chr);
 
829
    register_savevm("serial", base, 3, serial_save, serial_load, s);
462
830
 
463
831
    if (ioregister) {
464
832
        s_io_memory = cpu_register_io_memory(0, serial_mm_read,
465
833
                                             serial_mm_write, s);
466
834
        cpu_register_physical_memory(base, 8 << it_shift, s_io_memory);
467
835
    }
468
 
    s->chr = chr;
469
 
    qemu_chr_add_handlers(chr, serial_can_receive1, serial_receive1,
470
 
                          serial_event, s);
 
836
    serial_update_msl(s);
471
837
    return s;
472
838
}