mei: move doc files Documentation/misc-devices/mei

1. move mei.txt, TODO, and the example code under Documentation/misc-devices/mei
2. update the TODO file

Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

3 files changed, 0 insertions, 705 deletions

diff --git a/drivers/misc/mei/TODO b/drivers/misc/mei/TODO
deleted file mode 100644
index ed4d16c30ab5..000000000000
--- a/drivers/misc/mei/TODO
+++ /dev/null
@@ -1,9 +0,0 @@
-TODO:
-        - Cleanup and split the timer function
-Upon Unstaging:
-        - Documentation/ioctl/ioctl-number.txt
-        - move mei.txt under Documentation/mei/
-        - move mei-amt-version.c under Documentation/mei
-        - add hostprogs-y for mei-amt-version.c
-        - drop mei_version.h
-        - Updated MAINTAINERS
diff --git a/drivers/misc/mei/mei-amt-version.c b/drivers/misc/mei/mei-amt-version.c
deleted file mode 100644
index 01804f216312..000000000000
--- a/drivers/misc/mei/mei-amt-version.c
+++ /dev/null
@@ -1,481 +0,0 @@
-/******************************************************************************
- * 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 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;
-};
-
-
-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;
-}
diff --git a/drivers/misc/mei/mei.txt b/drivers/misc/mei/mei.txt
deleted file mode 100644
index 2785697da59d..000000000000
--- a/drivers/misc/mei/mei.txt
+++ /dev/null
@@ -1,215 +0,0 @@
-Intel(R) Management Engine Interface (Intel(R) MEI)
-=======================
-
-Introduction
-=======================
-
-The Intel Management Engine (Intel ME) is an isolated and protected computing
-resource (Co-processor) residing inside certain Intel chipsets. The Intel ME
-provides support for computer/IT management features. The feature set
-depends on the Intel chipset SKU.
-
-The Intel Management Engine Interface (Intel MEI, previously known as HECI)
-is the interface between the Host and Intel ME. This interface is exposed
-to the host as a PCI device. The Intel MEI Driver is in charge of the
-communication channel between a host application and the Intel ME feature.
-
-Each Intel ME feature (Intel ME Client) is addressed by a GUID/UUID and
-each client has its own protocol. The protocol is message-based with a
-header and payload up to 512 bytes.
-
-Prominent usage of the Intel ME Interface is to communicate with Intel(R)
-Active Management Technology (Intel AMT)implemented in firmware running on
-the Intel ME.
-
-Intel AMT provides the ability to manage a host remotely out-of-band (OOB)
-even when the operating system running on the host processor has crashed or
-is in a sleep state.
-
-Some examples of Intel AMT usage are:
-   - Monitoring hardware state and platform components
-   - Remote power off/on (useful for green computing or overnight IT
-     maintenance)
-   - OS updates
-   - Storage of useful platform information such as software assets
-   - Built-in hardware KVM
-   - Selective network isolation of Ethernet and IP protocol flows based
-     on policies set by a remote management console
-   - IDE device redirection from remote management console
-
-Intel AMT (OOB) communication is based on SOAP (deprecated
-starting with Release 6.0) over HTTP/S or WS-Management protocol over
-HTTP/S that are received from a remote management console application.
-
-For more information about Intel AMT:
-http://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide
-
-Intel MEI Driver
-=======================
-
-The driver exposes a misc device called /dev/mei.
-
-An application maintains communication with an Intel ME feature while
-/dev/mei is open. The binding to a specific features is performed by calling
-MEI_CONNECT_CLIENT_IOCTL, which passes the desired UUID.
-The number of instances of an Intel ME feature that can be opened
-at the same time depends on the Intel ME feature, but most of the
-features allow only a single instance.
-
-The Intel AMT Host Interface (Intel AMTHI) feature supports multiple
-simultaneous user applications. Therefore, the Intel MEI driver handles
-this internally by maintaining request queues for the applications.
-
-The driver is oblivious to data that is passed between firmware feature
-and host application.
-
-Because some of the Intel ME features can change the system
-configuration, the driver by default allows only a privileged
-user to access it.
-
-A code snippet for an application communicating with
-Intel AMTHI client:
-        struct mei_connect_client_data data;
-        fd = open(MEI_DEVICE);
-
-        data.d.in_client_uuid = AMTHI_UUID;
-
-        ioctl(fd, IOCTL_MEI_CONNECT_CLIENT, &data);
-
-        printf("Ver=%d, MaxLen=%ld\n",
-                        data.d.in_client_uuid.protocol_version,
-                        data.d.in_client_uuid.max_msg_length);
-
-        [...]
-
-        write(fd, amthi_req_data, amthi_req_data_len);
-
-        [...]
-
-        read(fd, &amthi_res_data, amthi_res_data_len);
-
-        [...]
-        close(fd);
-
-IOCTL:
-======
-The Intel MEI Driver supports the following IOCTL command:
-        IOCTL_MEI_CONNECT_CLIENT        Connect to firmware Feature (client).
-
-        usage:
-                struct mei_connect_client_data clientData;
-                ioctl(fd, IOCTL_MEI_CONNECT_CLIENT, &clientData);
-
-        inputs:
-                mei_connect_client_data struct contain the following
-                input field:
-
-                in_client_uuid -        UUID of the FW Feature that needs
-                                        to connect to.
-        outputs:
-                out_client_properties - Client Properties: MTU and Protocol Version.
-
-        error returns:
-                EINVAL  Wrong IOCTL Number
-                ENODEV  Device or Connection is not initialized or ready.
-                        (e.g. Wrong UUID)
-                ENOMEM  Unable to allocate memory to client internal data.
-                EFAULT  Fatal Error (e.g. Unable to access user input data)
-                EBUSY   Connection Already Open
-
-        Notes:
-        max_msg_length (MTU) in client properties describes the maximum
-        data that can be sent or received. (e.g. if MTU=2K, can send
-        requests up to bytes 2k and received responses upto 2k bytes).
-
-Intel ME Applications:
-==============
-
-1) Intel Local Management Service (Intel LMS)
-
-        Applications running locally on the platform communicate with Intel AMT Release
-        2.0 and later releases in the same way that network applications do via SOAP
-        over HTTP (deprecated starting with Release 6.0) or with WS-Management over
-        SOAP over HTTP. This means that some Intel AMT features can be accessed from a
-        local application using the same network interface as a remote application
-        communicating with Intel AMT over the network.
-
-        When a local application sends a message addressed to the local Intel AMT host
-        name, the Intel LMS, which listens for traffic directed to the host name,
-        intercepts the message and routes it to the Intel MEI.
-        For more information:
-        http://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide
-        Under "About Intel AMT" => "Local Access"
-
-        For downloading Intel LMS:
-        http://software.intel.com/en-us/articles/download-the-latest-intel-amt-open-source-drivers/
-
-        The Intel LMS opens a connection using the Intel MEI driver to the Intel LMS
-        firmware feature using a defined UUID and then communicates with the feature
-        using a protocol called Intel AMT Port Forwarding Protocol(Intel APF protocol).
-        The protocol is used to maintain multiple sessions with Intel AMT from a
-        single application.
-
-        See the protocol specification in the Intel AMT Software Development Kit(SDK)
-        http://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide
-        Under "SDK Resources" => "Intel(R) vPro(TM) Gateway(MPS)"
-        => "Information for Intel(R) vPro(TM) Gateway Developers"
-        => "Description of the Intel AMT Port Forwarding (APF)Protocol"
-
-  2) Intel AMT Remote configuration using a Local Agent
-        A Local Agent enables IT personnel to configure Intel AMT out-of-the-box
-        without requiring installing additional data to enable setup. The remote
-        configuration process may involve an ISV-developed remote configuration
-        agent that runs on the host.
-        For more information:
-        http://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide
-        Under "Setup and Configuration of Intel AMT" =>
-        "SDK Tools Supporting Setup and Configuration" =>
-        "Using the Local Agent Sample"
-
-        An open source Intel AMT configuration utility, implementing a local agent
-        that accesses the Intel MEI driver, can be found here:
-        http://software.intel.com/en-us/articles/download-the-latest-intel-amt-open-source-drivers/
-
-
-Intel AMT OS Health Watchdog:
-=============================
-The Intel AMT Watchdog is an OS Health (Hang/Crash) watchdog.
-Whenever the OS hangs or crashes, Intel AMT will send an event
-to any subscriber to this event. This mechanism means that
-IT knows when a platform crashes even when there is a hard failure on the host.
-
-The Intel AMT Watchdog is composed of two parts:
-        1) Firmware feature - receives the heartbeats
-           and sends an event when the heartbeats stop.
-        2) Intel MEI driver - connects to the watchdog feature, configures the
-           watchdog and sends the heartbeats.
-
-The Intel MEI driver uses the kernel watchdog to configure the Intel AMT
-Watchdog and to send heartbeats to it. The default timeout of the
-watchdog is 120 seconds.
-
-If the Intel AMT Watchdog feature does not exist (i.e. the connection failed),
-the Intel MEI driver will disable the sending of heartbeats.
-
-Supported Chipsets:
-==================
-7 Series Chipset Family
-6 Series Chipset Family
-5 Series Chipset Family
-4 Series Chipset Family
-Mobile 4 Series Chipset Family
-ICH9
-82946GZ/GL
-82G35 Express
-82Q963/Q965
-82P965/G965
-Mobile PM965/GM965
-Mobile GME965/GLE960
-82Q35 Express
-82G33/G31/P35/P31 Express
-82Q33 Express
-82X38/X48 Express
-
----
-linux-mei@linux.intel.com