Statistics
| Branch: | Revision:

root / hw / virtio-console.c @ 31d0f80f

History | View | Annotate | Download (4.4 kB)

1
/*
2
 * Virtio Console and Generic Serial Port Devices
3
 *
4
 * Copyright Red Hat, Inc. 2009, 2010
5
 *
6
 * Authors:
7
 *  Amit Shah <amit.shah@redhat.com>
8
 *
9
 * This work is licensed under the terms of the GNU GPL, version 2.  See
10
 * the COPYING file in the top-level directory.
11
 */
12

    
13
#include "qemu-char.h"
14
#include "qemu-error.h"
15
#include "virtio-serial.h"
16

    
17
typedef struct VirtConsole {
18
    VirtIOSerialPort port;
19
    CharDriverState *chr;
20
} VirtConsole;
21

    
22

    
23
/* Callback function that's called when the guest sends us data */
24
static ssize_t flush_buf(VirtIOSerialPort *port, const uint8_t *buf, size_t len)
25
{
26
    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
27

    
28
    return qemu_chr_write(vcon->chr, buf, len);
29
}
30

    
31
/* Callback function that's called when the guest opens the port */
32
static void guest_open(VirtIOSerialPort *port)
33
{
34
    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
35

    
36
    qemu_chr_guest_open(vcon->chr);
37
}
38

    
39
/* Callback function that's called when the guest closes the port */
40
static void guest_close(VirtIOSerialPort *port)
41
{
42
    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
43

    
44
    qemu_chr_guest_close(vcon->chr);
45
}
46

    
47
/* Readiness of the guest to accept data on a port */
48
static int chr_can_read(void *opaque)
49
{
50
    VirtConsole *vcon = opaque;
51

    
52
    return virtio_serial_guest_ready(&vcon->port);
53
}
54

    
55
/* Send data from a char device over to the guest */
56
static void chr_read(void *opaque, const uint8_t *buf, int size)
57
{
58
    VirtConsole *vcon = opaque;
59

    
60
    virtio_serial_write(&vcon->port, buf, size);
61
}
62

    
63
static void chr_event(void *opaque, int event)
64
{
65
    VirtConsole *vcon = opaque;
66

    
67
    switch (event) {
68
    case CHR_EVENT_OPENED:
69
        virtio_serial_open(&vcon->port);
70
        break;
71
    case CHR_EVENT_CLOSED:
72
        virtio_serial_close(&vcon->port);
73
        break;
74
    }
75
}
76

    
77
static int generic_port_init(VirtConsole *vcon, VirtIOSerialPort *port)
78
{
79
    if (vcon->chr) {
80
        qemu_chr_add_handlers(vcon->chr, chr_can_read, chr_read, chr_event,
81
                              vcon);
82
        vcon->port.info->have_data = flush_buf;
83
        vcon->port.info->guest_open = guest_open;
84
        vcon->port.info->guest_close = guest_close;
85
    }
86
    return 0;
87
}
88

    
89
/* Virtio Console Ports */
90
static int virtconsole_initfn(VirtIOSerialPort *port)
91
{
92
    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
93

    
94
    return generic_port_init(vcon, port);
95
}
96

    
97
static int virtconsole_exitfn(VirtIOSerialPort *port)
98
{
99
    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
100

    
101
    if (vcon->chr) {
102
        /*
103
         * Instead of closing the chardev, free it so it can be used
104
         * for other purposes.
105
         */
106
        qemu_chr_add_handlers(vcon->chr, NULL, NULL, NULL, NULL);
107
    }
108

    
109
    return 0;
110
}
111

    
112
static VirtIOSerialPortInfo virtconsole_info = {
113
    .qdev.name     = "virtconsole",
114
    .qdev.size     = sizeof(VirtConsole),
115
    .is_console    = true,
116
    .init          = virtconsole_initfn,
117
    .exit          = virtconsole_exitfn,
118
    .qdev.props = (Property[]) {
119
        DEFINE_PROP_UINT32("nr", VirtConsole, port.id, VIRTIO_CONSOLE_BAD_ID),
120
        DEFINE_PROP_CHR("chardev", VirtConsole, chr),
121
        DEFINE_PROP_STRING("name", VirtConsole, port.name),
122
        DEFINE_PROP_END_OF_LIST(),
123
    },
124
};
125

    
126
static void virtconsole_register(void)
127
{
128
    virtio_serial_port_qdev_register(&virtconsole_info);
129
}
130
device_init(virtconsole_register)
131

    
132
/* Generic Virtio Serial Ports */
133
static int virtserialport_initfn(VirtIOSerialPort *port)
134
{
135
    VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
136

    
137
    if (port->id == 0) {
138
        /*
139
         * Disallow a generic port at id 0, that's reserved for
140
         * console ports.
141
         */
142
        error_report("Port number 0 on virtio-serial devices reserved for virtconsole devices for backward compatibility.");
143
        return -1;
144
    }
145
    return generic_port_init(vcon, port);
146
}
147

    
148
static VirtIOSerialPortInfo virtserialport_info = {
149
    .qdev.name     = "virtserialport",
150
    .qdev.size     = sizeof(VirtConsole),
151
    .init          = virtserialport_initfn,
152
    .exit          = virtconsole_exitfn,
153
    .qdev.props = (Property[]) {
154
        DEFINE_PROP_UINT32("nr", VirtConsole, port.id, VIRTIO_CONSOLE_BAD_ID),
155
        DEFINE_PROP_CHR("chardev", VirtConsole, chr),
156
        DEFINE_PROP_STRING("name", VirtConsole, port.name),
157
        DEFINE_PROP_END_OF_LIST(),
158
    },
159
};
160

    
161
static void virtserialport_register(void)
162
{
163
    virtio_serial_port_qdev_register(&virtserialport_info);
164
}
165
device_init(virtserialport_register)