Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6490b2fc authored by Amy's avatar Amy
Browse files

Using named pipe as input/output of the CEC hal mock impl 

Test: see go/cec_1.0_cuttlefish "How to test HDMI framework on Cuttlefish"
Bug: 135684678
Change-Id: Ice53fe48780d10491a01ec2da764335753150521
parent 42d10ce6

tv/cec/1.0/default/HdmiCecMock.cpp

+173 −12
Original line number Diff line number Diff line
@@ -77,6 +77,7 @@ Return<SendMessageResult> HdmiCecMock::sendMessage(const CecMessage& message) { 
    if (message.body.size() == 0) {

        return SendMessageResult::NACK;

    }

    sendMessageToFifo(message);

    return SendMessageResult::SUCCESS;

}
@@ -88,6 +89,11 @@ Return<void> HdmiCecMock::setCallback(const sp<IHdmiCecCallback>& callback) { 
    if (callback != nullptr) {

        mCallback = callback;

        mCallback->linkToDeath(this, 0 /*cookie*/);



        mInputFile = open(CEC_MSG_IN_FIFO, O_RDWR);

        mOutputFile = open(CEC_MSG_OUT_FIFO, O_RDWR);

        pthread_create(&mThreadId, NULL, __threadLoop, this);

        pthread_setname_np(mThreadId, "hdmi_cec_loop");

    }

    return Void();

}
@@ -102,17 +108,8 @@ Return<uint32_t> HdmiCecMock::getVendorId() { 
}



Return<void> HdmiCecMock::getPortInfo(getPortInfo_cb _hidl_cb) {

    vector<HdmiPortInfo> portInfos;

    // TODO ready port info from device specific config

    portInfos.resize(mTotalPorts);

    for (int i = 0; i < mTotalPorts; ++i) {

        portInfos[i] = {.type = HdmiPortType::INPUT,

                        .portId = static_cast<uint32_t>(i),

                        .cecSupported = true,

                        .arcSupported = (i == 0),

                        .physicalAddress = static_cast<uint16_t>(i << 12)};

    }

    _hidl_cb(portInfos);

    _hidl_cb(mPortInfo);

    return Void();

}
@@ -140,13 +137,177 @@ Return<void> HdmiCecMock::enableAudioReturnChannel(int32_t portId __unused, bool 
    return Void();

}



