ManagementEngineInterface: intel-MEI.diff

a/drivers/char/heci/heci_data_structures.h

@@ +1 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2003 - 2007 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ *
+ */
+
+#ifndef _HECI_DATA_STRUCTURES_H_
+#define _HECI_DATA_STRUCTURES_H_
+
+#include <linux/version.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/pci.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/module.h>
+#include <linux/aio.h>
+#include <linux/types.h>
+
+/**
+ * error code definition
+ */
+#define     ESUCCESS                     0
+#define     ESLOTS_OVERFLOW              1
+#define     ECORRUPTED_MESSAGE_HEADER    1000
+#define     ECOMPLETE_MESSAGE            1001
+#define     FC_MESSAGE_RESERVED_LENGTH           5
+
+/**
+ * Number of queue lists used by this driver
+ */
+#define NUMBER_OF_LISTS        7
+
+#define LEGACY_MTU 4160
+#pragma pack(1)
+
+
+/**
+ * HECI HW Section
+ */
+
+/* HECI addresses and defines */
+#define H_CB_WW    0
+#define H_CSR      4
+#define ME_CB_RW   8
+#define ME_CSR_HA  0xC
+
+
+/* register bits - H_CSR */
+
+#define H_CBD             0xFF000000
+#define H_CBWP            0x00FF0000
+#define H_CBRP            0x0000FF00
+#define H_RST             0x00000010
+#define H_RDY             0x00000008
+#define H_IG              0x00000004
+#define H_IS              0x00000002
+#define H_IE              0x00000001
+
+
+/* register bits - ME_CSR_HA */
+#define ME_CBD_HRA        0xFF000000
+#define ME_CBWP_HRA       0x00FF0000
+#define ME_CBRP_HRA       0x0000FF00
+#define ME_RST_HRA        0x00000010
+#define ME_RDY_HRA        0x00000008
+#define ME_IG_HRA         0x00000004
+#define ME_IS_HRA         0x00000002
+#define ME_IE_HRA         0x00000001
+
+/**
+ *  heci driver use additional char device for legacy mode
+ */
+#define  MINORS_COUNT   2
+
+#define  LEGACY_MINOR_NUMBER    0
+#define  HECI_MINOR_NUMBER      1
+#define  MAX_OPEN_HANDLE_COUNT  253
+/**
+ * debug kernel print macro define
+ */
+#define INFO(format, arg...) \
+        printk(KERN_INFO     "%s: " format, THIS_MODULE->name, ## arg)
+#define ERR(format, arg...) \
+        printk(KERN_ERR      "%s: " format, THIS_MODULE->name, ## arg)
+#define WARN(format, arg...) \
+        printk(KERN_WARNING  "%s: " format, THIS_MODULE->name, ## arg)
+
+
+/* Module Parameters */
+/*
+#define DEF_PARM(type, name, init, perm, desc)   \
+        type name = (init);     \
+        MODULE_PARM_DESC(name, desc);   \
+        module_param(name, type, perm)
+*/
+
+extern int debug;
+
+#define DBG(format, arg...) do {if (debug) \
+printk(KERN_ERR "%s: " format , __func__ , ## arg); \
+} while (0)
+
+/*
+#ifdef HECI_DEBUG
+#define assert(expr) do {} while (0)
+#else
+#define assert(expr) \
+    if (!(expr)) {                                   \
+    printk("Assertion failed! %s, %s, %s, line=%d\n", \
+    #expr, __FILE__, __func__, __LINE__);          \
+    }
+#endif
+*/
+
+/**
+ * time to wait event
+ */
+#define HECI_INTEROP_TIMEOUT    (HZ * 7)
+
+/**
+ * watch dog definition
+ */
+#define HECI_WATCHDOG_DATA_SIZE         16
+#define HECI_START_WD_DATA_SIZE         20
+#define HECI_WD_PARAMS_SIZE             4
+
+
+#define HECI_WD_HOST_CLIENT_ID          1
+#define HECI_LEGACY_HOST_CLIENT_ID      2
+
+#undef FALSE
+#undef TRUE
+#define TRUE  1
+#define FALSE 0
+
+struct guid {
+        __u32 data1;
+        __u16 data2;
+        __u16 data3;
+        __u8 data4[8];
+};
+
+/* File state */
+enum file_state {
+        HECI_FILE_INITIALIZING = 0,
+        HECI_FILE_CONNECTING,
+        HECI_FILE_CONNECTED,
+        HECI_FILE_DISCONNECTING,
+        HECI_FILE_DISCONNECTED
+};
+
+/* HECI states */
+enum heci_states{
+        HECI_INITIALIZING = 0,
+        HECI_ENABLED,
+        HECI_RESETING,
+        HECI_DISABLED,
+        HECI_RECOVERING_FROM_RESET,
+        HECI_POWER_DOWN,
+        HECI_POWER_UP
+};
+
+enum legacy_states {
+        HECI_LEGACY_IDLE,
+        HECI_LEGACY_WRITING,
+        HECI_LEGACY_FLOW_CONTROL,
+        HECI_LEGACY_READING,
+        HECI_LEGACY_READ_COMPLETE
+};
+
+enum heci_file_transaction_states {
+        HECI_IDLE,
+        HECI_WRITING,
+        HECI_WRITE_COMPLETE,
+        HECI_FLOW_CONTROL,
+        HECI_READING,
+        HECI_READ_COMPLETE
+};
+
+/* HECI CB */
+enum heci_cb_major_types {
+        HECI_READ = 0,
+        HECI_WRITE,
+        HECI_IOCTL,
+        HECI_OPEN,
+        HECI_CLOSE
+};
+
+/* HECI user data struct */
+struct heci_message_data {
+        __u32 size;
+        char *data;
+};
+#define SECOND_TO_MILLI                 1000
+#define SECOND_TO_MICRO                 SECOND_TO_MILLI * 1000
+#define SECOND_TO_100NANO               SECOND_TO_MICRO * 10
+
+#define CONNECT_TIMEOUT                 3       /* at least 2 seconds */
+
+#define LEGACY_STALL_TIMER              12      /* seconds */
+#define LEGACY_READ_TIMER               15      /* seconds */
+
+struct heci_cb_private {
+        struct list_head cb_list;
+        enum heci_cb_major_types major_file_operations;
+        void *file_private;
+        struct heci_message_data request_buffer;
+        struct heci_message_data response_buffer;
+        unsigned long information;
+        unsigned long read_time;
+        struct file *file_object;
+};
+
+/* Private file struct */
+struct heci_file_private {
+        struct list_head link;
+        struct file *file;
+        enum file_state state;
+        wait_queue_head_t tx_wait;
+        wait_queue_head_t rx_wait;
+        wait_queue_head_t wait;
+        spinlock_t file_lock;   /*file lock */
+        spinlock_t read_io_lock;        /*read lock */
+        spinlock_t write_io_lock;  /*write lock */
+        int read_pending;
+        int status;
+        /* ID of client connected */
+        __u8 host_client_id;
+        __u8 me_client_id;
+        __u8 flow_ctrl_creds;
+        __u8 timer_count;
+        enum heci_file_transaction_states reading_state;
+        enum heci_file_transaction_states writing_state;
+        struct heci_cb_private *read_cb;
+};
+
+struct io_heci_list {
+        struct heci_cb_private heci_cb;
+        int status;
+        struct iamt_heci_device *device_extension;
+};
+
+struct heci_driver_version {
+        __u8 major;
+        __u8 minor;
+        __u8 hotfix;
+        __u16 build;
+};
+
+
+struct heci_client {
+        __u32 max_msg_length;
+        __u8 protocol_version;
+};
+/*
+ *  HECI BUS Interface Section
+ */
+struct heci_msg_hdr {
+        __u32 me_addr:8;
+        __u32 host_addr:8;
+        __u32 length:9;
+        __u32 reserved:6;
+        __u32 msg_complete:1;
+};
+
+
+struct hbm_cmd {
+        __u8 cmd:7;
+        __u8 is_response:1;
+};
+
+
+struct heci_bus_message {
+        struct hbm_cmd cmd;
+        __u8 command_specific_data[];
+};
+
+struct hbm_version {
+        __u8 minor_version;
+        __u8 major_version;
+};
+
+struct hbm_host_version_request {
+        struct hbm_cmd cmd;
+        __u8 reserved;
+        struct hbm_version host_version;
+};
+
+struct hbm_host_version_response {
+        struct hbm_cmd cmd;
+        int host_version_supported;
+        struct hbm_version me_max_version;
+};
+
+struct hbm_host_stop_request {
+        struct hbm_cmd cmd;
+        __u8 reason;
+        __u8 reserved[2];
+};
+
+struct hbm_host_stop_response {
+        struct hbm_cmd cmd;
+        __u8 reserved[3];
+};
+
+struct hbm_me_stop_request {
+        struct hbm_cmd cmd;
+        __u8 reason;
+        __u8 reserved[2];
+};
+
+struct hbm_host_enum_request {
+        struct hbm_cmd cmd;
+        __u8 reserved[3];
+};
+
+struct hbm_host_enum_response {
+        struct hbm_cmd cmd;
+        __u8 reserved[3];
+        __u8 valid_addresses[32];
+};
+
+struct heci_client_properties {
+        struct guid protocol_name;
+        __u8 protocol_version;
+        __u8 max_number_of_connections;
+        __u8 fixed_address;
+        __u8 single_recv_buf;
+        __u32 max_msg_length;
+};
+
+struct hbm_props_request {
+        struct hbm_cmd cmd;
+        __u8 address;
+        __u8 reserved[2];
+};
+
+
+struct hbm_props_response {
+        struct hbm_cmd cmd;
+        __u8 address;
+        __u8 status;
+        __u8 reserved[1];
+        struct heci_client_properties client_properties;
+};
+
+struct hbm_client_connect_request {
+        struct hbm_cmd cmd;
+        __u8 me_addr;
+        __u8 host_addr;
+        __u8 reserved;
+};
+
+struct hbm_client_connect_response {
+        struct hbm_cmd cmd;
+        __u8 me_addr;
+        __u8 host_addr;
+        __u8 status;
+};
+
+struct hbm_client_disconnect_request {
+        struct hbm_cmd cmd;
+        __u8 me_addr;
+        __u8 host_addr;
+        __u8 reserved[1];
+};
+
+struct hbm_flow_control {
+        struct hbm_cmd cmd;
+        __u8 me_addr;
+        __u8 host_addr;
+        __u8 reserved[FC_MESSAGE_RESERVED_LENGTH];
+};
+
+struct heci_me_client {
+        struct heci_client_properties props;
+        __u8 client_id;
+        __u8 flow_ctrl_creds;
+};
+
+/* private device struct */
+struct iamt_heci_device {
+        struct pci_dev *pdev;   /* pointer to pci device struct */
+        /*
+         * lists of queues
+         */
+         /* array of pointers to  aio lists */
+        struct io_heci_list *io_list_array[NUMBER_OF_LISTS];
+        struct io_heci_list read_list;  /* driver read queue */
+        struct io_heci_list write_list; /* driver write queue */
+        struct io_heci_list write_waiting_list; /* write waiting queue */
+        struct io_heci_list ctrl_wr_list;       /* managed write IOCTL list */
+        struct io_heci_list ctrl_rd_list;       /* managed read IOCTL list */
+        struct io_heci_list pthi_cmd_list;      /* PTHI list for cmd waiting */
+
+        /* driver managed PTHI list for  read completed pthi cmd data */
+        struct io_heci_list pthi_read_complete_list;
+        /*
+         * list of files
+         */
+        struct list_head file_list;
+        /*
+         * memory of device
+         */
+        unsigned int mem_base;
+        unsigned int mem_length;
+        char *mem_addr;
+        /*
+         * lock for the device
+         */
+        spinlock_t device_lock; /* device lock*/
+        spinlock_t extra_lock;  /* extra lock */
+        /*
+         * intterupts
+         */
+        int irq;
+        struct work_struct work;
+        int recvd_msg;
+
+        struct timer_list timer;
+        struct timer_list wd_timer;
+        /*
+         * hw states of host and fw(ME)
+         */
+        __u32 host_hw_state;
+        __u32 me_hw_state;
+        /*
+         * waiting queue for receive message from FW
+         */
+        wait_queue_head_t wait_recvd_msg;
+        wait_queue_head_t wait_stop_wd;
+        /*
+         * heci device  states
+         */
+        enum heci_states heci_state;
+        int stop;
+     /**
+      * virtual void GetParam(const char* UserParam);
+      * read write messages to/from heci fw
+      */
+        __u32 extra_write_index;
+        __u32 rd_msg_buf[128];  /* used for control messages */
+        __u32 wr_msg_buf[128];/* used for control messages */
+        __u32 ext_msg_buf[8];   /* for control responses    */
+        __u32 rd_msg_hdr;
+
+        struct hbm_version version;
+
+        int host_buffer_is_empty;
+        struct heci_file_private wd_file_ext;
+        struct heci_me_client *me_clients; /* Note: memory has to be allocated*/
+        __u8 heci_me_clients[32];       /* list of existing clients */
+        __u8 num_heci_me_clients;
+        __u8 heci_host_clients[32];     /* list of existing clients */
+        __u8 current_host_client_id;
+
+        int wd_pending;
+        int wd_stoped;
+        __u16 wd_timeout;       /* seconds ((wd_data[1] << 8) + wd_data[0]) */
+        unsigned char wd_data[HECI_START_WD_DATA_SIZE];
+
+
+        __u16 wd_due_counter;
+        int asf_mode;
+        int     wd_bypass;      /* if true,don't refresh watchdog ME client */
+
+        /* maybe this is not required */
+        struct file *legacy_file_object;
+        struct heci_file_private legacy_file_ext;
+        int legacy_ioctl;
+        int legacy_canceled;
+        __u32 legacy_timer;
+        __u32 legacy_stall_timer;
+        unsigned char legacy_msg_buf[LEGACY_MTU];
+        __u32 legacy_msg_buf_size;
+        __u32 legacy_msg_buf_index;
+        int legacy_flow_control_pending;
+        enum legacy_states legacy_state;
+
+        struct heci_cb_private *legacy_current_cb;
+        __u8 write_hang;
+        int need_reset;
+        long open_handle_count;
+
+};
+
+/**
+ * read_heci_register - Read a byte from the heci device
+ * @device: the device structure
+ * @offset: offset from which to read the data
+ *
+ * Return:
+ * the byte read.
+ */
+__u32 read_heci_register(struct iamt_heci_device *device,
+                            unsigned long offset);
+
+/**
+ * write_heci_register - Write  4 bytes to the heci device
+ * @device: the device structure
+ * @offset: offset from which to write the data
+ *
+ * @value: the byte to write
+ */
+void write_heci_register(struct iamt_heci_device *device, unsigned long offset,
+                         __u32 value);
+
+#endif                          /* _HECI_DATA_STRUCTURES_H_ */

a/drivers/char/heci/heci.h

@@ +1 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2003 - 2007 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ *
+ */
+
+#ifndef _HECI_H_
+#define _HECI_H_
+
+#include <linux/version.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/pci.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/module.h>
+#include <linux/aio.h>
+#include <linux/types.h>
+#include "heci_data_structures.h"
+
+#define SHUTDOWN_METHOD(method) .shutdown = method,
+#define HECI_REBOOT_NOTIFIER(reboot_notifier, driver, reboot_function)
+#define REGISTER_REBOOT_NOTIFIER(reboot_notifier)
+#define UNREGISTER_REBOOT_NOTIFIER(reboot_notifier)
+#define heci_reboot_notifier
+
+extern const struct guid heci_pthi_guid;
+extern const struct guid heci_wd_guid;
+extern const __u8 start_wd_params[];
+extern const __u8 stop_wd_params[];
+
+/**
+ * memory IO BAR definition
+ */
+#define     BAR_0                        0
+#define     BAR_1                        1
+#define     BAR_5                        5
+/**
+ * Number of queue lists used by this driver
+ */
+#define    PCI_HECI_DEVICE_ID1   0x2974
+#define    PCI_HECI_DEVICE_ID2   0x2984
+#define    PCI_HECI_DEVICE_ID3   0x2994
+#define    PCI_HECI_DEVICE_ID4   0x29A4
+#define    PCI_HECI_DEVICE_ID5   0x29B4
+#define    PCI_HECI_DEVICE_ID6   0x29C4
+#define    PCI_HECI_DEVICE_ID7   0x29E4
+#define    PCI_HECI_DEVICE_ID8   0x29F4
+
+/**
+ * heci init function prototypes
+ */
+struct iamt_heci_device *init_heci_device(struct pci_dev *pdev);
+void heci_reset(struct iamt_heci_device *dev, int interrupts);
+int heci_hw_init(struct iamt_heci_device *dev);
+int heci_initialize_clients(void *data);
+struct heci_file_private *alloc_priv(struct file *file);
+int heci_disconnect_host_client(struct iamt_heci_device *dev,
+                                struct heci_file_private *file_ext);
+void heci_initialize_list(struct io_heci_list *list,
+                          struct iamt_heci_device *dev);
+void heci_flush_list(struct io_heci_list *list,
+                     struct heci_file_private *file_ext);
+void heci_flush_queues(struct iamt_heci_device *dev,
+                       struct heci_file_private *file_ext);
+
+void heci_remove_client_from_file_list(struct iamt_heci_device *dev,
+                                       __u8 host_client_id);
+
+/**
+ *  interrupt function prototype
+ */
+irqreturn_t heci_isr_interrupt(int irq, void *dev_id);
+void heci_wd_timer(unsigned long data);
+void heci_bh_handler(struct work_struct *work);
+/**
+ *  input output function prototype
+ */
+int heci_ioctl_get_version(struct iamt_heci_device *device, int if_num,
+                           struct heci_message_data *u_msg,
+                           struct heci_message_data k_msg,
+                           struct heci_file_private *file_ext);
+
+int heci_ioctl_connect_client(struct iamt_heci_device *device, int if_num,
+                              struct heci_message_data *u_msg,
+                              struct heci_message_data k_msg,
+                              struct file *file);
+
+int heci_ioctl_wd(struct iamt_heci_device *device, int if_num,
+                  struct heci_message_data k_msg,
+                  struct heci_file_private *file_ext);
+
+int heci_ioctl_bypass_wd(struct iamt_heci_device *device, int if_num,
+                  struct heci_message_data k_msg,
+                  struct heci_file_private *file_ext);
+
+int legacy_ioctl_send_msg(struct iamt_heci_device *device, int if_num,
+                              struct heci_message_data k_msg,
+                              struct file *file);
+
+int legacy_ioctl_recv_msg(struct iamt_heci_device *device, int if_num,
+                                 struct heci_message_data *u_msg,
+                                 struct heci_message_data k_msg,
+                                 struct file *file);
+
+int heci_start_read(struct iamt_heci_device *device, int if_num,
+                    struct heci_file_private *file_ext);
+
+int pthi_write(struct iamt_heci_device *device,
+               struct heci_cb_private *priv_cb);
+
+int pthi_read(struct iamt_heci_device *device, int if_num, struct file *file,
+              char *ubuf, size_t length, loff_t *offset);
+
+struct heci_cb_private *find_pthi_read_list_entry(
+                        struct iamt_heci_device *device,
+                        struct file *file, struct heci_file_private *file_ext);
+
+void run_next_legacy_cmd(struct iamt_heci_device *device);
+
+
+
+#endif                          /* _HECI_H_ */

a/drivers/char/heci/heci_init.c

@@ +1 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2007 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/reboot.h>
+#include <linux/uaccess.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/kdev_t.h>
+#include <linux/moduleparam.h>
+#include <linux/wait.h>
+#include <linux/delay.h>
+
+#include "heci_data_structures.h"
+#include "heci_interface.h"
+#include "heci.h"
+
+
+const __u8 watch_dog_data[] = {
+        1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
+};
+const __u8 start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
+const __u8 stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
+const struct guid heci_asf_guid = {
+                0x75B30CD6, 0xA29E, 0x4AF7,
+                {0xA7, 0x12, 0xE6, 0x17, 0x43, 0x93, 0xC8, 0xA6}
+};
+const struct guid heci_wd_guid = {
+        0x05B79A6F, 0x4628, 0x4D7F,
+        {0x89, 0x9D, 0xA9, 0x15, 0x14, 0xCB, 0x32, 0xAB}
+};
+const struct guid heci_pthi_guid = {
+        0x12f80028, 0xb4b7, 0x4b2d,
+        {0xac, 0xa8, 0x46, 0xe0, 0xff, 0x65, 0x81, 0x4c}
+};
+
+
+/**
+ *  heci init function prototypes
+ */
+int host_start_message(struct iamt_heci_device *dev);
+int host_enum_clients_message(struct iamt_heci_device *dev);
+int allocate_me_clents_storage(struct iamt_heci_device *dev);
+void heci_disable(struct iamt_heci_device *dev);
+void host_init_wd(struct iamt_heci_device *dev);
+void host_init_legacy(struct iamt_heci_device *dev);
+int heci_wait_event_int_timeout(struct iamt_heci_device *dev, long timeout);
+
+/**
+ * same_id - tell if they have same id
+ * @fe1 -file extension
+ * @fe2 -file extension
+ *
+ * @return :
+ *  0 on success,
+ *  negative on failure.
+ */
+static int same_id(struct heci_file_private *fe1,
+                                        struct heci_file_private *fe2)
+{
+        if ((fe1->host_client_id == fe2->host_client_id)
+                && (fe1->me_client_id == fe2->me_client_id)) {
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+/**
+ * heci_initialize_list - Sets up a  queue  list.
+ *
+ * @list - An instance of our list structure
+ * @dev -Device object for our driver
+ *
+ * @return :
+ * none;
+ */
+void heci_initialize_list(struct io_heci_list *list,
+                          struct iamt_heci_device *dev)
+{
+        /* initialize our queue list */
+        INIT_LIST_HEAD(&list->heci_cb.cb_list);
+        list->status = ESUCCESS;
+        list->device_extension = dev;
+        return;
+}
+
+/**
+ * heci_flush_queues - flush our queues list belong to file_ext.
+ *
+ * @dev -Device object for our driver
+ *
+ * @return :
+ * none;
+ */
+void heci_flush_queues(struct iamt_heci_device *dev,
+                       struct heci_file_private *file_ext)
+{
+        int i;
+        if (!dev || !file_ext)
+                return;
+        /* flush our queue list belong to file_ext */
+        for (i = 0; i < NUMBER_OF_LISTS; i++) {
+                DBG("remove list etnry belong to file_ext\n");
+                heci_flush_list(dev->io_list_array[i], file_ext);
+        }
+
+}
+
+
+/**
+ * heci_flush_list - remove list etnry belong to file_ext.
+ *
+ * @list - An instance of our list structure
+ * @file_ext -extension of the file object
+
+ * @return :
+ * none;
+ */
+void heci_flush_list(struct io_heci_list *list,
+                struct heci_file_private *file_ext)
+{
+        struct heci_file_private *file_ext_tmp = NULL;
+        struct heci_cb_private *priv_cb_pos = NULL;
+        struct heci_cb_private *priv_cb_next = NULL;
+
+        if (!list || !file_ext)
+                return;
+        if (list->status == ESUCCESS
+                        && !list_empty(&list->heci_cb.cb_list)) {
+                list_for_each_entry_safe(priv_cb_pos,
+                                priv_cb_next, &list->heci_cb.cb_list, cb_list) {
+                        if (priv_cb_pos)
+                                file_ext_tmp = (struct heci_file_private *)
+                                        priv_cb_pos->file_private;
+
+                        if (file_ext_tmp) {
+                                if (same_id(file_ext, file_ext_tmp))
+                                        list_del(&priv_cb_pos->cb_list);
+                        }
+
+                }
+        }
+        return;
+}
+
+/**
+ * init_heci_device - allocates and initializes the heci device structure
+ * @pdev: The pci device structure
+ *
+ * @return :
+ * The heci_device_device pointer on success, NULL on failure.
+ */
+struct iamt_heci_device *init_heci_device(struct pci_dev *pdev)
+{
+        int i;
+        struct iamt_heci_device *device;
+
+        device = kmalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
+        if (!device)
+                return NULL;
+
+        /* setup our list array */
+        device->io_list_array[0] = &device->read_list;
+        device->io_list_array[1] = &device->write_list;
+        device->io_list_array[2] = &device->write_waiting_list;
+        device->io_list_array[3] = &device->ctrl_wr_list;
+        device->io_list_array[4] = &device->ctrl_rd_list;
+        device->io_list_array[5] = &device->pthi_cmd_list;
+        device->io_list_array[6] = &device->pthi_read_complete_list;
+        INIT_LIST_HEAD(&device->file_list);
+        INIT_LIST_HEAD(&device->wd_file_ext.link);
+        INIT_LIST_HEAD(&device->legacy_file_ext.link);
+        spin_lock_init(&device->device_lock);
+        init_waitqueue_head(&device->wait_recvd_msg);
+        init_waitqueue_head(&device->wait_stop_wd);
+        device->open_handle_count = 0;
+        device->num_heci_me_clients = 0;
+        device->mem_base = 0;
+        device->mem_length = 0;
+        device->extra_write_index = 0;
+        device->rd_msg_hdr = 0;
+        device->mem_addr = NULL;
+        device->asf_mode = FALSE;
+        device->need_reset = FALSE;
+        device->recvd_msg = FALSE;
+        device->heci_state = HECI_INITIALIZING;
+
+        device->num_heci_me_clients = 0;
+        device->legacy_current_cb = NULL;
+        device->legacy_file_object = NULL;
+        device->legacy_canceled = FALSE;
+        device->legacy_flow_control_pending = FALSE;
+        device->legacy_state = HECI_LEGACY_IDLE;
+        device->legacy_msg_buf_index = 0;
+        device->wd_pending = FALSE;
+        device->wd_stoped = FALSE;
+        device->wd_bypass = FALSE;
+
+        device->me_clients = NULL;
+        /* init work for schedule work */
+        INIT_WORK(&device->work, NULL);
+        for (i = 0; i < NUMBER_OF_LISTS; i++)
+                heci_initialize_list(device->io_list_array[i], device);
+        device->pdev = pdev;
+        return device;
+}
+
+
+
+
+int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
+                long timeout)
+{
+        int err = 0;
+        err = wait_event_interruptible_timeout(dev->wait_recvd_msg,
+                        (dev->recvd_msg), timeout);
+        return err;
+}
+
+/**
+ * heci_hw_init  - init host and fw to start work.
+ *
+ * @dev -Device object for our driver
+ *
+ *@return:
+ * 0 on success.
+ * negative on failure
+ */
+int heci_hw_init(struct iamt_heci_device *dev)
+{
+        int err = 0;
+        dev->host_hw_state = read_heci_register(dev, H_CSR);
+        dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
+        DBG("host_hw_state = 0x%08x, mestate = 0x%08x.\n",
+            dev->host_hw_state, dev->me_hw_state);
+
+        if ((dev->host_hw_state & H_IS) == H_IS) {
+                /* acknowledge interrupt and stop interupts */
+                write_heci_register(dev, H_CSR, dev->host_hw_state);
+        }
+        dev->recvd_msg = FALSE;
+        DBG("reset in start the heci device.\n");
+
+        heci_reset(dev, TRUE);
+
+        DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
+            dev->host_hw_state, dev->me_hw_state);
+
+        /* wait for ME to turn on ME_RDY */
+        if (!dev->recvd_msg)
+                err = heci_wait_event_int_timeout(dev, HECI_INTEROP_TIMEOUT);
+
+        if (!err && !dev->recvd_msg) {
+                dev->heci_state = HECI_DISABLED;
+                DBG("wait_event_interruptible_timeout failed" \
+                               "on wait for ME to turn on ME_RDY.\n");
+                return -ENODEV;
+        } else {
+                if (!(((dev->host_hw_state & H_RDY) == H_RDY)
+                      && ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA))) {
+                        dev->heci_state = HECI_DISABLED;
+                        DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
+                                        dev->host_hw_state,
+                                        dev->me_hw_state);
+
+                        if (!(dev->host_hw_state & H_RDY) != H_RDY)
+                                DBG("host turn off H_RDY.\n");
+                        if (!(dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
+                                DBG("ME turn off ME_RDY.\n");
+                        ERR("link layer initialization failed.\n");
+                        return -ENODEV;
+                }
+        }
+        dev->recvd_msg = FALSE;
+        DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
+            dev->host_hw_state, dev->me_hw_state);
+        DBG("ME turn on ME_RDY and host turn on H_RDY.\n");
+        INFO("link layer has been established.\n");
+        return ESUCCESS;
+}
+
+/**
+ * heci_reset  - reset host and fw.
+ *
+ * @dev -Device object for our driver
+ * @interrupts - if interrupt should be enable after reset.
+ *
+ * @return:
+ * none;
+ */
+void heci_reset(struct iamt_heci_device *dev, int interrupts)
+{
+       struct heci_file_private *file_pos = NULL;
+        struct heci_file_private *file_next = NULL;
+        struct heci_cb_private *priv_cb_pos = NULL;
+        struct heci_cb_private *priv_cb_next = NULL;
+
+        if (dev->heci_state == HECI_RECOVERING_FROM_RESET) {
+                dev->need_reset = TRUE;
+                return;
+        }
+        dev->host_hw_state = read_heci_register(dev, H_CSR);
+
+        DBG("before reset host_hw_state = 0x%08x.\n",
+            dev->host_hw_state);
+
+        dev->host_hw_state |= (H_RST | H_IG);
+
+        if (interrupts)
+                dev->host_hw_state |= (H_IE);
+        else
+                dev->host_hw_state &= ~(H_IE);
+
+        write_heci_register(dev, H_CSR, dev->host_hw_state);
+
+        dev->host_hw_state = read_heci_register(dev, H_CSR);
+        BUG_ON((dev->host_hw_state & H_RST) != H_RST);
+        BUG_ON((dev->host_hw_state & H_RDY) != 0);
+
+        dev->host_hw_state &= ~H_RST;
+        dev->host_hw_state |= H_IG;
+
+        write_heci_register(dev, H_CSR, dev->host_hw_state);
+
+        DBG("currently saved host_hw_state = 0x%08x.\n",
+            dev->host_hw_state);
+
+        dev->need_reset = FALSE;
+
+        if (dev->heci_state != HECI_INITIALIZING) {
+                if (dev->heci_state != HECI_DISABLED)
+                        dev->heci_state = HECI_RESETING;
+
+                list_for_each_entry_safe(file_pos,
+                                file_next, &dev->file_list, link) {
+                        file_pos->state = HECI_FILE_DISCONNECTED;
+                        file_pos->flow_ctrl_creds = 0;
+                        file_pos->read_cb = NULL;
+                        file_pos->timer_count = 0;
+                }
+                /* remove entry if already in list */
+