Commit c52827cc authored by Tomas Winkler's avatar Tomas Winkler Committed by Greg Kroah-Hartman
Browse files

staging/mei: add mei user space example 



this example tries to connect to amt host interface client and retrieve
versions of its sub components

When AMT is enabled an output might look like that:
Intel AMT: ENABLED
Flash:	6.1.0
Netstack:	6.1.0
AMTApps:	6.1.0
AMT:	6.1.0
Sku:	258
VendorID:	8086
Build Number:	1042
Recovery Version:	6.1.0
Recovery Build Num:	1042
Legacy Mode:	False

otherwise:
Intel AMT: DISABLED

Signed-off-by: default avatarTomas Winkler <tomas.winkler@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent edf1eed4

drivers/staging/mei/mei-amt-version.c

0 → 100644
+479 −0
Original line number Diff line number Diff line 
/******************************************************************************

 * 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 "mei.h"



/*****************************************************************************

 * Intel Management Enginin 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 Technolgy 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 Technolgy 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;

};





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;

}



void amt_host_if_deinit(struct amt_host_if *acmd)

{

	mei_deinit(&acmd->mei_cl);

	acmd->initialized = false;

}



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;

}



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;

}





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



	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;

}