/*******************************************************************************
* Copyright (C) 2004-2008 Intel Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Intel Corp. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cerrno>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdint.h>
#include <aio.h>
#ifdef __sun
#include <stdio.h>
#include <stdlib.h>
#endif // __sun
#include "HECIUnix.h"
#pragma pack(1)
typedef struct heci_ioctl_data
{
uint32_t size;
char *data;
#ifndef _LP64
/*
* If lms is compiled in 32-bit, padding is needed to
* talk to the driver which is 64-bit only.
*/
char *pad;
#endif
} heci_ioctl_data_t;
/* IOCTL commands */
#undef HECI_IOCTL
#undef IOCTL_HECI_GET_VERSION
#undef IOCTL_HECI_CONNECT_CLIENT
#undef IOCTL_HECI_WD
#define HECI_IOCTL_TYPE 0x48
#define IOCTL_HECI_GET_VERSION \
_IOWR(HECI_IOCTL_TYPE, 0x0, heci_ioctl_data_t)
#define IOCTL_HECI_CONNECT_CLIENT \
_IOWR(HECI_IOCTL_TYPE, 0x01, heci_ioctl_data_t)
#define IOCTL_HECI_WD \
_IOWR(HECI_IOCTL_TYPE, 0x02, heci_ioctl_data_t)
#define IAMT_HECI_GET_RECEIVED_MESSAGE_DATA \
_IOW(HECI_IOCTL_TYPE, 0x03, heci_ioctl_data_t)
#pragma pack(0)
/***************************** public functions *****************************/
HECILinux::HECILinux(const GUID guid, bool verbose) :
HECI(guid, verbose),
_fd(-1),
m_haveHeciVersion(false)
{
}
HECILinux::~HECILinux()
{
if (_fd != -1) {
close(_fd);
}
}
bool HECILinux::GetHeciVersion(HECI_VERSION &version) const
{
if (m_haveHeciVersion) {
memcpy(&version, &m_heciVersion, sizeof(HECI_VERSION));
return true;
}
return false;
}
bool HECILinux::Init(unsigned char reqProtocolVersion)
{
int result;
HECI_CLIENT *heci_client;
bool return_result = true;
heci_ioctl_data_t version_response;
heci_ioctl_data_t client_connect;
m_haveHeciVersion = false;
if (_initialized) {
Deinit();
}
_fd = open("/dev/heci", O_RDWR);
if (_fd == -1 ) {
if (_verbose) {
fprintf(stderr, "Error: Cannot establish a handle to the HECI driver\n");
}
return false;
}
_initialized = true;
version_response.size = sizeof(HECI_VERSION);
version_response.data = (char *)malloc(version_response.size);
if (!version_response.data) {
if (_verbose) {
fprintf(stderr, "malloc failure.\n");
}
return_result = false;
Deinit();
goto heci_free;
}
result = ioctl(_fd, IOCTL_HECI_GET_VERSION, &version_response);
if (result) {
if (_verbose) {
fprintf(stderr, "error in IOCTL_HECI_GET_VERSION recieve message. err=%d\n", result);
}
return_result = false;
Deinit();
goto heci_free;
}
memcpy(&m_heciVersion, version_response.data, sizeof(HECI_VERSION));
m_haveHeciVersion = true;
if (_verbose) {
fprintf(stdout, "Connected to HECI driver, version: %d.%d.%d.%d\n",
m_heciVersion.major, m_heciVersion.minor, m_heciVersion.hotfix, m_heciVersion.build);
fprintf(stdout, "Size of guid = %lu\n", (unsigned long)sizeof(_guid));
}
client_connect.size = sizeof(_guid);
client_connect.data = (char *)malloc(client_connect.size);
if (!client_connect.data) {
if (_verbose) {
fprintf(stderr, "malloc failure.\n");
}
return_result = false;
Deinit();
goto heci_free;
}
memcpy(client_connect.data, &_guid, sizeof(_guid));
result = ioctl(_fd, IOCTL_HECI_CONNECT_CLIENT, &client_connect);
if (result) {
if (_verbose) {
fprintf(stderr, "error in IOCTL_HECI_CONNECT_CLIENT recieve message. err=%d\n", result);
}
return_result = false;
Deinit();
goto heci_free;
}
heci_client = (HECI_CLIENT *) client_connect.data;
if (_verbose) {
fprintf(stdout, "max_message_length %d \n", (heci_client->MaxMessageLength));
fprintf(stdout, "protocol_version %d \n", (heci_client->ProtocolVersion));
}
if ((reqProtocolVersion > 0) && (heci_client->ProtocolVersion != reqProtocolVersion)) {
if (_verbose) {
fprintf(stderr, "Error: MEI protocol version not supported\n");
}
return_result = false;
Deinit();
goto heci_free;
}
_protocolVersion = heci_client->ProtocolVersion;
_bufSize = heci_client->MaxMessageLength;
heci_free:
if (NULL != version_response.data) {
free(version_response.data);
}
if (NULL != client_connect.data) {
free(client_connect.data);
}
return return_result;
}
void HECILinux::Deinit()
{
if (_fd != -1) {
close(_fd);
_fd = -1;
}
_bufSize = 0;
_protocolVersion = 0;
_initialized = false;
}
int HECILinux::ReceiveMessage(unsigned char *buffer, int len, unsigned long timeout)
{
int rv = 0;
int error = 0;
if (_verbose) {
fprintf(stdout, "call read length = %d\n", len);
}
rv = read(_fd, (void*)buffer, len);
if (rv < 0) {
error = errno;
if (_verbose) {
fprintf(stderr, "read failed with status %d %d\n", rv, error);
}
Deinit();
} else {
if (_verbose) {
fprintf(stderr, "read succeded with result %d\n", rv);
}
}
return rv;
}
int HECILinux::SendMessage(const unsigned char *buffer, int len, unsigned long timeout)
{
int rv = 0;
int return_length =0;
int error = 0;
fd_set set;
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec =(timeout % 1000) * 1000000;
if (_verbose) {
fprintf(stdout, "call write length = %d\n", len);
}
rv = write(_fd, (void *)buffer, len);
if (rv < 0) {
error = errno;
if (_verbose) {
fprintf(stderr,"write failed with status %d %d\n", rv, error);
}
goto out;
}
return_length = rv;
FD_ZERO(&set);
FD_SET(_fd, &set);
rv = select(_fd+1 ,&set, NULL, NULL, &tv);
if (rv > 0 && FD_ISSET(_fd, &set)) {
if (_verbose) {
fprintf(stderr, "write success\n");
}
}
else if (rv == 0) {
if (_verbose) {
fprintf(stderr, "write failed on timeout with status\n");
}
goto out;
}
else { //rv<0
if (_verbose) {
fprintf(stderr, "write failed on select with status %d\n", rv);
}
goto out;
}
rv = return_length;
out:
if (rv < 0) {
Deinit();
}
return rv;
}