[GitHub/mt8127/android_kernel_alcatel_ttab.git] / Documentation / misc-devices / mei / mei-amt-version.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;

	mei_deinit(me);

	me->verbose = verbose;

	me->fd = open("/dev/mei", 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)
{
	ssize_t rc;

	mei_msg(me, "call read length = %zd\n", len);

	rc = read(me->fd, buffer, len);
	if (rc < 0) {
		mei_err(me, "read failed with status %zd %s\n",
				rc, strerror(errno));
		mei_deinit(me);
	} else {
		mei_msg(me, "read succeeded with result %zd\n", rc);
	}
	return rc;
}

static ssize_t mei_send_msg(struct mei *me, const unsigned char *buffer,
			ssize_t len, unsigned long timeout)
{
	struct timeval tv;
	ssize_t written;
	ssize_t rc;
	fd_set set;

	tv.tv_sec = timeout / 1000;
	tv.tv_usec = (timeout % 1000) * 1000000;

	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;
	}

	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, "write success\n");
	} else if (rc == 0) {
		mei_err(me, "write failed on timeout with status\n");
		goto out;
	} else { /* rc < 0 */
		mei_err(me, "write failed on select with status %zd\n", rc);
		goto out;
	}

	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[0];
} __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;
	uint32_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;
}
Commit	Line	Data
c52827cc TW	1	/******************************************************************************
	2	* Intel Management Engine Interface (Intel MEI) Linux driver
	3	* Intel MEI Interface Header
	4	*
	5	* This file is provided under a dual BSD/GPLv2 license. When using or
	6	* redistributing this file, you may do so under either license.
	7	*
	8	* GPL LICENSE SUMMARY
	9	*
	10	* Copyright(c) 2012 Intel Corporation. All rights reserved.
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of version 2 of the GNU General Public License as
	14	* published by the Free Software Foundation.
	15	*
	16	* This program is distributed in the hope that it will be useful, but
	17	* WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	19	* General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
	24	* USA
	25	*
	26	* The full GNU General Public License is included in this distribution
	27	* in the file called LICENSE.GPL.
	28	*
	29	* Contact Information:
	30	* Intel Corporation.
	31	* linux-mei@linux.intel.com
	32	* http://www.intel.com
	33	*
	34	* BSD LICENSE
	35	*
	36	* Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved.
	37	* All rights reserved.
	38	*
	39	* Redistribution and use in source and binary forms, with or without
	40	* modification, are permitted provided that the following conditions
	41	* are met:
	42	*
	43	* * Redistributions of source code must retain the above copyright
	44	* notice, this list of conditions and the following disclaimer.
	45	* * Redistributions in binary form must reproduce the above copyright
	46	* notice, this list of conditions and the following disclaimer in
	47	* the documentation and/or other materials provided with the
	48	* distribution.
	49	* * Neither the name Intel Corporation nor the names of its
	50	* contributors may be used to endorse or promote products derived
	51	* from this software without specific prior written permission.
	52	*
	53	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	54	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	55	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	56	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	57	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	58	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	59	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	60	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	61	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	62	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	63	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	64	*
65	*****************************************************************************/
66
67	#include <stdio.h>
68	#include <stdlib.h>
69	#include <string.h>
70	#include <fcntl.h>
71	#include <sys/ioctl.h>
72	#include <unistd.h>
73	#include <errno.h>
74	#include <stdint.h>
75	#include <stdbool.h>
76	#include <bits/wordsize.h>
4f3afe1d	77	#include <linux/mei.h>
c52827cc TW	78
c52827cc TW	79	/*****************************************************************************
5f9092f3	80	* Intel Management Engine Interface
c52827cc TW	81	*****************************************************************************/
	82
	83	#define mei_msg(_me, fmt, ARGS...) do { \
	84	if (_me->verbose) \
	85	fprintf(stderr, fmt, ##ARGS); \
	86	} while (0)
	87
	88	#define mei_err(_me, fmt, ARGS...) do { \
	89	fprintf(stderr, "Error: " fmt, ##ARGS); \
	90	} while (0)
	91
	92	struct mei {
	93	uuid_le guid;
	94	bool initialized;
	95	bool verbose;
	96	unsigned int buf_size;
	97	unsigned char prot_ver;
	98	int fd;
	99	};
	100
	101	static void mei_deinit(struct mei *cl)
	102	{
	103	if (cl->fd != -1)
	104	close(cl->fd);
	105	cl->fd = -1;
	106	cl->buf_size = 0;
	107	cl->prot_ver = 0;
	108	cl->initialized = false;
	109	}
	110
	111	static bool mei_init(struct mei me, const uuid_le guid,
	112	unsigned char req_protocol_version, bool verbose)
	113	{
	114	int result;
	115	struct mei_client *cl;
	116	struct mei_connect_client_data data;
	117
	118	mei_deinit(me);
	119
	120	me->verbose = verbose;
	121
	122	me->fd = open("/dev/mei", O_RDWR);
	123	if (me->fd == -1) {
	124	mei_err(me, "Cannot establish a handle to the Intel MEI driver\n");
	125	goto err;
	126	}
	127	memcpy(&me->guid, guid, sizeof(*guid));
	128	memset(&data, 0, sizeof(data));
	129	me->initialized = true;
	130
	131	memcpy(&data.in_client_uuid, &me->guid, sizeof(me->guid));
	132	result = ioctl(me->fd, IOCTL_MEI_CONNECT_CLIENT, &data);
	133	if (result) {
	134	mei_err(me, "IOCTL_MEI_CONNECT_CLIENT receive message. err=%d\n", result);
	135	goto err;
	136	}
	137	cl = &data.out_client_properties;
	138	mei_msg(me, "max_message_length %d\n", cl->max_msg_length);
	139	mei_msg(me, "protocol_version %d\n", cl->protocol_version);
	140
	141	if ((req_protocol_version > 0) &&
	142	(cl->protocol_version != req_protocol_version)) {
	143	mei_err(me, "Intel MEI protocol version not supported\n");
	144	goto err;
145	}
146
147	me->buf_size = cl->max_msg_length;
148	me->prot_ver = cl->protocol_version;
149
150	return true;
151	err:
152	mei_deinit(me);
153	return false;
154	}
155
156	static ssize_t mei_recv_msg(struct mei me, unsigned char buffer,
157	ssize_t len, unsigned long timeout)
158	{
159	ssize_t rc;
160
161	mei_msg(me, "call read length = %zd\n", len);
162
163	rc = read(me->fd, buffer, len);
164	if (rc < 0) {
165	mei_err(me, "read failed with status %zd %s\n",
166	rc, strerror(errno));
167	mei_deinit(me);
168	} else {
169	mei_msg(me, "read succeeded with result %zd\n", rc);
170	}
171	return rc;
172	}
173
174	static ssize_t mei_send_msg(struct mei me, const unsigned char buffer,
175	ssize_t len, unsigned long timeout)
176	{
177	struct timeval tv;
178	ssize_t written;
179	ssize_t rc;
180	fd_set set;
181
182	tv.tv_sec = timeout / 1000;
183	tv.tv_usec = (timeout % 1000) * 1000000;
184
185	mei_msg(me, "call write length = %zd\n", len);
186
187	written = write(me->fd, buffer, len);
188	if (written < 0) {
189	rc = -errno;
190	mei_err(me, "write failed with status %zd %s\n",
191	written, strerror(errno));
192	goto out;
193	}
194
195	FD_ZERO(&set);
196	FD_SET(me->fd, &set);
197	rc = select(me->fd + 1 , &set, NULL, NULL, &tv);
198	if (rc > 0 && FD_ISSET(me->fd, &set)) {
199	mei_msg(me, "write success\n");
200	} else if (rc == 0) {
201	mei_err(me, "write failed on timeout with status\n");
202	goto out;
203	} else { /* rc < 0 */
204	mei_err(me, "write failed on select with status %zd\n", rc);
205	goto out;
206	}
207
208	rc = written;
209	out:
210	if (rc < 0)
211	mei_deinit(me);
212
213	return rc;
214	}
215
216	/***************************************************************************
4e79162a	217	* Intel Advanced Management Technology ME Client
c52827cc TW	218	***************************************************************************/
	219
	220	#define AMT_MAJOR_VERSION 1
	221	#define AMT_MINOR_VERSION 1
	222
	223	#define AMT_STATUS_SUCCESS 0x0
	224	#define AMT_STATUS_INTERNAL_ERROR 0x1
	225	#define AMT_STATUS_NOT_READY 0x2
	226	#define AMT_STATUS_INVALID_AMT_MODE 0x3
	227	#define AMT_STATUS_INVALID_MESSAGE_LENGTH 0x4
	228
	229	#define AMT_STATUS_HOST_IF_EMPTY_RESPONSE 0x4000
	230	#define AMT_STATUS_SDK_RESOURCES 0x1004
	231
	232
	233	#define AMT_BIOS_VERSION_LEN 65
	234	#define AMT_VERSIONS_NUMBER 50
	235	#define AMT_UNICODE_STRING_LEN 20
	236
	237	struct amt_unicode_string {
	238	uint16_t length;
	239	char string[AMT_UNICODE_STRING_LEN];
	240	} __attribute__((packed));
	241
	242	struct amt_version_type {
	243	struct amt_unicode_string description;
	244	struct amt_unicode_string version;
	245	} __attribute__((packed));
	246
	247	struct amt_version {
	248	uint8_t major;
	249	uint8_t minor;
	250	} __attribute__((packed));
	251
	252	struct amt_code_versions {
	253	uint8_t bios[AMT_BIOS_VERSION_LEN];
	254	uint32_t count;
	255	struct amt_version_type versions[AMT_VERSIONS_NUMBER];
	256	} __attribute__((packed));
	257
	258	/***************************************************************************
4e79162a	259	* Intel Advanced Management Technology Host Interface
c52827cc TW	260	***************************************************************************/
	261
	262	struct amt_host_if_msg_header {
	263	struct amt_version version;
	264	uint16_t _reserved;
	265	uint32_t command;
	266	uint32_t length;
	267	} __attribute__((packed));
	268
	269	struct amt_host_if_resp_header {
	270	struct amt_host_if_msg_header header;
	271	uint32_t status;
	272	unsigned char data[0];
	273	} __attribute__((packed));
	274
	275	const uuid_le MEI_IAMTHIF = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, \
	276	0xac, 0xa8, 0x46, 0xe0, 0xff, 0x65, 0x81, 0x4c);
	277
	278	#define AMT_HOST_IF_CODE_VERSIONS_REQUEST 0x0400001A
	279	#define AMT_HOST_IF_CODE_VERSIONS_RESPONSE 0x0480001A
	280
	281	const struct amt_host_if_msg_header CODE_VERSION_REQ = {
	282	.version = {AMT_MAJOR_VERSION, AMT_MINOR_VERSION},
	283	._reserved = 0,
	284	.command = AMT_HOST_IF_CODE_VERSIONS_REQUEST,
	285	.length = 0
	286	};
	287
	288
	289	struct amt_host_if {
	290	struct mei mei_cl;
	291	unsigned long send_timeout;
	292	bool initialized;
	293	};
	294
	295
