adb: Correct class size on TYPE_ADB_DEVICE
[qemu.git] / hw / input / adb.c
1 /*
2 * QEMU ADB support
3 *
4 * Copyright (c) 2004 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
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 /* error codes */
35 #define ADB_RET_NOTPRESENT (-2)
36
37 static 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
44 static void adb_device_reset(ADBDevice *d)
45 {
46 qdev_reset_all(DEVICE(d));
47 }
48
49 static 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
95 int 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
109 int 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 /* if there is data, we poll again the same device */
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
137 void 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
151 void 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
162 void 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
176 void 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
186 void 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
198 static 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
213 void 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
220 static 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
234 static 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
243 static 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
253 static 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
262 static 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
271 static 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
278 const 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
289 static 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
301 static 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
309 static 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
318 static void adb_register_types(void)
319 {
320 type_register_static(&adb_bus_type_info);
321 type_register_static(&adb_device_type_info);
322 }
323
324 type_init(adb_register_types)