tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
Treehugger Robot 2019-09-06 03:47:13 +00:00 committed by Gerrit Code Review
commit 321f443d65
2 changed files with 199 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

185
tv/cec/1.0/default/HdmiCecMock.cpp
View file

@ -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

27
tv/cec/1.0/default/HdmiCecMock.h
View file

@ -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