/** Mouse pointer has moved. */ void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy, int dz) { async_exch_t *exch = async_exchange_begin(client_sess); if (dx || dy) async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy); if (dz) { // TODO: Implement proper wheel support keycode_t code = dz > 0 ? KC_UP : KC_DOWN; for (int i = 0; i < 3; ++i) { async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0); } async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0); } async_exchange_end(exch); }
static void push_event(async_sess_t *sess, kbd_event_type_t type, unsigned int key) { async_exch_t *exch = async_exchange_begin(sess); async_msg_4(exch, KBDEV_EVENT, type, key, 0, 0); async_exchange_end(exch); }
static void emit_event(const isdv4_event_t *event) { fibril_mutex_lock(&client_mutex); async_sess_t *sess = client_sess; fibril_mutex_unlock(&client_mutex); if (!sess) return; async_exch_t *exch = async_exchange_begin(sess); if (exch) { unsigned int max_x = state.stylus_max_x; unsigned int max_y = state.stylus_max_y; if (event->source == TOUCH) { max_x = state.touch_max_x; max_y = state.touch_max_y; } async_msg_4(exch, MOUSEEV_ABS_MOVE_EVENT, event->x, event->y, max_x, max_y); if (event->type == PRESS || event->type == RELEASE) { async_msg_2(exch, MOUSEEV_BUTTON_EVENT, event->button, event->type == PRESS); } } async_exchange_end(exch); }
/** Mouse pointer has moved in absolute mode. */ void mouse_push_event_abs_move(mouse_dev_t *mdev, unsigned int x, unsigned int y, unsigned int max_x, unsigned int max_y) { if (max_x && max_y) { async_exch_t *exch = async_exchange_begin(client_sess); async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y); async_exchange_end(exch); } }
/** Get data and parse scancodes. * @param arg Pointer to xt_kbd_t structure. * @return Never. */ int polling(void *arg) { assert(arg); const xt_kbd_t *kbd = arg; assert(kbd->parent_sess); async_exch_t *parent_exch = async_exchange_begin(kbd->parent_sess); while (1) { if (!parent_exch) parent_exch = async_exchange_begin(kbd->parent_sess); const int *map = scanmap_simple; size_t map_size = sizeof(scanmap_simple) / sizeof(int); uint8_t code = 0; ssize_t size = chardev_read(parent_exch, &code, 1); /** Ignore AT command reply */ if (code == KBD_ACK || code == KBD_RESEND) { continue; } if (code == KBD_SCANCODE_SET_EXTENDED) { map = scanmap_e0; map_size = sizeof(scanmap_e0) / sizeof(int); size = chardev_read(parent_exch, &code, 1); // TODO handle print screen } /* Invalid read. */ if (size != 1) { continue; } /* Bit 7 indicates press/release */ const kbd_event_type_t type = (code & 0x80) ? KEY_RELEASE : KEY_PRESS; code &= ~0x80; const unsigned key = (code < map_size) ? map[code] : 0; if (key != 0) { async_exch_t *exch = async_exchange_begin(kbd->client_sess); if (!exch) { ddf_msg(LVL_ERROR, "Failed creating exchange."); continue; } async_msg_4(exch, KBDEV_EVENT, type, key, 0, 0); async_exchange_end(exch); } else { ddf_msg(LVL_WARN, "Unknown scancode: %hhx", code); } } }
/** * Processes key events. * * @note This function was copied from AT keyboard driver and modified to suit * USB keyboard. * * @note Lock keys are not sent to the console, as they are completely handled * in the driver. It may, however, be required later that the driver * sends also these keys to application (otherwise it cannot use those * keys at all). * * @param hid_dev * @param multim_dev * @param type Type of the event (press / release). Recognized values: * KEY_PRESS, KEY_RELEASE * @param key Key code of the key according to HID Usage Tables. */ static void usb_multimedia_push_ev( usb_multimedia_t *multim_dev, int type, unsigned int key) { assert(multim_dev != NULL); const kbd_event_t ev = { .type = type, .key = key, .mods = 0, .c = 0, }; usb_log_debug2(NAME " Sending key %d to the console\n", ev.key); if (multim_dev->console_sess == NULL) { usb_log_warning( "Connection to console not ready, key discarded.\n"); return; } async_exch_t *exch = async_exchange_begin(multim_dev->console_sess); if (exch != NULL) { async_msg_4(exch, KBDEV_EVENT, ev.type, ev.key, ev.mods, ev.c); async_exchange_end(exch); } else { usb_log_warning("Failed to send multimedia key.\n"); } } int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data) { if (hid_dev == NULL || hid_dev->usb_dev == NULL) { return EINVAL; } usb_log_debug(NAME " Initializing HID/multimedia structure...\n"); /* Create the exposed function. */ ddf_fun_t *fun = ddf_fun_create( hid_dev->usb_dev->ddf_dev, fun_exposed, NAME); if (fun == NULL) { usb_log_error("Could not create DDF function node.\n"); return ENOMEM; } ddf_fun_set_ops(fun, &multimedia_ops); usb_multimedia_t *multim_dev = ddf_fun_data_alloc(fun, sizeof(usb_multimedia_t)); if (multim_dev == NULL) { ddf_fun_destroy(fun); return ENOMEM; } multim_dev->console_sess = NULL; //todo Autorepeat? int rc = ddf_fun_bind(fun); if (rc != EOK) { usb_log_error("Could not bind DDF function: %s.\n", str_error(rc)); ddf_fun_destroy(fun); return rc; } usb_log_debug(NAME " function created (handle: %" PRIun ").\n", ddf_fun_get_handle(fun)); rc = ddf_fun_add_to_category(fun, "keyboard"); if (rc != EOK) { usb_log_error( "Could not add DDF function to category 'keyboard': %s.\n", str_error(rc)); if (ddf_fun_unbind(fun) != EOK) { usb_log_error("Failed to unbind %s, won't destroy.\n", ddf_fun_get_name(fun)); } else { ddf_fun_destroy(fun); } return rc; } /* Save the KBD device structure into the HID device structure. */ *data = fun; usb_log_debug(NAME " HID/multimedia structure initialized.\n"); return EOK; } void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data) { ddf_fun_t *fun = data; usb_multimedia_t *multim_dev = ddf_fun_data_get(fun); /* Hangup session to the console */ if (multim_dev->console_sess) async_hangup(multim_dev->console_sess); if (ddf_fun_unbind(fun) != EOK) { usb_log_error("Failed to unbind %s, won't destroy.\n", ddf_fun_get_name(fun)); } else { usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun)); /* This frees multim_dev too as it was stored in * fun->data */ ddf_fun_destroy(fun); } }
void kbd_push_event(kbd_dev_t *kdev, int type, unsigned int key) { kbd_event_t ev; unsigned int mod_mask; switch (key) { case KC_LCTRL: mod_mask = KM_LCTRL; break; case KC_RCTRL: mod_mask = KM_RCTRL; break; case KC_LSHIFT: mod_mask = KM_LSHIFT; break; case KC_RSHIFT: mod_mask = KM_RSHIFT; break; case KC_LALT: mod_mask = KM_LALT; break; case KC_RALT: mod_mask = KM_RALT; break; default: mod_mask = 0; break; } if (mod_mask != 0) { if (type == KEY_PRESS) kdev->mods = kdev->mods | mod_mask; else kdev->mods = kdev->mods & ~mod_mask; } switch (key) { case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break; case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break; case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break; default: mod_mask = 0; break; } if (mod_mask != 0) { if (type == KEY_PRESS) { /* * Only change lock state on transition from released * to pressed. This prevents autorepeat from messing * up the lock state. */ kdev->mods = kdev->mods ^ (mod_mask & ~kdev->lock_keys); kdev->lock_keys = kdev->lock_keys | mod_mask; /* Update keyboard lock indicator lights. */ (*kdev->ctl_ops->set_ind)(kdev, kdev->mods); } else { kdev->lock_keys = kdev->lock_keys & ~mod_mask; } } if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) && key == KC_F1) { layout_destroy(kdev->active_layout); kdev->active_layout = layout_create(layout[0]); return; } if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) && key == KC_F2) { layout_destroy(kdev->active_layout); kdev->active_layout = layout_create(layout[1]); return; } if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) && key == KC_F3) { layout_destroy(kdev->active_layout); kdev->active_layout = layout_create(layout[2]); return; } if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) && key == KC_F4) { layout_destroy(kdev->active_layout); kdev->active_layout = layout_create(layout[3]); return; } ev.type = type; ev.key = key; ev.mods = kdev->mods; ev.c = layout_parse_ev(kdev->active_layout, &ev); async_exch_t *exch = async_exchange_begin(client_sess); async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c); async_exchange_end(exch); }