You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
333 lines
9.8 KiB
333 lines
9.8 KiB
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
#include "HidRawDevice.h"
|
|
#include "HidLog.h"
|
|
#include "Utils.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <linux/input.h>
|
|
#include <linux/hidraw.h>
|
|
#include <linux/hiddev.h> // HID_STRING_SIZE
|
|
#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <set>
|
|
|
|
namespace android {
|
|
namespace SensorHalExt {
|
|
|
|
using HidUtil::HidItem;
|
|
|
|
HidRawDevice::HidRawDevice(
|
|
const std::string &devName, const std::unordered_set<unsigned int> &usageSet)
|
|
: mDevFd(-1), mMultiIdDevice(false), mValid(false) {
|
|
// open device
|
|
mDevFd = ::open(devName.c_str(), O_RDWR); // read write?
|
|
if (mDevFd < 0) {
|
|
LOG_E << "Error in open device node: " << errno << " (" << ::strerror(errno) << ")"
|
|
<< LOG_ENDL;
|
|
return;
|
|
}
|
|
|
|
// get device information, including hid descriptor
|
|
if (!populateDeviceInfo()) {
|
|
LOG_E << "Error obtaining HidRaw device information" << LOG_ENDL;
|
|
return;
|
|
}
|
|
|
|
if (!generateDigest(usageSet)) {
|
|
LOG_E << "Cannot parse hid descriptor" << LOG_ENDL;
|
|
return;
|
|
}
|
|
|
|
// digest error checking
|
|
std::unordered_set<unsigned int> reportIdSet;
|
|
for (auto const &digest : mDigestVector) {
|
|
for (auto const &packet : digest.packets) {
|
|
if (mReportTypeIdMap.emplace(
|
|
std::make_pair(packet.type, packet.id), &packet).second == false) {
|
|
LOG_E << "Same type - report id pair (" << packet.type << ", " << packet.id << ")"
|
|
<< "is used by more than one usage collection" << LOG_ENDL;
|
|
return;
|
|
}
|
|
reportIdSet.insert(packet.id);
|
|
}
|
|
}
|
|
if (mReportTypeIdMap.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (reportIdSet.size() > 1) {
|
|
if (reportIdSet.find(0) != reportIdSet.end()) {
|
|
LOG_E << "Default report id 0 is not expected when more than one report id is found."
|
|
<< LOG_ENDL;
|
|
return;
|
|
}
|
|
mMultiIdDevice = true;
|
|
} else { // reportIdSet.size() == 1
|
|
mMultiIdDevice = !(reportIdSet.find(0) != reportIdSet.end());
|
|
}
|
|
mValid = true;
|
|
}
|
|
|
|
HidRawDevice::~HidRawDevice() {
|
|
if (mDevFd > 0) {
|
|
::close(mDevFd);
|
|
mDevFd = -1;
|
|
}
|
|
}
|
|
|
|
bool HidRawDevice::populateDeviceInfo() {
|
|
HidDeviceInfo info;
|
|
char buffer[HID_STRING_SIZE + 1];
|
|
|
|
if (mDevFd < 0) {
|
|
return false;
|
|
}
|
|
|
|
// name
|
|
if (ioctl(mDevFd, HIDIOCGRAWNAME(sizeof(buffer) - 1), buffer) < 0) {
|
|
return false;
|
|
}
|
|
buffer[sizeof(buffer) - 1] = '\0';
|
|
info.name = buffer;
|
|
|
|
// physical path
|
|
if (ioctl(mDevFd, HIDIOCGRAWPHYS(sizeof(buffer) - 1), buffer) < 0) {
|
|
return false;
|
|
}
|
|
buffer[sizeof(buffer) - 1] = '\0';
|
|
info.physicalPath = buffer;
|
|
|
|
// raw device info
|
|
hidraw_devinfo devInfo;
|
|
if (ioctl(mDevFd, HIDIOCGRAWINFO, &devInfo) < 0) {
|
|
return false;
|
|
}
|
|
|
|
switch (devInfo.bustype) {
|
|
case BUS_USB:
|
|
info.busType = "USB";
|
|
break;
|
|
case BUS_HIL:
|
|
info.busType = "HIL";
|
|
break;
|
|
case BUS_BLUETOOTH:
|
|
info.busType = "Bluetooth";
|
|
break;
|
|
case BUS_VIRTUAL:
|
|
info.busType = "Virtual";
|
|
break;
|
|
default:
|
|
info.busType = "Other";
|
|
break;
|
|
}
|
|
|
|
info.vendorId = devInfo.vendor;
|
|
info.productId = devInfo.vendor;
|
|
|
|
uint32_t descriptorSize;
|
|
/* Get Report Descriptor Size */
|
|
if (ioctl(mDevFd, HIDIOCGRDESCSIZE, &descriptorSize) < 0) {
|
|
return false;
|
|
}
|
|
|
|
struct hidraw_report_descriptor reportDescriptor;
|
|
memset(&reportDescriptor, 0, sizeof(reportDescriptor));
|
|
info.descriptor.resize(descriptorSize);
|
|
reportDescriptor.size = descriptorSize;
|
|
if (ioctl(mDevFd, HIDIOCGRDESC, &reportDescriptor) < 0) {
|
|
return false;
|
|
}
|
|
std::copy(reportDescriptor.value, reportDescriptor.value + descriptorSize,
|
|
info.descriptor.begin());
|
|
mDeviceInfo = info;
|
|
return true;
|
|
}
|
|
|
|
bool HidRawDevice::generateDigest(const std::unordered_set<unsigned int> &usage) {
|
|
if (mDeviceInfo.descriptor.empty()) {
|
|
return false;
|
|
}
|
|
|
|
std::vector<HidItem> tokens = HidItem::tokenize(mDeviceInfo.descriptor);
|
|
HidParser parser;
|
|
if (!parser.parse(tokens)) {
|
|
return false;
|
|
}
|
|
|
|
parser.filterTree();
|
|
mDigestVector = parser.generateDigest(usage);
|
|
|
|
return mDigestVector.size() > 0;
|
|
}
|
|
|
|
bool HidRawDevice::isValid() {
|
|
return mValid;
|
|
}
|
|
|
|
bool HidRawDevice::getFeature(uint8_t id, std::vector<uint8_t> *out) {
|
|
if (mDevFd < 0) {
|
|
return false;
|
|
}
|
|
|
|
if (out == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
const HidParser::ReportPacket *packet = getReportPacket(HidParser::REPORT_TYPE_FEATURE, id);
|
|
if (packet == nullptr) {
|
|
LOG_E << "HidRawDevice::getFeature: unknown feature " << id << LOG_ENDL;
|
|
return false;
|
|
}
|
|
|
|
size_t size = packet->getByteSize() + 1; // report id size
|
|
|
|
std::lock_guard<std::mutex> l(mIoBufferLock);
|
|
if (mIoBuffer.size() < size) {
|
|
mIoBuffer.resize(size);
|
|
}
|
|
mIoBuffer[0] = id;
|
|
int res = ::ioctl(mDevFd, HIDIOCGFEATURE(size), mIoBuffer.data());
|
|
if (res < 0) {
|
|
LOG_E << "HidRawDevice::getFeature: feature " << static_cast<int>(id)
|
|
<< " ioctl returns " << res << " (" << ::strerror(res) << ")" << LOG_ENDL;
|
|
return false;
|
|
}
|
|
|
|
if (static_cast<size_t>(res) != size) {
|
|
LOG_E << "HidRawDevice::getFeature: get feature " << static_cast<int>(id)
|
|
<< " returned " << res << " bytes, does not match expected " << size << LOG_ENDL;
|
|
return false;
|
|
}
|
|
if (mIoBuffer.front() != id) {
|
|
LOG_E << "HidRawDevice::getFeature: get feature " << static_cast<int>(id)
|
|
<< " result has header " << mIoBuffer.front() << LOG_ENDL;
|
|
}
|
|
out->resize(size - 1);
|
|
std::copy(mIoBuffer.begin() + 1, mIoBuffer.begin() + size, out->begin());
|
|
return true;
|
|
}
|
|
|
|
bool HidRawDevice::setFeature(uint8_t id, const std::vector<uint8_t> &in) {
|
|
if (mDevFd < 0) {
|
|
return false;
|
|
}
|
|
|
|
const HidParser::ReportPacket *packet = getReportPacket(HidParser::REPORT_TYPE_FEATURE, id);
|
|
if (packet == nullptr) {
|
|
LOG_E << "HidRawDevice::setFeature: Unknown feature " << id << LOG_ENDL;
|
|
return false;
|
|
}
|
|
|
|
size_t size = packet->getByteSize();
|
|
if (size != in.size()) {
|
|
LOG_E << "HidRawDevice::setFeature: set feature " << id << " size mismatch, need "
|
|
<< size << " bytes, have " << in.size() << " bytes" << LOG_ENDL;
|
|
return false;
|
|
}
|
|
|
|
++size; // report id byte
|
|
std::lock_guard<std::mutex> l(mIoBufferLock);
|
|
if (mIoBuffer.size() < size) {
|
|
mIoBuffer.resize(size);
|
|
}
|
|
mIoBuffer[0] = id;
|
|
std::copy(in.begin(), in.end(), &mIoBuffer[1]);
|
|
int res = ::ioctl(mDevFd, HIDIOCSFEATURE(size), mIoBuffer.data());
|
|
if (res < 0) {
|
|
LOG_E << "HidRawDevice::setFeature: feature " << id << " ioctl returns " << res
|
|
<< " (" << ::strerror(res) << ")" << LOG_ENDL;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HidRawDevice::sendReport(uint8_t id, std::vector<uint8_t> &data) {
|
|
if (mDevFd < 0) {
|
|
return false;
|
|
}
|
|
|
|
const HidParser::ReportPacket *packet = getReportPacket(HidParser::REPORT_TYPE_OUTPUT, id);
|
|
if (packet == nullptr) {
|
|
LOG_E << "HidRawDevice::sendReport: unknown output " << id << LOG_ENDL;
|
|
return false;
|
|
}
|
|
|
|
size_t size = packet->getByteSize();
|
|
if (size != data.size()) {
|
|
LOG_E << "HidRawDevice::sendReport: send report " << id << " size mismatch, need "
|
|
<< size << " bytes, have " << data.size() << " bytes" << LOG_ENDL;
|
|
return false;
|
|
}
|
|
int res;
|
|
if (mMultiIdDevice) {
|
|
std::lock_guard<std::mutex> l(mIoBufferLock);
|
|
++size;
|
|
if (mIoBuffer.size() < size) {
|
|
mIoBuffer.resize(size);
|
|
}
|
|
mIoBuffer[0] = id;
|
|
std::copy(mIoBuffer.begin() + 1, mIoBuffer.end(), data.begin());
|
|
res = ::write(mDevFd, mIoBuffer.data(), size);
|
|
} else {
|
|
res = ::write(mDevFd, data.data(), size);
|
|
}
|
|
if (res < 0) {
|
|
LOG_E << "HidRawDevice::sendReport: output " << id << " write returns " << res
|
|
<< " (" << ::strerror(res) << ")" << LOG_ENDL;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HidRawDevice::receiveReport(uint8_t *id, std::vector<uint8_t> *data) {
|
|
if (mDevFd < 0) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t buffer[256];
|
|
int res = ::read(mDevFd, buffer, 256);
|
|
if (res < 0) {
|
|
LOG_E << "HidRawDevice::receiveReport: read returns " << res
|
|
<< " (" << ::strerror(res) << ")" << LOG_ENDL;
|
|
return false;
|
|
}
|
|
|
|
if (mMultiIdDevice) {
|
|
if (!(res > 1)) {
|
|
LOG_E << "read hidraw returns data too short, len: " << res << LOG_ENDL;
|
|
return false;
|
|
}
|
|
data->resize(static_cast<size_t>(res - 1));
|
|
std::copy(buffer + 1, buffer + res, data->begin());
|
|
*id = buffer[0];
|
|
} else {
|
|
data->resize(static_cast<size_t>(res));
|
|
std::copy(buffer, buffer + res, data->begin());
|
|
*id = 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const HidParser::ReportPacket *HidRawDevice::getReportPacket(unsigned int type, unsigned int id) {
|
|
auto i = mReportTypeIdMap.find(std::make_pair(type, id));
|
|
return (i == mReportTypeIdMap.end()) ? nullptr : i->second;
|
|
}
|
|
|
|
} // namespace SensorHalExt
|
|
} // namespace android
|