void slavio_serial_ms_kbd_init(target_phys_addr_t base, qemu_irq irq, int disabled) { int slavio_serial_io_memory, i; SerialState *s; s = qemu_mallocz(sizeof(SerialState)); if (!s) return; for (i = 0; i < 2; i++) { s->chn[i].irq = irq; s->chn[i].chn = 1 - i; s->chn[i].chr = NULL; } s->chn[0].otherchn = &s->chn[1]; s->chn[1].otherchn = &s->chn[0]; s->chn[0].type = mouse; s->chn[1].type = kbd; s->chn[0].disabled = disabled; s->chn[1].disabled = disabled; slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read, slavio_serial_mem_write, s); cpu_register_physical_memory(base, SERIAL_SIZE, slavio_serial_io_memory); qemu_add_mouse_event_handler(sunmouse_event, &s->chn[0], 0, "QEMU Sun Mouse"); qemu_add_kbd_event_handler(sunkbd_event, &s->chn[1]); register_savevm("slavio_serial_mouse", base, 2, slavio_serial_save, slavio_serial_load, s); qemu_register_reset(slavio_serial_reset, s); slavio_serial_reset(s); }
static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len) { int b; if (!s->mouse_grabbed) { s->eh_entry = qemu_add_mouse_event_handler(usb_wacom_event, s, 1, //"QEMU PenPartner tablet"); "DELL PenPartner tablet"); s->mouse_grabbed = 1; } b = 0; if (s->buttons_state & MOUSE_EVENT_LBUTTON) b |= 0x01; if (s->buttons_state & MOUSE_EVENT_RBUTTON) b |= 0x02; if (s->buttons_state & MOUSE_EVENT_MBUTTON) b |= 0x04; if (len < 7) return 0; buf[0] = s->mode; buf[5] = 0x00; if (b) { buf[1] = s->x & 0xff; buf[2] = s->x >> 8; buf[3] = s->y & 0xff; buf[4] = s->y >> 8; buf[6] = 0; } else {
static int usb_tablet_poll(USBHIDState *hs, uint8_t *buf, int len) { int dz, b, l; USBMouseState *s = &hs->ptr; if (!s->mouse_grabbed) { s->eh_entry = qemu_add_mouse_event_handler(usb_tablet_event, hs, 1, "QEMU USB Tablet"); s->mouse_grabbed = 1; } dz = int_clamp(s->dz, -128, 127); s->dz -= dz; /* Appears we have to invert the wheel direction */ dz = 0 - dz; b = 0; if (s->buttons_state & MOUSE_EVENT_LBUTTON) b |= 0x01; if (s->buttons_state & MOUSE_EVENT_RBUTTON) b |= 0x02; if (s->buttons_state & MOUSE_EVENT_MBUTTON) b |= 0x04; buf[0] = b; buf[1] = s->x & 0xff; buf[2] = s->x >> 8; buf[3] = s->y & 0xff; buf[4] = s->y >> 8; buf[5] = dz; l = 6; return l; }
static void usb_mouse_handle_destroy(USBDevice *dev) { USBMouseState *s = (USBMouseState *)dev; qemu_add_mouse_event_handler(NULL, NULL, 0); free(s); }
/* Register a QEMU graphical console, and key/mouse handler, * connecting up their events to the frontend */ static int xenfb_register_console(struct xenfb *xenfb) { /* Register our keyboard & mouse handlers */ qemu_add_kbd_event_handler(xenfb_key_event, xenfb); qemu_add_mouse_event_handler(xenfb_mouse_event, xenfb, xenfb->abs_pointer_wanted, "Xen PVFB Mouse"); /* Tell QEMU to allocate a graphical console */ graphic_console_init(xenfb->ds, xenfb_update, xenfb_invalidate, xenfb_screen_dump, xenfb); if (xenfb->ds->dpy_resize_shared) dpy_resize_shared(xenfb->ds, xenfb->width, xenfb->height, xenfb->depth, xenfb->row_stride, xenfb->pixels + xenfb->offset); else dpy_resize(xenfb->ds, xenfb->width, xenfb->height); if (qemu_set_fd_handler2(xc_evtchn_fd(xenfb->evt_xch), NULL, xenfb_dispatch_channel, NULL, xenfb) < 0) return -1; if (qemu_set_fd_handler2(xs_fileno(xenfb->xsh), NULL, xenfb_dispatch_store, NULL, xenfb) < 0) return -1; fprintf(stderr, "Xen Framebuffer registered\n"); return 0; }
void slavio_serial_ms_kbd_init(int base, int irq) { int slavio_serial_io_memory, i; SerialState *s; s = qemu_mallocz(sizeof(SerialState)); if (!s) return; for (i = 0; i < 2; i++) { s->chn[i].irq = irq; s->chn[i].chn = 1 - i; s->chn[i].chr = NULL; } s->chn[0].otherchn = &s->chn[1]; s->chn[1].otherchn = &s->chn[0]; s->chn[0].type = mouse; s->chn[1].type = kbd; slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read, slavio_serial_mem_write, s); cpu_register_physical_memory(base, SERIAL_MAXADDR, slavio_serial_io_memory); qemu_add_mouse_event_handler(sunmouse_event, &s->chn[0], 0, "QEMU Sun Mouse"); qemu_add_kbd_event_handler(sunkbd_event, &s->chn[1]); qemu_register_reset(slavio_serial_reset, s); slavio_serial_reset(s); }
static int input_connect(struct XenDevice *xendev) { struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); int rc; if (xenstore_read_fe_int(xendev, "request-abs-pointer", &in->abs_pointer_wanted) == -1) in->abs_pointer_wanted = 0; if (!in->c.ds) { char *vfb = xenstore_read_str(NULL, "device/vfb"); if (vfb == NULL) { /* there is no vfb, run vkbd on its own */ in->c.ds = get_displaystate(); } else { qemu_free(vfb); xen_be_printf(xendev, 1, "ds not set (yet)\n"); return -1; } } rc = common_bind(&in->c); if (rc != 0) return rc; qemu_add_kbd_event_handler(xenfb_key_event, in); in->qmouse = qemu_add_mouse_event_handler(xenfb_mouse_event, in, in->abs_pointer_wanted, "Xen PVFB Mouse"); return 0; }
static int usb_mouse_poll(USBMouseState *s, uint8_t *buf, int len) { int dx, dy, dz, b, l; if (!s->mouse_grabbed) { qemu_add_mouse_event_handler(usb_mouse_event, s, 0); s->mouse_grabbed = 1; } dx = int_clamp(s->dx, -128, 127); dy = int_clamp(s->dy, -128, 127); dz = int_clamp(s->dz, -128, 127); s->dx -= dx; s->dy -= dy; s->dz -= dz; b = 0; if (s->buttons_state & MOUSE_EVENT_LBUTTON) b |= 0x01; if (s->buttons_state & MOUSE_EVENT_RBUTTON) b |= 0x02; if (s->buttons_state & MOUSE_EVENT_MBUTTON) b |= 0x04; buf[0] = b; buf[1] = dx; buf[2] = dy; l = 3; if (len >= 4) { buf[3] = dz; l = 4; } return l; }
static void adb_mouse_realizefn(DeviceState *dev, Error **errp) { MouseState *s = ADB_MOUSE(dev); ADBMouseClass *amc = ADB_MOUSE_GET_CLASS(dev); amc->parent_realize(dev, errp); qemu_add_mouse_event_handler(adb_mouse_event, s, 0, "QEMU ADB Mouse"); }
static void vmmouse_update_handler(VMMouseState *s) { if (s->entry) { qemu_remove_mouse_event_handler(s->entry); s->entry = NULL; } if (s->status == 0) s->entry = qemu_add_mouse_event_handler(vmmouse_mouse_event, s, s->absolute, "vmmouse"); }
void adb_mouse_init(ADBBusState *bus) { ADBDevice *d; MouseState *s; s = g_malloc0(sizeof(MouseState)); d = adb_register_device(bus, ADB_MOUSE, adb_mouse_request, adb_mouse_reset, s); qemu_add_mouse_event_handler(adb_mouse_event, d, 0, "QEMU ADB Mouse"); vmstate_register(NULL, -1, &vmstate_adb_mouse, s); }
void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg) { PS2MouseState *s = (PS2MouseState *)qemu_mallocz(sizeof(PS2MouseState)); s->common.update_irq = update_irq; s->common.update_arg = update_arg; vmstate_register(NULL, 0, &vmstate_ps2_mouse, s); qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse"); qemu_register_reset(ps2_mouse_reset, s); return s; }
void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg) { PS2MouseState *s = (PS2MouseState *)qemu_mallocz(sizeof(PS2MouseState)); s->common.update_irq = update_irq; s->common.update_arg = update_arg; ps2_reset(&s->common); register_savevm("ps2mouse", 0, 2, ps2_mouse_save, ps2_mouse_load, s); qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse"); qemu_register_reset(ps2_reset, &s->common); return s; }
int qemu_chr_open_msmouse(QemuOpts *opts, CharDriverState **_chr) { CharDriverState *chr; chr = g_malloc0(sizeof(CharDriverState)); chr->chr_write = msmouse_chr_write; chr->chr_close = msmouse_chr_close; qemu_add_mouse_event_handler(msmouse_event, chr, 0, "QEMU Microsoft Mouse"); *_chr = chr; return 0; }
static CharDriverState *qemu_chr_open_msmouse(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp) { CharDriverState *chr; chr = qemu_chr_alloc(); chr->chr_write = msmouse_chr_write; chr->chr_close = msmouse_chr_close; chr->explicit_be_open = true; qemu_add_mouse_event_handler(msmouse_event, chr, 0, "QEMU Microsoft Mouse"); return chr; }
static void vmmouse_update_handler(VMMouseState *s, int absolute) { if (s->status != 0) { return; } if (s->absolute != absolute) { s->absolute = absolute; vmmouse_remove_handler(s); } if (s->entry == NULL) { s->entry = qemu_add_mouse_event_handler(vmmouse_mouse_event, s, s->absolute, "vmmouse"); qemu_activate_mouse_event_handler(s->entry); } }
static void input_connected(struct XenDevice *xendev) { struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); if (xenstore_read_fe_int(xendev, "request-abs-pointer", &in->abs_pointer_wanted) == -1) { in->abs_pointer_wanted = 0; } if (in->qmouse) { qemu_remove_mouse_event_handler(in->qmouse); } in->qmouse = qemu_add_mouse_event_handler(xenfb_mouse_event, in, in->abs_pointer_wanted, "Xen PVFB Mouse"); }
static int input_connect(struct XenDevice *xendev) { struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); int rc; if (xenstore_read_fe_int(xendev, "request-abs-pointer", &in->abs_pointer_wanted) == -1) in->abs_pointer_wanted = 0; rc = common_bind(&in->c); if (rc != 0) return rc; qemu_add_kbd_event_handler(xenfb_key_event, in); in->qmouse = qemu_add_mouse_event_handler(xenfb_mouse_event, in, in->abs_pointer_wanted, "Xen PVFB Mouse"); return 0; }
void events_dev_init(uint32_t base, qemu_irq irq) { events_state *s; int iomemtype; AndroidHwConfig* config = android_hw; s = (events_state *) qemu_mallocz(sizeof(events_state)); /* now set the events capability bits depending on hardware configuration */ /* apparently, the EV_SYN array is used to indicate which other * event classes to consider. */ /* configure EV_KEY array * * All Android devices must have the following keys: * KEY_HOME, KEY_BACK, KEY_SEND (Call), KEY_END (EndCall), * KEY_SOFT1 (Menu), VOLUME_UP, VOLUME_DOWN * * Note that previous models also had a KEY_SOFT2, * and a KEY_POWER which we still support here. * * Newer models have a KEY_SEARCH key, which we always * enable here. * * A Dpad will send: KEY_DOWN / UP / LEFT / RIGHT / CENTER * * The KEY_CAMERA button isn't very useful if there is no camera. * * BTN_MOUSE is sent when the trackball is pressed * BTN_TOUCH is sent when the touchscreen is pressed */ events_set_bit (s, EV_SYN, EV_KEY ); events_set_bit(s, EV_KEY, KEY_HOME); events_set_bit(s, EV_KEY, KEY_BACK); events_set_bit(s, EV_KEY, KEY_SEND); events_set_bit(s, EV_KEY, KEY_END); events_set_bit(s, EV_KEY, KEY_SOFT1); events_set_bit(s, EV_KEY, KEY_VOLUMEUP); events_set_bit(s, EV_KEY, KEY_VOLUMEDOWN); events_set_bit(s, EV_KEY, KEY_SOFT2); events_set_bit(s, EV_KEY, KEY_POWER); events_set_bit(s, EV_KEY, KEY_SEARCH); if (config->hw_dPad) { events_set_bit(s, EV_KEY, KEY_DOWN); events_set_bit(s, EV_KEY, KEY_UP); events_set_bit(s, EV_KEY, KEY_LEFT); events_set_bit(s, EV_KEY, KEY_RIGHT); events_set_bit(s, EV_KEY, KEY_CENTER); } if (config->hw_trackBall) { events_set_bit(s, EV_KEY, BTN_MOUSE); } if (androidHwConfig_isScreenTouch(config)) { events_set_bit(s, EV_KEY, BTN_TOUCH); } if (strcmp(config->hw_camera_back, "none") || strcmp(config->hw_camera_front, "none")) { /* Camera emulation is enabled. */ events_set_bit(s, EV_KEY, KEY_CAMERA); } if (config->hw_keyboard) { /* since we want to implement Unicode reverse-mapping * allow any kind of key, even those not available on * the skin. * * the previous code did set the [1..0x1ff] range, but * we don't want to enable certain bits in the middle * of the range that are registered for mouse/trackball/joystick * events. * * see "linux_keycodes.h" for the list of events codes. */ events_set_bits(s, EV_KEY, 1, 0xff); events_set_bits(s, EV_KEY, 0x160, 0x1ff); /* If there is a keyboard, but no DPad, we need to clear the * corresponding bits. Doing this is simpler than trying to exclude * the DPad values from the ranges above. */ if (!config->hw_dPad) { events_clr_bit(s, EV_KEY, KEY_DOWN); events_clr_bit(s, EV_KEY, KEY_UP); events_clr_bit(s, EV_KEY, KEY_LEFT); events_clr_bit(s, EV_KEY, KEY_RIGHT); events_clr_bit(s, EV_KEY, KEY_CENTER); } } /* configure EV_REL array * * EV_REL events are sent when the trackball is moved */ if (config->hw_trackBall) { events_set_bit (s, EV_SYN, EV_REL ); events_set_bits(s, EV_REL, REL_X, REL_Y); } /* configure EV_ABS array. * * EV_ABS events are sent when the touchscreen is pressed */ if (!androidHwConfig_isScreenNoTouch(config)) { ABSEntry* abs_values; events_set_bit (s, EV_SYN, EV_ABS ); events_set_bits(s, EV_ABS, ABS_X, ABS_Z); /* Allocate the absinfo to report the min/max bounds for each * absolute dimension. The array must contain 3, or ABS_MAX tuples * of (min,max,fuzz,flat) 32-bit values. * * min and max are the bounds * fuzz corresponds to the device's fuziness, we set it to 0 * flat corresponds to the flat position for JOEYDEV devices, * we also set it to 0. * * There is no need to save/restore this array in a snapshot * since the values only depend on the hardware configuration. */ s->abs_info_count = androidHwConfig_isScreenMultiTouch(config) ? ABS_MAX * 4 : 3 * 4; const int abs_size = sizeof(uint32_t) * s->abs_info_count; s->abs_info = malloc(abs_size); memset(s->abs_info, 0, abs_size); abs_values = (ABSEntry*)s->abs_info; abs_values[ABS_X].max = config->hw_lcd_width-1; abs_values[ABS_Y].max = config->hw_lcd_height-1; abs_values[ABS_Z].max = 1; if (androidHwConfig_isScreenMultiTouch(config)) { /* * Setup multitouch. */ events_set_bit(s, EV_ABS, ABS_MT_SLOT); events_set_bit(s, EV_ABS, ABS_MT_POSITION_X); events_set_bit(s, EV_ABS, ABS_MT_POSITION_Y); events_set_bit(s, EV_ABS, ABS_MT_TRACKING_ID); events_set_bit(s, EV_ABS, ABS_MT_TOUCH_MAJOR); events_set_bit(s, EV_ABS, ABS_MT_PRESSURE); abs_values[ABS_MT_SLOT].max = multitouch_get_max_slot(); abs_values[ABS_MT_TRACKING_ID].max = abs_values[ABS_MT_SLOT].max + 1; abs_values[ABS_MT_POSITION_X].max = abs_values[ABS_X].max; abs_values[ABS_MT_POSITION_Y].max = abs_values[ABS_Y].max; abs_values[ABS_MT_TOUCH_MAJOR].max = 0x7fffffff; // TODO: Make it less random abs_values[ABS_MT_PRESSURE].max = 0x100; // TODO: Make it less random } } /* configure EV_SW array * * EV_SW events are sent to indicate that the keyboard lid * was closed or opened (done when we switch layouts through * KP-7 or KP-9). * * We only support this when hw.keyboard.lid is true. */ if (config->hw_keyboard && config->hw_keyboard_lid) { events_set_bit(s, EV_SYN, EV_SW); events_set_bit(s, EV_SW, 0); } iomemtype = cpu_register_io_memory(events_readfn, events_writefn, s); cpu_register_physical_memory(base, 0xfff, iomemtype); qemu_add_kbd_event_handler(events_put_keycode, s); qemu_add_mouse_event_handler(events_put_mouse, s, 1, "goldfish-events"); s->base = base; s->irq = irq; s->first = 0; s->last = 0; s->state = STATE_INIT; s->name = qemu_strdup(config->hw_keyboard_charmap); /* This function migh fire buffered events to the device, so * ensure that it is called after initialization is complete */ user_event_register_generic(s, events_put_generic); register_savevm( "events_state", 0, EVENTS_STATE_SAVE_VERSION, events_state_save, events_state_load, s ); }
void events_dev_init(uint32_t base, qemu_irq irq) { events_state *s; int iomemtype; AndroidHwConfig* config = android_hw; s = (events_state *) qemu_mallocz(sizeof(events_state)); s->name = android_skin_keycharmap; /* now set the events capability bits depending on hardware configuration */ /* apparently, the EV_SYN array is used to indicate which other * event classes to consider. */ /* configure EV_KEY array * * All Android devices must have the following keys: * KEY_HOME, KEY_BACK, KEY_SEND (Call), KEY_END (EndCall), * KEY_SOFT1 (Menu), VOLUME_UP, VOLUME_DOWN * * Note that previous models also had a KEY_SOFT2, * and a KEY_POWER which we still support here. * * Newer models have a KEY_SEARCH key, which we always * enable here. * * A Dpad will send: KEY_DOWN / UP / LEFT / RIGHT / CENTER * * The KEY_CAMERA button isn't very useful if there is no camera. * * BTN_MOUSE is sent when the trackball is pressed * BTN_TOUCH is sent when the touchscreen is pressed */ events_set_bit (s, EV_SYN, EV_KEY ); events_set_bit(s, EV_KEY, KEY_HOME); events_set_bit(s, EV_KEY, KEY_BACK); events_set_bit(s, EV_KEY, KEY_SEND); events_set_bit(s, EV_KEY, KEY_END); events_set_bit(s, EV_KEY, KEY_SOFT1); events_set_bit(s, EV_KEY, KEY_VOLUMEUP); events_set_bit(s, EV_KEY, KEY_VOLUMEDOWN); events_set_bit(s, EV_KEY, KEY_SOFT2); events_set_bit(s, EV_KEY, KEY_POWER); events_set_bit(s, EV_KEY, KEY_SEARCH); if (config->hw_dPad) { events_set_bit(s, EV_KEY, KEY_DOWN); events_set_bit(s, EV_KEY, KEY_UP); events_set_bit(s, EV_KEY, KEY_LEFT); events_set_bit(s, EV_KEY, KEY_RIGHT); events_set_bit(s, EV_KEY, KEY_CENTER); } if (config->hw_trackBall) { events_set_bit(s, EV_KEY, BTN_MOUSE); } if (config->hw_touchScreen) { events_set_bit(s, EV_KEY, BTN_TOUCH); } if (config->hw_camera) { events_set_bit(s, EV_KEY, KEY_CAMERA); } if (config->hw_keyboard) { /* since we want to implement Unicode reverse-mapping * allow any kind of key, even those not available on * the skin. * * the previous code did set the [1..0x1ff] range, but * we don't want to enable certain bits in the middle * of the range that are registered for mouse/trackball/joystick * events. * * see "linux_keycodes.h" for the list of events codes. */ events_set_bits(s, EV_KEY, 1, 0xff); events_set_bits(s, EV_KEY, 0x160, 0x1ff); } /* configure EV_REL array * * EV_REL events are sent when the trackball is moved */ if (config->hw_trackBall) { events_set_bit (s, EV_SYN, EV_REL ); events_set_bits(s, EV_REL, REL_X, REL_Y); } /* configure EV_ABS array. * * EV_ABS events are sent when the touchscreen is pressed */ if (config->hw_touchScreen) { events_set_bit (s, EV_SYN, EV_ABS ); events_set_bits(s, EV_ABS, ABS_X, ABS_Z); } /* configure EV_SW array * * EW_SW events are sent to indicate that the keyboard lid * was closed or opened (done when we switch layouts through * KP-7 or KP-9). * * We only support this when there is a real keyboard, which * we assume can be hidden/revealed. */ if (config->hw_keyboard) { events_set_bit(s, EV_SYN, EV_SW); events_set_bit(s, EV_SW, 0); } iomemtype = cpu_register_io_memory(events_readfn, events_writefn, s); cpu_register_physical_memory(base, 0xfff, iomemtype); qemu_add_kbd_event_handler(events_put_keycode, s); qemu_add_mouse_event_handler(events_put_mouse, s, 1, "goldfish-events"); user_event_register_generic(s, events_put_generic); s->base = base; s->irq = irq; s->first = 0; s->last = 0; register_savevm( "events_state", 0, EVENTS_STATE_SAVE_VERSION, events_state_save, events_state_load, s ); }
static int usb_pointer_poll(USBHIDState *hs, uint8_t *buf, int len) { int dx, dy, dz, b, l; USBPointerState *s = &hs->ptr; USBPointerEvent *e; if (usb_suppress_report(hs, s->head == s->tail)) return USB_RET_NAK; if (!s->mouse_grabbed) { s->eh_entry = qemu_add_mouse_event_handler(usb_pointer_event, hs, !s->xyrel, "QEMU USB Pointer"); s->mouse_grabbed = 1; } if (s->head == s->tail) /* use the last report */ s->head = (s->head - 1) & QUEUEINDEXMASK; e = &s->queue[s->head]; dz = int_clamp(e->dz, -127, 127); if (s->xyrel) { dx = int_clamp(e->xdx, -127, 127); dy = int_clamp(e->ydy, -127, 127); e->xdx -= dx; e->ydy -= dy; } else { dx = e->xdx; dy = e->ydy; } /* Appears we have to invert the wheel direction */ dz = 0 - dz; if (!(e->dz || (s->xyrel && (e->xdx || e->ydy)))) { /* that deals with this event */ QUEUE_INCR(s->head); } b = 0; if (e->buttons_state & MOUSE_EVENT_LBUTTON) b |= 0x01; if (e->buttons_state & MOUSE_EVENT_RBUTTON) b |= 0x02; if (e->buttons_state & MOUSE_EVENT_MBUTTON) b |= 0x04; switch (hs->kind) { case USB_MOUSE: l = 0; if (len > l) buf[l ++] = b; if (len > l) buf[l ++] = dx; if (len > l) buf[l ++] = dy; if (len > l) buf[l ++] = dz; break; case USB_TABLET: /* Appears we have to invert the wheel direction */ dz = 0 - dz; buf[0] = b; buf[1] = dx & 0xff; buf[2] = dx >> 8; buf[3] = dy & 0xff; buf[4] = dy >> 8; buf[5] = dz; l = 6; break; default: abort(); } return l; }