2 * Exynos4210 UART Emulation
4 * Copyright (C) 2011 Samsung Electronics Co Ltd.
5 * Maksim Kozlov, <m.kozlov@samsung.com>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, see <http://www.gnu.org/licenses/>.
22 #include "qemu/osdep.h"
23 #include "hw/sysbus.h"
24 #include "migration/vmstate.h"
25 #include "qapi/error.h"
26 #include "qemu/error-report.h"
27 #include "qemu/module.h"
28 #include "qemu/timer.h"
29 #include "chardev/char-fe.h"
30 #include "chardev/char-serial.h"
32 #include "hw/arm/exynos4210.h"
34 #include "hw/qdev-properties.h"
37 #include "qom/object.h"
40 * Offsets for UART registers relative to SFR base address
44 #define ULCON 0x0000 /* Line Control */
45 #define UCON 0x0004 /* Control */
46 #define UFCON 0x0008 /* FIFO Control */
47 #define UMCON 0x000C /* Modem Control */
48 #define UTRSTAT 0x0010 /* Tx/Rx Status */
49 #define UERSTAT 0x0014 /* UART Error Status */
50 #define UFSTAT 0x0018 /* FIFO Status */
51 #define UMSTAT 0x001C /* Modem Status */
52 #define UTXH 0x0020 /* Transmit Buffer */
53 #define URXH 0x0024 /* Receive Buffer */
54 #define UBRDIV 0x0028 /* Baud Rate Divisor */
55 #define UFRACVAL 0x002C /* Divisor Fractional Value */
56 #define UINTP 0x0030 /* Interrupt Pending */
57 #define UINTSP 0x0034 /* Interrupt Source Pending */
58 #define UINTM 0x0038 /* Interrupt Mask */
61 * for indexing register in the uint32_t array
63 * 'reg' - register offset (see offsets definitions above)
66 #define I_(reg) (reg / sizeof(uint32_t))
68 typedef struct Exynos4210UartReg
{
69 const char *name
; /* the only reason is the debug output */
74 static const Exynos4210UartReg exynos4210_uart_regs
[] = {
75 {"ULCON", ULCON
, 0x00000000},
76 {"UCON", UCON
, 0x00003000},
77 {"UFCON", UFCON
, 0x00000000},
78 {"UMCON", UMCON
, 0x00000000},
79 {"UTRSTAT", UTRSTAT
, 0x00000006}, /* RO */
80 {"UERSTAT", UERSTAT
, 0x00000000}, /* RO */
81 {"UFSTAT", UFSTAT
, 0x00000000}, /* RO */
82 {"UMSTAT", UMSTAT
, 0x00000000}, /* RO */
83 {"UTXH", UTXH
, 0x5c5c5c5c}, /* WO, undefined reset value*/
84 {"URXH", URXH
, 0x00000000}, /* RO */
85 {"UBRDIV", UBRDIV
, 0x00000000},
86 {"UFRACVAL", UFRACVAL
, 0x00000000},
87 {"UINTP", UINTP
, 0x00000000},
88 {"UINTSP", UINTSP
, 0x00000000},
89 {"UINTM", UINTM
, 0x00000000},
92 #define EXYNOS4210_UART_REGS_MEM_SIZE 0x3C
94 /* UART FIFO Control */
95 #define UFCON_FIFO_ENABLE 0x1
96 #define UFCON_Rx_FIFO_RESET 0x2
97 #define UFCON_Tx_FIFO_RESET 0x4
98 #define UFCON_Tx_FIFO_TRIGGER_LEVEL_SHIFT 8
99 #define UFCON_Tx_FIFO_TRIGGER_LEVEL (7 << UFCON_Tx_FIFO_TRIGGER_LEVEL_SHIFT)
100 #define UFCON_Rx_FIFO_TRIGGER_LEVEL_SHIFT 4
101 #define UFCON_Rx_FIFO_TRIGGER_LEVEL (7 << UFCON_Rx_FIFO_TRIGGER_LEVEL_SHIFT)
103 /* Uart FIFO Status */
104 #define UFSTAT_Rx_FIFO_COUNT 0xff
105 #define UFSTAT_Rx_FIFO_FULL 0x100
106 #define UFSTAT_Rx_FIFO_ERROR 0x200
107 #define UFSTAT_Tx_FIFO_COUNT_SHIFT 16
108 #define UFSTAT_Tx_FIFO_COUNT (0xff << UFSTAT_Tx_FIFO_COUNT_SHIFT)
109 #define UFSTAT_Tx_FIFO_FULL_SHIFT 24
110 #define UFSTAT_Tx_FIFO_FULL (1 << UFSTAT_Tx_FIFO_FULL_SHIFT)
112 /* UART Interrupt Source Pending */
113 #define UINTSP_RXD 0x1 /* Receive interrupt */
114 #define UINTSP_ERROR 0x2 /* Error interrupt */
115 #define UINTSP_TXD 0x4 /* Transmit interrupt */
116 #define UINTSP_MODEM 0x8 /* Modem interrupt */
118 /* UART Line Control */
119 #define ULCON_IR_MODE_SHIFT 6
120 #define ULCON_PARITY_SHIFT 3
121 #define ULCON_STOP_BIT_SHIFT 1
123 /* UART Tx/Rx Status */
124 #define UTRSTAT_Rx_TIMEOUT 0x8
125 #define UTRSTAT_TRANSMITTER_EMPTY 0x4
126 #define UTRSTAT_Tx_BUFFER_EMPTY 0x2
127 #define UTRSTAT_Rx_BUFFER_DATA_READY 0x1
129 /* UART Error Status */
130 #define UERSTAT_OVERRUN 0x1
131 #define UERSTAT_PARITY 0x2
132 #define UERSTAT_FRAME 0x4
133 #define UERSTAT_BREAK 0x8
137 uint32_t sp
, rp
; /* store and retrieve pointers */
139 } Exynos4210UartFIFO
;
141 #define TYPE_EXYNOS4210_UART "exynos4210.uart"
142 typedef struct Exynos4210UartState Exynos4210UartState
;
143 DECLARE_INSTANCE_CHECKER(Exynos4210UartState
, EXYNOS4210_UART
,
144 TYPE_EXYNOS4210_UART
)
146 struct Exynos4210UartState
{
147 SysBusDevice parent_obj
;
151 uint32_t reg
[EXYNOS4210_UART_REGS_MEM_SIZE
/ sizeof(uint32_t)];
152 Exynos4210UartFIFO rx
;
153 Exynos4210UartFIFO tx
;
155 QEMUTimer
*fifo_timeout_timer
;
156 uint64_t wordtime
; /* word time in ns */
167 /* Used only for tracing */
168 static const char *exynos4210_uart_regname(hwaddr offset
)
173 for (i
= 0; i
< ARRAY_SIZE(exynos4210_uart_regs
); i
++) {
174 if (offset
== exynos4210_uart_regs
[i
].offset
) {
175 return exynos4210_uart_regs
[i
].name
;
183 static void fifo_store(Exynos4210UartFIFO
*q
, uint8_t ch
)
186 q
->sp
= (q
->sp
+ 1) % q
->size
;
189 static uint8_t fifo_retrieve(Exynos4210UartFIFO
*q
)
191 uint8_t ret
= q
->data
[q
->rp
];
192 q
->rp
= (q
->rp
+ 1) % q
->size
;
196 static int fifo_elements_number(const Exynos4210UartFIFO
*q
)
199 return q
->size
- q
->rp
+ q
->sp
;
202 return q
->sp
- q
->rp
;
205 static int fifo_empty_elements_number(const Exynos4210UartFIFO
*q
)
207 return q
->size
- fifo_elements_number(q
);
210 static void fifo_reset(Exynos4210UartFIFO
*q
)
215 q
->data
= (uint8_t *)g_malloc0(q
->size
);
221 static uint32_t exynos4210_uart_FIFO_trigger_level(uint32_t channel
,
240 trace_exynos_uart_channel_error(channel
);
247 exynos4210_uart_Tx_FIFO_trigger_level(const Exynos4210UartState
*s
)
251 reg
= (s
->reg
[I_(UFCON
)] & UFCON_Tx_FIFO_TRIGGER_LEVEL
) >>
252 UFCON_Tx_FIFO_TRIGGER_LEVEL_SHIFT
;
254 return exynos4210_uart_FIFO_trigger_level(s
->channel
, reg
);
258 exynos4210_uart_Rx_FIFO_trigger_level(const Exynos4210UartState
*s
)
262 reg
= ((s
->reg
[I_(UFCON
)] & UFCON_Rx_FIFO_TRIGGER_LEVEL
) >>
263 UFCON_Rx_FIFO_TRIGGER_LEVEL_SHIFT
) + 1;
265 return exynos4210_uart_FIFO_trigger_level(s
->channel
, reg
);
269 * Update Rx DMA busy signal if Rx DMA is enabled. For simplicity,
270 * mark DMA as busy if DMA is enabled and the receive buffer is empty.
272 static void exynos4210_uart_update_dmabusy(Exynos4210UartState
*s
)
274 bool rx_dma_enabled
= (s
->reg
[I_(UCON
)] & 0x03) == 0x02;
275 uint32_t count
= fifo_elements_number(&s
->rx
);
277 if (rx_dma_enabled
&& !count
) {
278 qemu_irq_raise(s
->dmairq
);
279 trace_exynos_uart_dmabusy(s
->channel
);
281 qemu_irq_lower(s
->dmairq
);
282 trace_exynos_uart_dmaready(s
->channel
);
286 static void exynos4210_uart_update_irq(Exynos4210UartState
*s
)
289 * The Tx interrupt is always requested if the number of data in the
290 * transmit FIFO is smaller than the trigger level.
292 if (s
->reg
[I_(UFCON
)] & UFCON_FIFO_ENABLE
) {
293 uint32_t count
= (s
->reg
[I_(UFSTAT
)] & UFSTAT_Tx_FIFO_COUNT
) >>
294 UFSTAT_Tx_FIFO_COUNT_SHIFT
;
296 if (count
<= exynos4210_uart_Tx_FIFO_trigger_level(s
)) {
297 s
->reg
[I_(UINTSP
)] |= UINTSP_TXD
;
301 * Rx interrupt if trigger level is reached or if rx timeout
302 * interrupt is disabled and there is data in the receive buffer
304 count
= fifo_elements_number(&s
->rx
);
305 if ((count
&& !(s
->reg
[I_(UCON
)] & 0x80)) ||
306 count
>= exynos4210_uart_Rx_FIFO_trigger_level(s
)) {
307 exynos4210_uart_update_dmabusy(s
);
308 s
->reg
[I_(UINTSP
)] |= UINTSP_RXD
;
309 timer_del(s
->fifo_timeout_timer
);
311 } else if (s
->reg
[I_(UTRSTAT
)] & UTRSTAT_Rx_BUFFER_DATA_READY
) {
312 exynos4210_uart_update_dmabusy(s
);
313 s
->reg
[I_(UINTSP
)] |= UINTSP_RXD
;
316 s
->reg
[I_(UINTP
)] = s
->reg
[I_(UINTSP
)] & ~s
->reg
[I_(UINTM
)];
318 if (s
->reg
[I_(UINTP
)]) {
319 qemu_irq_raise(s
->irq
);
320 trace_exynos_uart_irq_raised(s
->channel
, s
->reg
[I_(UINTP
)]);
322 qemu_irq_lower(s
->irq
);
323 trace_exynos_uart_irq_lowered(s
->channel
);
327 static void exynos4210_uart_timeout_int(void *opaque
)
329 Exynos4210UartState
*s
= opaque
;
331 trace_exynos_uart_rx_timeout(s
->channel
, s
->reg
[I_(UTRSTAT
)],
334 if ((s
->reg
[I_(UTRSTAT
)] & UTRSTAT_Rx_BUFFER_DATA_READY
) ||
335 (s
->reg
[I_(UCON
)] & (1 << 11))) {
336 s
->reg
[I_(UINTSP
)] |= UINTSP_RXD
;
337 s
->reg
[I_(UTRSTAT
)] |= UTRSTAT_Rx_TIMEOUT
;
338 exynos4210_uart_update_dmabusy(s
);
339 exynos4210_uart_update_irq(s
);
343 static void exynos4210_uart_update_parameters(Exynos4210UartState
*s
)
345 int speed
, parity
, data_bits
, stop_bits
;
346 QEMUSerialSetParams ssp
;
349 if (s
->reg
[I_(UBRDIV
)] == 0) {
353 if (s
->reg
[I_(ULCON
)] & 0x20) {
354 if (s
->reg
[I_(ULCON
)] & 0x28) {
363 if (s
->reg
[I_(ULCON
)] & 0x4) {
369 data_bits
= (s
->reg
[I_(ULCON
)] & 0x3) + 5;
371 uclk_rate
= 24000000;
373 speed
= uclk_rate
/ ((16 * (s
->reg
[I_(UBRDIV
)]) & 0xffff) +
374 (s
->reg
[I_(UFRACVAL
)] & 0x7) + 16);
378 ssp
.data_bits
= data_bits
;
379 ssp
.stop_bits
= stop_bits
;
381 s
->wordtime
= NANOSECONDS_PER_SECOND
* (data_bits
+ stop_bits
+ 1) / speed
;
383 qemu_chr_fe_ioctl(&s
->chr
, CHR_IOCTL_SERIAL_SET_PARAMS
, &ssp
);
385 trace_exynos_uart_update_params(
386 s
->channel
, speed
, parity
, data_bits
, stop_bits
, s
->wordtime
);
389 static void exynos4210_uart_rx_timeout_set(Exynos4210UartState
*s
)
391 if (s
->reg
[I_(UCON
)] & 0x80) {
392 uint32_t timeout
= ((s
->reg
[I_(UCON
)] >> 12) & 0x0f) * s
->wordtime
;
394 timer_mod(s
->fifo_timeout_timer
,
395 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + timeout
);
397 timer_del(s
->fifo_timeout_timer
);
401 static void exynos4210_uart_write(void *opaque
, hwaddr offset
,
402 uint64_t val
, unsigned size
)
404 Exynos4210UartState
*s
= (Exynos4210UartState
*)opaque
;
407 trace_exynos_uart_write(s
->channel
, offset
,
408 exynos4210_uart_regname(offset
), val
);
414 s
->reg
[I_(offset
)] = val
;
415 exynos4210_uart_update_parameters(s
);
418 s
->reg
[I_(UFCON
)] = val
;
419 if (val
& UFCON_Rx_FIFO_RESET
) {
421 s
->reg
[I_(UFCON
)] &= ~UFCON_Rx_FIFO_RESET
;
422 trace_exynos_uart_rx_fifo_reset(s
->channel
);
424 if (val
& UFCON_Tx_FIFO_RESET
) {
426 s
->reg
[I_(UFCON
)] &= ~UFCON_Tx_FIFO_RESET
;
427 trace_exynos_uart_tx_fifo_reset(s
->channel
);
432 if (qemu_chr_fe_backend_connected(&s
->chr
)) {
433 s
->reg
[I_(UTRSTAT
)] &= ~(UTRSTAT_TRANSMITTER_EMPTY
|
434 UTRSTAT_Tx_BUFFER_EMPTY
);
436 /* XXX this blocks entire thread. Rewrite to use
437 * qemu_chr_fe_write and background I/O callbacks */
438 qemu_chr_fe_write_all(&s
->chr
, &ch
, 1);
439 trace_exynos_uart_tx(s
->channel
, ch
);
440 s
->reg
[I_(UTRSTAT
)] |= UTRSTAT_TRANSMITTER_EMPTY
|
441 UTRSTAT_Tx_BUFFER_EMPTY
;
442 s
->reg
[I_(UINTSP
)] |= UINTSP_TXD
;
443 exynos4210_uart_update_irq(s
);
448 s
->reg
[I_(UINTP
)] &= ~val
;
449 s
->reg
[I_(UINTSP
)] &= ~val
;
450 trace_exynos_uart_intclr(s
->channel
, s
->reg
[I_(UINTP
)]);
451 exynos4210_uart_update_irq(s
);
454 if (val
& UTRSTAT_Rx_TIMEOUT
) {
455 s
->reg
[I_(UTRSTAT
)] &= ~UTRSTAT_Rx_TIMEOUT
;
462 trace_exynos_uart_ro_write(
463 s
->channel
, exynos4210_uart_regname(offset
), offset
);
466 s
->reg
[I_(UINTSP
)] &= ~val
;
469 s
->reg
[I_(UINTM
)] = val
;
470 exynos4210_uart_update_irq(s
);
475 s
->reg
[I_(offset
)] = val
;
480 static uint64_t exynos4210_uart_read(void *opaque
, hwaddr offset
,
483 Exynos4210UartState
*s
= (Exynos4210UartState
*)opaque
;
487 case UERSTAT
: /* Read Only */
488 res
= s
->reg
[I_(UERSTAT
)];
489 s
->reg
[I_(UERSTAT
)] = 0;
490 trace_exynos_uart_read(s
->channel
, offset
,
491 exynos4210_uart_regname(offset
), res
);
493 case UFSTAT
: /* Read Only */
494 s
->reg
[I_(UFSTAT
)] = fifo_elements_number(&s
->rx
) & 0xff;
495 if (fifo_empty_elements_number(&s
->rx
) == 0) {
496 s
->reg
[I_(UFSTAT
)] |= UFSTAT_Rx_FIFO_FULL
;
497 s
->reg
[I_(UFSTAT
)] &= ~0xff;
499 trace_exynos_uart_read(s
->channel
, offset
,
500 exynos4210_uart_regname(offset
),
502 return s
->reg
[I_(UFSTAT
)];
504 if (s
->reg
[I_(UFCON
)] & UFCON_FIFO_ENABLE
) {
505 if (fifo_elements_number(&s
->rx
)) {
506 res
= fifo_retrieve(&s
->rx
);
507 trace_exynos_uart_rx(s
->channel
, res
);
508 if (!fifo_elements_number(&s
->rx
)) {
509 s
->reg
[I_(UTRSTAT
)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY
;
511 s
->reg
[I_(UTRSTAT
)] |= UTRSTAT_Rx_BUFFER_DATA_READY
;
514 trace_exynos_uart_rx_error(s
->channel
);
515 s
->reg
[I_(UINTSP
)] |= UINTSP_ERROR
;
516 exynos4210_uart_update_irq(s
);
520 s
->reg
[I_(UTRSTAT
)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY
;
521 res
= s
->reg
[I_(URXH
)];
523 exynos4210_uart_update_dmabusy(s
);
524 trace_exynos_uart_read(s
->channel
, offset
,
525 exynos4210_uart_regname(offset
), res
);
528 trace_exynos_uart_wo_read(s
->channel
, exynos4210_uart_regname(offset
),
532 trace_exynos_uart_read(s
->channel
, offset
,
533 exynos4210_uart_regname(offset
),
535 return s
->reg
[I_(offset
)];
538 trace_exynos_uart_read(s
->channel
, offset
, exynos4210_uart_regname(offset
),
543 static const MemoryRegionOps exynos4210_uart_ops
= {
544 .read
= exynos4210_uart_read
,
545 .write
= exynos4210_uart_write
,
546 .endianness
= DEVICE_NATIVE_ENDIAN
,
548 .max_access_size
= 4,
553 static int exynos4210_uart_can_receive(void *opaque
)
555 Exynos4210UartState
*s
= (Exynos4210UartState
*)opaque
;
557 return fifo_empty_elements_number(&s
->rx
);
560 static void exynos4210_uart_receive(void *opaque
, const uint8_t *buf
, int size
)
562 Exynos4210UartState
*s
= (Exynos4210UartState
*)opaque
;
565 if (s
->reg
[I_(UFCON
)] & UFCON_FIFO_ENABLE
) {
566 if (fifo_empty_elements_number(&s
->rx
) < size
) {
567 size
= fifo_empty_elements_number(&s
->rx
);
568 s
->reg
[I_(UINTSP
)] |= UINTSP_ERROR
;
570 for (i
= 0; i
< size
; i
++) {
571 fifo_store(&s
->rx
, buf
[i
]);
573 exynos4210_uart_rx_timeout_set(s
);
575 s
->reg
[I_(URXH
)] = buf
[0];
577 s
->reg
[I_(UTRSTAT
)] |= UTRSTAT_Rx_BUFFER_DATA_READY
;
579 exynos4210_uart_update_irq(s
);
583 static void exynos4210_uart_event(void *opaque
, QEMUChrEvent event
)
585 Exynos4210UartState
*s
= (Exynos4210UartState
*)opaque
;
587 if (event
== CHR_EVENT_BREAK
) {
588 /* When the RxDn is held in logic 0, then a null byte is pushed into the
590 fifo_store(&s
->rx
, '\0');
591 s
->reg
[I_(UERSTAT
)] |= UERSTAT_BREAK
;
592 exynos4210_uart_update_irq(s
);
597 static void exynos4210_uart_reset(DeviceState
*dev
)
599 Exynos4210UartState
*s
= EXYNOS4210_UART(dev
);
602 for (i
= 0; i
< ARRAY_SIZE(exynos4210_uart_regs
); i
++) {
603 s
->reg
[I_(exynos4210_uart_regs
[i
].offset
)] =
604 exynos4210_uart_regs
[i
].reset_value
;
610 trace_exynos_uart_rxsize(s
->channel
, s
->rx
.size
);
613 static int exynos4210_uart_post_load(void *opaque
, int version_id
)
615 Exynos4210UartState
*s
= (Exynos4210UartState
*)opaque
;
617 exynos4210_uart_update_parameters(s
);
618 exynos4210_uart_rx_timeout_set(s
);
623 static const VMStateDescription vmstate_exynos4210_uart_fifo
= {
624 .name
= "exynos4210.uart.fifo",
626 .minimum_version_id
= 1,
627 .post_load
= exynos4210_uart_post_load
,
628 .fields
= (VMStateField
[]) {
629 VMSTATE_UINT32(sp
, Exynos4210UartFIFO
),
630 VMSTATE_UINT32(rp
, Exynos4210UartFIFO
),
631 VMSTATE_VBUFFER_UINT32(data
, Exynos4210UartFIFO
, 1, NULL
, size
),
632 VMSTATE_END_OF_LIST()
636 static const VMStateDescription vmstate_exynos4210_uart
= {
637 .name
= "exynos4210.uart",
639 .minimum_version_id
= 1,
640 .fields
= (VMStateField
[]) {
641 VMSTATE_STRUCT(rx
, Exynos4210UartState
, 1,
642 vmstate_exynos4210_uart_fifo
, Exynos4210UartFIFO
),
643 VMSTATE_UINT32_ARRAY(reg
, Exynos4210UartState
,
644 EXYNOS4210_UART_REGS_MEM_SIZE
/ sizeof(uint32_t)),
645 VMSTATE_END_OF_LIST()
649 DeviceState
*exynos4210_uart_create(hwaddr addr
,
658 dev
= qdev_new(TYPE_EXYNOS4210_UART
);
660 qdev_prop_set_chr(dev
, "chardev", chr
);
661 qdev_prop_set_uint32(dev
, "channel", channel
);
662 qdev_prop_set_uint32(dev
, "rx-size", fifo_size
);
663 qdev_prop_set_uint32(dev
, "tx-size", fifo_size
);
665 bus
= SYS_BUS_DEVICE(dev
);
666 sysbus_realize_and_unref(bus
, &error_fatal
);
667 if (addr
!= (hwaddr
)-1) {
668 sysbus_mmio_map(bus
, 0, addr
);
670 sysbus_connect_irq(bus
, 0, irq
);
675 static void exynos4210_uart_init(Object
*obj
)
677 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
678 Exynos4210UartState
*s
= EXYNOS4210_UART(dev
);
680 s
->wordtime
= NANOSECONDS_PER_SECOND
* 10 / 9600;
683 memory_region_init_io(&s
->iomem
, obj
, &exynos4210_uart_ops
, s
,
684 "exynos4210.uart", EXYNOS4210_UART_REGS_MEM_SIZE
);
685 sysbus_init_mmio(dev
, &s
->iomem
);
687 sysbus_init_irq(dev
, &s
->irq
);
688 sysbus_init_irq(dev
, &s
->dmairq
);
691 static void exynos4210_uart_realize(DeviceState
*dev
, Error
**errp
)
693 Exynos4210UartState
*s
= EXYNOS4210_UART(dev
);
695 s
->fifo_timeout_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
696 exynos4210_uart_timeout_int
, s
);
698 qemu_chr_fe_set_handlers(&s
->chr
, exynos4210_uart_can_receive
,
699 exynos4210_uart_receive
, exynos4210_uart_event
,
700 NULL
, s
, NULL
, true);
703 static Property exynos4210_uart_properties
[] = {
704 DEFINE_PROP_CHR("chardev", Exynos4210UartState
, chr
),
705 DEFINE_PROP_UINT32("channel", Exynos4210UartState
, channel
, 0),
706 DEFINE_PROP_UINT32("rx-size", Exynos4210UartState
, rx
.size
, 16),
707 DEFINE_PROP_UINT32("tx-size", Exynos4210UartState
, tx
.size
, 16),
708 DEFINE_PROP_END_OF_LIST(),
711 static void exynos4210_uart_class_init(ObjectClass
*klass
, void *data
)
713 DeviceClass
*dc
= DEVICE_CLASS(klass
);
715 dc
->realize
= exynos4210_uart_realize
;
716 dc
->reset
= exynos4210_uart_reset
;
717 device_class_set_props(dc
, exynos4210_uart_properties
);
718 dc
->vmsd
= &vmstate_exynos4210_uart
;
721 static const TypeInfo exynos4210_uart_info
= {
722 .name
= TYPE_EXYNOS4210_UART
,
723 .parent
= TYPE_SYS_BUS_DEVICE
,
724 .instance_size
= sizeof(Exynos4210UartState
),
725 .instance_init
= exynos4210_uart_init
,
726 .class_init
= exynos4210_uart_class_init
,
729 static void exynos4210_uart_register(void)
731 type_register_static(&exynos4210_uart_info
);
734 type_init(exynos4210_uart_register
)