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 "hw/qdev-properties.h"
28#include "migration/vmstate.h"
29#include "qemu/module.h"
30#include "qemu/timer.h"
31#include "adb-internal.h"
32#include "trace.h"
33
34
35#define ADB_RET_NOTPRESENT (-2)
36
37static const char *adb_commands[] = {
38 "RESET", "FLUSH", "(Reserved 0x2)", "(Reserved 0x3)",
39 "Reserved (0x4)", "(Reserved 0x5)", "(Reserved 0x6)", "(Reserved 0x7)",
40 "LISTEN r0", "LISTEN r1", "LISTEN r2", "LISTEN r3",
41 "TALK r0", "TALK r1", "TALK r2", "TALK r3",
42};
43
44static void adb_device_reset(ADBDevice *d)
45{
46 device_cold_reset(DEVICE(d));
47}
48
49static int do_adb_request(ADBBusState *s, uint8_t *obuf, const uint8_t *buf,
50 int len)
51{
52 ADBDevice *d;
53 ADBDeviceClass *adc;
54 int devaddr, cmd, olen, i;
55
56 cmd = buf[0] & 0xf;
57 if (cmd == ADB_BUSRESET) {
58 for (i = 0; i < s->nb_devices; i++) {
59 d = s->devices[i];
60 adb_device_reset(d);
61 }
62 s->status = 0;
63 return 0;
64 }
65
66 s->pending = 0;
67 for (i = 0; i < s->nb_devices; i++) {
68 d = s->devices[i];
69 adc = ADB_DEVICE_GET_CLASS(d);
70
71 if (adc->devhasdata(d)) {
72 s->pending |= (1 << d->devaddr);
73 }
74 }
75
76 s->status = 0;
77 devaddr = buf[0] >> 4;
78 for (i = 0; i < s->nb_devices; i++) {
79 d = s->devices[i];
80 adc = ADB_DEVICE_GET_CLASS(d);
81
82 if (d->devaddr == devaddr) {
83 olen = adc->devreq(d, obuf, buf, len);
84 if (!olen) {
85 s->status |= ADB_STATUS_BUSTIMEOUT;
86 }
87 return olen;
88 }
89 }
90
91 s->status |= ADB_STATUS_BUSTIMEOUT;
92 return ADB_RET_NOTPRESENT;
93}
94
95int adb_request(ADBBusState *s, uint8_t *obuf, const uint8_t *buf, int len)
96{
97 int ret;
98
99 trace_adb_bus_request(buf[0] >> 4, adb_commands[buf[0] & 0xf], len);
100
101 assert(s->autopoll_blocked);
102
103 ret = do_adb_request(s, obuf, buf, len);
104
105 trace_adb_bus_request_done(buf[0] >> 4, adb_commands[buf[0] & 0xf], ret);
106 return ret;
107}
108
109int adb_poll(ADBBusState *s, uint8_t *obuf, uint16_t poll_mask)
110{
111 ADBDevice *d;
112 int olen, i;
113 uint8_t buf[1];
114
115 olen = 0;
116 for (i = 0; i < s->nb_devices; i++) {
117 if (s->poll_index >= s->nb_devices) {
118 s->poll_index = 0;
119 }
120 d = s->devices[s->poll_index];
121 if ((1 << d->devaddr) & poll_mask) {
122 buf[0] = ADB_READREG | (d->devaddr << 4);
123 olen = do_adb_request(s, obuf + 1, buf, 1);
124
125 if (olen > 0) {
126 s->status |= ADB_STATUS_POLLREPLY;
127 obuf[0] = buf[0];
128 olen++;
129 return olen;
130 }
131 }
132 s->poll_index++;
133 }
134 return olen;
135}
136
137void adb_set_autopoll_enabled(ADBBusState *s, bool enabled)
138{
139 if (s->autopoll_enabled != enabled) {
140 s->autopoll_enabled = enabled;
141 if (s->autopoll_enabled) {
142 timer_mod(s->autopoll_timer,
143 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
144 s->autopoll_rate_ms);
145 } else {
146 timer_del(s->autopoll_timer);
147 }
148 }
149}
150
151void adb_set_autopoll_rate_ms(ADBBusState *s, int rate_ms)
152{
153 s->autopoll_rate_ms = rate_ms;
154
155 if (s->autopoll_enabled) {
156 timer_mod(s->autopoll_timer,
157 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
158 s->autopoll_rate_ms);
159 }
160}
161
162void adb_set_autopoll_mask(ADBBusState *s, uint16_t mask)
163{
164 if (s->autopoll_mask != mask) {
165 s->autopoll_mask = mask;
166 if (s->autopoll_enabled && s->autopoll_mask) {
167 timer_mod(s->autopoll_timer,
168 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
169 s->autopoll_rate_ms);
170 } else {
171 timer_del(s->autopoll_timer);
172 }
173 }
174}
175
176void adb_autopoll_block(ADBBusState *s)
177{
178 s->autopoll_blocked = true;
179 trace_adb_bus_autopoll_block(s->autopoll_blocked);
180
181 if (s->autopoll_enabled) {
182 timer_del(s->autopoll_timer);
183 }
184}
185
186void adb_autopoll_unblock(ADBBusState *s)
187{
188 s->autopoll_blocked = false;
189 trace_adb_bus_autopoll_block(s->autopoll_blocked);
190
191 if (s->autopoll_enabled) {
192 timer_mod(s->autopoll_timer,
193 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
194 s->autopoll_rate_ms);
195 }
196}
197
198static void adb_autopoll(void *opaque)
199{
200 ADBBusState *s = opaque;
201
202 if (!s->autopoll_blocked) {
203 trace_adb_bus_autopoll_cb(s->autopoll_mask);
204 s->autopoll_cb(s->autopoll_cb_opaque);
205 trace_adb_bus_autopoll_cb_done(s->autopoll_mask);
206 }
207
208 timer_mod(s->autopoll_timer,
209 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
210 s->autopoll_rate_ms);
211}
212
213void adb_register_autopoll_callback(ADBBusState *s, void (*cb)(void *opaque),
214 void *opaque)
215{
216 s->autopoll_cb = cb;
217 s->autopoll_cb_opaque = opaque;
218}
219
220static const VMStateDescription vmstate_adb_bus = {
221 .name = "adb_bus",
222 .version_id = 0,
223 .minimum_version_id = 0,
224 .fields = (VMStateField[]) {
225 VMSTATE_TIMER_PTR(autopoll_timer, ADBBusState),
226 VMSTATE_BOOL(autopoll_enabled, ADBBusState),
227 VMSTATE_UINT8(autopoll_rate_ms, ADBBusState),
228 VMSTATE_UINT16(autopoll_mask, ADBBusState),
229 VMSTATE_BOOL(autopoll_blocked, ADBBusState),
230 VMSTATE_END_OF_LIST()
231 }
232};
233
234static void adb_bus_reset(BusState *qbus)
235{
236 ADBBusState *adb_bus = ADB_BUS(qbus);
237
238 adb_bus->autopoll_enabled = false;
239 adb_bus->autopoll_mask = 0xffff;
240 adb_bus->autopoll_rate_ms = 20;
241}
242
243static void adb_bus_realize(BusState *qbus, Error **errp)
244{
245 ADBBusState *adb_bus = ADB_BUS(qbus);
246
247 adb_bus->autopoll_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, adb_autopoll,
248 adb_bus);
249
250 vmstate_register(NULL, -1, &vmstate_adb_bus, adb_bus);
251}
252
253static void adb_bus_unrealize(BusState *qbus)
254{
255 ADBBusState *adb_bus = ADB_BUS(qbus);
256
257 timer_del(adb_bus->autopoll_timer);
258
259 vmstate_unregister(NULL, &vmstate_adb_bus, adb_bus);
260}
261
262static void adb_bus_class_init(ObjectClass *klass, void *data)
263{
264 BusClass *k = BUS_CLASS(klass);
265
266 k->realize = adb_bus_realize;
267 k->unrealize = adb_bus_unrealize;
268 k->reset = adb_bus_reset;
269}
270
271static const TypeInfo adb_bus_type_info = {
272 .name = TYPE_ADB_BUS,
273 .parent = TYPE_BUS,
274 .instance_size = sizeof(ADBBusState),
275 .class_init = adb_bus_class_init,
276};
277
278const VMStateDescription vmstate_adb_device = {
279 .name = "adb_device",
280 .version_id = 0,
281 .minimum_version_id = 0,
282 .fields = (VMStateField[]) {
283 VMSTATE_INT32(devaddr, ADBDevice),
284 VMSTATE_INT32(handler, ADBDevice),
285 VMSTATE_END_OF_LIST()
286 }
287};
288
289static void adb_device_realizefn(DeviceState *dev, Error **errp)
290{
291 ADBDevice *d = ADB_DEVICE(dev);
292 ADBBusState *bus = ADB_BUS(qdev_get_parent_bus(dev));
293
294 if (bus->nb_devices >= MAX_ADB_DEVICES) {
295 return;
296 }
297
298 bus->devices[bus->nb_devices++] = d;
299}
300
301static void adb_device_class_init(ObjectClass *oc, void *data)
302{
303 DeviceClass *dc = DEVICE_CLASS(oc);
304
305 dc->realize = adb_device_realizefn;
306 dc->bus_type = TYPE_ADB_BUS;
307}
308
309static const TypeInfo adb_device_type_info = {
310 .name = TYPE_ADB_DEVICE,
311 .parent = TYPE_DEVICE,
312 .class_size = sizeof(ADBDeviceClass),
313 .instance_size = sizeof(ADBDevice),
314 .abstract = true,
315 .class_init = adb_device_class_init,
316};
317
318static void adb_register_types(void)
319{
320 type_register_static(&adb_bus_type_info);
321 type_register_static(&adb_device_type_info);
322}
323
324type_init(adb_register_types)
325