63319ba2	296	static bool amt_host_if_init(struct amt_host_if *acmd,
c52827cc TW	297	unsigned long send_timeout, bool verbose)
	298	{
	299	acmd->send_timeout = (send_timeout) ? send_timeout : 20000;
	300	acmd->initialized = mei_init(&acmd->mei_cl, &MEI_IAMTHIF, 0, verbose);
	301	return acmd->initialized;
	302	}
	303
63319ba2	304	static void amt_host_if_deinit(struct amt_host_if *acmd)
c52827cc TW	305	{
	306	mei_deinit(&acmd->mei_cl);
	307	acmd->initialized = false;
	308	}
	309
63319ba2	310	static uint32_t amt_verify_code_versions(const struct amt_host_if_resp_header *resp)
c52827cc TW	311	{
	312	uint32_t status = AMT_STATUS_SUCCESS;
	313	struct amt_code_versions *code_ver;
	314	size_t code_ver_len;
	315	uint32_t ver_type_cnt;
	316	uint32_t len;
	317	uint32_t i;
	318
	319	code_ver = (struct amt_code_versions *)resp->data;
	320	/* length - sizeof(status) */
	321	code_ver_len = resp->header.length - sizeof(uint32_t);
	322	ver_type_cnt = code_ver_len -
	323	sizeof(code_ver->bios) -
	324	sizeof(code_ver->count);
	325	if (code_ver->count != ver_type_cnt / sizeof(struct amt_version_type)) {
	326	status = AMT_STATUS_INTERNAL_ERROR;
	327	goto out;
	328	}
	329
	330	for (i = 0; i < code_ver->count; i++) {
	331	len = code_ver->versions[i].description.length;
	332
	333	if (len > AMT_UNICODE_STRING_LEN) {
	334	status = AMT_STATUS_INTERNAL_ERROR;
	335	goto out;
	336	}
	337
	338	len = code_ver->versions[i].version.length;
	339	if (code_ver->versions[i].version.string[len] != '\0' \|\|
	340	len != strlen(code_ver->versions[i].version.string)) {
	341	status = AMT_STATUS_INTERNAL_ERROR;
	342	goto out;
	343	}
	344	}
	345	out:
	346	return status;
	347	}
	348
