2 * QEMU ADB keyboard support
4 * Copyright (c) 2004 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "hw/input/adb.h"
27 #include "migration/vmstate.h"
28 #include "qemu/module.h"
30 #include "hw/input/adb-keys.h"
31 #include "sysemu/sysemu.h"
32 #include "adb-internal.h"
35 #define ADB_KEYBOARD(obj) OBJECT_CHECK(KBDState, (obj), TYPE_ADB_KEYBOARD)
37 typedef struct KBDState
{
43 int rptr
, wptr
, count
;
46 #define ADB_KEYBOARD_CLASS(class) \
47 OBJECT_CLASS_CHECK(ADBKeyboardClass, (class), TYPE_ADB_KEYBOARD)
48 #define ADB_KEYBOARD_GET_CLASS(obj) \
49 OBJECT_GET_CLASS(ADBKeyboardClass, (obj), TYPE_ADB_KEYBOARD)
51 typedef struct ADBKeyboardClass
{
53 ADBDeviceClass parent_class
;
56 DeviceRealize parent_realize
;
59 /* The adb keyboard doesn't have every key imaginable */
62 int qcode_to_adb_keycode
[] = {
63 /* Make sure future additions are automatically set to NO_KEY */
64 [0 ... 0xff] = NO_KEY
,
66 [Q_KEY_CODE_SHIFT
] = ADB_KEY_LEFT_SHIFT
,
67 [Q_KEY_CODE_SHIFT_R
] = ADB_KEY_RIGHT_SHIFT
,
68 [Q_KEY_CODE_ALT
] = ADB_KEY_LEFT_OPTION
,
69 [Q_KEY_CODE_ALT_R
] = ADB_KEY_RIGHT_OPTION
,
70 [Q_KEY_CODE_CTRL
] = ADB_KEY_LEFT_CONTROL
,
71 [Q_KEY_CODE_CTRL_R
] = ADB_KEY_RIGHT_CONTROL
,
72 [Q_KEY_CODE_META_L
] = ADB_KEY_COMMAND
,
73 [Q_KEY_CODE_META_R
] = ADB_KEY_COMMAND
,
74 [Q_KEY_CODE_SPC
] = ADB_KEY_SPACEBAR
,
76 [Q_KEY_CODE_ESC
] = ADB_KEY_ESC
,
77 [Q_KEY_CODE_1
] = ADB_KEY_1
,
78 [Q_KEY_CODE_2
] = ADB_KEY_2
,
79 [Q_KEY_CODE_3
] = ADB_KEY_3
,
80 [Q_KEY_CODE_4
] = ADB_KEY_4
,
81 [Q_KEY_CODE_5
] = ADB_KEY_5
,
82 [Q_KEY_CODE_6
] = ADB_KEY_6
,
83 [Q_KEY_CODE_7
] = ADB_KEY_7
,
84 [Q_KEY_CODE_8
] = ADB_KEY_8
,
85 [Q_KEY_CODE_9
] = ADB_KEY_9
,
86 [Q_KEY_CODE_0
] = ADB_KEY_0
,
87 [Q_KEY_CODE_MINUS
] = ADB_KEY_MINUS
,
88 [Q_KEY_CODE_EQUAL
] = ADB_KEY_EQUAL
,
89 [Q_KEY_CODE_BACKSPACE
] = ADB_KEY_DELETE
,
90 [Q_KEY_CODE_TAB
] = ADB_KEY_TAB
,
91 [Q_KEY_CODE_Q
] = ADB_KEY_Q
,
92 [Q_KEY_CODE_W
] = ADB_KEY_W
,
93 [Q_KEY_CODE_E
] = ADB_KEY_E
,
94 [Q_KEY_CODE_R
] = ADB_KEY_R
,
95 [Q_KEY_CODE_T
] = ADB_KEY_T
,
96 [Q_KEY_CODE_Y
] = ADB_KEY_Y
,
97 [Q_KEY_CODE_U
] = ADB_KEY_U
,
98 [Q_KEY_CODE_I
] = ADB_KEY_I
,
99 [Q_KEY_CODE_O
] = ADB_KEY_O
,
100 [Q_KEY_CODE_P
] = ADB_KEY_P
,
101 [Q_KEY_CODE_BRACKET_LEFT
] = ADB_KEY_LEFT_BRACKET
,
102 [Q_KEY_CODE_BRACKET_RIGHT
] = ADB_KEY_RIGHT_BRACKET
,
103 [Q_KEY_CODE_RET
] = ADB_KEY_RETURN
,
104 [Q_KEY_CODE_A
] = ADB_KEY_A
,
105 [Q_KEY_CODE_S
] = ADB_KEY_S
,
106 [Q_KEY_CODE_D
] = ADB_KEY_D
,
107 [Q_KEY_CODE_F
] = ADB_KEY_F
,
108 [Q_KEY_CODE_G
] = ADB_KEY_G
,
109 [Q_KEY_CODE_H
] = ADB_KEY_H
,
110 [Q_KEY_CODE_J
] = ADB_KEY_J
,
111 [Q_KEY_CODE_K
] = ADB_KEY_K
,
112 [Q_KEY_CODE_L
] = ADB_KEY_L
,
113 [Q_KEY_CODE_SEMICOLON
] = ADB_KEY_SEMICOLON
,
114 [Q_KEY_CODE_APOSTROPHE
] = ADB_KEY_APOSTROPHE
,
115 [Q_KEY_CODE_GRAVE_ACCENT
] = ADB_KEY_GRAVE_ACCENT
,
116 [Q_KEY_CODE_BACKSLASH
] = ADB_KEY_BACKSLASH
,
117 [Q_KEY_CODE_Z
] = ADB_KEY_Z
,
118 [Q_KEY_CODE_X
] = ADB_KEY_X
,
119 [Q_KEY_CODE_C
] = ADB_KEY_C
,
120 [Q_KEY_CODE_V
] = ADB_KEY_V
,
121 [Q_KEY_CODE_B
] = ADB_KEY_B
,
122 [Q_KEY_CODE_N
] = ADB_KEY_N
,
123 [Q_KEY_CODE_M
] = ADB_KEY_M
,
124 [Q_KEY_CODE_COMMA
] = ADB_KEY_COMMA
,
125 [Q_KEY_CODE_DOT
] = ADB_KEY_PERIOD
,
126 [Q_KEY_CODE_SLASH
] = ADB_KEY_FORWARD_SLASH
,
127 [Q_KEY_CODE_ASTERISK
] = ADB_KEY_KP_MULTIPLY
,
128 [Q_KEY_CODE_CAPS_LOCK
] = ADB_KEY_CAPS_LOCK
,
130 [Q_KEY_CODE_F1
] = ADB_KEY_F1
,
131 [Q_KEY_CODE_F2
] = ADB_KEY_F2
,
132 [Q_KEY_CODE_F3
] = ADB_KEY_F3
,
133 [Q_KEY_CODE_F4
] = ADB_KEY_F4
,
134 [Q_KEY_CODE_F5
] = ADB_KEY_F5
,
135 [Q_KEY_CODE_F6
] = ADB_KEY_F6
,
136 [Q_KEY_CODE_F7
] = ADB_KEY_F7
,
137 [Q_KEY_CODE_F8
] = ADB_KEY_F8
,
138 [Q_KEY_CODE_F9
] = ADB_KEY_F9
,
139 [Q_KEY_CODE_F10
] = ADB_KEY_F10
,
140 [Q_KEY_CODE_F11
] = ADB_KEY_F11
,
141 [Q_KEY_CODE_F12
] = ADB_KEY_F12
,
142 [Q_KEY_CODE_PRINT
] = ADB_KEY_F13
,
143 [Q_KEY_CODE_SYSRQ
] = ADB_KEY_F13
,
144 [Q_KEY_CODE_SCROLL_LOCK
] = ADB_KEY_F14
,
145 [Q_KEY_CODE_PAUSE
] = ADB_KEY_F15
,
147 [Q_KEY_CODE_NUM_LOCK
] = ADB_KEY_KP_CLEAR
,
148 [Q_KEY_CODE_KP_EQUALS
] = ADB_KEY_KP_EQUAL
,
149 [Q_KEY_CODE_KP_DIVIDE
] = ADB_KEY_KP_DIVIDE
,
150 [Q_KEY_CODE_KP_MULTIPLY
] = ADB_KEY_KP_MULTIPLY
,
151 [Q_KEY_CODE_KP_SUBTRACT
] = ADB_KEY_KP_SUBTRACT
,
152 [Q_KEY_CODE_KP_ADD
] = ADB_KEY_KP_PLUS
,
153 [Q_KEY_CODE_KP_ENTER
] = ADB_KEY_KP_ENTER
,
154 [Q_KEY_CODE_KP_DECIMAL
] = ADB_KEY_KP_PERIOD
,
155 [Q_KEY_CODE_KP_0
] = ADB_KEY_KP_0
,
156 [Q_KEY_CODE_KP_1
] = ADB_KEY_KP_1
,
157 [Q_KEY_CODE_KP_2
] = ADB_KEY_KP_2
,
158 [Q_KEY_CODE_KP_3
] = ADB_KEY_KP_3
,
159 [Q_KEY_CODE_KP_4
] = ADB_KEY_KP_4
,
160 [Q_KEY_CODE_KP_5
] = ADB_KEY_KP_5
,
161 [Q_KEY_CODE_KP_6
] = ADB_KEY_KP_6
,
162 [Q_KEY_CODE_KP_7
] = ADB_KEY_KP_7
,
163 [Q_KEY_CODE_KP_8
] = ADB_KEY_KP_8
,
164 [Q_KEY_CODE_KP_9
] = ADB_KEY_KP_9
,
166 [Q_KEY_CODE_UP
] = ADB_KEY_UP
,
167 [Q_KEY_CODE_DOWN
] = ADB_KEY_DOWN
,
168 [Q_KEY_CODE_LEFT
] = ADB_KEY_LEFT
,
169 [Q_KEY_CODE_RIGHT
] = ADB_KEY_RIGHT
,
171 [Q_KEY_CODE_HELP
] = ADB_KEY_HELP
,
172 [Q_KEY_CODE_INSERT
] = ADB_KEY_HELP
,
173 [Q_KEY_CODE_DELETE
] = ADB_KEY_FORWARD_DELETE
,
174 [Q_KEY_CODE_HOME
] = ADB_KEY_HOME
,
175 [Q_KEY_CODE_END
] = ADB_KEY_END
,
176 [Q_KEY_CODE_PGUP
] = ADB_KEY_PAGE_UP
,
177 [Q_KEY_CODE_PGDN
] = ADB_KEY_PAGE_DOWN
,
179 [Q_KEY_CODE_POWER
] = ADB_KEY_POWER
182 static void adb_kbd_put_keycode(void *opaque
, int keycode
)
184 KBDState
*s
= opaque
;
186 if (s
->count
< sizeof(s
->data
)) {
187 s
->data
[s
->wptr
] = keycode
;
188 if (++s
->wptr
== sizeof(s
->data
)) {
195 static int adb_kbd_poll(ADBDevice
*d
, uint8_t *obuf
)
197 KBDState
*s
= ADB_KEYBOARD(d
);
205 keycode
= s
->data
[s
->rptr
];
207 if (s
->rptr
== sizeof(s
->data
)) {
212 * The power key is the only two byte value key, so it is a special case.
213 * Since 0x7f is not a used keycode for ADB we overload it to indicate the
214 * power button when we're storing keycodes in our internal buffer, and
215 * expand it out to two bytes when we send to the guest.
217 if (keycode
== 0x7f) {
223 /* NOTE: the power key key-up is the two byte sequence 0xff 0xff;
224 * otherwise we could in theory send a second keycode in the second
225 * byte, but choose not to bother.
234 static int adb_kbd_request(ADBDevice
*d
, uint8_t *obuf
,
235 const uint8_t *buf
, int len
)
237 KBDState
*s
= ADB_KEYBOARD(d
);
240 if ((buf
[0] & 0x0f) == ADB_FLUSH
) {
241 /* flush keyboard fifo */
242 s
->wptr
= s
->rptr
= s
->count
= 0;
251 trace_adb_kbd_writereg(reg
, buf
[1]);
258 case ADB_CMD_SELF_TEST
:
260 case ADB_CMD_CHANGE_ID
:
261 case ADB_CMD_CHANGE_ID_AND_ACT
:
262 case ADB_CMD_CHANGE_ID_AND_ENABLE
:
263 d
->devaddr
= buf
[1] & 0xf;
264 trace_adb_kbd_request_change_addr(d
->devaddr
);
267 if (!d
->disable_direct_reg3_writes
) {
268 d
->devaddr
= buf
[1] & 0xf;
270 /* we support handlers:
271 * 1: Apple Standard Keyboard
272 * 2: Apple Extended Keyboard (LShift = RShift)
273 * 3: Apple Extended Keyboard (LShift != RShift)
275 if (buf
[2] == 1 || buf
[2] == 2 || buf
[2] == 3) {
279 trace_adb_kbd_request_change_addr_and_handler(d
->devaddr
,
289 olen
= adb_kbd_poll(d
, obuf
);
294 obuf
[0] = 0x00; /* XXX: check this */
295 obuf
[1] = 0x07; /* led status */
299 obuf
[0] = d
->devaddr
;
300 obuf
[1] = d
->handler
;
304 trace_adb_kbd_readreg(reg
, obuf
[0], obuf
[1]);
310 /* This is where keyboard events enter this file */
311 static void adb_keyboard_event(DeviceState
*dev
, QemuConsole
*src
,
314 KBDState
*s
= (KBDState
*)dev
;
317 qcode
= qemu_input_key_value_to_qcode(evt
->u
.key
.data
->key
);
318 if (qcode
>= ARRAY_SIZE(qcode_to_adb_keycode
)) {
321 /* FIXME: take handler into account when translating qcode */
322 keycode
= qcode_to_adb_keycode
[qcode
];
323 if (keycode
== NO_KEY
) { /* We don't want to send this to the guest */
324 trace_adb_kbd_no_key();
327 if (evt
->u
.key
.data
->down
== false) { /* if key release event */
328 keycode
= keycode
| 0x80; /* create keyboard break code */
331 adb_kbd_put_keycode(s
, keycode
);
334 static const VMStateDescription vmstate_adb_kbd
= {
337 .minimum_version_id
= 2,
338 .fields
= (VMStateField
[]) {
339 VMSTATE_STRUCT(parent_obj
, KBDState
, 0, vmstate_adb_device
, ADBDevice
),
340 VMSTATE_BUFFER(data
, KBDState
),
341 VMSTATE_INT32(rptr
, KBDState
),
342 VMSTATE_INT32(wptr
, KBDState
),
343 VMSTATE_INT32(count
, KBDState
),
344 VMSTATE_END_OF_LIST()
348 static void adb_kbd_reset(DeviceState
*dev
)
350 ADBDevice
*d
= ADB_DEVICE(dev
);
351 KBDState
*s
= ADB_KEYBOARD(dev
);
354 d
->devaddr
= ADB_DEVID_KEYBOARD
;
355 memset(s
->data
, 0, sizeof(s
->data
));
361 static QemuInputHandler adb_keyboard_handler
= {
362 .name
= "QEMU ADB Keyboard",
363 .mask
= INPUT_EVENT_MASK_KEY
,
364 .event
= adb_keyboard_event
,
367 static void adb_kbd_realizefn(DeviceState
*dev
, Error
**errp
)
369 ADBKeyboardClass
*akc
= ADB_KEYBOARD_GET_CLASS(dev
);
370 akc
->parent_realize(dev
, errp
);
371 qemu_input_handler_register(dev
, &adb_keyboard_handler
);
374 static void adb_kbd_initfn(Object
*obj
)
376 ADBDevice
*d
= ADB_DEVICE(obj
);
378 d
->devaddr
= ADB_DEVID_KEYBOARD
;
381 static void adb_kbd_class_init(ObjectClass
*oc
, void *data
)
383 DeviceClass
*dc
= DEVICE_CLASS(oc
);
384 ADBDeviceClass
*adc
= ADB_DEVICE_CLASS(oc
);
385 ADBKeyboardClass
*akc
= ADB_KEYBOARD_CLASS(oc
);
387 device_class_set_parent_realize(dc
, adb_kbd_realizefn
,
388 &akc
->parent_realize
);
389 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
391 adc
->devreq
= adb_kbd_request
;
392 dc
->reset
= adb_kbd_reset
;
393 dc
->vmsd
= &vmstate_adb_kbd
;
396 static const TypeInfo adb_kbd_type_info
= {
397 .name
= TYPE_ADB_KEYBOARD
,
398 .parent
= TYPE_ADB_DEVICE
,
399 .instance_size
= sizeof(KBDState
),
400 .instance_init
= adb_kbd_initfn
,
401 .class_init
= adb_kbd_class_init
,
402 .class_size
= sizeof(ADBKeyboardClass
),
405 static void adb_kbd_register_types(void)
407 type_register_static(&adb_kbd_type_info
);
410 type_init(adb_kbd_register_types
)