Revision bec9d989 hw/adb.c
| b/hw/adb.c | ||
|---|---|---|
| 43 | 43 |
#define ADB_MODEM 5 |
| 44 | 44 |
#define ADB_MISC 7 |
| 45 | 45 |
|
| 46 |
/* error codes */ |
|
| 47 |
#define ADB_RET_NOTPRESENT (-2) |
|
| 48 |
|
|
| 46 | 49 |
int adb_request(ADBBusState *s, uint8_t *obuf, const uint8_t *buf, int len) |
| 47 | 50 |
{
|
| 48 | 51 |
ADBDevice *d; |
| 49 | 52 |
int devaddr, cmd, i; |
| 50 | 53 |
|
| 51 | 54 |
cmd = buf[0] & 0xf; |
| 52 |
devaddr = buf[0] >> 4; |
|
| 53 |
if (buf[1] == ADB_BUSRESET) {
|
|
| 54 |
obuf[0] = 0x00; |
|
| 55 |
obuf[1] = 0x00; |
|
| 56 |
return 2; |
|
| 57 |
} |
|
| 58 |
if (cmd == ADB_FLUSH) {
|
|
| 59 |
obuf[0] = 0x00; |
|
| 60 |
obuf[1] = 0x00; |
|
| 61 |
return 2; |
|
| 55 |
if (cmd == ADB_BUSRESET) {
|
|
| 56 |
for(i = 0; i < s->nb_devices; i++) {
|
|
| 57 |
d = &s->devices[i]; |
|
| 58 |
if (d->devreset) {
|
|
| 59 |
d->devreset(d); |
|
| 60 |
} |
|
| 61 |
} |
|
| 62 |
return 0; |
|
| 62 | 63 |
} |
| 63 |
|
|
| 64 |
devaddr = buf[0] >> 4; |
|
| 64 | 65 |
for(i = 0; i < s->nb_devices; i++) {
|
| 65 | 66 |
d = &s->devices[i]; |
| 66 | 67 |
if (d->devaddr == devaddr) {
|
| 67 | 68 |
return d->devreq(d, obuf, buf, len); |
| 68 | 69 |
} |
| 69 | 70 |
} |
| 70 |
return 0;
|
|
| 71 |
return ADB_RET_NOTPRESENT;
|
|
| 71 | 72 |
} |
| 72 | 73 |
|
| 74 |
/* XXX: move that to cuda ? */ |
|
| 73 | 75 |
int adb_poll(ADBBusState *s, uint8_t *obuf) |
| 74 | 76 |
{
|
| 75 | 77 |
ADBDevice *d; |
| 76 | 78 |
int olen, i; |
| 79 |
uint8_t buf[1]; |
|
| 77 | 80 |
|
| 78 | 81 |
olen = 0; |
| 79 | 82 |
for(i = 0; i < s->nb_devices; i++) {
|
| 80 | 83 |
if (s->poll_index >= s->nb_devices) |
| 81 | 84 |
s->poll_index = 0; |
| 82 | 85 |
d = &s->devices[s->poll_index]; |
| 83 |
olen = d->devreq(d, obuf, NULL, 0); |
|
| 84 |
s->poll_index++; |
|
| 85 |
if (olen) |
|
| 86 |
buf[0] = ADB_READREG | (d->devaddr << 4); |
|
| 87 |
olen = adb_request(s, obuf + 1, buf, 1); |
|
| 88 |
/* if there is data, we poll again the same device */ |
|
| 89 |
if (olen > 0) {
|
|
| 90 |
obuf[0] = buf[0]; |
|
| 91 |
olen++; |
|
| 86 | 92 |
break; |
| 93 |
} |
|
| 94 |
s->poll_index++; |
|
| 87 | 95 |
} |
| 88 | 96 |
return olen; |
| 89 | 97 |
} |
| 90 | 98 |
|
| 91 | 99 |
ADBDevice *adb_register_device(ADBBusState *s, int devaddr, |
| 92 | 100 |
ADBDeviceRequest *devreq, |
| 101 |
ADBDeviceReset *devreset, |
|
| 93 | 102 |
void *opaque) |
| 94 | 103 |
{
|
| 95 | 104 |
ADBDevice *d; |
| ... | ... | |
| 99 | 108 |
d->bus = s; |
| 100 | 109 |
d->devaddr = devaddr; |
| 101 | 110 |
d->devreq = devreq; |
| 111 |
d->devreset = devreset; |
|
| 102 | 112 |
d->opaque = opaque; |
| 103 | 113 |
return d; |
| 104 | 114 |
} |
| ... | ... | |
| 166 | 176 |
adb_keycode = pc_to_adb_keycode[keycode | 0x80]; |
| 167 | 177 |
else |
| 168 | 178 |
adb_keycode = pc_to_adb_keycode[keycode & 0x7f]; |
| 169 |
obuf[0] = (d->devaddr << 4) | 0x0c;
|
|
| 170 |
obuf[1] = adb_keycode | (keycode & 0x80);
|
|
| 171 |
obuf[2] = 0xff;
|
|
| 172 |
olen = 3;
|
|
| 179 |
obuf[0] = adb_keycode | (keycode & 0x80);
|
|
| 180 |
/* NOTE: could put a second keycode if needed */
|
|
| 181 |
obuf[1] = 0xff;
|
|
| 182 |
olen = 2;
|
|
| 173 | 183 |
ext_keycode = 0; |
| 174 | 184 |
break; |
| 175 | 185 |
} |
| ... | ... | |
| 180 | 190 |
static int adb_kbd_request(ADBDevice *d, uint8_t *obuf, |
| 181 | 191 |
const uint8_t *buf, int len) |
| 182 | 192 |
{
|
| 193 |
KBDState *s = d->opaque; |
|
| 183 | 194 |
int cmd, reg, olen; |
| 184 | 195 |
|
| 185 |
if (!buf) {
|
|
| 186 |
return adb_kbd_poll(d, obuf); |
|
| 196 |
if ((buf[0] & 0x0f) == ADB_FLUSH) {
|
|
| 197 |
/* flush keyboard fifo */ |
|
| 198 |
s->wptr = s->rptr = s->count = 0; |
|
| 199 |
return 0; |
|
| 187 | 200 |
} |
| 188 | 201 |
|
| 189 | 202 |
cmd = buf[0] & 0xc; |
| ... | ... | |
| 214 | 227 |
break; |
| 215 | 228 |
case ADB_READREG: |
| 216 | 229 |
switch(reg) {
|
| 230 |
case 0: |
|
| 231 |
olen = adb_kbd_poll(d, obuf); |
|
| 232 |
break; |
|
| 217 | 233 |
case 1: |
| 218 | 234 |
break; |
| 219 | 235 |
case 2: |
| ... | ... | |
| 237 | 253 |
ADBDevice *d; |
| 238 | 254 |
KBDState *s; |
| 239 | 255 |
s = qemu_mallocz(sizeof(KBDState)); |
| 240 |
d = adb_register_device(bus, ADB_KEYBOARD, adb_kbd_request, s); |
|
| 256 |
d = adb_register_device(bus, ADB_KEYBOARD, adb_kbd_request, NULL, s);
|
|
| 241 | 257 |
d->handler = 1; |
| 242 | 258 |
qemu_add_kbd_event_handler(adb_kbd_put_keycode, d); |
| 243 | 259 |
} |
| ... | ... | |
| 291 | 307 |
dx &= 0x7f; |
| 292 | 308 |
dy &= 0x7f; |
| 293 | 309 |
|
| 294 |
if (s->buttons_state & MOUSE_EVENT_LBUTTON)
|
|
| 310 |
if (!(s->buttons_state & MOUSE_EVENT_LBUTTON))
|
|
| 295 | 311 |
dy |= 0x80; |
| 296 |
if (s->buttons_state & MOUSE_EVENT_RBUTTON)
|
|
| 312 |
if (!(s->buttons_state & MOUSE_EVENT_RBUTTON))
|
|
| 297 | 313 |
dx |= 0x80; |
| 298 | 314 |
|
| 299 |
obuf[0] = (d->devaddr << 4) | 0x0c; |
|
| 300 |
obuf[1] = dy; |
|
| 301 |
obuf[2] = dx; |
|
| 302 |
return 3; |
|
| 315 |
obuf[0] = dy; |
|
| 316 |
obuf[1] = dx; |
|
| 317 |
return 2; |
|
| 303 | 318 |
} |
| 304 | 319 |
|
| 305 | 320 |
static int adb_mouse_request(ADBDevice *d, uint8_t *obuf, |
| 306 | 321 |
const uint8_t *buf, int len) |
| 307 | 322 |
{
|
| 323 |
MouseState *s = d->opaque; |
|
| 308 | 324 |
int cmd, reg, olen; |
| 309 | 325 |
|
| 310 |
if (!buf) {
|
|
| 311 |
return adb_mouse_poll(d, obuf); |
|
| 326 |
if ((buf[0] & 0x0f) == ADB_FLUSH) {
|
|
| 327 |
/* flush mouse fifo */ |
|
| 328 |
s->buttons_state = s->last_buttons_state; |
|
| 329 |
s->dx = 0; |
|
| 330 |
s->dy = 0; |
|
| 331 |
s->dz = 0; |
|
| 332 |
return 0; |
|
| 312 | 333 |
} |
| 313 | 334 |
|
| 314 | 335 |
cmd = buf[0] & 0xc; |
| ... | ... | |
| 337 | 358 |
break; |
| 338 | 359 |
case ADB_READREG: |
| 339 | 360 |
switch(reg) {
|
| 361 |
case 0: |
|
| 362 |
olen = adb_mouse_poll(d, obuf); |
|
| 363 |
break; |
|
| 340 | 364 |
case 1: |
| 341 | 365 |
break; |
| 342 | 366 |
case 3: |
| ... | ... | |
| 356 | 380 |
MouseState *s; |
| 357 | 381 |
|
| 358 | 382 |
s = qemu_mallocz(sizeof(MouseState)); |
| 359 |
d = adb_register_device(bus, ADB_MOUSE, adb_mouse_request, s); |
|
| 383 |
d = adb_register_device(bus, ADB_MOUSE, adb_mouse_request, NULL, s);
|
|
| 360 | 384 |
d->handler = 2; |
| 361 | 385 |
qemu_add_mouse_event_handler(adb_mouse_event, d); |
| 362 | 386 |
} |
Also available in: Unified diff