Merge remote-tracking branch 'remotes/philmd-gitlab/tags/renesas-20201027' into staging
[qemu.git] / hw / char / spapr_vty.c
1 #include "qemu/osdep.h"
2 #include "qemu/error-report.h"
3 #include "qemu/module.h"
4 #include "qapi/error.h"
5 #include "cpu.h"
6 #include "migration/vmstate.h"
7 #include "chardev/char-fe.h"
8 #include "hw/ppc/spapr.h"
9 #include "hw/ppc/spapr_vio.h"
10 #include "hw/qdev-properties.h"
11 #include "qom/object.h"
12
13 #define VTERM_BUFSIZE 16
14
15 struct SpaprVioVty {
16 SpaprVioDevice sdev;
17 CharBackend chardev;
18 uint32_t in, out;
19 uint8_t buf[VTERM_BUFSIZE];
20 };
21
22 #define TYPE_VIO_SPAPR_VTY_DEVICE "spapr-vty"
23 OBJECT_DECLARE_SIMPLE_TYPE(SpaprVioVty, VIO_SPAPR_VTY_DEVICE)
24
25 static int vty_can_receive(void *opaque)
26 {
27 SpaprVioVty *dev = VIO_SPAPR_VTY_DEVICE(opaque);
28
29 return VTERM_BUFSIZE - (dev->in - dev->out);
30 }
31
32 static void vty_receive(void *opaque, const uint8_t *buf, int size)
33 {
34 SpaprVioVty *dev = VIO_SPAPR_VTY_DEVICE(opaque);
35 int i;
36
37 if ((dev->in == dev->out) && size) {
38 /* toggle line to simulate edge interrupt */
39 spapr_vio_irq_pulse(&dev->sdev);
40 }
41 for (i = 0; i < size; i++) {
42 if (dev->in - dev->out >= VTERM_BUFSIZE) {
43 static bool reported;
44 if (!reported) {
45 error_report("VTY input buffer exhausted - characters dropped."
46 " (input size = %i)", size);
47 reported = true;
48 }
49 break;
50 }
51 dev->buf[dev->in++ % VTERM_BUFSIZE] = buf[i];
52 }
53 }
54
55 static int vty_getchars(SpaprVioDevice *sdev, uint8_t *buf, int max)
56 {
57 SpaprVioVty *dev = VIO_SPAPR_VTY_DEVICE(sdev);
58 int n = 0;
59
60 while ((n < max) && (dev->out != dev->in)) {
61 /*
62 * Long ago, PowerVM's vty implementation had a bug where it
63 * inserted a \0 after every \r going to the guest. Existing
64 * guests have a workaround for this which removes every \0
65 * immediately following a \r. To avoid triggering this
66 * workaround, we stop before inserting a \0 if the preceding
67 * character in the output buffer is a \r.
68 */
69 if (n > 0 && (buf[n - 1] == '\r') &&
70 (dev->buf[dev->out % VTERM_BUFSIZE] == '\0')) {
71 break;
72 }
73 buf[n++] = dev->buf[dev->out++ % VTERM_BUFSIZE];
74 }
75
76 qemu_chr_fe_accept_input(&dev->chardev);
77
78 return n;
79 }
80
81 void vty_putchars(SpaprVioDevice *sdev, uint8_t *buf, int len)
82 {
83 SpaprVioVty *dev = VIO_SPAPR_VTY_DEVICE(sdev);
84
85 /* XXX this blocks entire thread. Rewrite to use
86 * qemu_chr_fe_write and background I/O callbacks */
87 qemu_chr_fe_write_all(&dev->chardev, buf, len);
88 }
89
90 static void spapr_vty_realize(SpaprVioDevice *sdev, Error **errp)
91 {
92 SpaprVioVty *dev = VIO_SPAPR_VTY_DEVICE(sdev);
93
94 if (!qemu_chr_fe_backend_connected(&dev->chardev)) {
95 error_setg(errp, "chardev property not set");
96 return;
97 }
98
99 qemu_chr_fe_set_handlers(&dev->chardev, vty_can_receive,
100 vty_receive, NULL, NULL, dev, NULL, true);
101 }
102
103 /* Forward declaration */
104 static target_ulong h_put_term_char(PowerPCCPU *cpu, SpaprMachineState *spapr,
105 target_ulong opcode, target_ulong *args)
106 {
107 target_ulong reg = args[0];
108 target_ulong len = args[1];
109 target_ulong char0_7 = args[2];
110 target_ulong char8_15 = args[3];
111 SpaprVioDevice *sdev;
112 uint8_t buf[16];
113
114 sdev = vty_lookup(spapr, reg);
115 if (!sdev) {
116 return H_PARAMETER;
117 }
118
119 if (len > 16) {
120 return H_PARAMETER;
121 }
122
123 *((uint64_t *)buf) = cpu_to_be64(char0_7);
124 *((uint64_t *)buf + 1) = cpu_to_be64(char8_15);
125
126 vty_putchars(sdev, buf, len);
127
128 return H_SUCCESS;
129 }
130
131 static target_ulong h_get_term_char(PowerPCCPU *cpu, SpaprMachineState *spapr,
132 target_ulong opcode, target_ulong *args)
133 {
134 target_ulong reg = args[0];
135 target_ulong *len = args + 0;
136 target_ulong *char0_7 = args + 1;
137 target_ulong *char8_15 = args + 2;
138 SpaprVioDevice *sdev;
139 uint8_t buf[16];
140
141 sdev = vty_lookup(spapr, reg);
142 if (!sdev) {
143 return H_PARAMETER;
144 }
145
146 *len = vty_getchars(sdev, buf, sizeof(buf));
147 if (*len < 16) {
148 memset(buf + *len, 0, 16 - *len);
149 }
150
151 *char0_7 = be64_to_cpu(*((uint64_t *)buf));
152 *char8_15 = be64_to_cpu(*((uint64_t *)buf + 1));
153
154 return H_SUCCESS;
155 }
156
157 void spapr_vty_create(SpaprVioBus *bus, Chardev *chardev)
158 {
159 DeviceState *dev;
160
161 dev = qdev_new("spapr-vty");
162 qdev_prop_set_chr(dev, "chardev", chardev);
163 qdev_realize_and_unref(dev, &bus->bus, &error_fatal);
164 }
165
166 static Property spapr_vty_properties[] = {
167 DEFINE_SPAPR_PROPERTIES(SpaprVioVty, sdev),
168 DEFINE_PROP_CHR("chardev", SpaprVioVty, chardev),
169 DEFINE_PROP_END_OF_LIST(),
170 };
171
172 static const VMStateDescription vmstate_spapr_vty = {
173 .name = "spapr_vty",
174 .version_id = 1,
175 .minimum_version_id = 1,
176 .fields = (VMStateField[]) {
177 VMSTATE_SPAPR_VIO(sdev, SpaprVioVty),
178
179 VMSTATE_UINT32(in, SpaprVioVty),
180 VMSTATE_UINT32(out, SpaprVioVty),
181 VMSTATE_BUFFER(buf, SpaprVioVty),
182 VMSTATE_END_OF_LIST()
183 },
184 };
185
186 static void spapr_vty_class_init(ObjectClass *klass, void *data)
187 {
188 DeviceClass *dc = DEVICE_CLASS(klass);
189 SpaprVioDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);
190
191 k->realize = spapr_vty_realize;
192 k->dt_name = "vty";
193 k->dt_type = "serial";
194 k->dt_compatible = "hvterm1";
195 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
196 device_class_set_props(dc, spapr_vty_properties);
197 dc->vmsd = &vmstate_spapr_vty;
198 }
199
200 static const TypeInfo spapr_vty_info = {
201 .name = TYPE_VIO_SPAPR_VTY_DEVICE,
202 .parent = TYPE_VIO_SPAPR_DEVICE,
203 .instance_size = sizeof(SpaprVioVty),
204 .class_init = spapr_vty_class_init,
205 };
206
207 SpaprVioDevice *spapr_vty_get_default(SpaprVioBus *bus)
208 {
209 SpaprVioDevice *sdev, *selected;
210 BusChild *kid;
211
212 /*
213 * To avoid the console bouncing around we want one VTY to be
214 * the "default". We haven't really got anything to go on, so
215 * arbitrarily choose the one with the lowest reg value.
216 */
217
218 selected = NULL;
219 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
220 DeviceState *iter = kid->child;
221
222 /* Only look at VTY devices */
223 if (!object_dynamic_cast(OBJECT(iter), TYPE_VIO_SPAPR_VTY_DEVICE)) {
224 continue;
225 }
226
227 sdev = VIO_SPAPR_DEVICE(iter);
228
229 /* First VTY we've found, so it is selected for now */
230 if (!selected) {
231 selected = sdev;
232 continue;
233 }
234
235 /* Choose VTY with lowest reg value */
236 if (sdev->reg < selected->reg) {
237 selected = sdev;
238 }
239 }
240
241 return selected;
242 }
243
244 SpaprVioDevice *vty_lookup(SpaprMachineState *spapr, target_ulong reg)
245 {
246 SpaprVioDevice *sdev;
247
248 sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
249 if (!sdev && reg == 0) {
250 /* Hack for kernel early debug, which always specifies reg==0.
251 * We search all VIO devices, and grab the vty with the lowest
252 * reg. This attempts to mimic existing PowerVM behaviour
253 * (early debug does work there, despite having no vty with
254 * reg==0. */
255 return spapr_vty_get_default(spapr->vio_bus);
256 }
257
258 if (!object_dynamic_cast(OBJECT(sdev), TYPE_VIO_SPAPR_VTY_DEVICE)) {
259 return NULL;
260 }
261
262 return sdev;
263 }
264
265 static void spapr_vty_register_types(void)
266 {
267 spapr_register_hypercall(H_PUT_TERM_CHAR, h_put_term_char);
268 spapr_register_hypercall(H_GET_TERM_CHAR, h_get_term_char);
269 type_register_static(&spapr_vty_info);
270 }
271
272 type_init(spapr_vty_register_types)