3 * Ascii Console Data (VT220 Console)
5 * Copyright IBM, Corp. 2012
8 * Heinz Graalfs <graalfs@de.ibm.com>
10 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
11 * option) any later version. See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
17 #include "qemu/thread.h"
18 #include "qemu/error-report.h"
19 #include "qemu/module.h"
21 #include "hw/s390x/sclp.h"
22 #include "hw/s390x/event-facility.h"
23 #include "chardev/char-fe.h"
25 typedef struct ASCIIConsoleData
{
26 EventBufferHeader ebh
;
28 } QEMU_PACKED ASCIIConsoleData
;
30 /* max size for ASCII data in 4K SCCB page */
31 #define SIZE_BUFFER_VT220 4080
33 typedef struct SCLPConsole
{
36 uint8_t iov
[SIZE_BUFFER_VT220
];
37 uint32_t iov_sclp
; /* offset in buf for SCLP read operation */
38 uint32_t iov_bs
; /* offset in buf for char layer read operation */
39 uint32_t iov_data_len
; /* length of byte stream in buffer */
40 uint32_t iov_sclp_rest
; /* length of byte stream not read via SCLP */
41 bool notify
; /* qemu_notify_event() req'd if true */
44 #define TYPE_SCLP_CONSOLE "sclpconsole"
45 #define SCLP_CONSOLE(obj) \
46 OBJECT_CHECK(SCLPConsole, (obj), TYPE_SCLP_CONSOLE)
48 /* character layer call-back functions */
50 /* Return number of bytes that fit into iov buffer */
51 static int chr_can_read(void *opaque
)
53 SCLPConsole
*scon
= opaque
;
54 int avail
= SIZE_BUFFER_VT220
- scon
->iov_data_len
;
62 /* Send data from a char device over to the guest */
63 static void chr_read(void *opaque
, const uint8_t *buf
, int size
)
65 SCLPConsole
*scon
= opaque
;
68 /* read data must fit into current buffer */
69 assert(size
<= SIZE_BUFFER_VT220
- scon
->iov_data_len
);
71 /* put byte-stream from character layer into buffer */
72 memcpy(&scon
->iov
[scon
->iov_bs
], buf
, size
);
73 scon
->iov_data_len
+= size
;
74 scon
->iov_sclp_rest
+= size
;
76 scon
->event
.event_pending
= true;
77 sclp_service_interrupt(0);
80 /* functions to be called by event facility */
82 static bool can_handle_event(uint8_t type
)
84 return type
== SCLP_EVENT_ASCII_CONSOLE_DATA
;
87 static sccb_mask_t
send_mask(void)
89 return SCLP_EVENT_MASK_MSG_ASCII
;
92 static sccb_mask_t
receive_mask(void)
94 return SCLP_EVENT_MASK_MSG_ASCII
;
97 /* triggered by SCLP's read_event_data -
98 * copy console data byte-stream into provided (SCLP) buffer
100 static void get_console_data(SCLPEvent
*event
, uint8_t *buf
, size_t *size
,
103 SCLPConsole
*cons
= SCLP_CONSOLE(event
);
105 /* first byte is hex 0 saying an ascii string follows */
108 /* if all data fit into provided SCLP buffer */
109 if (avail
>= cons
->iov_sclp_rest
) {
110 /* copy character byte-stream to SCLP buffer */
111 memcpy(buf
, &cons
->iov
[cons
->iov_sclp
], cons
->iov_sclp_rest
);
112 *size
= cons
->iov_sclp_rest
+ 1;
115 cons
->iov_data_len
= 0;
116 cons
->iov_sclp_rest
= 0;
117 event
->event_pending
= false;
118 /* data provided and no more data pending */
120 /* if provided buffer is too small, just copy part */
121 memcpy(buf
, &cons
->iov
[cons
->iov_sclp
], avail
);
123 cons
->iov_sclp_rest
-= avail
;
124 cons
->iov_sclp
+= avail
;
125 /* more data pending */
128 cons
->notify
= false;
133 static int read_event_data(SCLPEvent
*event
, EventBufferHeader
*evt_buf_hdr
,
139 ASCIIConsoleData
*acd
= (ASCIIConsoleData
*) evt_buf_hdr
;
141 if (!event
->event_pending
) {
142 /* no data pending */
146 to
= (uint8_t *)&acd
->data
;
147 avail
= *slen
- sizeof(ASCIIConsoleData
);
148 get_console_data(event
, to
, &src_len
, avail
);
150 acd
->ebh
.length
= cpu_to_be16(sizeof(ASCIIConsoleData
) + src_len
);
151 acd
->ebh
.type
= SCLP_EVENT_ASCII_CONSOLE_DATA
;
152 acd
->ebh
.flags
|= SCLP_EVENT_BUFFER_ACCEPTED
;
153 *slen
= avail
- src_len
;
158 /* triggered by SCLP's write_event_data
159 * - write console data to character layer
160 * returns < 0 if an error occurred
162 static ssize_t
write_console_data(SCLPEvent
*event
, const uint8_t *buf
,
165 SCLPConsole
*scon
= SCLP_CONSOLE(event
);
167 if (!qemu_chr_fe_backend_connected(&scon
->chr
)) {
168 /* If there's no backend, we can just say we consumed all data. */
172 /* XXX this blocks entire thread. Rewrite to use
173 * qemu_chr_fe_write and background I/O callbacks */
174 return qemu_chr_fe_write_all(&scon
->chr
, buf
, len
);
177 static int write_event_data(SCLPEvent
*event
, EventBufferHeader
*evt_buf_hdr
)
182 ASCIIConsoleData
*acd
= (ASCIIConsoleData
*) evt_buf_hdr
;
184 length
= be16_to_cpu(evt_buf_hdr
->length
) - sizeof(EventBufferHeader
);
185 written
= write_console_data(event
, (uint8_t *)acd
->data
, length
);
187 rc
= SCLP_RC_NORMAL_COMPLETION
;
188 /* set event buffer accepted flag */
189 evt_buf_hdr
->flags
|= SCLP_EVENT_BUFFER_ACCEPTED
;
191 /* written will be zero if a pty is not connected - don't treat as error */
193 /* event buffer not accepted due to error in character layer */
194 evt_buf_hdr
->flags
&= ~(SCLP_EVENT_BUFFER_ACCEPTED
);
195 rc
= SCLP_RC_CONTAINED_EQUIPMENT_CHECK
;
201 static const VMStateDescription vmstate_sclpconsole
= {
202 .name
= "sclpconsole",
204 .minimum_version_id
= 0,
205 .fields
= (VMStateField
[]) {
206 VMSTATE_BOOL(event
.event_pending
, SCLPConsole
),
207 VMSTATE_UINT8_ARRAY(iov
, SCLPConsole
, SIZE_BUFFER_VT220
),
208 VMSTATE_UINT32(iov_sclp
, SCLPConsole
),
209 VMSTATE_UINT32(iov_bs
, SCLPConsole
),
210 VMSTATE_UINT32(iov_data_len
, SCLPConsole
),
211 VMSTATE_UINT32(iov_sclp_rest
, SCLPConsole
),
212 VMSTATE_END_OF_LIST()
216 /* qemu object creation and initialization functions */
218 /* tell character layer our call-back functions */
220 static int console_init(SCLPEvent
*event
)
222 static bool console_available
;
224 SCLPConsole
*scon
= SCLP_CONSOLE(event
);
226 if (console_available
) {
227 error_report("Multiple VT220 operator consoles are not supported");
230 console_available
= true;
231 qemu_chr_fe_set_handlers(&scon
->chr
, chr_can_read
,
232 chr_read
, NULL
, NULL
, scon
, NULL
, true);
237 static void console_reset(DeviceState
*dev
)
239 SCLPEvent
*event
= SCLP_EVENT(dev
);
240 SCLPConsole
*scon
= SCLP_CONSOLE(event
);
242 event
->event_pending
= false;
245 scon
->iov_data_len
= 0;
246 scon
->iov_sclp_rest
= 0;
247 scon
->notify
= false;
250 static Property console_properties
[] = {
251 DEFINE_PROP_CHR("chardev", SCLPConsole
, chr
),
252 DEFINE_PROP_END_OF_LIST(),
255 static void console_class_init(ObjectClass
*klass
, void *data
)
257 DeviceClass
*dc
= DEVICE_CLASS(klass
);
258 SCLPEventClass
*ec
= SCLP_EVENT_CLASS(klass
);
260 dc
->props
= console_properties
;
261 dc
->reset
= console_reset
;
262 dc
->vmsd
= &vmstate_sclpconsole
;
263 ec
->init
= console_init
;
264 ec
->get_send_mask
= send_mask
;
265 ec
->get_receive_mask
= receive_mask
;
266 ec
->can_handle_event
= can_handle_event
;
267 ec
->read_event_data
= read_event_data
;
268 ec
->write_event_data
= write_event_data
;
269 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
272 static const TypeInfo sclp_console_info
= {
273 .name
= "sclpconsole",
274 .parent
= TYPE_SCLP_EVENT
,
275 .instance_size
= sizeof(SCLPConsole
),
276 .class_init
= console_class_init
,
277 .class_size
= sizeof(SCLPEventClass
),
280 static void register_types(void)
282 type_register_static(&sclp_console_info
);
285 type_init(register_types
)