PL286/hardware/libhardware/modules/sensors/dynamic_sensor/HidRawDevice.cpp

/*
 * 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