src/cffi/oh_usb.cpp

/*
 * Copyright (C) 2023 Huawei Device Co., Ltd.
 * 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 "oh_usb.h"
#include "usb_ffs.h"
#include "usb_util.h"
#include "sys_para.h"
#include "log.h"

#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <cerrno>
#include <csignal>

using namespace Hdc;

static constexpr int CONFIG_COUNT2 = 2;
static constexpr int CONFIG_COUNT3 = 3;
static constexpr int CONFIG_COUNT5 = 5;

// make gnuc++ happy. Clang support direct assignment value to structure, buf g++ weakness
void FillUsbV2Head(struct Hdc::UsbFunctionfsDescV2 &descUsbFfs)
{
    descUsbFfs.head.magic = LONG_LE(FUNCTIONFS_DESCRIPTORS_MAGIC_V2);
    descUsbFfs.head.length = LONG_LE(sizeof(descUsbFfs));
    descUsbFfs.head.flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC |
                            FUNCTIONFS_HAS_SS_DESC | FUNCTIONFS_HAS_MS_OS_DESC;
    descUsbFfs.config1Count = CONFIG_COUNT3;
    descUsbFfs.config2Count = CONFIG_COUNT3;
    descUsbFfs.config3Count = CONFIG_COUNT5;
    descUsbFfs.configWosCount = CONFIG_COUNT2;
    descUsbFfs.config1Desc = Hdc::config1;
    descUsbFfs.config2Desc = Hdc::config2;
    descUsbFfs.config3Desc = Hdc::config3;
    descUsbFfs.wosHead = Hdc::g_wosHead;
    descUsbFfs.wosDesc = Hdc::g_wosDesc;
    descUsbFfs.osPropHead = Hdc::g_osPropHead;
    descUsbFfs.osPropValues = Hdc::g_osPropValues;
}

int ConfigEpPoint(int& controlEp, const std::string& path)
{
    struct Hdc::UsbFunctionfsDescV2 descUsbFfs = {};
    FillUsbV2Head(descUsbFfs);
    while (true) {
        if (controlEp <= 0) {
            // After the control port sends the instruction, the device is initialized by the device to the HOST host,
            // which can be found for USB devices. Do not send initialization to the EP0 control port, the USB
            // device will not be initialized by Host
            WRITE_LOG(LOG_INFO, "Begin send to control(EP0) for usb descriptor init\n");
            if ((controlEp = open(path.c_str(), O_RDWR)) < 0) {
                WRITE_LOG(LOG_WARN, "%s: cannot open control endpoint: errno=%d\n", path.c_str(), errno);
                break;
            }
            if (write(controlEp, &descUsbFfs, sizeof(descUsbFfs)) < 0) {
                WRITE_LOG(LOG_WARN, "%s: write ffs configs failed: errno=%d\n", path.c_str(), errno);
                break;
            }
            if (write(controlEp, &Hdc::USB_FFS_VALUE, sizeof(Hdc::USB_FFS_VALUE)) < 0) {
                WRITE_LOG(LOG_WARN, "%s: write USB_FFS_VALUE failed: errno=%d\n", path.c_str(), errno);
                break;
            }
            // active usbrc, Send USB initialization signal
            WRITE_LOG(LOG_INFO, "ConnectEPPoint ctrl init finish, set usb-ffs ready\n");
            fcntl(controlEp, F_SETFD, FD_CLOEXEC);
            Hdc::SetDevItem("sys.usb.ffs.ready.hdc", "0");
            Hdc::SetDevItem("sys.usb.ffs.ready", "1");
            Hdc::SetDevItem("sys.usb.ffs.ready.hdc", "1");
            return ERR_SUCCESS;
        }
    }
    return ERR_GENERIC;
}

int OpenEpPoint(int &fd, const std::string path)
{
    if ((fd = open(path.c_str(), O_RDWR)) < 0) {
        WRITE_LOG(LOG_WARN, "%s: cannot open ep: errno=%d\n", path.c_str(), errno);
        return ERR_GENERIC;
    }
    fcntl(fd, F_SETFD, FD_CLOEXEC);
    return ERR_SUCCESS;
}

int CloseUsbFd(int &fd)
{
        int rc = 0;
#ifndef HDC_HOST
        WRITE_LOG(LOG_INFO, "CloseFd fd:%d\n", fd);
#endif
        if (fd > 0) {
            rc = close(fd);
            if (rc < 0) {
                char buffer[Hdc::BUF_SIZE_DEFAULT] = { 0 };
#ifdef _WIN32
                strerror_s(buffer, Hdc::BUF_SIZE_DEFAULT, errno);
#else
                strerror_r(errno, buffer, Hdc::BUF_SIZE_DEFAULT);
#endif
                WRITE_LOG(LOG_WARN, "close failed errno:%d %s\n", errno, buffer);
            } else {
                fd = -1;
            }
        }
        return rc;
}

void CloseEndpoint(int &bulkInFd, int &bulkOutFd, int &controlEp, bool closeCtrlEp)
{
    CloseUsbFd(bulkInFd);
    CloseUsbFd(bulkOutFd);
    if (controlEp > 0 && closeCtrlEp) {
        CloseUsbFd(controlEp);
        controlEp = 0;
    }
    WRITE_LOG(LOG_INFO, "close endpoint ok\n");
}

int WriteData(int bulkIn, const uint8_t *data, const int length)
{
    int ret;
    int writen = 0;
    bool restoreSigmask = true;

    sigset_t newmask;
    sigset_t oldmask;
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGCHLD);
    if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
        WRITE_LOG(LOG_FATAL, "before write usb, ignor the sigchld failed, err(%d)\n", errno);
        restoreSigmask = false;
    }

    while (writen < length) {
        ret = write(bulkIn, const_cast<uint8_t *>(data + writen), length - writen);
        if (ret < 0) {
            if (errno == EINTR) {
                WRITE_LOG(LOG_FATAL, "write usb fd(%d) (%d) bytes interrupted, will retry\n",
                    bulkIn, length - writen);
                continue;
            }
            WRITE_LOG(LOG_FATAL, "write usb fd(%d) (%d) bytes failed(%d), err(%d)\n",
                bulkIn, length - writen, ret, errno);
            break;
        }
        writen += ret;
    }

    if (restoreSigmask && sigprocmask(SIG_SETMASK, &oldmask, nullptr) < 0) {
        WRITE_LOG(LOG_FATAL, "after write usb, restore signal mask failed, err(%d)\n", errno);
    }

    return ret < 0 ? ret : writen;
}

size_t ReadData(int bulkOut, uint8_t* buf, const size_t size)
{
    int ret = -1;
    size_t readed = 0;

    while (readed < size) {
        ret = read(bulkOut, buf + readed, size - readed);
        if (ret >= 0) {
            readed += static_cast<size_t>(ret);
        } else if (errno == EINTR) {
                WRITE_LOG(LOG_FATAL, "read usb fd(%d) (%d) bytes interrupted, will retry\n",
                    bulkOut, size - readed);
                continue;
        } else {
            WRITE_LOG(LOG_FATAL, "read usb fd(%d) (%d) bytes failed(%d), err(%d)\n",
                bulkOut, size - readed, ret, errno);
            break;
        }
    }

    return ret < 0 ? 0 : readed;
}