mirror of https://github.com/AxioDL/boo.git
292 lines
9.3 KiB
C++
292 lines
9.3 KiB
C++
#include "IHIDDevice.hpp"
|
|
#include "boo/inputdev/DeviceToken.hpp"
|
|
#include "boo/inputdev/DeviceBase.hpp"
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <condition_variable>
|
|
|
|
#include <cstdio>
|
|
#include <libudev.h>
|
|
#include <stropts.h>
|
|
#include <linux/usb/ch9.h>
|
|
#include <linux/usbdevice_fs.h>
|
|
#include <linux/input.h>
|
|
#include <linux/hidraw.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
#include <cstring>
|
|
#include "boo/inputdev/HIDParser.hpp"
|
|
|
|
namespace boo {
|
|
|
|
udev* GetUdev();
|
|
|
|
/*
|
|
* Reference: http://tali.admingilde.org/linux-docbook/usb/ch07s06.html
|
|
*/
|
|
|
|
class HIDDeviceUdev final : public IHIDDevice {
|
|
DeviceToken& m_token;
|
|
std::shared_ptr<DeviceBase> m_devImp;
|
|
|
|
int m_devFd = 0;
|
|
unsigned m_usbIntfInPipe = 0;
|
|
unsigned m_usbIntfOutPipe = 0;
|
|
bool m_runningTransferLoop = false;
|
|
|
|
std::string_view m_devPath;
|
|
std::mutex m_initMutex;
|
|
std::condition_variable m_initCond;
|
|
std::thread m_thread;
|
|
|
|
bool _sendUSBInterruptTransfer(const uint8_t* data, size_t length) {
|
|
if (m_devFd) {
|
|
usbdevfs_bulktransfer xfer = {m_usbIntfOutPipe | USB_DIR_OUT, (unsigned)length, 30, (void*)data};
|
|
int ret = ioctl(m_devFd, USBDEVFS_BULK, &xfer);
|
|
if (ret != (int)length)
|
|
return false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t _receiveUSBInterruptTransfer(uint8_t* data, size_t length) {
|
|
if (m_devFd) {
|
|
usbdevfs_bulktransfer xfer = {m_usbIntfInPipe | USB_DIR_IN, (unsigned)length, 30, data};
|
|
return ioctl(m_devFd, USBDEVFS_BULK, &xfer);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void _threadProcUSBLL(std::shared_ptr<HIDDeviceUdev> device) {
|
|
int i;
|
|
std::unique_lock<std::mutex> lk(device->m_initMutex);
|
|
udev_device* udevDev = udev_device_new_from_syspath(GetUdev(), device->m_devPath.data());
|
|
|
|
/* Get device file */
|
|
const char* dp = udev_device_get_devnode(udevDev);
|
|
int fd = open(dp, O_RDWR);
|
|
if (fd < 0) {
|
|
device->m_devImp->deviceError(fmt("Unable to open {}@{}: {}\n"),
|
|
device->m_token.getProductName(), dp, strerror(errno));
|
|
lk.unlock();
|
|
device->m_initCond.notify_one();
|
|
udev_device_unref(udevDev);
|
|
return;
|
|
}
|
|
device->m_devFd = fd;
|
|
usb_device_descriptor devDesc = {};
|
|
read(fd, &devDesc, 1);
|
|
read(fd, &devDesc.bDescriptorType, devDesc.bLength - 1);
|
|
if (devDesc.bNumConfigurations) {
|
|
usb_config_descriptor confDesc = {};
|
|
read(fd, &confDesc, 1);
|
|
read(fd, &confDesc.bDescriptorType, confDesc.bLength - 1);
|
|
if (confDesc.bNumInterfaces) {
|
|
usb_interface_descriptor intfDesc = {};
|
|
read(fd, &intfDesc, 1);
|
|
read(fd, &intfDesc.bDescriptorType, intfDesc.bLength - 1);
|
|
for (i = 0; i < intfDesc.bNumEndpoints + 1; ++i) {
|
|
usb_endpoint_descriptor endpDesc = {};
|
|
read(fd, &endpDesc, 1);
|
|
read(fd, &endpDesc.bDescriptorType, endpDesc.bLength - 1);
|
|
if ((endpDesc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
|
|
if ((endpDesc.bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
|
|
device->m_usbIntfInPipe = endpDesc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
|
|
else if ((endpDesc.bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT)
|
|
device->m_usbIntfOutPipe = endpDesc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Request that kernel disconnects existing driver */
|
|
usbdevfs_ioctl disconnectReq = {0, USBDEVFS_DISCONNECT, NULL};
|
|
ioctl(fd, USBDEVFS_IOCTL, &disconnectReq);
|
|
|
|
/* Return control to main thread */
|
|
device->m_runningTransferLoop = true;
|
|
lk.unlock();
|
|
device->m_initCond.notify_one();
|
|
|
|
/* Start transfer loop */
|
|
device->m_devImp->initialCycle();
|
|
while (device->m_runningTransferLoop)
|
|
device->m_devImp->transferCycle();
|
|
device->m_devImp->finalCycle();
|
|
|
|
/* Cleanup */
|
|
close(fd);
|
|
device->m_devFd = 0;
|
|
udev_device_unref(udevDev);
|
|
}
|
|
|
|
static void _threadProcBTLL(std::shared_ptr<HIDDeviceUdev> device) {
|
|
std::unique_lock<std::mutex> lk(device->m_initMutex);
|
|
udev_device* udevDev = udev_device_new_from_syspath(GetUdev(), device->m_devPath.data());
|
|
|
|
/* Return control to main thread */
|
|
device->m_runningTransferLoop = true;
|
|
lk.unlock();
|
|
device->m_initCond.notify_one();
|
|
|
|
/* Start transfer loop */
|
|
device->m_devImp->initialCycle();
|
|
while (device->m_runningTransferLoop)
|
|
device->m_devImp->transferCycle();
|
|
device->m_devImp->finalCycle();
|
|
|
|
udev_device_unref(udevDev);
|
|
}
|
|
|
|
static void _threadProcHID(std::shared_ptr<HIDDeviceUdev> device) {
|
|
std::unique_lock<std::mutex> lk(device->m_initMutex);
|
|
udev_device* udevDev = udev_device_new_from_syspath(GetUdev(), device->m_devPath.data());
|
|
|
|
/* Get device file */
|
|
const char* dp = udev_device_get_devnode(udevDev);
|
|
int fd = open(dp, O_RDWR | O_NONBLOCK);
|
|
if (fd < 0) {
|
|
device->m_devImp->deviceError(fmt("Unable to open {}@{}: {}\n"),
|
|
device->m_token.getProductName(), dp, strerror(errno));
|
|
lk.unlock();
|
|
device->m_initCond.notify_one();
|
|
udev_device_unref(udevDev);
|
|
return;
|
|
}
|
|
device->m_devFd = fd;
|
|
|
|
/* Return control to main thread */
|
|
device->m_runningTransferLoop = true;
|
|
lk.unlock();
|
|
device->m_initCond.notify_one();
|
|
|
|
/* Report descriptor size */
|
|
int reportDescSize;
|
|
if (ioctl(fd, HIDIOCGRDESCSIZE, &reportDescSize) == -1) {
|
|
device->m_devImp->deviceError(fmt("Unable to ioctl(HIDIOCGRDESCSIZE) {}@{}: {}\n"),
|
|
device->m_token.getProductName(), dp, strerror(errno));
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/* Get report descriptor */
|
|
hidraw_report_descriptor reportDesc;
|
|
reportDesc.size = reportDescSize;
|
|
if (ioctl(fd, HIDIOCGRDESC, &reportDesc) == -1) {
|
|
device->m_devImp->deviceError(fmt("Unable to ioctl(HIDIOCGRDESC) {}@{}: {}\n"),
|
|
device->m_token.getProductName(), dp, strerror(errno));
|
|
close(fd);
|
|
return;
|
|
}
|
|
size_t readSz = HIDParser::CalculateMaxInputReportSize(reportDesc.value, reportDesc.size);
|
|
std::unique_ptr<uint8_t[]> readBuf(new uint8_t[readSz]);
|
|
|
|
/* Start transfer loop */
|
|
device->m_devImp->initialCycle();
|
|
while (device->m_runningTransferLoop) {
|
|
fd_set readset;
|
|
FD_ZERO(&readset);
|
|
FD_SET(fd, &readset);
|
|
struct timeval timeout = {0, 10000};
|
|
if (select(fd + 1, &readset, nullptr, nullptr, &timeout) > 0) {
|
|
while (true) {
|
|
ssize_t sz = read(fd, readBuf.get(), readSz);
|
|
if (sz < 0)
|
|
break;
|
|
device->m_devImp->receivedHIDReport(readBuf.get(), sz, HIDReportType::Input, readBuf[0]);
|
|
}
|
|
}
|
|
if (device->m_runningTransferLoop)
|
|
device->m_devImp->transferCycle();
|
|
}
|
|
device->m_devImp->finalCycle();
|
|
|
|
/* Cleanup */
|
|
close(fd);
|
|
device->m_devFd = 0;
|
|
udev_device_unref(udevDev);
|
|
}
|
|
|
|
void _deviceDisconnected() { m_runningTransferLoop = false; }
|
|
|
|
std::vector<uint8_t> _getReportDescriptor() {
|
|
/* Report descriptor size */
|
|
int reportDescSize;
|
|
if (ioctl(m_devFd, HIDIOCGRDESCSIZE, &reportDescSize) == -1)
|
|
return {};
|
|
|
|
/* Get report descriptor */
|
|
hidraw_report_descriptor reportDesc;
|
|
reportDesc.size = reportDescSize;
|
|
if (ioctl(m_devFd, HIDIOCGRDESC, &reportDesc) == -1)
|
|
return {};
|
|
std::vector<uint8_t> ret(reportDesc.size, '\0');
|
|
memmove(ret.data(), reportDesc.value, reportDesc.size);
|
|
return ret;
|
|
}
|
|
|
|
bool _sendHIDReport(const uint8_t* data, size_t length, HIDReportType tp, uint32_t message) {
|
|
if (m_devFd) {
|
|
if (tp == HIDReportType::Feature) {
|
|
int ret = ioctl(m_devFd, HIDIOCSFEATURE(length), data);
|
|
if (ret < 0)
|
|
return false;
|
|
return true;
|
|
} else if (tp == HIDReportType::Output) {
|
|
ssize_t ret = write(m_devFd, data, length);
|
|
if (ret < 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t _receiveHIDReport(uint8_t* data, size_t length, HIDReportType tp, uint32_t message) {
|
|
if (m_devFd) {
|
|
if (tp == HIDReportType::Feature) {
|
|
data[0] = message;
|
|
int ret = ioctl(m_devFd, HIDIOCGFEATURE(length), data);
|
|
if (ret < 0)
|
|
return 0;
|
|
return length;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public:
|
|
HIDDeviceUdev(DeviceToken& token, const std::shared_ptr<DeviceBase>& devImp)
|
|
: m_token(token), m_devImp(devImp), m_devPath(token.getDevicePath()) {}
|
|
|
|
void _startThread() {
|
|
std::unique_lock<std::mutex> lk(m_initMutex);
|
|
DeviceType dType = m_token.getDeviceType();
|
|
if (dType == DeviceType::USB)
|
|
m_thread = std::thread(_threadProcUSBLL, std::static_pointer_cast<HIDDeviceUdev>(shared_from_this()));
|
|
else if (dType == DeviceType::Bluetooth)
|
|
m_thread = std::thread(_threadProcBTLL, std::static_pointer_cast<HIDDeviceUdev>(shared_from_this()));
|
|
else if (dType == DeviceType::HID)
|
|
m_thread = std::thread(_threadProcHID, std::static_pointer_cast<HIDDeviceUdev>(shared_from_this()));
|
|
else {
|
|
fmt::print(stderr, fmt("invalid token supplied to device constructor"));
|
|
abort();
|
|
}
|
|
m_initCond.wait(lk);
|
|
}
|
|
|
|
~HIDDeviceUdev() {
|
|
m_runningTransferLoop = false;
|
|
if (m_thread.joinable())
|
|
m_thread.detach();
|
|
}
|
|
};
|
|
|
|
std::shared_ptr<IHIDDevice> IHIDDeviceNew(DeviceToken& token, const std::shared_ptr<DeviceBase>& devImp) {
|
|
return std::make_shared<HIDDeviceUdev>(token, devImp);
|
|
}
|
|
|
|
} // namespace boo
|