63319ba2	349	static uint32_t amt_verify_response_header(uint32_t command,
c52827cc TW	350	const struct amt_host_if_msg_header *resp_hdr,
	351	uint32_t response_size)
	352	{
	353	if (response_size < sizeof(struct amt_host_if_resp_header)) {
	354	return AMT_STATUS_INTERNAL_ERROR;
	355	} else if (response_size != (resp_hdr->length +
	356	sizeof(struct amt_host_if_msg_header))) {
	357	return AMT_STATUS_INTERNAL_ERROR;
	358	} else if (resp_hdr->command != command) {
	359	return AMT_STATUS_INTERNAL_ERROR;
	360	} else if (resp_hdr->_reserved != 0) {
	361	return AMT_STATUS_INTERNAL_ERROR;
	362	} else if (resp_hdr->version.major != AMT_MAJOR_VERSION \|\|
	363	resp_hdr->version.minor < AMT_MINOR_VERSION) {
	364	return AMT_STATUS_INTERNAL_ERROR;
	365	}
	366	return AMT_STATUS_SUCCESS;
	367	}
	368
	369	static uint32_t amt_host_if_call(struct amt_host_if *acmd,
	370	const unsigned char *command, ssize_t command_sz,
	371	uint8_t **read_buf, uint32_t rcmd,
	372	unsigned int expected_sz)
	373	{
	374	uint32_t in_buf_sz;
	375	uint32_t out_buf_sz;
	376	ssize_t written;
	377	uint32_t status;
	378	struct amt_host_if_resp_header *msg_hdr;
	379
	380	in_buf_sz = acmd->mei_cl.buf_size;
	381	read_buf = (uint8_t )malloc(sizeof(uint8_t) * in_buf_sz);
	382	if (*read_buf == NULL)
	383	return AMT_STATUS_SDK_RESOURCES;
	384	memset(*read_buf, 0, in_buf_sz);
	385	msg_hdr = (struct amt_host_if_resp_header )read_buf;
	386
	387	written = mei_send_msg(&acmd->mei_cl,
	388	command, command_sz, acmd->send_timeout);
	389	if (written != command_sz)
	390	return AMT_STATUS_INTERNAL_ERROR;
	391
	392	out_buf_sz = mei_recv_msg(&acmd->mei_cl, *read_buf, in_buf_sz, 2000);
	393	if (out_buf_sz <= 0)
	394	return AMT_STATUS_HOST_IF_EMPTY_RESPONSE;
	395
	396	status = msg_hdr->status;
	397	if (status != AMT_STATUS_SUCCESS)
	398	return status;
	399
	400	status = amt_verify_response_header(rcmd,
	401	&msg_hdr->header, out_buf_sz);
	402	if (status != AMT_STATUS_SUCCESS)
	403	return status;
	404
	405	if (expected_sz && expected_sz != out_buf_sz)
	406	return AMT_STATUS_INTERNAL_ERROR;
	407
	408	return AMT_STATUS_SUCCESS;
	409	}
	410
	411
