1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "hw/input/adb.h"
27#include "qemu/module.h"
28#include "ui/input.h"
29#include "hw/input/adb-keys.h"
30#include "sysemu/sysemu.h"
31#include "adb-internal.h"
32#include "trace.h"
33
34#define ADB_KEYBOARD(obj) OBJECT_CHECK(KBDState, (obj), TYPE_ADB_KEYBOARD)
35
36typedef struct KBDState {
37
38 ADBDevice parent_obj;
39
40
41 uint8_t data[128];
42 int rptr, wptr, count;
43} KBDState;
44
45#define ADB_KEYBOARD_CLASS(class) \
46 OBJECT_CLASS_CHECK(ADBKeyboardClass, (class), TYPE_ADB_KEYBOARD)
47#define ADB_KEYBOARD_GET_CLASS(obj) \
48 OBJECT_GET_CLASS(ADBKeyboardClass, (obj), TYPE_ADB_KEYBOARD)
49
50typedef struct ADBKeyboardClass {
51
52 ADBDeviceClass parent_class;
53
54
55 DeviceRealize parent_realize;
56} ADBKeyboardClass;
57
58
59#define NO_KEY 0xff
60
61int qcode_to_adb_keycode[] = {
62
63 [0 ... 0xff] = NO_KEY,
64
65 [Q_KEY_CODE_SHIFT] = ADB_KEY_LEFT_SHIFT,
66 [Q_KEY_CODE_SHIFT_R] = ADB_KEY_RIGHT_SHIFT,
67 [Q_KEY_CODE_ALT] = ADB_KEY_LEFT_OPTION,
68 [Q_KEY_CODE_ALT_R] = ADB_KEY_RIGHT_OPTION,
69 [Q_KEY_CODE_CTRL] = ADB_KEY_LEFT_CONTROL,
70 [Q_KEY_CODE_CTRL_R] = ADB_KEY_RIGHT_CONTROL,
71 [Q_KEY_CODE_META_L] = ADB_KEY_COMMAND,
72 [Q_KEY_CODE_META_R] = ADB_KEY_COMMAND,
73 [Q_KEY_CODE_SPC] = ADB_KEY_SPACEBAR,
74
75 [Q_KEY_CODE_ESC] = ADB_KEY_ESC,
76 [Q_KEY_CODE_1] = ADB_KEY_1,
77 [Q_KEY_CODE_2] = ADB_KEY_2,
78 [Q_KEY_CODE_3] = ADB_KEY_3,
79 [Q_KEY_CODE_4] = ADB_KEY_4,
80 [Q_KEY_CODE_5] = ADB_KEY_5,
81 [Q_KEY_CODE_6] = ADB_KEY_6,
82 [Q_KEY_CODE_7] = ADB_KEY_7,
83 [Q_KEY_CODE_8] = ADB_KEY_8,
84 [Q_KEY_CODE_9] = ADB_KEY_9,
85 [Q_KEY_CODE_0] = ADB_KEY_0,
86 [Q_KEY_CODE_MINUS] = ADB_KEY_MINUS,
87 [Q_KEY_CODE_EQUAL] = ADB_KEY_EQUAL,
88 [Q_KEY_CODE_BACKSPACE] = ADB_KEY_DELETE,
89 [Q_KEY_CODE_TAB] = ADB_KEY_TAB,
90 [Q_KEY_CODE_Q] = ADB_KEY_Q,
91 [Q_KEY_CODE_W] = ADB_KEY_W,
92 [Q_KEY_CODE_E] = ADB_KEY_E,
93 [Q_KEY_CODE_R] = ADB_KEY_R,
94 [Q_KEY_CODE_T] = ADB_KEY_T,
95 [Q_KEY_CODE_Y] = ADB_KEY_Y,
96 [Q_KEY_CODE_U] = ADB_KEY_U,
97 [Q_KEY_CODE_I] = ADB_KEY_I,
98 [Q_KEY_CODE_O] = ADB_KEY_O,
99 [Q_KEY_CODE_P] = ADB_KEY_P,
100 [Q_KEY_CODE_BRACKET_LEFT] = ADB_KEY_LEFT_BRACKET,
101 [Q_KEY_CODE_BRACKET_RIGHT] = ADB_KEY_RIGHT_BRACKET,
102 [Q_KEY_CODE_RET] = ADB_KEY_RETURN,
103 [Q_KEY_CODE_A] = ADB_KEY_A,
104 [Q_KEY_CODE_S] = ADB_KEY_S,
105 [Q_KEY_CODE_D] = ADB_KEY_D,
106 [Q_KEY_CODE_F] = ADB_KEY_F,
107 [Q_KEY_CODE_G] = ADB_KEY_G,
108 [Q_KEY_CODE_H] = ADB_KEY_H,
109 [Q_KEY_CODE_J] = ADB_KEY_J,
110 [Q_KEY_CODE_K] = ADB_KEY_K,
111 [Q_KEY_CODE_L] = ADB_KEY_L,
112 [Q_KEY_CODE_SEMICOLON] = ADB_KEY_SEMICOLON,
113 [Q_KEY_CODE_APOSTROPHE] = ADB_KEY_APOSTROPHE,
114 [Q_KEY_CODE_GRAVE_ACCENT] = ADB_KEY_GRAVE_ACCENT,
115 [Q_KEY_CODE_BACKSLASH] = ADB_KEY_BACKSLASH,
116 [Q_KEY_CODE_Z] = ADB_KEY_Z,
117 [Q_KEY_CODE_X] = ADB_KEY_X,
118 [Q_KEY_CODE_C] = ADB_KEY_C,
119 [Q_KEY_CODE_V] = ADB_KEY_V,
120 [Q_KEY_CODE_B] = ADB_KEY_B,
121 [Q_KEY_CODE_N] = ADB_KEY_N,
122 [Q_KEY_CODE_M] = ADB_KEY_M,
123 [Q_KEY_CODE_COMMA] = ADB_KEY_COMMA,
124 [Q_KEY_CODE_DOT] = ADB_KEY_PERIOD,
125 [Q_KEY_CODE_SLASH] = ADB_KEY_FORWARD_SLASH,
126 [Q_KEY_CODE_ASTERISK] = ADB_KEY_KP_MULTIPLY,
127 [Q_KEY_CODE_CAPS_LOCK] = ADB_KEY_CAPS_LOCK,
128
129 [Q_KEY_CODE_F1] = ADB_KEY_F1,
130 [Q_KEY_CODE_F2] = ADB_KEY_F2,
131 [Q_KEY_CODE_F3] = ADB_KEY_F3,
132 [Q_KEY_CODE_F4] = ADB_KEY_F4,
133 [Q_KEY_CODE_F5] = ADB_KEY_F5,
134 [Q_KEY_CODE_F6] = ADB_KEY_F6,
135 [Q_KEY_CODE_F7] = ADB_KEY_F7,
136 [Q_KEY_CODE_F8] = ADB_KEY_F8,
137 [Q_KEY_CODE_F9] = ADB_KEY_F9,
138 [Q_KEY_CODE_F10] = ADB_KEY_F10,
139 [Q_KEY_CODE_F11] = ADB_KEY_F11,
140 [Q_KEY_CODE_F12] = ADB_KEY_F12,
141 [Q_KEY_CODE_PRINT] = ADB_KEY_F13,
142 [Q_KEY_CODE_SYSRQ] = ADB_KEY_F13,
143 [Q_KEY_CODE_SCROLL_LOCK] = ADB_KEY_F14,
144 [Q_KEY_CODE_PAUSE] = ADB_KEY_F15,
145
146 [Q_KEY_CODE_NUM_LOCK] = ADB_KEY_KP_CLEAR,
147 [Q_KEY_CODE_KP_EQUALS] = ADB_KEY_KP_EQUAL,
148 [Q_KEY_CODE_KP_DIVIDE] = ADB_KEY_KP_DIVIDE,
149 [Q_KEY_CODE_KP_MULTIPLY] = ADB_KEY_KP_MULTIPLY,
150 [Q_KEY_CODE_KP_SUBTRACT] = ADB_KEY_KP_SUBTRACT,
151 [Q_KEY_CODE_KP_ADD] = ADB_KEY_KP_PLUS,
152 [Q_KEY_CODE_KP_ENTER] = ADB_KEY_KP_ENTER,
153 [Q_KEY_CODE_KP_DECIMAL] = ADB_KEY_KP_PERIOD,
154 [Q_KEY_CODE_KP_0] = ADB_KEY_KP_0,
155 [Q_KEY_CODE_KP_1] = ADB_KEY_KP_1,
156 [Q_KEY_CODE_KP_2] = ADB_KEY_KP_2,
157 [Q_KEY_CODE_KP_3] = ADB_KEY_KP_3,
158 [Q_KEY_CODE_KP_4] = ADB_KEY_KP_4,
159 [Q_KEY_CODE_KP_5] = ADB_KEY_KP_5,
160 [Q_KEY_CODE_KP_6] = ADB_KEY_KP_6,
161 [Q_KEY_CODE_KP_7] = ADB_KEY_KP_7,
162 [Q_KEY_CODE_KP_8] = ADB_KEY_KP_8,
163 [Q_KEY_CODE_KP_9] = ADB_KEY_KP_9,
164
165 [Q_KEY_CODE_UP] = ADB_KEY_UP,
166 [Q_KEY_CODE_DOWN] = ADB_KEY_DOWN,
167 [Q_KEY_CODE_LEFT] = ADB_KEY_LEFT,
168 [Q_KEY_CODE_RIGHT] = ADB_KEY_RIGHT,
169
170 [Q_KEY_CODE_HELP] = ADB_KEY_HELP,
171 [Q_KEY_CODE_INSERT] = ADB_KEY_HELP,
172 [Q_KEY_CODE_DELETE] = ADB_KEY_FORWARD_DELETE,
173 [Q_KEY_CODE_HOME] = ADB_KEY_HOME,
174 [Q_KEY_CODE_END] = ADB_KEY_END,
175 [Q_KEY_CODE_PGUP] = ADB_KEY_PAGE_UP,
176 [Q_KEY_CODE_PGDN] = ADB_KEY_PAGE_DOWN,
177
178 [Q_KEY_CODE_POWER] = ADB_KEY_POWER
179};
180
181static void adb_kbd_put_keycode(void *opaque, int keycode)
182{
183 KBDState *s = opaque;
184
185 if (s->count < sizeof(s->data)) {
186 s->data[s->wptr] = keycode;
187 if (++s->wptr == sizeof(s->data)) {
188 s->wptr = 0;
189 }
190 s->count++;
191 }
192}
193
194static int adb_kbd_poll(ADBDevice *d, uint8_t *obuf)
195{
196 KBDState *s = ADB_KEYBOARD(d);
197 int keycode;
198 int olen;
199
200 olen = 0;
201 if (s->count == 0) {
202 return 0;
203 }
204 keycode = s->data[s->rptr];
205 s->rptr++;
206 if (s->rptr == sizeof(s->data)) {
207 s->rptr = 0;
208 }
209 s->count--;
210
211
212
213
214
215
216 if (keycode == 0x7f) {
217 obuf[0] = 0x7f;
218 obuf[1] = 0x7f;
219 olen = 2;
220 } else {
221 obuf[0] = keycode;
222
223
224
225
226 obuf[1] = 0xff;
227 olen = 2;
228 }
229
230 return olen;
231}
232
233static int adb_kbd_request(ADBDevice *d, uint8_t *obuf,
234 const uint8_t *buf, int len)
235{
236 KBDState *s = ADB_KEYBOARD(d);
237 int cmd, reg, olen;
238
239 if ((buf[0] & 0x0f) == ADB_FLUSH) {
240
241 s->wptr = s->rptr = s->count = 0;
242 return 0;
243 }
244
245 cmd = buf[0] & 0xc;
246 reg = buf[0] & 0x3;
247 olen = 0;
248 switch (cmd) {
249 case ADB_WRITEREG:
250 trace_adb_kbd_writereg(reg, buf[1]);
251 switch (reg) {
252 case 2:
253
254 break;
255 case 3:
256 switch (buf[2]) {
257 case ADB_CMD_SELF_TEST:
258 break;
259 case ADB_CMD_CHANGE_ID:
260 case ADB_CMD_CHANGE_ID_AND_ACT:
261 case ADB_CMD_CHANGE_ID_AND_ENABLE:
262 d->devaddr = buf[1] & 0xf;
263 trace_adb_kbd_request_change_addr(d->devaddr);
264 break;
265 default:
266 if (!d->disable_direct_reg3_writes) {
267 d->devaddr = buf[1] & 0xf;
268
269
270
271
272
273
274 if (buf[2] == 1 || buf[2] == 2 || buf[2] == 3) {
275 d->handler = buf[2];
276 }
277
278 trace_adb_kbd_request_change_addr_and_handler(d->devaddr,
279 d->handler);
280 }
281 break;
282 }
283 }
284 break;
285 case ADB_READREG:
286 switch (reg) {
287 case 0:
288 olen = adb_kbd_poll(d, obuf);
289 break;
290 case 1:
291 break;
292 case 2:
293 obuf[0] = 0x00;
294 obuf[1] = 0x07;
295 olen = 2;
296 break;
297 case 3:
298 obuf[0] = d->devaddr;
299 obuf[1] = d->handler;
300 olen = 2;
301 break;
302 }
303 trace_adb_kbd_readreg(reg, obuf[0], obuf[1]);
304 break;
305 }
306 return olen;
307}
308
309
310static void adb_keyboard_event(DeviceState *dev, QemuConsole *src,
311 InputEvent *evt)
312{
313 KBDState *s = (KBDState *)dev;
314 int qcode, keycode;
315
316 qcode = qemu_input_key_value_to_qcode(evt->u.key.data->key);
317 if (qcode >= ARRAY_SIZE(qcode_to_adb_keycode)) {
318 return;
319 }
320
321 keycode = qcode_to_adb_keycode[qcode];
322 if (keycode == NO_KEY) {
323 trace_adb_kbd_no_key();
324 return;
325 }
326 if (evt->u.key.data->down == false) {
327 keycode = keycode | 0x80;
328 }
329
330 adb_kbd_put_keycode(s, keycode);
331}
332
333static const VMStateDescription vmstate_adb_kbd = {
334 .name = "adb_kbd",
335 .version_id = 2,
336 .minimum_version_id = 2,
337 .fields = (VMStateField[]) {
338 VMSTATE_STRUCT(parent_obj, KBDState, 0, vmstate_adb_device, ADBDevice),
339 VMSTATE_BUFFER(data, KBDState),
340 VMSTATE_INT32(rptr, KBDState),
341 VMSTATE_INT32(wptr, KBDState),
342 VMSTATE_INT32(count, KBDState),
343 VMSTATE_END_OF_LIST()
344 }
345};
346
347static void adb_kbd_reset(DeviceState *dev)
348{
349 ADBDevice *d = ADB_DEVICE(dev);
350 KBDState *s = ADB_KEYBOARD(dev);
351
352 d->handler = 1;
353 d->devaddr = ADB_DEVID_KEYBOARD;
354 memset(s->data, 0, sizeof(s->data));
355 s->rptr = 0;
356 s->wptr = 0;
357 s->count = 0;
358}
359
360static QemuInputHandler adb_keyboard_handler = {
361 .name = "QEMU ADB Keyboard",
362 .mask = INPUT_EVENT_MASK_KEY,
363 .event = adb_keyboard_event,
364};
365
366static void adb_kbd_realizefn(DeviceState *dev, Error **errp)
367{
368 ADBKeyboardClass *akc = ADB_KEYBOARD_GET_CLASS(dev);
369 akc->parent_realize(dev, errp);
370 qemu_input_handler_register(dev, &adb_keyboard_handler);
371}
372
373static void adb_kbd_initfn(Object *obj)
374{
375 ADBDevice *d = ADB_DEVICE(obj);
376
377 d->devaddr = ADB_DEVID_KEYBOARD;
378}
379
380static void adb_kbd_class_init(ObjectClass *oc, void *data)
381{
382 DeviceClass *dc = DEVICE_CLASS(oc);
383 ADBDeviceClass *adc = ADB_DEVICE_CLASS(oc);
384 ADBKeyboardClass *akc = ADB_KEYBOARD_CLASS(oc);
385
386 device_class_set_parent_realize(dc, adb_kbd_realizefn,
387 &akc->parent_realize);
388 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
389
390 adc->devreq = adb_kbd_request;
391 dc->reset = adb_kbd_reset;
392 dc->vmsd = &vmstate_adb_kbd;
393}
394
395static const TypeInfo adb_kbd_type_info = {
396 .name = TYPE_ADB_KEYBOARD,
397 .parent = TYPE_ADB_DEVICE,
398 .instance_size = sizeof(KBDState),
399 .instance_init = adb_kbd_initfn,
400 .class_init = adb_kbd_class_init,
401 .class_size = sizeof(ADBKeyboardClass),
402};
403
404static void adb_kbd_register_types(void)
405{
406 type_register_static(&adb_kbd_type_info);
407}
408
409type_init(adb_kbd_register_types)
410
