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