* Copyright 2013, Jérôme Duval, korli@users.berlios.de.
* Copyright 2021, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <virtio.h>
#include <virtio_defs.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <new>
#include <kernel.h>
#include <fs/devfs.h>
#include <virtio_input_driver.h>
#include <AutoDeleter.h>
#include <AutoDeleterOS.h>
#include <AutoDeleterDrivers.h>
#include <debug.h>
#ifdef TRACE_VIRTIO_INPUT
# define TRACE(x...) dprintf("virtio_input: " x)
#else
# define TRACE(x...) ;
#endif
#define ERROR(x...) dprintf("virtio_input: " x)
#define CALLED() TRACE("CALLED %s\n", __PRETTY_FUNCTION__)
#define VIRTIO_INPUT_DRIVER_MODULE_NAME "drivers/input/virtio_input/driver_v1"
#define VIRTIO_INPUT_DEVICE_MODULE_NAME "drivers/input/virtio_input/device_v1"
#define VIRTIO_INPUT_DEVICE_ID_GENERATOR "virtio_input/device_id"
struct Packet {
VirtioInputPacket data;
int32 next;
};
struct VirtioInputDevice {
device_node* node;
::virtio_device virtio_device;
virtio_device_interface* virtio;
::virtio_queue virtio_queue;
uint64 features;
uint32 packetCnt;
int32 freePackets;
int32 readyPackets, lastReadyPacket;
AreaDeleter packetArea;
phys_addr_t physAdr;
Packet* packets;
SemDeleter sem_cb;
};
struct VirtioInputHandle {
VirtioInputDevice* info;
};
device_manager_info* gDeviceManager;
#ifdef TRACE_VIRTIO_INPUT
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("%" B_PRId32, pkt.value);
}
break;
default:
TRACE(", %" B_PRId32, pkt.value);
}
}
#endif
static void
InitPackets(VirtioInputDevice* dev, uint32 count)
{
TRACE("InitPackets(%p, %" B_PRIu32 ")\n", dev, count);
size_t size = ROUNDUP(sizeof(Packet)*count, B_PAGE_SIZE);
dev->packetArea.SetTo(create_area("VirtIO input packets",
(void**)&dev->packets, B_ANY_KERNEL_ADDRESS, size,
B_CONTIGUOUS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA));
if (!dev->packetArea.IsSet()) {
ERROR("Unable to set packet area!");
return;
}
physical_entry pe;
if (get_memory_map(dev->packets, size, &pe, 1) < B_OK) {
ERROR("Unable to get memory map for input packets!");
return;
}
dev->physAdr = pe.address;
memset(dev->packets, 0, size);
dprintf(" size: 0x%" B_PRIxSIZE "\n", size);
dprintf(" virt: %p\n", dev->packets);
dprintf(" phys: %p\n", (void*)dev->physAdr);
dev->packetCnt = count;
dev->freePackets = 0;
for (uint32 i = 0; i < dev->packetCnt - 1; i++)
dev->packets[i].next = i + 1;
dev->packets[dev->packetCnt - 1].next = -1;
dev->readyPackets = -1;
dev->lastReadyPacket = -1;
}
static const physical_entry
PacketPhysEntry(VirtioInputDevice* dev, Packet* pkt)
{
physical_entry pe;
pe.address = dev->physAdr + (uint8*)pkt - (uint8*)dev->packets;
pe.size = sizeof(VirtioInputPacket);
return pe;
}
static void
ScheduleReadyPacket(VirtioInputDevice* dev, Packet* pkt)
{
if (dev->readyPackets < 0)
dev->readyPackets = pkt - dev->packets;
else
dev->packets[dev->lastReadyPacket].next = pkt - dev->packets;
dev->lastReadyPacket = pkt - dev->packets;
}
static Packet*
ConsumeReadyPacket(VirtioInputDevice* dev)
{
if (dev->readyPackets < 0)
return NULL;
Packet* pkt = &dev->packets[dev->readyPackets];
dev->readyPackets = pkt->next;
if (dev->readyPackets < 0)
dev->lastReadyPacket = -1;
return pkt;
}
static void
virtio_input_callback(void* driverCookie, void* cookie)
{
CALLED();
VirtioInputDevice* dev = (VirtioInputDevice*)cookie;
Packet* pkt;
while (dev->virtio->queue_dequeue(dev->virtio_queue, (void**)&pkt, NULL)) {
#ifdef TRACE_VIRTIO_INPUT
TRACE("%" B_PRIdSSIZE ": ", pkt - dev->packets);
WriteInputPacket(pkt->data);
TRACE("\n");
#endif
ScheduleReadyPacket(dev, pkt);
release_sem_etc(dev->sem_cb.Get(), 1, B_DO_NOT_RESCHEDULE);
}
}
static status_t
virtio_input_init_device(void* _info, void** _cookie)
{
CALLED();
VirtioInputDevice* info = (VirtioInputDevice*)_info;
DeviceNodePutter<&gDeviceManager> parent(
gDeviceManager->get_parent_node(info->node));
gDeviceManager->get_driver(parent.Get(),
(driver_module_info **)&info->virtio,
(void **)&info->virtio_device);
info->virtio->negotiate_features(info->virtio_device, 0,
&info->features, NULL);
status_t status = B_OK;
status = info->virtio->read_device_config(
info->virtio_device, 0, &info->config,
sizeof(struct virtio_blk_config));
if (status != B_OK)
return status;
*/
InitPackets(info, 8);
status = info->virtio->alloc_queues(info->virtio_device, 1,
&info->virtio_queue, NULL);
if (status != B_OK) {
ERROR("queue allocation failed (%s)\n", strerror(status));
return status;
}
TRACE(" queue: %p\n", info->virtio_queue);
status = info->virtio->queue_setup_interrupt(info->virtio_queue,
virtio_input_callback, info);
if (status < B_OK)
return status;
for (uint32 i = 0; i < info->packetCnt; i++) {
Packet* pkt = &info->packets[i];
physical_entry pe = PacketPhysEntry(info, pkt);
info->virtio->queue_request(info->virtio_queue, NULL, &pe, pkt);
}
*_cookie = info;
return B_OK;
}
static void
virtio_input_uninit_device(void* _cookie)
{
CALLED();
VirtioInputDevice* info = (VirtioInputDevice*)_cookie;
(void)info;
}
static status_t
virtio_input_open(void* _info, const char* path, int openMode, void** _cookie)
{
CALLED();
VirtioInputDevice* info = (VirtioInputDevice*)_info;
ObjectDeleter<VirtioInputHandle>
handle(new(std::nothrow) (VirtioInputHandle));
if (!handle.IsSet())
return B_NO_MEMORY;
handle->info = info;
*_cookie = handle.Detach();
return B_OK;
}
static status_t
virtio_input_close(void* cookie)
{
CALLED();
return B_OK;
}
static status_t
virtio_input_free(void* cookie)
{
CALLED();
ObjectDeleter<VirtioInputHandle> handle((VirtioInputHandle*)cookie);
return B_OK;
}
static status_t
virtio_input_read(void* cookie, off_t pos, void* buffer, size_t* _length)
{
return B_ERROR;
}
static status_t
virtio_input_write(void* cookie, off_t pos, const void* buffer,
size_t* _length)
{
*_length = 0;
return B_ERROR;
}
static status_t
virtio_input_ioctl(void* cookie, uint32 op, void* buffer, size_t length)
{
CALLED();
VirtioInputHandle* handle = (VirtioInputHandle*)cookie;
VirtioInputDevice* info = handle->info;
(void)info;
TRACE("ioctl(op = %" B_PRIu32 ")\n", op);
switch (op) {
case virtioInputRead: {
TRACE("virtioInputRead\n");
if (buffer == NULL || length < sizeof(VirtioInputPacket))
return B_BAD_VALUE;
status_t res = acquire_sem_etc(info->sem_cb.Get(), 1, B_CAN_INTERRUPT,
B_INFINITE_TIMEOUT);
if (res < B_OK)
return res;
Packet* pkt = ConsumeReadyPacket(info);
TRACE(" pkt: %" B_PRIdSSIZE "\n", pkt - info->packets);
physical_entry pe = PacketPhysEntry(info, pkt);
info->virtio->queue_request(info->virtio_queue, NULL, &pe, pkt);
res = user_memcpy(buffer, pkt, sizeof(Packet));
if (res < B_OK)
return res;
return B_OK;
}
}
return B_DEV_INVALID_IOCTL;
}
static float
virtio_input_supports_device(device_node *parent)
{
CALLED();
const char *bus;
uint16 deviceType;
if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
return -1;
if (strcmp(bus, "virtio"))
return 0.0;
if (gDeviceManager->get_attr_uint16(parent, VIRTIO_DEVICE_TYPE_ITEM,
&deviceType, true) != B_OK || deviceType != kVirtioDevInput)
return 0.0;
TRACE("Virtio input device found!\n");
return 0.6;
}
static status_t
virtio_input_register_device(device_node *node)
{
CALLED();
device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "VirtIO input" }},
{ NULL }
};
return gDeviceManager->register_node(node, VIRTIO_INPUT_DRIVER_MODULE_NAME,
attrs, NULL, NULL);
}
static status_t
virtio_input_init_driver(device_node *node, void **cookie)
{
CALLED();
ObjectDeleter<VirtioInputDevice>
info(new(std::nothrow) VirtioInputDevice());
if (!info.IsSet())
return B_NO_MEMORY;
memset(info.Get(), 0, sizeof(*info.Get()));
info->sem_cb.SetTo(create_sem(0, "virtio_input_cb"));
if (!info->sem_cb.IsSet())
return info->sem_cb.Get();
info->node = node;
*cookie = info.Detach();
return B_OK;
}
static void
virtio_input_uninit_driver(void *_cookie)
{
CALLED();
ObjectDeleter<VirtioInputDevice> info((VirtioInputDevice*)_cookie);
}
static status_t
virtio_input_register_child_devices(void* _cookie)
{
CALLED();
VirtioInputDevice* info = (VirtioInputDevice*)_cookie;
status_t status;
int32 id = gDeviceManager->create_id(VIRTIO_INPUT_DEVICE_ID_GENERATOR);
if (id < 0)
return id;
char name[64];
snprintf(name, sizeof(name), "input/virtio/%" B_PRId32 "/raw", id);
status = gDeviceManager->publish_device(info->node, name,
VIRTIO_INPUT_DEVICE_MODULE_NAME);
if (status < B_OK) {
ERROR("publish_device error: 0x%" B_PRIx32 "(%s) \n", status,
strerror(status));
}
return status;
}
module_dependency module_dependencies[] = {
{ B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&gDeviceManager },
{ NULL }
};
struct device_module_info sVirtioInputDevice = {
{
VIRTIO_INPUT_DEVICE_MODULE_NAME,
0,
NULL
},
virtio_input_init_device,
virtio_input_uninit_device,
NULL,
virtio_input_open,
virtio_input_close,
virtio_input_free,
virtio_input_read,
virtio_input_write,
NULL,
virtio_input_ioctl,
NULL,
NULL,
};
struct driver_module_info sVirtioInputDriver = {
{
VIRTIO_INPUT_DRIVER_MODULE_NAME,
0,
NULL
},
virtio_input_supports_device,
virtio_input_register_device,
virtio_input_init_driver,
virtio_input_uninit_driver,
virtio_input_register_child_devices,
NULL,
NULL,
};
module_info* modules[] = {
(module_info*)&sVirtioInputDriver,
(module_info*)&sVirtioInputDevice,
NULL
};
