* Copyright 2021, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include "VirtioInputDevice.h"
#include <virtio_input_driver.h>
#include <virtio_defs.h>
#include <stdio.h>
#include <string.h>
#include <Application.h>
#include <String.h>
#ifdef TRACE_VIRTIO_INPUT_DEVICE
# define TRACE(x...) debug_printf("virtio_input_device: " x)
#else
# define TRACE(x...) ;
#endif
#define ERROR(x...) debug_printf("virtio_input_device: " x)
#define CALLED() TRACE("CALLED %s\n", __PRETTY_FUNCTION__)
enum {
kWatcherThreadPriority = B_FIRST_REAL_TIME_PRIORITY + 4,
};
template<typename Type>
inline static void SetBit(Type &val, int bit) {val |= Type(1) << bit;}
template<typename Type>
inline static void ClearBit(Type &val, int bit) {val &= ~(Type(1) << bit);}
template<typename Type>
inline static void InvertBit(Type &val, int bit) {val ^= Type(1) << bit;}
template<typename Type>
inline static void SetBitTo(Type &val, int bit, bool isSet) {
val ^= ((isSet? -1: 0) ^ val) & (Type(1) << bit);}
template<typename Type>
inline static bool IsBitSet(Type val, int bit) {
return (val & (Type(1) << bit)) != 0;}
#ifdef TRACE_VIRTIO_INPUT_DEVICE
static void WriteInputPacket(const VirtioInputPacket &pkt)
{
switch (pkt.type) {
case kVirtioInputEvSyn:
TRACE("syn");
break;
case kVirtioInputEvKey:
TRACE("key, ");
switch (pkt.code) {
case kVirtioInputBtnLeft:
TRACE("left");
break;
case kVirtioInputBtnRight:
TRACE("middle");
break;
case kVirtioInputBtnMiddle:
TRACE("right");
break;
case kVirtioInputBtnGearDown:
TRACE("gearDown");
break;
case kVirtioInputBtnGearUp:
TRACE("gearUp");
break;
default:
TRACE("%d", pkt.code);
}
break;
case kVirtioInputEvRel:
TRACE("rel, ");
switch (pkt.code) {
case kVirtioInputRelX:
TRACE("relX");
break;
case kVirtioInputRelY:
TRACE("relY");
break;
case kVirtioInputRelZ:
TRACE("relZ");
break;
case kVirtioInputRelWheel:
TRACE("relWheel");
break;
default:
TRACE("%d", pkt.code);
}
break;
case kVirtioInputEvAbs:
TRACE("abs, ");
switch (pkt.code) {
case kVirtioInputAbsX:
TRACE("absX");
break;
case kVirtioInputAbsY:
TRACE("absY");
break;
case kVirtioInputAbsZ:
TRACE("absZ");
break;
default:
TRACE("%d", pkt.code);
}
break;
case kVirtioInputEvRep:
TRACE("rep");
break;
default:
TRACE("?(%d)", pkt.type);
}
switch (pkt.type) {
case kVirtioInputEvSyn:
break;
case kVirtioInputEvKey:
TRACE(", ");
if (pkt.value == 0) {
TRACE("up");
} else if (pkt.value == 1) {
TRACE("down");
} else {
TRACE("%d", pkt.value);
}
break;
default:
TRACE(", ");
TRACE("%d", pkt.value);
}
}
#endif
VirtioInputDevice::VirtioInputDevice()
{
}
VirtioInputDevice::~VirtioInputDevice()
{
}
status_t
VirtioInputDevice::InitCheck()
{
static input_device_ref *devices[3];
input_device_ref **devicesEnd = devices;
FileDescriptorCloser fd;
ObjectDeleter<VirtioInputHandler> tablet(
new TabletHandler(this, "VirtIO tablet"));
fd.SetTo(open("/dev/input/virtio/0/raw", O_RDWR));
if (fd.IsSet()) {
tablet->SetFd(fd.Detach());
*devicesEnd++ = tablet->Ref();
tablet.Detach();
} else {
TRACE("Unable to detect tablet device!");
}
ObjectDeleter<VirtioInputHandler> keyboard(
new KeyboardHandler(this, "VirtIO keyboard"));
fd.SetTo(open("/dev/input/virtio/1/raw", O_RDWR));
if (fd.IsSet()) {
keyboard->SetFd(fd.Detach());
*devicesEnd++ = keyboard->Ref();
keyboard.Detach();
} else {
TRACE("Unable to detect keyboard device!");
}
*devicesEnd = NULL;
RegisterDevices(devices);
return B_OK;
}
status_t
VirtioInputDevice::Start(const char* name, void* cookie)
{
return ((VirtioInputHandler*)cookie)->Start();
}
status_t
VirtioInputDevice::Stop(const char* name, void* cookie)
{
return ((VirtioInputHandler*)cookie)->Stop();
}
status_t
VirtioInputDevice::Control(const char* name, void* cookie, uint32 command,
BMessage* message)
{
return ((VirtioInputHandler*)cookie)->Control(command, message);
}
VirtioInputHandler::VirtioInputHandler(VirtioInputDevice* dev, const char* name,
input_device_type type)
:
fDev(dev),
fWatcherThread(B_ERROR),
fRun(false)
{
fRef.name = (char*)name;
fRef.type = type;
fRef.cookie = this;
}
VirtioInputHandler::~VirtioInputHandler()
{
}
void
VirtioInputHandler::SetFd(int fd)
{
fDeviceFd.SetTo(fd);
}
status_t
VirtioInputHandler::Start()
{
char threadName[B_OS_NAME_LENGTH];
snprintf(threadName, B_OS_NAME_LENGTH, "%s watcher", fRef.name);
if (fWatcherThread < 0) {
fWatcherThread = spawn_thread(Watcher, threadName,
kWatcherThreadPriority, this);
if (fWatcherThread < B_OK)
return fWatcherThread;
fRun = true;
resume_thread(fWatcherThread);
}
return B_OK;
}
status_t
VirtioInputHandler::Stop()
{
if (fWatcherThread >= B_OK) {
suspend_thread(fWatcherThread);
fRun = false;
status_t res;
wait_for_thread(fWatcherThread, &res);
fWatcherThread = B_ERROR;
}
return B_OK;
}
status_t
VirtioInputHandler::Control(uint32 command, BMessage* message)
{
return B_OK;
}
int32
VirtioInputHandler::Watcher(void *arg)
{
VirtioInputHandler &handler = *((VirtioInputHandler*)arg);
handler.Reset();
while (handler.fRun) {
VirtioInputPacket pkt;
status_t res = ioctl(handler.fDeviceFd.Get(), virtioInputRead, &pkt,
sizeof(pkt));
if (res < B_OK)
continue;
handler.PacketReceived(pkt);
}
return B_OK;
}
KeyboardHandler::KeyboardHandler(VirtioInputDevice* dev, const char* name)
:
VirtioInputHandler(dev, name, B_KEYBOARD_DEVICE),
fRepeatThread(-1),
fRepeatThreadSem(-1)
{
TRACE("+KeyboardHandler()\n");
{
key_map *keyMap = NULL;
char *chars = NULL;
get_key_map(&keyMap, &chars);
fKeyMap.SetTo(keyMap);
fChars.SetTo(chars);
}
TRACE(" fKeymap: %p\n", fKeyMap.Get());
TRACE(" fChars: %p\n", fChars.Get());
get_key_repeat_delay(&fRepeatDelay);
get_key_repeat_rate (&fRepeatRate);
TRACE(" fRepeatDelay: %" B_PRIdBIGTIME "\n", fRepeatDelay);
TRACE(" fRepeatRate: % " B_PRId32 "\n", fRepeatRate);
if (fRepeatRate < 1)
fRepeatRate = 1;
}
KeyboardHandler::~KeyboardHandler()
{
_StopRepeating();
}
void
KeyboardHandler::Reset()
{
memset(&fNewState, 0, sizeof(KeyboardState));
memcpy(&fState, &fNewState, sizeof(KeyboardState));
_StopRepeating();
}
status_t
KeyboardHandler::Control(uint32 command, BMessage* message)
{
switch (command) {
case B_KEY_MAP_CHANGED: {
key_map *keyMap = NULL;
char *chars = NULL;
get_key_map(&keyMap, &chars);
if (keyMap == NULL || chars == NULL)
return B_NO_MEMORY;
fKeyMap.SetTo(keyMap);
fChars.SetTo(chars);
return B_OK;
}
case B_KEY_REPEAT_DELAY_CHANGED:
get_key_repeat_delay(&fRepeatDelay);
TRACE(" fRepeatDelay: %" B_PRIdBIGTIME "\n", fRepeatDelay);
return B_OK;
case B_KEY_REPEAT_RATE_CHANGED:
get_key_repeat_rate(&fRepeatRate);
TRACE(" fRepeatRate: %" B_PRId32 "\n", fRepeatRate);
if (fRepeatRate < 1) fRepeatRate = 1;
return B_OK;
}
return VirtioInputHandler::Control(command, message);
}
void
KeyboardHandler::PacketReceived(const VirtioInputPacket &pkt)
{
#ifdef TRACE_VIRTIO_INPUT_DEVICE
TRACE("keyboard: ");
WriteInputPacket(pkt);
TRACE("\n");
#endif
switch (pkt.type) {
case kVirtioInputEvKey: {
if (pkt.code < 256)
SetBitTo(fNewState.keys[pkt.code / 8], pkt.code % 8,
pkt.value != 0);
break;
}
case kVirtioInputEvSyn: {
fState.when = system_time();
_StateChanged();
}
}
}
bool
KeyboardHandler::_IsKeyPressed(const KeyboardState &state, uint32 key)
{
return key < 256 && IsBitSet(state.keys[key / 8], key % 8);
}
void
KeyboardHandler::_KeyString(uint32 code, char *str, size_t len)
{
char *ch;
switch (fNewState.modifiers & (
B_SHIFT_KEY | B_CONTROL_KEY | B_OPTION_KEY | B_CAPS_LOCK)) {
case B_OPTION_KEY | B_CAPS_LOCK | B_SHIFT_KEY:
ch = fChars.Get() + fKeyMap->option_caps_shift_map[code];
break;
case B_OPTION_KEY | B_CAPS_LOCK:
ch = fChars.Get() + fKeyMap->option_caps_map[code];
break;
case B_OPTION_KEY | B_SHIFT_KEY:
ch = fChars.Get() + fKeyMap->option_shift_map[code];
break;
case B_OPTION_KEY:
ch = fChars.Get() + fKeyMap->option_map[code];
break;
case B_CAPS_LOCK | B_SHIFT_KEY:
ch = fChars.Get() + fKeyMap->caps_shift_map[code];
break;
case B_CAPS_LOCK:
ch = fChars.Get() + fKeyMap->caps_map[code];
break;
case B_SHIFT_KEY:
ch = fChars.Get() + fKeyMap->shift_map[code];
break;
default:
if ((fNewState.modifiers & B_CONTROL_KEY) != 0)
ch = fChars.Get() + fKeyMap->control_map[code];
else
ch = fChars.Get() + fKeyMap->normal_map[code];
}
if (len > 0) {
uint32 i;
for (i = 0; (i < (uint32)ch[0]) && (i < len - 1); i++)
str[i] = ch[i + 1];
str[i] = '\0';
}
}
void
KeyboardHandler::_StartRepeating(BMessage* msg)
{
if (fRepeatThread >= B_OK)
_StopRepeating();
fRepeatMsg = *msg;
fRepeatThread = spawn_thread(_RepeatThread, "repeat thread",
B_REAL_TIME_DISPLAY_PRIORITY + 4, this);
fRepeatThreadSem = create_sem(0, "repeat thread sem");
if (fRepeatThread >= B_OK)
resume_thread(fRepeatThread);
}
void
KeyboardHandler::_StopRepeating()
{
if (fRepeatThread >= B_OK) {
status_t res;
release_sem(fRepeatThreadSem);
wait_for_thread(fRepeatThread, &res);
fRepeatThread = -1;
delete_sem(fRepeatThreadSem);
fRepeatThreadSem = -1;
}
}
status_t
KeyboardHandler::_RepeatThread(void *arg)
{
status_t res;
KeyboardHandler *h = (KeyboardHandler*)arg;
res = acquire_sem_etc(h->fRepeatThreadSem, 1, B_RELATIVE_TIMEOUT,
h->fRepeatDelay);
if (res >= B_OK)
return B_OK;
while (true) {
int32 count;
h->fRepeatMsg.ReplaceInt64("when", system_time());
h->fRepeatMsg.FindInt32("be:key_repeat", &count);
h->fRepeatMsg.ReplaceInt32("be:key_repeat", count + 1);
ObjectDeleter<BMessage> msg(new(std::nothrow) BMessage(h->fRepeatMsg));
if (msg.IsSet() && h->Device()->EnqueueMessage(msg.Get()) >= B_OK)
msg.Detach();
res = acquire_sem_etc(h->fRepeatThreadSem, 1, B_RELATIVE_TIMEOUT,
(bigtime_t)10000000 / h->fRepeatRate);
if (res >= B_OK)
return B_OK;
}
}
void
KeyboardHandler::_StateChanged()
{
uint32 i, j;
fNewState.modifiers = fState.modifiers
& (B_CAPS_LOCK | B_SCROLL_LOCK | B_NUM_LOCK);
if (_IsKeyPressed(fNewState, fKeyMap->left_shift_key))
fNewState.modifiers |= B_SHIFT_KEY | B_LEFT_SHIFT_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->right_shift_key))
fNewState.modifiers |= B_SHIFT_KEY | B_RIGHT_SHIFT_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->left_command_key))
fNewState.modifiers |= B_COMMAND_KEY | B_LEFT_COMMAND_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->right_command_key))
fNewState.modifiers |= B_COMMAND_KEY | B_RIGHT_COMMAND_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->left_control_key))
fNewState.modifiers |= B_CONTROL_KEY | B_LEFT_CONTROL_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->right_control_key))
fNewState.modifiers |= B_CONTROL_KEY | B_RIGHT_CONTROL_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->caps_key))
fNewState.modifiers ^= B_CAPS_LOCK;
if (_IsKeyPressed(fNewState, fKeyMap->scroll_key))
fNewState.modifiers ^= B_SCROLL_LOCK;
if (_IsKeyPressed(fNewState, fKeyMap->num_key))
fNewState.modifiers ^= B_NUM_LOCK;
if (_IsKeyPressed(fNewState, fKeyMap->left_option_key))
fNewState.modifiers |= B_OPTION_KEY | B_LEFT_OPTION_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->right_option_key))
fNewState.modifiers |= B_OPTION_KEY | B_RIGHT_OPTION_KEY;
if (_IsKeyPressed(fNewState, fKeyMap->menu_key))
fNewState.modifiers |= B_MENU_KEY;
if (fState.modifiers != fNewState.modifiers) {
ObjectDeleter<BMessage> msg(
new(std::nothrow) BMessage(B_MODIFIERS_CHANGED));
if (msg.IsSet()) {
msg->AddInt64("when", system_time());
msg->AddInt32("modifiers", fNewState.modifiers);
msg->AddInt32("be:old_modifiers", fState.modifiers);
msg->AddData("states", B_UINT8_TYPE, fNewState.keys, 16);
if (Device()->EnqueueMessage(msg.Get()) >= B_OK) {
msg.Detach();
fState.modifiers = fNewState.modifiers;
}
}
}
uint8 diff[16];
char rawCh;
char str[5];
for (i = 0; i < 16; ++i)
diff[i] = fState.keys[i] ^ fNewState.keys[i];
for (i = 0; i < 128; ++i) {
if (diff[i/8] & (1 << (i % 8))) {
ObjectDeleter<BMessage> msg(new(std::nothrow) BMessage());
if (msg.IsSet()) {
_KeyString(i, str, sizeof(str));
msg->AddInt64("when", system_time());
msg->AddInt32("key", i);
msg->AddInt32("modifiers", fNewState.modifiers);
msg->AddData("states", B_UINT8_TYPE, fNewState.keys, 16);
if (str[0] != '\0') {
if (fChars.Get()[fKeyMap->normal_map[i]] != 0)
rawCh = fChars.Get()[fKeyMap->normal_map[i] + 1];
else
rawCh = str[0];
for (j = 0; str[j] != '\0'; ++j)
msg->AddInt8("byte", str[j]);
msg->AddString("bytes", str);
msg->AddInt32("raw_char", rawCh);
}
if (fNewState.keys[i / 8] & (1 << (i % 8))) {
if (str[0] != '\0')
msg->what = B_KEY_DOWN;
else
msg->what = B_UNMAPPED_KEY_DOWN;
msg->AddInt32("be:key_repeat", 1);
_StartRepeating(msg.Get());
} else {
if (str[0] != '\0')
msg->what = B_KEY_UP;
else
msg->what = B_UNMAPPED_KEY_UP;
_StopRepeating();
}
if (Device()->EnqueueMessage(msg.Get()) >= B_OK) {
msg.Detach();
for (j = 0; j < 16; ++j)
fState.keys[j] = fNewState.keys[j];
}
}
}
}
}
TabletHandler::TabletHandler(VirtioInputDevice* dev, const char* name)
:
VirtioInputHandler(dev, name, B_POINTING_DEVICE)
{
}
void
TabletHandler::Reset()
{
memset(&fNewState, 0, sizeof(TabletState));
fNewState.x = 0.5f;
fNewState.y = 0.5f;
memcpy(&fState, &fNewState, sizeof(TabletState));
fLastClick = -1;
fLastClickBtn = -1;
get_click_speed(Ref()->name, &fClickSpeed);
TRACE(" fClickSpeed: %" B_PRIdBIGTIME "\n", fClickSpeed);
}
status_t
TabletHandler::Control(uint32 command, BMessage* message)
{
switch (command) {
case B_CLICK_SPEED_CHANGED: {
get_click_speed(Ref()->name, &fClickSpeed);
TRACE(" fClickSpeed: %" B_PRIdBIGTIME "\n", fClickSpeed);
return B_OK;
}
}
return VirtioInputHandler::Control(command, message);
}
void
TabletHandler::PacketReceived(const VirtioInputPacket &pkt)
{
switch (pkt.type) {
case kVirtioInputEvAbs: {
switch (pkt.code) {
case kVirtioInputAbsX:
fNewState.x = float(pkt.value) / 32768.0f;
break;
case kVirtioInputAbsY:
fNewState.y = float(pkt.value) / 32768.0f;
break;
}
break;
}
case kVirtioInputEvRel: {
switch (pkt.code) {
case kVirtioInputRelWheel:
fNewState.wheelY -= pkt.value;
break;
}
break;
}
case kVirtioInputEvKey: {
switch (pkt.code) {
case kVirtioInputBtnLeft:
SetBitTo(fNewState.buttons, 0, pkt.value != 0);
break;
case kVirtioInputBtnRight:
SetBitTo(fNewState.buttons, 1, pkt.value != 0);
break;
case kVirtioInputBtnMiddle:
SetBitTo(fNewState.buttons, 2, pkt.value != 0);
break;
}
break;
}
case kVirtioInputEvSyn: {
fState.when = system_time();
if (fState.x != fNewState.x || fState.y != fNewState.y
|| fState.pressure != fNewState.pressure) {
fState.x = fNewState.x;
fState.y = fNewState.y;
fState.pressure = fNewState.pressure;
ObjectDeleter<BMessage> msg(
new(std::nothrow) BMessage(B_MOUSE_MOVED));
if (!msg.IsSet() || !_FillMessage(*msg.Get(), fState))
return;
if (Device()->EnqueueMessage(msg.Get()) >= B_OK)
msg.Detach();
}
for (int i = 0; i < 32; i++) {
if ((IsBitSet(fState.buttons, i)
!= IsBitSet(fNewState.buttons, i))) {
InvertBit(fState.buttons, i);
ObjectDeleter<BMessage> msg(new(std::nothrow) BMessage());
if (!msg.IsSet() || !_FillMessage(*msg.Get(), fState))
return;
if (IsBitSet(fState.buttons, i)) {
msg->what = B_MOUSE_DOWN;
if (i == fLastClickBtn
&& fState.when - fLastClick <= fClickSpeed)
fState.clicks++;
else
fState.clicks = 1;
fLastClickBtn = i;
fLastClick = fState.when;
msg->AddInt32("clicks", fState.clicks);
} else
msg->what = B_MOUSE_UP;
if (Device()->EnqueueMessage(msg.Get()) >= B_OK)
msg.Detach();
}
}
if (fState.wheelX != fNewState.wheelX
|| fState.wheelY != fNewState.wheelY) {
ObjectDeleter<BMessage> msg(
new(std::nothrow) BMessage(B_MOUSE_WHEEL_CHANGED));
if (!msg.IsSet()
|| msg->AddInt64("when", fState.when) < B_OK
|| msg->AddFloat("be:wheel_delta_x",
fNewState.wheelX - fState.wheelX) < B_OK
|| msg->AddFloat("be:wheel_delta_y",
fNewState.wheelY - fState.wheelY) < B_OK) {
return;
}
fState.wheelX = fNewState.wheelX;
fState.wheelY = fNewState.wheelY;
if (Device()->EnqueueMessage(msg.Get()) >= B_OK)
msg.Detach();
}
break;
}
}
}
bool
TabletHandler::_FillMessage(BMessage &msg, const TabletState &s)
{
if (msg.AddInt64("when", s.when) < B_OK
|| msg.AddInt32("buttons", s.buttons) < B_OK
|| msg.AddFloat("x", s.x) < B_OK
|| msg.AddFloat("y", s.y) < B_OK) {
return false;
}
msg.AddFloat("be:tablet_x", s.x);
msg.AddFloat("be:tablet_y", s.y);
msg.AddFloat("be:tablet_pressure", s.pressure);
return true;
}
extern "C" BInputServerDevice*
instantiate_input_device()
{
return new(std::nothrow) VirtioInputDevice();
}