Return<bool> HdmiCecMock::isConnected(int32_t portId __unused) {

Return<bool> HdmiCecMock::isConnected(int32_t portId) {

    // maintain port connection status and update on hotplug event

    if (portId < mTotalPorts && portId >= 0) {

        return mPortConnectionStatus[portId];

    }

    return false;

}



void* HdmiCecMock::__threadLoop(void* user) {

    HdmiCecMock* const self = static_cast<HdmiCecMock*>(user);

    self->threadLoop();

    return 0;

}



int HdmiCecMock::readMessageFromFifo(unsigned char* buf, int msgCount) {

    if (msgCount <= 0 || !buf) {

        return 0;

    }



    int ret = -1;

    /* maybe blocked at driver */

    ret = read(mInputFile, buf, msgCount);

    if (ret < 0) {

        ALOGE("[halimp] read :%s failed, ret:%d\n", CEC_MSG_IN_FIFO, ret);

        return -1;

    }



    return ret;

}



int HdmiCecMock::sendMessageToFifo(const CecMessage& message) {

    unsigned char msgBuf[CEC_MESSAGE_BODY_MAX_LENGTH];

    int ret = -1;



    memset(msgBuf, 0, sizeof(msgBuf));

    msgBuf[0] = ((static_cast<uint8_t>(message.initiator) & 0xf) << 4) |

                (static_cast<uint8_t>(message.destination) & 0xf);



    size_t length = std::min(static_cast<size_t>(message.body.size()),

                             static_cast<size_t>(MaxLength::MESSAGE_BODY));

    for (size_t i = 0; i < length; ++i) {

        msgBuf[i + 1] = static_cast<unsigned char>(message.body[i]);

    }



    // open the output pipe for writing outgoing cec message

    mOutputFile = open(CEC_MSG_OUT_FIFO, O_WRONLY);

    if (mOutputFile < 0) {

        ALOGD("[halimp] file open failed for writing");

        return -1;

    }



    // write message into the output pipe

    ret = write(mOutputFile, msgBuf, length + 1);

    close(mOutputFile);

    if (ret < 0) {

        ALOGE("[halimp] write :%s failed, ret:%d\n", CEC_MSG_OUT_FIFO, ret);

        return -1;

    }

    return ret;

}



void HdmiCecMock::printCecMsgBuf(const char* msg_buf, int len) {

    char buf[64] = {};

    int i, size = 0;

    memset(buf, 0, sizeof(buf));

    for (i = 0; i < len; i++) {

        size += sprintf(buf + size, " %02x", msg_buf[i]);

    }

    ALOGD("[halimp] %s, msg:%s", __FUNCTION__, buf);

}



void HdmiCecMock::handleHotplugMessage(unsigned char* msgBuf) {

    HotplugEvent hotplugEvent{.connected = ((msgBuf[3]) & 0xf) > 0,

                              .portId = static_cast<uint32_t>(msgBuf[0] & 0xf)};



    if (hotplugEvent.portId >= mPortInfo.size()) {

        ALOGD("[halimp] ignore hot plug message, id %x does not exist", hotplugEvent.portId);

        return;

    }



    ALOGD("[halimp] hot plug port id %x, is connected %x", (msgBuf[0] & 0xf), (msgBuf[3] & 0xf));

    if (mPortInfo[hotplugEvent.portId].type == HdmiPortType::OUTPUT) {

        mPhysicalAddress =

                ((hotplugEvent.connected == 0) ? 0xffff : ((msgBuf[1] << 8) | (msgBuf[2])));

        mPortInfo[hotplugEvent.portId].physicalAddress = mPhysicalAddress;

        ALOGD("[halimp] hot plug physical address %x", mPhysicalAddress);

    }



    // todo update connection status



    if (mCallback != nullptr) {

        mCallback->onHotplugEvent(hotplugEvent);

    }

}



void HdmiCecMock::handleCecMessage(unsigned char* msgBuf, int megSize) {

    CecMessage message;

    size_t length = std::min(static_cast<size_t>(megSize - 1),

                             static_cast<size_t>(MaxLength::MESSAGE_BODY));

    message.body.resize(length);



    for (size_t i = 0; i < length; ++i) {

        message.body[i] = static_cast<uint8_t>(msgBuf[i + 1]);

        ALOGD("[halimp] msg body %x", message.body[i]);

    }



    message.initiator = static_cast<CecLogicalAddress>((msgBuf[0] >> 4) & 0xf);

    ALOGD("[halimp] msg init %x", message.initiator);

    message.destination = static_cast<CecLogicalAddress>((msgBuf[0] >> 0) & 0xf);

    ALOGD("[halimp] msg dest %x", message.destination);



    // messageValidateAndHandle(&event);



    if (mCallback != nullptr) {

        mCallback->onCecMessage(message);

    }

}



void HdmiCecMock::threadLoop() {

    ALOGD("[halimp] threadLoop start.");

    unsigned char msgBuf[CEC_MESSAGE_BODY_MAX_LENGTH];

    int r = -1;



    // open the input pipe

    while (mInputFile < 0) {

        usleep(1000 * 1000);

        mInputFile = open(CEC_MSG_IN_FIFO, O_RDONLY);

    }

    ALOGD("[halimp] file open ok, fd = %d.", mInputFile);



    while (mCecThreadRun) {

        if (!mOptionSystemCecControl) {

            usleep(1000 * 1000);

            continue;

        }



        memset(msgBuf, 0, sizeof(msgBuf));

        // try to get a message from dev.

        // echo -n -e '\x04\x83' >> /dev/cec

        r = readMessageFromFifo(msgBuf, CEC_MESSAGE_BODY_MAX_LENGTH);

        if (r <= 1) {

            // ignore received ping messages

            continue;

        }



        printCecMsgBuf((const char*)msgBuf, r);



        if (((msgBuf[0] >> 4) & 0xf) == 0xf) {

            // the message is a hotplug event

            handleHotplugMessage(msgBuf);

            continue;

        }



        handleCecMessage(msgBuf, r);

    }



    ALOGD("[halimp] thread end.");

    // mCecDevice.mExited = true;

}



HdmiCecMock::HdmiCecMock() {

    ALOGE("Opening a virtual HAL for testing and virtual machine.");

    ALOGE("[halimp] Opening a virtual HAL for testing and virtual machine.");

    mCallback = nullptr;

    mPortInfo.resize(mTotalPorts);

    mPortConnectionStatus.resize(mTotalPorts);

    mPortInfo[0] = {.type = HdmiPortType::OUTPUT,

                    .portId = static_cast<uint32_t>(0),

                    .cecSupported = true,

                    .arcSupported = false,

                    .physicalAddress = mPhysicalAddress};

    mPortConnectionStatus[0] = false;

}



}  // namespace implementation

tv/cec/1.0/default/HdmiCecMock.h

+26 −1
Original line number Diff line number Diff line
@@ -49,6 +49,9 @@ using ::android::hardware::tv::cec::V1_0::OptionKey; 
using ::android::hardware::tv::cec::V1_0::Result;

using ::android::hardware::tv::cec::V1_0::SendMessageResult;



#define CEC_MSG_IN_FIFO "/dev/cec_in_pipe"

#define CEC_MSG_OUT_FIFO "/dev/cec_out_pipe"



struct HdmiCecMock : public IHdmiCec, public hidl_death_recipient {

    HdmiCecMock();

    // Methods from ::android::hardware::tv::cec::V1_0::IHdmiCec follow.
@@ -71,21 +74,43 @@ struct HdmiCecMock : public IHdmiCec, public hidl_death_recipient { 
    }



    void cec_set_option(int flag, int value);

    void printCecMsgBuf(const char* msg_buf, int len);



  private:

    static void* __threadLoop(void* data);

    void threadLoop();

    int readMessageFromFifo(unsigned char* buf, int msgCount);

    int sendMessageToFifo(const CecMessage& message);

    void handleHotplugMessage(unsigned char* msgBuf);

    void handleCecMessage(unsigned char* msgBuf, int length);



  private:

    sp<IHdmiCecCallback> mCallback;



    // Variables for the virtual cec hal impl

    uint16_t mPhysicalAddress = 0xFFFF;

    vector<CecLogicalAddress> mLogicalAddresses;

    int32_t mCecVersion = 0;

    uint32_t mCecVendorId = 0;



    // Port configuration

    int mTotalPorts = 4;

    int mTotalPorts = 1;

    hidl_vec<HdmiPortInfo> mPortInfo;

    hidl_vec<bool> mPortConnectionStatus;



    // CEC Option value

    int mOptionWakeUp = 0;

    int mOptionEnableCec = 0;

    int mOptionSystemCecControl = 0;

    int mOptionLanguage = 0;



    // Testing variables

    // Input file descriptor

    int mInputFile;

    // Output file descriptor

    int mOutputFile;

    bool mCecThreadRun = true;

    pthread_t mThreadId = 0;

};

}  // namespace implementation

}  // namespace V1_0