mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-20 14:16:02 +00:00
![Alexander Usyskin](/assets/img/avatar_default.png)
The original mei driver communication was strictly write command and receive response flow, the completion of write was determined when response was ready using select(). This paradigm is a long time not true. There can be write without a response and an unsolicited read. The driver is capable of handling those. Adjust also the sample code and remove select() on read() from the write flow. Add select to the read flow to showcase how to do the read with a timeout. Signed-off-by: Alexander Usyskin <alexander.usyskin@intel.com> Signed-off-by: Tomas Winkler <tomas.winkler@intel.com> Link: https://lore.kernel.org/r/20210801072532.8668-1-tomas.winkler@intel.com Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
488 lines
13 KiB
C
488 lines
13 KiB
C
/******************************************************************************
|
|
* Intel Management Engine Interface (Intel MEI) Linux driver
|
|
* Intel MEI Interface Header
|
|
*
|
|
* This file is provided under a dual BSD/GPLv2 license. When using or
|
|
* redistributing this file, you may do so under either license.
|
|
*
|
|
* GPL LICENSE SUMMARY
|
|
*
|
|
* Copyright(c) 2012 Intel Corporation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
|
|
* USA
|
|
*
|
|
* The full GNU General Public License is included in this distribution
|
|
* in the file called LICENSE.GPL.
|
|
*
|
|
* Contact Information:
|
|
* Intel Corporation.
|
|
* linux-mei@linux.intel.com
|
|
* http://www.intel.com
|
|
*
|
|
* BSD LICENSE
|
|
*
|
|
* Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved.
|
|
* 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 Intel Corporation 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 THE COPYRIGHT
|
|
* OWNER OR 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.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <bits/wordsize.h>
|
|
#include <linux/mei.h>
|
|
|
|
/*****************************************************************************
|
|
* Intel Management Engine Interface
|
|
*****************************************************************************/
|
|
|
|
#define mei_msg(_me, fmt, ARGS...) do { \
|
|
if (_me->verbose) \
|
|
fprintf(stderr, fmt, ##ARGS); \
|
|
} while (0)
|
|
|
|
#define mei_err(_me, fmt, ARGS...) do { \
|
|
fprintf(stderr, "Error: " fmt, ##ARGS); \
|
|
} while (0)
|
|
|
|
struct mei {
|
|
uuid_le guid;
|
|
bool initialized;
|
|
bool verbose;
|
|
unsigned int buf_size;
|
|
unsigned char prot_ver;
|
|
int fd;
|
|
};
|
|
|
|
static void mei_deinit(struct mei *cl)
|
|
{
|
|
if (cl->fd != -1)
|
|
close(cl->fd);
|
|
cl->fd = -1;
|
|
cl->buf_size = 0;
|
|
cl->prot_ver = 0;
|
|
cl->initialized = false;
|
|
}
|
|
|
|
static bool mei_init(struct mei *me, const uuid_le *guid,
|
|
unsigned char req_protocol_version, bool verbose)
|
|
{
|
|
int result;
|
|
struct mei_client *cl;
|
|
struct mei_connect_client_data data;
|
|
|
|
me->verbose = verbose;
|
|
|
|
me->fd = open("/dev/mei0", O_RDWR);
|
|
if (me->fd == -1) {
|
|
mei_err(me, "Cannot establish a handle to the Intel MEI driver\n");
|
|
goto err;
|
|
}
|
|
memcpy(&me->guid, guid, sizeof(*guid));
|
|
memset(&data, 0, sizeof(data));
|
|
me->initialized = true;
|
|
|
|
memcpy(&data.in_client_uuid, &me->guid, sizeof(me->guid));
|
|
result = ioctl(me->fd, IOCTL_MEI_CONNECT_CLIENT, &data);
|
|
if (result) {
|
|
mei_err(me, "IOCTL_MEI_CONNECT_CLIENT receive message. err=%d\n", result);
|
|
goto err;
|
|
}
|
|
cl = &data.out_client_properties;
|
|
mei_msg(me, "max_message_length %d\n", cl->max_msg_length);
|
|
mei_msg(me, "protocol_version %d\n", cl->protocol_version);
|
|
|
|
if ((req_protocol_version > 0) &&
|
|
(cl->protocol_version != req_protocol_version)) {
|
|
mei_err(me, "Intel MEI protocol version not supported\n");
|
|
goto err;
|
|
}
|
|
|
|
me->buf_size = cl->max_msg_length;
|
|
me->prot_ver = cl->protocol_version;
|
|
|
|
return true;
|
|
err:
|
|
mei_deinit(me);
|
|
return false;
|
|
}
|
|
|
|
static ssize_t mei_recv_msg(struct mei *me, unsigned char *buffer,
|
|
ssize_t len, unsigned long timeout)
|
|
{
|
|
struct timeval tv;
|
|
fd_set set;
|
|
ssize_t rc;
|
|
|
|
tv.tv_sec = timeout / 1000;
|
|
tv.tv_usec = (timeout % 1000) * 1000000;
|
|
|
|
mei_msg(me, "call read length = %zd\n", len);
|
|
|
|
FD_ZERO(&set);
|
|
FD_SET(me->fd, &set);
|
|
rc = select(me->fd + 1, &set, NULL, NULL, &tv);
|
|
if (rc > 0 && FD_ISSET(me->fd, &set)) {
|
|
mei_msg(me, "have reply\n");
|
|
} else if (rc == 0) {
|
|
rc = -1;
|
|
mei_err(me, "read failed on timeout\n");
|
|
goto out;
|
|
} else { /* rc < 0 */
|
|
rc = errno;
|
|
mei_err(me, "read failed on select with status %zd %s\n",
|
|
rc, strerror(errno));
|
|
goto out;
|
|
}
|
|
|
|
rc = read(me->fd, buffer, len);
|
|
if (rc < 0) {
|
|
mei_err(me, "read failed with status %zd %s\n",
|
|
rc, strerror(errno));
|
|
goto out;
|
|
}
|
|
|
|
mei_msg(me, "read succeeded with result %zd\n", rc);
|
|
|
|
out:
|
|
if (rc < 0)
|
|
mei_deinit(me);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static ssize_t mei_send_msg(struct mei *me, const unsigned char *buffer,
|
|
ssize_t len, unsigned long timeout)
|
|
{
|
|
ssize_t written;
|
|
ssize_t rc;
|
|
|
|
mei_msg(me, "call write length = %zd\n", len);
|
|
|
|
written = write(me->fd, buffer, len);
|
|
if (written < 0) {
|
|
rc = -errno;
|
|
mei_err(me, "write failed with status %zd %s\n",
|
|
written, strerror(errno));
|
|
goto out;
|
|
}
|
|
mei_msg(me, "write success\n");
|
|
|
|
rc = written;
|
|
out:
|
|
if (rc < 0)
|
|
mei_deinit(me);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/***************************************************************************
|
|
* Intel Advanced Management Technology ME Client
|
|
***************************************************************************/
|
|
|
|
#define AMT_MAJOR_VERSION 1
|
|
#define AMT_MINOR_VERSION 1
|
|
|
|
#define AMT_STATUS_SUCCESS 0x0
|
|
#define AMT_STATUS_INTERNAL_ERROR 0x1
|
|
#define AMT_STATUS_NOT_READY 0x2
|
|
#define AMT_STATUS_INVALID_AMT_MODE 0x3
|
|
#define AMT_STATUS_INVALID_MESSAGE_LENGTH 0x4
|
|
|
|
#define AMT_STATUS_HOST_IF_EMPTY_RESPONSE 0x4000
|
|
#define AMT_STATUS_SDK_RESOURCES 0x1004
|
|
|
|
|
|
#define AMT_BIOS_VERSION_LEN 65
|
|
#define AMT_VERSIONS_NUMBER 50
|
|
#define AMT_UNICODE_STRING_LEN 20
|
|
|
|
struct amt_unicode_string {
|
|
uint16_t length;
|
|
char string[AMT_UNICODE_STRING_LEN];
|
|
} __attribute__((packed));
|
|
|
|
struct amt_version_type {
|
|
struct amt_unicode_string description;
|
|
struct amt_unicode_string version;
|
|
} __attribute__((packed));
|
|
|
|
struct amt_version {
|
|
uint8_t major;
|
|
uint8_t minor;
|
|
} __attribute__((packed));
|
|
|
|
struct amt_code_versions {
|
|
uint8_t bios[AMT_BIOS_VERSION_LEN];
|
|
uint32_t count;
|
|
struct amt_version_type versions[AMT_VERSIONS_NUMBER];
|
|
} __attribute__((packed));
|
|
|
|
/***************************************************************************
|
|
* Intel Advanced Management Technology Host Interface
|
|
***************************************************************************/
|
|
|
|
struct amt_host_if_msg_header {
|
|
struct amt_version version;
|
|
uint16_t _reserved;
|
|
uint32_t command;
|
|
uint32_t length;
|
|
} __attribute__((packed));
|
|
|
|
struct amt_host_if_resp_header {
|
|
struct amt_host_if_msg_header header;
|
|
uint32_t status;
|
|
unsigned char data[];
|
|
} __attribute__((packed));
|
|
|
|
const uuid_le MEI_IAMTHIF = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, \
|
|
0xac, 0xa8, 0x46, 0xe0, 0xff, 0x65, 0x81, 0x4c);
|
|
|
|
#define AMT_HOST_IF_CODE_VERSIONS_REQUEST 0x0400001A
|
|
#define AMT_HOST_IF_CODE_VERSIONS_RESPONSE 0x0480001A
|
|
|
|
const struct amt_host_if_msg_header CODE_VERSION_REQ = {
|
|
.version = {AMT_MAJOR_VERSION, AMT_MINOR_VERSION},
|
|
._reserved = 0,
|
|
.command = AMT_HOST_IF_CODE_VERSIONS_REQUEST,
|
|
.length = 0
|
|
};
|
|
|
|
|
|
struct amt_host_if {
|
|
struct mei mei_cl;
|
|
unsigned long send_timeout;
|
|
bool initialized;
|
|
};
|
|
|
|
|
|
static bool amt_host_if_init(struct amt_host_if *acmd,
|
|
unsigned long send_timeout, bool verbose)
|
|
{
|
|
acmd->send_timeout = (send_timeout) ? send_timeout : 20000;
|
|
acmd->initialized = mei_init(&acmd->mei_cl, &MEI_IAMTHIF, 0, verbose);
|
|
return acmd->initialized;
|
|
}
|
|
|
|
static void amt_host_if_deinit(struct amt_host_if *acmd)
|
|
{
|
|
mei_deinit(&acmd->mei_cl);
|
|
acmd->initialized = false;
|
|
}
|
|
|
|
static uint32_t amt_verify_code_versions(const struct amt_host_if_resp_header *resp)
|
|
{
|
|
uint32_t status = AMT_STATUS_SUCCESS;
|
|
struct amt_code_versions *code_ver;
|
|
size_t code_ver_len;
|
|
uint32_t ver_type_cnt;
|
|
uint32_t len;
|
|
uint32_t i;
|
|
|
|
code_ver = (struct amt_code_versions *)resp->data;
|
|
/* length - sizeof(status) */
|
|
code_ver_len = resp->header.length - sizeof(uint32_t);
|
|
ver_type_cnt = code_ver_len -
|
|
sizeof(code_ver->bios) -
|
|
sizeof(code_ver->count);
|
|
if (code_ver->count != ver_type_cnt / sizeof(struct amt_version_type)) {
|
|
status = AMT_STATUS_INTERNAL_ERROR;
|
|
goto out;
|
|
}
|
|
|
|
for (i = 0; i < code_ver->count; i++) {
|
|
len = code_ver->versions[i].description.length;
|
|
|
|
if (len > AMT_UNICODE_STRING_LEN) {
|
|
status = AMT_STATUS_INTERNAL_ERROR;
|
|
goto out;
|
|
}
|
|
|
|
len = code_ver->versions[i].version.length;
|
|
if (code_ver->versions[i].version.string[len] != '\0' ||
|
|
len != strlen(code_ver->versions[i].version.string)) {
|
|
status = AMT_STATUS_INTERNAL_ERROR;
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
return status;
|
|
}
|
|
|
|
static uint32_t amt_verify_response_header(uint32_t command,
|
|
const struct amt_host_if_msg_header *resp_hdr,
|
|
uint32_t response_size)
|
|
{
|
|
if (response_size < sizeof(struct amt_host_if_resp_header)) {
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
} else if (response_size != (resp_hdr->length +
|
|
sizeof(struct amt_host_if_msg_header))) {
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
} else if (resp_hdr->command != command) {
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
} else if (resp_hdr->_reserved != 0) {
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
} else if (resp_hdr->version.major != AMT_MAJOR_VERSION ||
|
|
resp_hdr->version.minor < AMT_MINOR_VERSION) {
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
}
|
|
return AMT_STATUS_SUCCESS;
|
|
}
|
|
|
|
static uint32_t amt_host_if_call(struct amt_host_if *acmd,
|
|
const unsigned char *command, ssize_t command_sz,
|
|
uint8_t **read_buf, uint32_t rcmd,
|
|
unsigned int expected_sz)
|
|
{
|
|
uint32_t in_buf_sz;
|
|
ssize_t out_buf_sz;
|
|
ssize_t written;
|
|
uint32_t status;
|
|
struct amt_host_if_resp_header *msg_hdr;
|
|
|
|
in_buf_sz = acmd->mei_cl.buf_size;
|
|
*read_buf = (uint8_t *)malloc(sizeof(uint8_t) * in_buf_sz);
|
|
if (*read_buf == NULL)
|
|
return AMT_STATUS_SDK_RESOURCES;
|
|
memset(*read_buf, 0, in_buf_sz);
|
|
msg_hdr = (struct amt_host_if_resp_header *)*read_buf;
|
|
|
|
written = mei_send_msg(&acmd->mei_cl,
|
|
command, command_sz, acmd->send_timeout);
|
|
if (written != command_sz)
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
|
|
out_buf_sz = mei_recv_msg(&acmd->mei_cl, *read_buf, in_buf_sz, 2000);
|
|
if (out_buf_sz <= 0)
|
|
return AMT_STATUS_HOST_IF_EMPTY_RESPONSE;
|
|
|
|
status = msg_hdr->status;
|
|
if (status != AMT_STATUS_SUCCESS)
|
|
return status;
|
|
|
|
status = amt_verify_response_header(rcmd,
|
|
&msg_hdr->header, out_buf_sz);
|
|
if (status != AMT_STATUS_SUCCESS)
|
|
return status;
|
|
|
|
if (expected_sz && expected_sz != out_buf_sz)
|
|
return AMT_STATUS_INTERNAL_ERROR;
|
|
|
|
return AMT_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
static uint32_t amt_get_code_versions(struct amt_host_if *cmd,
|
|
struct amt_code_versions *versions)
|
|
{
|
|
struct amt_host_if_resp_header *response = NULL;
|
|
uint32_t status;
|
|
|
|
status = amt_host_if_call(cmd,
|
|
(const unsigned char *)&CODE_VERSION_REQ,
|
|
sizeof(CODE_VERSION_REQ),
|
|
(uint8_t **)&response,
|
|
AMT_HOST_IF_CODE_VERSIONS_RESPONSE, 0);
|
|
|
|
if (status != AMT_STATUS_SUCCESS)
|
|
goto out;
|
|
|
|
status = amt_verify_code_versions(response);
|
|
if (status != AMT_STATUS_SUCCESS)
|
|
goto out;
|
|
|
|
memcpy(versions, response->data, sizeof(struct amt_code_versions));
|
|
out:
|
|
if (response != NULL)
|
|
free(response);
|
|
|
|
return status;
|
|
}
|
|
|
|
/************************** end of amt_host_if_command ***********************/
|
|
int main(int argc, char **argv)
|
|
{
|
|
struct amt_code_versions ver;
|
|
struct amt_host_if acmd;
|
|
unsigned int i;
|
|
uint32_t status;
|
|
int ret;
|
|
bool verbose;
|
|
|
|
verbose = (argc > 1 && strcmp(argv[1], "-v") == 0);
|
|
|
|
if (!amt_host_if_init(&acmd, 5000, verbose)) {
|
|
ret = 1;
|
|
goto out;
|
|
}
|
|
|
|
status = amt_get_code_versions(&acmd, &ver);
|
|
|
|
amt_host_if_deinit(&acmd);
|
|
|
|
switch (status) {
|
|
case AMT_STATUS_HOST_IF_EMPTY_RESPONSE:
|
|
printf("Intel AMT: DISABLED\n");
|
|
ret = 0;
|
|
break;
|
|
case AMT_STATUS_SUCCESS:
|
|
printf("Intel AMT: ENABLED\n");
|
|
for (i = 0; i < ver.count; i++) {
|
|
printf("%s:\t%s\n", ver.versions[i].description.string,
|
|
ver.versions[i].version.string);
|
|
}
|
|
ret = 0;
|
|
break;
|
|
default:
|
|
printf("An error has occurred\n");
|
|
ret = 1;
|
|
break;
|
|
}
|
|
|
|
out:
|
|
return ret;
|
|
}
|