/** 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);
}