63319ba2	412	static uint32_t amt_get_code_versions(struct amt_host_if *cmd,
c52827cc TW	413	struct amt_code_versions *versions)
	414	{
	415	struct amt_host_if_resp_header *response = NULL;
	416	uint32_t status;
	417
	418	status = amt_host_if_call(cmd,
	419	(const unsigned char *)&CODE_VERSION_REQ,
	420	sizeof(CODE_VERSION_REQ),
	421	(uint8_t **)&response,
	422	AMT_HOST_IF_CODE_VERSIONS_RESPONSE, 0);
	423
	424	if (status != AMT_STATUS_SUCCESS)
	425	goto out;
	426
	427	status = amt_verify_code_versions(response);
	428	if (status != AMT_STATUS_SUCCESS)
	429	goto out;
	430
	431	memcpy(versions, response->data, sizeof(struct amt_code_versions));
	432	out:
	433	if (response != NULL)
	434	free(response);
	435
	436	return status;
	437	}
	438
	439	/************************ end of amt_host_if_command *********************/
	440	int main(int argc, char **argv)
	441	{
	442	struct amt_code_versions ver;
	443	struct amt_host_if acmd;
	444	unsigned int i;
	445	uint32_t status;
	446	int ret;
	447	bool verbose;
	448
	449	verbose = (argc > 1 && strcmp(argv[1], "-v") == 0);
	450
	451	if (!amt_host_if_init(&acmd, 5000, verbose)) {
	452	ret = 1;
	453	goto out;
	454	}
	455
	456	status = amt_get_code_versions(&acmd, &ver);
	457
63319ba2 TW	458	amt_host_if_deinit(&acmd);
63319ba2 TW	459
c52827cc TW	460	switch (status) {
	461	case AMT_STATUS_HOST_IF_EMPTY_RESPONSE:
	462	printf("Intel AMT: DISABLED\n");
	463	ret = 0;
	464	break;
	465	case AMT_STATUS_SUCCESS:
	466	printf("Intel AMT: ENABLED\n");
	467	for (i = 0; i < ver.count; i++) {
	468	printf("%s:\t%s\n", ver.versions[i].description.string,
	469	ver.versions[i].version.string);
	470	}
	471	ret = 0;
	472	break;
	473	default:
	474	printf("An error has occurred\n");
	475	ret = 1;
	476	break;
	477	}
	478
	479	out:
	480	return ret;
	481	}