Menu
▾
▴
openamt-checkin — checkin emails
You can subscribe to this list here.
| 2008 |
Jan
|
Feb
|
Mar
(10) |
Apr
(25) |
May
(48) |
Jun
(6) |
Jul
(12) |
Aug
|
Sep
(2) |
Oct
|
Nov
|
Dec
|
|---|
|
From: <mar...@us...> - 2008-09-12 15:13:40
|
Revision: 213
http://openamt.svn.sourceforge.net/openamt/?rev=213&view=rev
Author: marcin_obara
Date: 2008-09-12 15:13:49 +0000 (Fri, 12 Sep 2008)
Log Message:
-----------
kernel mainline branch of heci-5.0 - initial code as posted to LKML for kernel 2.6.27 (does not contain compatibility with older kernels)
Added Paths:
-----------
heci/branches/heci-5.0_mainline_kernel/
heci/branches/heci-5.0_mainline_kernel/Kconfig
heci/branches/heci-5.0_mainline_kernel/Makefile
heci/branches/heci-5.0_mainline_kernel/heci.h
heci/branches/heci-5.0_mainline_kernel/heci_data_structures.h
heci/branches/heci-5.0_mainline_kernel/heci_init.c
heci/branches/heci-5.0_mainline_kernel/heci_interface.c
heci/branches/heci-5.0_mainline_kernel/heci_interface.h
heci/branches/heci-5.0_mainline_kernel/heci_main.c
heci/branches/heci-5.0_mainline_kernel/heci_version.h
heci/branches/heci-5.0_mainline_kernel/interrupt.c
heci/branches/heci-5.0_mainline_kernel/io_heci.c
Added: heci/branches/heci-5.0_mainline_kernel/Kconfig
===================================================================
--- heci/branches/heci-5.0_mainline_kernel/Kconfig (rev 0)
+++ heci/branches/heci-5.0_mainline_kernel/Kconfig 2008-09-12 15:13:49 UTC (rev 213)
@@ -0,0 +1,12 @@
+#
+# HECI device configuration
+#
+
+config INTEL_MEI
+ tristate "Intel Management Engine Interface (MEI) Support (EXPERIMENTAL)"
+ depends on EXPERIMENTAL
+ ---help---
+ The Intel Management Engine Interface (Intel MEI) driver allows
+ applications to access the Active Management Technology
+ firmware and other Management Engine sub-systems.
+
Added: heci/branches/heci-5.0_mainline_kernel/Makefile
===================================================================
--- heci/branches/heci-5.0_mainline_kernel/Makefile (rev 0)
+++ heci/branches/heci-5.0_mainline_kernel/Makefile 2008-09-12 15:13:49 UTC (rev 213)
@@ -0,0 +1,7 @@
+#
+## Makefile for the Intel MEI driver (heci)
+#
+
+obj-$(CONFIG_INTEL_MEI) += heci.o
+
+heci-objs := heci_init.o heci_interface.o heci_main.o interrupt.o io_heci.o
Added: heci/branches/heci-5.0_mainline_kernel/heci.h
===================================================================
--- heci/branches/heci-5.0_mainline_kernel/heci.h (rev 0)
+++ heci/branches/heci-5.0_mainline_kernel/heci.h 2008-09-12 15:13:49 UTC (rev 213)
@@ -0,0 +1,176 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2003 - 2008 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"
+
+extern const struct guid heci_pthi_guid;
+extern const struct guid heci_wd_guid;
+extern const __u8 heci_start_wd_params[];
+extern const __u8 heci_stop_wd_params[];
+extern const __u8 heci_wd_state_independence_msg[3][4];
+
+/*
+ * heci device ID
+ */
+#define HECI_DEV_ID_82946GZ 0x2974 /* 82946GZ/GL */
+#define HECI_DEV_ID_82G35 0x2984 /* 82G35 Express */
+#define HECI_DEV_ID_82Q965 0x2994 /* 82Q963/Q965 */
+#define HECI_DEV_ID_82G965 0x29A4 /* 82P965/G965 */
+
+#define HECI_DEV_ID_82GM965 0x2A04 /* Mobile PM965/GM965 */
+#define HECI_DEV_ID_82GME965 0x2A14 /* Mobile GME965/GLE960 */
+
+#define HECI_DEV_ID_ICH9_82Q35 0x29B4 /* 82Q35 Express */
+#define HECI_DEV_ID_ICH9_82G33 0x29C4 /* 82G33/G31/P35/P31 Express */
+#define HECI_DEV_ID_ICH9_82Q33 0x29D4 /* 82Q33 Express */
+#define HECI_DEV_ID_ICH9_82X38 0x29E4 /* 82X38/X48 Express */
+#define HECI_DEV_ID_ICH9_3200 0x29F4 /* 3200/3210 Server */
+
+#define HECI_DEV_ID_ICH9_6 0x28B4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_7 0x28C4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_8 0x28D4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_9 0x28E4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_10 0x28F4 /* Bearlake */
+
+#define HECI_DEV_ID_ICH9M_1 0x2A44 /* Cantiga */
+#define HECI_DEV_ID_ICH9M_2 0x2A54 /* Cantiga */
+#define HECI_DEV_ID_ICH9M_3 0x2A64 /* Cantiga */
+#define HECI_DEV_ID_ICH9M_4 0x2A74 /* Cantiga */
+
+#define HECI_DEV_ID_ICH10_1 0x2E04 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_2 0x2E14 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_3 0x2E24 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_4 0x2E34 /* Eaglelake */
+
+/*
+ * 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_task_initialize_clients(void *data);
+int heci_initialize_clients(struct iamt_heci_device *dev);
+struct heci_file_private *heci_alloc_file_private(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);
+
+/*
+ * input output function prototype
+ */
+int heci_ioctl_get_version(struct iamt_heci_device *dev, 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 *dev, 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 *dev, int if_num,
+ struct heci_message_data k_msg,
+ struct heci_file_private *file_ext);
+
+int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
+ struct heci_message_data k_msg,
+ struct heci_file_private *file_ext);
+
+int heci_start_read(struct iamt_heci_device *dev, int if_num,
+ struct heci_file_private *file_ext);
+
+int pthi_write(struct iamt_heci_device *dev,
+ struct heci_cb_private *priv_cb);
+
+int pthi_read(struct iamt_heci_device *dev, 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 *dev,
+ struct file *file);
+
+void run_next_iamthif_cmd(struct iamt_heci_device *dev);
+
+void heci_free_cb_private(struct heci_cb_private *priv_cb);
+
+/**
+ * heci_fe_same_id - tell if file private data have same id
+ *
+ * @fe1: private data of 1. file object
+ * @fe2: private data of 2. file object
+ *
+ * returns !=0 - if ids are the same, 0 - if differ.
+ */
+static inline int heci_fe_same_id(const struct heci_file_private *fe1,
+ const struct heci_file_private *fe2)
+{
+ return ((fe1->host_client_id == fe2->host_client_id)
+ && (fe1->me_client_id == fe2->me_client_id));
+}
+
+#endif /* _HECI_H_ */
Added: heci/branches/heci-5.0_mainline_kernel/heci_data_structures.h
===================================================================
--- heci/branches/heci-5.0_mainline_kernel/heci_data_structures.h (rev 0)
+++ heci/branches/heci-5.0_mainline_kernel/heci_data_structures.h 2008-09-12 15:13:49 UTC (rev 213)
@@ -0,0 +1,536 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2003 - 2008 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 ESLOTS_OVERFLOW 1
+#define ECORRUPTED_MESSAGE_HEADER 1000
+#define ECOMPLETE_MESSAGE 1001
+
+#define HECI_FC_MESSAGE_RESERVED_LENGTH 5
+
+/*
+ * Number of queue lists used by this driver
+ */
+#define HECI_IO_LISTS_NUMBER 7
+
+/*
+ * Maximum transmission unit (MTU) of heci messages
+ */
+#define IAMTHIF_MTU 4160
+
+
+/*
+ * HECI HW Section
+ */
+
+/* HECI registers */
+/* H_CB_WW - Host Circular Buffer (CB) Write Window register */
+#define H_CB_WW 0
+/* H_CSR - Host Control Status register */
+#define H_CSR 4
+/* ME_CB_RW - ME Circular Buffer Read Window register (read only) */
+#define ME_CB_RW 8
+/* ME_CSR_HA - ME Control Status Host Access register (read only) */
+#define ME_CSR_HA 0xC
+
+
+/* register bits of H_CSR (Host Control Status register) */
+/* Host Circular Buffer Depth - maximum number of 32-bit entries in CB */
+#define H_CBD 0xFF000000
+/* Host Circular Buffer Write Pointer */
+#define H_CBWP 0x00FF0000
+/* Host Circular Buffer Read Pointer */
+#define H_CBRP 0x0000FF00
+/* Host Reset */
+#define H_RST 0x00000010
+/* Host Ready */
+#define H_RDY 0x00000008
+/* Host Interrupt Generate */
+#define H_IG 0x00000004
+/* Host Interrupt Status */
+#define H_IS 0x00000002
+/* Host Interrupt Enable */
+#define H_IE 0x00000001
+
+
+/* register bits of ME_CSR_HA (ME Control Status Host Access register) */
+/* ME CB (Circular Buffer) Depth HRA (Host Read Access)
+ * - host read only access to ME_CBD */
+#define ME_CBD_HRA 0xFF000000
+/* ME CB Write Pointer HRA - host read only access to ME_CBWP */
+#define ME_CBWP_HRA 0x00FF0000
+/* ME CB Read Pointer HRA - host read only access to ME_CBRP */
+#define ME_CBRP_HRA 0x0000FF00
+/* ME Reset HRA - host read only access to ME_RST */
+#define ME_RST_HRA 0x00000010
+/* ME Ready HRA - host read only access to ME_RDY */
+#define ME_RDY_HRA 0x00000008
+/* ME Interrupt Generate HRA - host read only access to ME_IG */
+#define ME_IG_HRA 0x00000004
+/* ME Interrupt Status HRA - host read only access to ME_IS */
+#define ME_IS_HRA 0x00000002
+/* ME Interrupt Enable HRA - host read only access to ME_IE */
+#define ME_IE_HRA 0x00000001
+
+#define HECI_MINORS_BASE 1
+#define HECI_MINORS_COUNT 1
+
+#define HECI_MINOR_NUMBER 1
+#define HECI_MAX_OPEN_HANDLE_COUNT 253
+
+/*
+ * debug kernel print macro define
+ */
+extern int heci_debug;
+extern struct device *heci_dev;
+
+#define DBG(format, arg...) do { \
+ if (heci_debug) { \
+ if (heci_dev) \
+ dev_info(heci_dev, "%s: " format, __func__, ## arg); \
+ else \
+ printk(KERN_INFO "heci: %s: " format, \
+ __func__, ## arg); \
+ } \
+} while (0)
+
+
+/*
+ * time to wait HECI become ready after init
+ */
+#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_STATE_INDEPENDENCE_MSG_SENT (1 << 0)
+
+#define HECI_WD_HOST_CLIENT_ID 1
+#define HECI_IAMTHIF_HOST_CLIENT_ID 2
+
+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 device states */
+enum heci_states {
+ HECI_INITIALIZING = 0,
+ HECI_ENABLED,
+ HECI_RESETING,
+ HECI_DISABLED,
+ HECI_RECOVERING_FROM_RESET,
+ HECI_POWER_DOWN,
+ HECI_POWER_UP
+};
+
+enum iamthif_states {
+ HECI_IAMTHIF_IDLE,
+ HECI_IAMTHIF_WRITING,
+ HECI_IAMTHIF_FLOW_CONTROL,
+ HECI_IAMTHIF_READING,
+ HECI_IAMTHIF_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;
+} __attribute__((packed));
+
+#define HECI_CONNECT_TIMEOUT 3 /* at least 2 seconds */
+
+#define IAMTHIF_STALL_TIMER 12 /* seconds */
+#define IAMTHIF_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;
+ int sm_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;
+} __attribute__((packed));
+
+
+struct heci_client {
+ __u32 max_msg_length;
+ __u8 protocol_version;
+} __attribute__((packed));
+
+/*
+ * 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;
+} __attribute__((packed));
+
+
+struct hbm_cmd {
+ __u8 cmd:7;
+ __u8 is_response:1;
+} __attribute__((packed));
+
+
+struct heci_bus_message {
+ struct hbm_cmd cmd;
+ __u8 command_specific_data[];
+} __attribute__((packed));
+
+struct hbm_version {
+ __u8 minor_version;
+ __u8 major_version;
+} __attribute__((packed));
+
+struct hbm_host_version_request {
+ struct hbm_cmd cmd;
+ __u8 reserved;
+ struct hbm_version host_version;
+} __attribute__((packed));
+
+struct hbm_host_version_response {
+ struct hbm_cmd cmd;
+ int host_version_supported;
+ struct hbm_version me_max_version;
+} __attribute__((packed));
+
+struct hbm_host_stop_request {
+ struct hbm_cmd cmd;
+ __u8 reason;
+ __u8 reserved[2];
+} __attribute__((packed));
+
+struct hbm_host_stop_response {
+ struct hbm_cmd cmd;
+ __u8 reserved[3];
+} __attribute__((packed));
+
+struct hbm_me_stop_request {
+ struct hbm_cmd cmd;
+ __u8 reason;
+ __u8 reserved[2];
+} __attribute__((packed));
+
+struct hbm_host_enum_request {
+ struct hbm_cmd cmd;
+ __u8 reserved[3];
+} __attribute__((packed));
+
+struct hbm_host_enum_response {
+ struct hbm_cmd cmd;
+ __u8 reserved[3];
+ __u8 valid_addresses[32];
+} __attribute__((packed));
+
+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;
+} __attribute__((packed));
+
+struct hbm_props_request {
+ struct hbm_cmd cmd;
+ __u8 address;
+ __u8 reserved[2];
+} __attribute__((packed));
+
+
+struct hbm_props_response {
+ struct hbm_cmd cmd;
+ __u8 address;
+ __u8 status;
+ __u8 reserved[1];
+ struct heci_client_properties client_properties;
+} __attribute__((packed));
+
+struct hbm_client_connect_request {
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
+ __u8 reserved;
+} __attribute__((packed));
+
+struct hbm_client_connect_response {
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
+ __u8 status;
+} __attribute__((packed));
+
+struct hbm_client_disconnect_request {
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
+ __u8 reserved[1];
+} __attribute__((packed));
+
+struct hbm_flow_control {
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
+ __u8 reserved[HECI_FC_MESSAGE_RESERVED_LENGTH];
+} __attribute__((packed));
+
+struct heci_me_client {
+ struct heci_client_properties props;
+ __u8 client_id;
+ __u8 flow_ctrl_creds;
+} __attribute__((packed));
+
+/* 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[HECI_IO_LISTS_NUMBER];
+ 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 reading 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*/
+ struct work_struct work;
+ int recvd_msg;
+
+ struct task_struct *reinit_tsk;
+
+ 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;
+
+ __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 1, don't refresh watchdog ME client */
+
+ struct file *iamthif_file_object;
+ struct heci_file_private iamthif_file_ext;
+ int iamthif_ioctl;
+ int iamthif_canceled;
+ __u32 iamthif_timer;
+ __u32 iamthif_stall_timer;
+ unsigned char iamthif_msg_buf[IAMTHIF_MTU];
+ __u32 iamthif_msg_buf_size;
+ __u32 iamthif_msg_buf_index;
+ int iamthif_flow_control_pending;
+ enum iamthif_states iamthif_state;
+
+ struct heci_cb_private *iamthif_current_cb;
+ __u8 write_hang;
+ int need_reset;
+ long open_handle_count;
+
+};
+
+/**
+ * read_heci_register - Read a byte from the heci device
+ *
+ * @dev: the device structure
+ * @offset: offset from which to read the data
+ *
+ * returns the byte read.
+ */
+static inline __u32 read_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset)
+{
+ return readl(dev->mem_addr + offset);
+}
+
+/**
+ * write_heci_register - Write 4 bytes to the heci device
+ *
+ * @dev: the device structure
+ * @offset: offset from which to write the data
+ * @value: the byte to write
+ */
+static inline void write_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset, __u32 value)
+{
+ writel(value, dev->mem_addr + offset);
+}
+
+#endif /* _HECI_DATA_STRUCTURES_H_ */
Added: heci/branches/heci-5.0_mainline_kernel/heci_init.c
===================================================================
--- heci/branches/heci-5.0_mainline_kernel/heci_init.c (rev 0)
+++ heci/branches/heci-5.0_mainline_kernel/heci_init.c 2008-09-12 15:13:49 UTC (rev 213)
@@ -0,0 +1,1077 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2003 - 2008 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/poll.h>
+#include <linux/init.h>
+#include <linux/kdev_t.h>
+#include <linux/moduleparam.h>
+#include <linux/wait.h>
+#include <linux/delay.h>
+#include <linux/kthread.h>
+
+#include "heci_data_structures.h"
+#include "heci_interface.h"
+#include "heci.h"
+
+
+const __u8 heci_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
+const __u8 heci_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
+
+const __u8 heci_wd_state_independence_msg[3][4] = {
+ {0x05, 0x02, 0x51, 0x10},
+ {0x05, 0x02, 0x52, 0x10},
+ {0x07, 0x02, 0x01, 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
+ */
+static void heci_check_asf_mode(struct iamt_heci_device *dev);
+static int host_start_message(struct iamt_heci_device *dev);
+static int host_enum_clients_message(struct iamt_heci_device *dev);
+static int allocate_me_clients_storage(struct iamt_heci_device *dev);
+static void host_init_wd(struct iamt_heci_device *dev);
+static void host_init_iamthif(struct iamt_heci_device *dev);
+static int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
+ long timeout);
+
+
+/**
+ * heci_initialize_list - Sets up a queue list.
+ *
+ * @list: An instance of our list structure
+ * @dev: Device object for our driver
+ */
+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 = 0;
+ list->device_extension = dev;
+}
+
+/**
+ * heci_flush_queues - flush our queues list belong to file_ext.
+ *
+ * @dev: Device object for our driver
+ * @file_ext: private data of the file object
+ */
+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 < HECI_IO_LISTS_NUMBER; i++) {
+ DBG("remove list entry belong to file_ext\n");
+ heci_flush_list(dev->io_list_array[i], file_ext);
+ }
+}
+
+
+/**
+ * heci_flush_list - remove list entry belong to file_ext.
+ *
+ * @list: An instance of our list structure
+ * @file_ext: private data of the file object
+ */
+void heci_flush_list(struct io_heci_list *list,
+ struct heci_file_private *file_ext)
+{
+ struct heci_file_private *file_ext_tmp;
+ struct heci_cb_private *priv_cb_pos = NULL;
+ struct heci_cb_private *priv_cb_next = NULL;
+
+ if (!list || !file_ext)
+ return;
+
+ if (list->status != 0)
+ return;
+
+ if (list_empty(&list->heci_cb.cb_list))
+ return;
+
+ 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 (heci_fe_same_id(file_ext, file_ext_tmp))
+ list_del(&priv_cb_pos->cb_list);
+ }
+ }
+ }
+}
+
+/**
+ * heci_reset_iamthif_params - initializes heci device iamthif
+ *
+ * @dev: The heci device structure
+ */
+static void heci_reset_iamthif_params(struct iamt_heci_device *dev)
+{
+ /* reset iamthif parameters. */
+ dev->iamthif_current_cb = NULL;
+ dev->iamthif_msg_buf_size = 0;
+ dev->iamthif_msg_buf_index = 0;
+ dev->iamthif_canceled = 0;
+ dev->iamthif_file_ext.file = NULL;
+ dev->iamthif_ioctl = 0;
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
+ dev->iamthif_timer = 0;
+}
+
+/**
+ * init_heci_device - allocates and initializes the heci device structure
+ *
+ * @pdev: The pci device structure
+ *
+ * returns 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 *dev;
+
+ dev = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
+ if (!dev)
+ return NULL;
+
+ /* setup our list array */
+ dev->io_list_array[0] = &dev->read_list;
+ dev->io_list_array[1] = &dev->write_list;
+ dev->io_list_array[2] = &dev->write_waiting_list;
+ dev->io_list_array[3] = &dev->ctrl_wr_list;
+ dev->io_list_array[4] = &dev->ctrl_rd_list;
+ dev->io_list_array[5] = &dev->pthi_cmd_list;
+ dev->io_list_array[6] = &dev->pthi_read_complete_list;
+ INIT_LIST_HEAD(&dev->file_list);
+ INIT_LIST_HEAD(&dev->wd_file_ext.link);
+ INIT_LIST_HEAD(&dev->iamthif_file_ext.link);
+ spin_lock_init(&dev->device_lock);
+ init_waitqueue_head(&dev->wait_recvd_msg);
+ init_waitqueue_head(&dev->wait_stop_wd);
+ dev->heci_state = HECI_INITIALIZING;
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
+
+ /* init work for schedule work */
+ INIT_WORK(&dev->work, NULL);
+ for (i = 0; i < HECI_IO_LISTS_NUMBER; i++)
+ heci_initialize_list(dev->io_list_array[i], dev);
+ dev->pdev = pdev;
+ return dev;
+}
+
+
+
+
+static int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
+ long timeout)
+{
+ return wait_event_interruptible_timeout(dev->wait_recvd_msg,
+ (dev->recvd_msg), timeout);
+}
+
+/**
+ * heci_hw_init - init host and fw to start work.
+ *
+ * @dev: Device object for our driver
+ *
+ * returns 0 on success, <0 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 */
+ heci_set_csr_register(dev);
+ }
+ dev->recvd_msg = 0;
+ DBG("reset in start the heci device.\n");
+
+ heci_reset(dev, 1);
+
+ 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");
+
+ printk(KERN_ERR
+ "heci: link layer initialization failed.\n");
+ return -ENODEV;
+ }
+ }
+ dev->recvd_msg = 0;
+ 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");
+ printk(KERN_INFO "heci: link layer has been established.\n");
+ return 0;
+}
+
+/**
+ * heci_hw_reset - reset fw via heci csr register.
+ *
+ * @dev: Device object for our driver
+ * @interrupts: if interrupt should be enable after reset.
+ */
+static void heci_hw_reset(struct iamt_heci_device *dev, int interrupts)
+{
+ dev->host_hw_state |= (H_RST | H_IG);
+
+ if (interrupts)
+ heci_csr_enable_interrupts(dev);
+ else
+ heci_csr_disable_interrupts(dev);
+
+ BUG_ON((dev->host_hw_state & H_RST) != H_RST);
+ BUG_ON((dev->host_hw_state & H_RDY) != 0);
+}
+
+/**
+ * heci_reset - reset host and fw.
+ *
+ * @dev: Device object for our driver
+ * @interrupts: if interrupt should be enable after reset.
+ */
+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;
+ int unexpected = 0;
+
+ if (dev->heci_state == HECI_RECOVERING_FROM_RESET) {
+ dev->need_reset = 1;
+ return;
+ }
+
+ if (dev->heci_state != HECI_INITIALIZING &&
+ dev->heci_state != HECI_DISABLED &&
+ dev->heci_state != HECI_POWER_DOWN &&
+ dev->heci_state != HECI_POWER_UP)
+ unexpected = 1;
+
+ if (dev->reinit_tsk != NULL) {
+ kthread_stop(dev->reinit_tsk);
+ dev->reinit_tsk = NULL;
+ }
+
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+
+ DBG("before reset host_hw_state = 0x%08x.\n",
+ dev->host_hw_state);
+
+ heci_hw_reset(dev, interrupts);
+
+ 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 = 0;
+
+ if (dev->heci_state != HECI_INITIALIZING) {
+ if ((dev->heci_state != HECI_DISABLED) &&
+ (dev->heci_state != HECI_POWER_DOWN))
+ 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 */
+ DBG("list del iamthif and wd file list.\n");
+ heci_remove_client_from_file_list(dev,
+ dev->wd_file_ext.host_client_id);
+
+ heci_remove_client_from_file_list(dev,
+ dev->iamthif_file_ext.host_client_id);
+
+ heci_reset_iamthif_params(dev);
+ dev->wd_due_counter = 0;
+ dev->extra_write_index = 0;
+ }
+
+ dev->num_heci_me_clients = 0;
+ dev->rd_msg_hdr = 0;
+ dev->stop = 0;
+ dev->wd_pending = 0;
+
+ /* update the state of the registers after reset */
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+ dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
+
+ DBG("after reset host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
+ dev->host_hw_state, dev->me_hw_state);
+
+ if (unexpected)
+ printk(KERN_WARNING "heci: unexpected reset.\n");
+
+ /* Wake up all readings so they can be interrupted */
+ list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
+ if (&file_pos->rx_wait &&
+ waitqueue_active(&file_pos->rx_wait)) {
+ printk(KERN_INFO "heci: Waking up client!\n");
+ wake_up_interruptible(&file_pos->rx_wait);
+ }
+ }
+ /* remove all waiting requests */
+ if (dev->write_list.status == 0 &&
+ !list_empty(&dev->write_list.heci_cb.cb_list)) {
+ list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
+ &dev->write_list.heci_cb.cb_list, cb_list) {
+ if (priv_cb_pos) {
+ list_del(&priv_cb_pos->cb_list);
+ heci_free_cb_private(priv_cb_pos);
+ }
+ }
+ }
+}
+
+/**
+ * heci_initialize_clients - heci communication initialization.
+ *
+ * @dev: Device object for our driver
+ */
+int heci_initialize_clients(struct iamt_heci_device *dev)
+{
+ int status;
+
+ msleep(100); /* FW needs time to be ready to talk with us */
+ DBG("link is established start sending messages.\n");
+ /* link is established start sending messages. */
+ status = host_start_message(dev);
+ if (status != 0) {
+ spin_lock_bh(&dev->device_lock);
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
+ DBG("start sending messages failed.\n");
+ return status;
+ }
+
+ /* enumerate clients */
+ status = host_enum_clients_message(dev);
+ if (status != 0) {
+ spin_lock_bh(&dev->device_lock);
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
+ DBG("enum clients failed.\n");
+ return status;
+ }
+ /* allocate storage for ME clients representation */
+ status = allocate_me_clients_storage(dev);
+ if (status != 0) {
+ spin_lock_bh(&dev->device_lock);
+ dev->num_heci_me_clients = 0;
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
+ DBG("allocate clients failed.\n");
+ return status;
+ }
+
+ heci_check_asf_mode(dev);
+ /* heci watchdog initialization */
+ host_init_wd(dev);
+ /* heci iamthif client initialization */
+ host_init_iamthif(dev);
+
+ spin_lock_bh(&dev->device_lock);
+ if (dev->need_reset) {
+ dev->need_reset = 0;
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
+ return -ENODEV;
+ }
+
+ memset(dev->heci_host_clients, 0, sizeof(dev->heci_host_clients));
+ dev->open_handle_count = 0;
+ dev->heci_host_clients[0] |= 7;
+ dev->current_host_client_id = 3;
+ dev->heci_state = HECI_ENABLED;
+ spin_unlock_bh(&dev->device_lock);
+ DBG("initialization heci clients successful.\n");
+ return 0;
+}
+
+/**
+ * heci_task_initialize_clients - heci reinitialization task
+ *
+ * @data: Device object for our driver
+ */
+int heci_task_initialize_clients(void *data)
+{
+ int ret;
+ struct iamt_heci_device *dev = (struct iamt_heci_device *) data;
+
+ spin_lock_bh(&dev->device_lock);
+ if (dev->reinit_tsk != NULL) {
+ spin_unlock_bh(&dev->device_lock);
+ DBG("reinit task already started.\n");
+ return 0;
+ }
+ dev->reinit_tsk = current;
+ current->flags |= PF_NOFREEZE;
+ spin_unlock_bh(&dev->device_lock);
+
+ ret = heci_initialize_clients(dev);
+
+ spin_lock_bh(&dev->device_lock);
+ dev->reinit_tsk = NULL;
+ spin_unlock_bh(&dev->device_lock);
+
+ return ret;
+}
+
+/**
+ * host_start_message - heci host send start message.
+ *
+ * @dev: Device object for our driver
+ *
+ * returns 0 on success, <0 on failure.
+ */
+static int host_start_message(struct iamt_heci_device *dev)
+{
+ long timeout = 60; /* 60 second */
+
+ struct heci_msg_hdr *heci_hdr;
+ struct hbm_host_version_request *host_start_req;
+ struct hbm_host_stop_request *host_stop_req;
+ int err = 0;
+
+ /* host start message */
+ heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_host_version_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ host_start_req =
+ (struct hbm_host_version_request *) &dev->wr_msg_buf[1];
+ memset(host_start_req, 0, sizeof(struct hbm_host_version_request));
+ host_start_req->cmd.cmd = HOST_START_REQ_CMD;
+ host_start_req->host_version.major_version = HBM_MAJOR_VERSION;
+ host_start_req->host_version.minor_version = HBM_MINOR_VERSION;
+ dev->recvd_msg = 0;
+ if (!heci_write_message(dev, heci_hdr,
+ (unsigned char *) (host_start_req),
+ heci_hdr->length)) {
+ DBG("send version to fw fail.\n");
+ return -ENODEV;
+ }
+ DBG("call wait_event_interruptible_timeout for response message.\n");
+ /* wait for response */
+ err = heci_wait_event_int_timeout(dev, timeout * HZ);
+ if (!err && !dev->recvd_msg) {
+ DBG("wait_timeout failed on host start response message.\n");
+ return -ENODEV;
+ }
+ dev->recvd_msg = 0;
+ DBG("wait_timeout successful on host start response message.\n");
+ if ((dev->version.major_version != HBM_MAJOR_VERSION) ||
+ (dev->version.minor_version != HBM_MINOR_VERSION)) {
+ /* send stop message */
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_host_stop_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ host_stop_req =
+ (struct hbm_host_stop_request *) &dev->wr_msg_buf[1];
+
+ memset(host_stop_req, 0, sizeof(struct hbm_host_stop_request));
+ host_stop_req->cmd.cmd = HOST_STOP_REQ_CMD;
+ host_stop_req->reason = DRIVER_STOP_REQUEST;
+ heci_write_message(dev, heci_hdr,
+ (unsigned char *) (host_stop_req),
+ heci_hdr->length);
+ DBG("version mismatch.\n");
+ return -ENODEV;
+ }
+
+ return 0;
+}
+
+/**
+ * host_enum_clients_message - host send enumeration client request message.
+ *
+ * @dev: Device object for our driver
+ *
+ * returns 0 on success, <0 on failure.
+ */
+static int host_enum_clients_message(struct iamt_heci_device *dev)
+{
+ long timeout = 5; /*5 second */
+ struct heci_msg_hdr *heci_hdr;
+ struct hbm_host_enum_request *host_enum_req;
+ int err = 0;
+ int i, j;
+
+ heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
+ /* enumerate clients */
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_host_enum_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ host_enum_req = (struct hbm_host_enum_request *) &dev->wr_msg_buf[1];
+ memset(host_enum_req, 0, sizeof(struct hbm_host_enum_request));
+ host_enum_req->cmd.cmd = HOST_ENUM_REQ_CMD;
+ if (!heci_write_message(dev, heci_hdr,
+ (unsigned char *) (host_enum_req),
+ heci_hdr->length)) {
+ DBG("send enumeration request failed.\n");
+ return -ENODEV;
+ }
+ /* wait for response */
+ dev->recvd_msg = 0;
+ err = heci_wait_event_int_timeout(dev, timeout * HZ);
+ if (!err && !dev->recvd_msg) {
+ DBG("wait_event_interruptible_timeout failed "
+ "on enumeration clients response message.\n");
+ return -ENODEV;
+ }
+ dev->recvd_msg = 0;
+
+ spin_lock_bh(&dev->device_lock);
+ /* count how many ME clients we have */
+ for (i = 0; i < sizeof(dev->heci_me_clients); i++) {
+ for (j = 0; j < 8; j++) {
+ if ((dev->heci_me_clients[i] & (1 << j)) != 0)
+ dev->num_heci_me_clients++;
+
+ }
+ }
+ spin_unlock_bh(&dev->device_lock);
+
+ return 0;
+}
+
+/**
+ * host_client_properties - reads properties for client
+ *
+ * @dev: Device object for our driver
+ * @idx: client index in me client array
+ * @client_id: id of the client
+ *
+ * returns 0 on success, <0 on failure.
+ */
+static int host_client_properties(struct iamt_heci_device *dev,
+ struct heci_me_client *client)
+{
+ struct heci_msg_hdr *heci_hdr;
+ struct hbm_props_request *host_cli_req;
+ int err;
+
+ heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_props_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ host_cli_req = (struct hbm_props_request *) &dev->wr_msg_buf[1];
+ memset(host_cli_req, 0, sizeof(struct hbm_props_request));
+ host_cli_req->cmd.cmd = HOST_CLIENT_PROPERTEIS_REQ_CMD;
+ host_cli_req->address = client->client_id;
+ if (!heci_write_message(dev, heci_hdr,
+ (unsigned char *) (host_cli_req),
+ heci_hdr->length)) {
+ DBG("send props request failed.\n");
+ return -ENODEV;
+ }
+ /* wait for response */
+ dev->recvd_msg = 0;
+ err = heci_wait_event_int_timeout(dev, 10 * HZ);
+ if (!err && !dev->recvd_msg) {
+ DBG("wait failed on props resp msg.\n");
+ return -ENODEV;
+ }
+ dev->recvd_msg = 0;
+ return 0;
+}
+
+/**
+ * allocate_me_clients_storage - allocate storage for me clients
+ *
+ * @dev: Device object for our driver
+ *
+ * returns 0 on success, <0 on failure.
+ */
+static int allocate_me_clients_storage(struct iamt_heci_device *dev)
+{
+ struct heci_me_client *clients;
+ struct heci_me_client *client;
+ __u8 num, i, j;
+ int err;
+
+ if (dev->num_heci_me_clients <= 0)
+ return 0;
+
+ spin_lock_bh(&dev->device_lock);
+ kfree(dev->me_clients);
+ dev->me_clients = NULL;
+ spin_unlock_bh(&dev->device_lock);
+
+ /* allocate storage for ME clients representation */
+ clients = kcalloc(dev->num_heci_me_clients,
+ sizeof(struct heci_me_client), GFP_KERNEL);
+ if (!clients) {
+ DBG("memory allocation for ME clients failed.\n");
+ return -ENOMEM;
+ }
+
+ spin_lock_bh(&dev->device_lock);
+ dev->me_clients = clients;
+ spin_unlock_bh(&dev->device_lock);
+
+ num = 0;
+ for (i = 0; i < sizeof(dev->heci_me_clients); i++) {
+ for (j = 0; j < 8; j++) {
+ if ((dev->heci_me_clients[i] & (1 << j)) != 0) {
+ client = &dev->me_clients[num];
+ client->client_id = (i * 8) + j;
+ client->flow_ctrl_creds = 0;
+ err = host_client_properties(dev, client);
+ if (err != 0) {
+ spin_lock_bh(&dev->device_lock);
+ kfree(dev->me_clients);
+ dev->me_clients = NULL;
+ spin_unlock_bh(&dev->device_lock);
+ return err;
+ }
+ num++;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * heci_init_file_private - initializes private file structure.
+ *
+ * @priv: private file structure to be initialized
+ * @file: the file structure
+ */
+static void heci_init_file_private(struct heci_file_private *priv,
+ struct file *file)
+{
+ memset(priv, 0, sizeof(struct heci_file_private));
+ spin_lock_init(&priv->file_lock);
+ spin_lock_init(&priv->read_io_lock);
+ spin_lock_init(&priv->write_io_lock);
+ init_waitqueue_head(&priv->wait);
+ init_waitqueue_head(&priv->rx_wait);
+ DBG("priv->rx_wait =%p\n", &priv->rx_wait);
+ init_waitqueue_head(&priv->tx_wait);
+ INIT_LIST_HEAD(&priv->link);
+ priv->reading_state = HECI_IDLE;
+ priv->writing_state = HECI_IDLE;
+}
+
+/**
+ * heci_find_me_client - search for ME client guid
+ * sets client_id in heci_file_private if found
+ * @dev: Device object for our driver
+ * @priv: private file structure to set client_id in
+ * @cguid: searched guid of ME client
+ * @client_id: id of host client to be set in file private structure
+ *
+ * returns ME client index
+ */
+static __u8 heci_find_me_client(struct iamt_heci_device *dev,
+ struct heci_file_private *priv,
+ const struct guid *cguid, __u8 client_id)
+{
+ __u8 i;
+
+ if ((dev == NULL) || (priv == NULL) || (cguid == NULL))
+ return 0;
+
+ for (i = 0; i < dev->num_heci_me_clients; i++) {
+ if (memcmp(cguid,
+ &dev->me_clients[i].props.protocol_name,
+ sizeof(struct guid)) == 0) {
+ priv->me_client_id = dev->me_clients[i].client_id;
+ priv->state = HECI_FILE_CONNECTING;
+ priv->host_client_id = client_id;
+
+ list_add_tail(&priv->link, &dev->file_list);
+ return i;
+ }
+ }
+ return 0;
+}
+
+/**
+ * heci_check_asf_mode - check for ASF client
+ *
+ * @dev: Device object for our driver
+ */
+static void heci_check_asf_mode(struct iamt_heci_device *dev)
+{
+ __u8 i;
+
+ spin_lock_bh(&dev->device_lock);
+ dev->asf_mode = 0;
+ /* find ME ASF client - otherwise assume AMT mode */
+ DBG("find ME ASF client - otherwise assume AMT mode.\n");
+ for (i = 0; i < dev->num_heci_me_clients; i++) {
+ if (memcmp(&heci_asf_guid,
+ &dev->me_clients[i].props.protocol_name,
+ sizeof(struct guid)) == 0) {
+ dev->asf_mode = 1;
+ spin_unlock_bh(&dev->device_lock);
+ DBG("found ME ASF client.\n");
+ return;
+ }
+ }
+ spin_unlock_bh(&dev->device_lock);
+ DBG("assume AMT mode.\n");
+}
+
+/**
+ * heci_connect_me_client - connect ME client
+ * @dev: Device object for our driver
+ * @priv: private file structure
+ * @timeout: connect timeout in seconds
+ *
+ * returns 1 - if connected, 0 - if not
+ */
+static __u8 heci_connect_me_client(struct iamt_heci_device *dev,
+ struct heci_file_private *priv,
+ long timeout)
+{
+ int err = 0;
+
+ if ((dev == NULL) || (priv == NULL))
+ return 0;
+
+ if (!heci_connect(dev, priv)) {
+ DBG("failed to call heci_connect for client_id=%d.\n",
+ priv->host_client_id);
+ spin_lock_bh(&dev->device_lock);
+ heci_remove_client_from_file_list(dev, priv->host_client_id);
+ priv->state = HECI_FILE_DISCONNECTED;
+ spin_unlock_bh(&dev->device_lock);
+ return 0;
+ }
+
+ err = wait_event_timeout(dev->wait_recvd_msg,
+ (HECI_FILE_CONNECTED == priv->state ||
+ HECI_FILE_DISCONNECTED == priv->state),
+ timeout * HZ);
+ if (HECI_FILE_CONNECTED != priv->state) {
+ spin_lock_bh(&dev->device_lock);
+ heci_remove_client_from_file_list(dev, priv->host_client_id);
+ DBG("failed to connect client_id=%d state=%d.\n",
+ priv->host_client_id, priv->state);
+ if (err)
+ DBG("failed connect err=%08x\n", err);
+ priv->state = HECI_FILE_DISCONNECTED;
+ spin_unlock_bh(&dev->device_lock);
+ return 0;
+ }
+ DBG("successfully connected client_id=%d.\n",
+ priv->host_client_id);
+ return 1;
+}
+
+/**
+ * host_init_wd - heci initialization wd.
+ *
+ * @dev: Device object for our driver
+ */
+static void host_init_wd(struct iamt_heci_device *dev)
+{
+ spin_lock_bh(&dev->device_lock);
+
+ heci_init_file_private(&dev->wd_file_ext, NULL);
+
+ /* look for WD client and connect to it */
+ dev->wd_file_ext.state = HECI_FILE_DISCONNECTED;
+ dev->wd_timeout = 0;
+
+ if (dev->asf_mode) {
+ memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
+ } else {
+ /* AMT mode */
+ dev->wd_timeout = AMT_WD_VALUE;
+ DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
+ memcpy(dev->wd_data, heci_start_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
+ &dev->wd_timeout, sizeof(__u16));
+ }
+
+ /* find ME WD client */
+ heci_find_me_client(dev, &dev->wd_file_ext,
+ &heci_wd_guid, HECI_WD_HOST_CLIENT_ID);
+ spin_unlock_bh(&dev->device_lock);
+
+ DBG("check wd_file_ext\n");
+ if (HECI_FILE_CONNECTING == dev->wd_file_ext.state) {
+ if (heci_connect_me_client(dev, &dev->wd_file_ext, 15) == 1) {
+ DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
+ if (dev->wd_timeout != 0)
+ dev->wd_due_counter = 1;
+ else
+ dev->wd_due_counter = 0;
+ DBG("successfully connected to WD client.\n");
+ }
+ } else
+ DBG("failed to find WD client.\n");
+
+
+ spin_lock_bh(&dev->device_lock);
+ dev->wd_timer.function = &heci_wd_timer;
+ dev->wd_timer.data = (unsigned long) dev;
+ spin_unlock_bh(&dev->device_lock);
+}
+
+
+/**
+ * host_init_iamthif - heci initialization iamthif client.
+ *
+ * @dev: Device object for our driver
+ *
+ */
+static void host_init_iamthif(struct iamt_heci_device *dev)
+{
+ __u8 i;
+
+ spin_lock_bh(&dev->device_lock);
+
+ heci_init_file_private(&dev->iamthif_file_ext, NULL);
+ dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTED;
+
+ /* find ME PTHI client */
+ i = heci_find_me_client(dev, &dev->iamthif_file_ext,
+ &heci_pthi_guid, HECI_IAMTHIF_HOST_CLIENT_ID);
+ if (dev->iamthif_file_ext.state != HECI_FILE_CONNECTING) {
+ DBG("failed to find iamthif client.\n");
+ spin_unlock_bh(&dev->device_lock);
+ return;
+ }
+
+ BUG_ON(dev->me_clients[i].props.max_msg_length != IAMTHIF_MTU);
+
+ spin_unlock_bh(&dev->device_lock);
+ if (heci_connect_me_client(dev, &dev->iamthif_file_ext, 15) == 1) {
+ DBG("connected to iamthif client.\n");
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
+ }
+}
+
+/**
+ * heci_alloc_file_private - allocates a private file structure and set it up.
+ * @file: the file structure
+ *
+ * returns The allocated file or NULL on failure
+ */
+struct heci_file_private *heci_alloc_file_private(struct file *file)
+{
+ struct heci_file_private *priv;
+
+ priv = kmalloc(sizeof(struct heci_file_private), GFP_KERNEL);
+ if (!priv)
+ return NULL;
+
+ heci_init_file_private(priv, file);
+
+ return priv;
+}
+
+
+
+/**
+ * heci_disconnect_host_client - send disconnect message to fw from host client.
+ *
+ * @dev: Device object for our driver
+ * @file_ext: private data of the file object
+ *
+ * returns 0 on success, <0 on failure.
+ */
+int heci_disconnect_host_client(struct iamt_heci_device *dev,
+ struct heci_file_private *file_ext)
+{
+ int rets, err;
+ long timeout = 15; /* 15 seconds */
+ struct heci_cb_private *priv_cb;
+
+ if ((!dev) || (!file_ext))
+ return -ENODEV;
+
+ if (file_ext->state != HECI_FILE_DISCONNECTING)
+ return 0;
+
+ priv_cb = kzalloc(sizeof(struct heci_cb_private), GFP_KERNEL);
+ if (!priv_cb)
+ return -ENOMEM;
+
+ INIT_LIST_HEAD(&priv_cb->cb_list);
+ priv_cb->file_private = file_ext;
+ priv_cb->major_file_operations = HECI_CLOSE;
+ spin_lock_bh(&dev->device_lock);
+ if (dev->host_buffer_is_empty) {
+ dev->host_buffer_is_empty = 0;
+ if (heci_disconnect(dev, file_ext)) {
+ list_add_tail(&priv_cb->cb_list,
+ &dev->ctrl_rd_list.heci_cb.cb_list);
+ } else {
+ spin_unlock_bh(&dev->device_lock);
+ rets = -ENODEV;
+ DBG("failed to call heci_disconnect.\n");
+ goto free;
+ }
+ } else {
+ DBG("add disconnect cb to control write list\n");
+ list_add_tail(&priv_cb->cb_list,
+ &dev->ctrl_wr_list.heci_cb.cb_list);
+ }
+ spin_unlock_bh(&dev->device_lock);
+
+ err = wait_event_timeout(dev->wait_recvd_msg,
+ (HECI_FILE_DISCONNECTED == file_ext->state),
+ timeout * HZ);
+ if (HECI_FILE_DISCONNECTED == file_ext->state) {
+ rets = 0;
+ DBG("successfully disconnected from fw client.\n");
+ } else {
+ rets = -ENODEV;
+ if (HECI_FILE_DISCONNECTED != file_ext->state)
+ DBG("wrong status client disconnect.\n");
+
+ if (err)
+ DBG("wait failed disconnect err=%08x\n", err);
+
+ DBG("failed to disconnect from fw client.\n");
+ }
+
+ spin_lock_bh(&dev->device_lock);
+ heci_flush_list(&dev->ctrl_rd_list, file_ext);
+ heci_flush_list(&dev->ctrl_wr_list, file_ext);
+ spin_unlock_bh(&dev->device_lock);
+free:
+ heci_free_cb_private(priv_cb);
+ return rets;
+}
+
+/**
+ * heci_remove_client_from_file_list -
+ * remove file private data from device file list
+ *
+ * @dev: Device object for our driver
+ * @host_client_id: host client id to be removed
+ */
+void heci_remove_client_from_file_list(struct iamt_heci_device *dev,
+ __u8 host_client_id)
+{
+ struct heci_file_private *file_pos = NULL;
+ struct heci_file_private *file_next = NULL;
+ list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
+ if (host_client_id == file_pos->host_client_id) {
+ DBG("remove host client = %d, ME client = %d\n",
+ file_pos->host_client_id,
+ file_pos->me_client_id);
+ list_del_init(&file_pos->link);
+ break;
+ }
+ }
+}
Added: heci/branches/heci-5.0_mainline_kernel/heci_interface.c
===================================================================
--- heci/branches/heci-5.0_mainline_kernel/heci_interface.c (rev 0)
+++ heci/branches/heci-5.0_mainline_kernel/heci_interface.c 2008-09-12 15:13:49 UTC (rev 213)
@@ -0,0 +1,485 @@
+/*
+ * Part of Intel(R) Manageability Engine Interface Linux driver
+ *
+ * Copyright (c) 2003 - 2008 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 "heci.h"
+#include "heci_interface.h"
+
+
+/**
+ * heci_set_csr_register - write H_CSR register to the heci device
+ *
+ * @dev: device object for our driver
+ */
+void heci_set_csr_register(struct iamt_heci_device *dev)
+{
+ write_heci_register(dev, H_CSR, dev->host_hw_state);
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+}
+
+/**
+ * heci_csr_enable_interrupts - enable heci device interrupts
+ *
+ * @dev: device object for our driver
+ */
+void heci_csr_enable_interrupts(struct iamt_heci_device *dev)
+{
+ dev->host_hw_state |= H_IE;
+ heci_set_csr_register(dev);
+}
+
+/**
+ * heci_csr_disable_interrupts - disable heci device interrupts
+ *
+ * @dev: device object for our driver
+ */
+void heci_csr_disable_interrupts(struct iamt_heci_device *dev)
+{
+ dev->host_hw_state &= ~H_IE;
+ heci_set_csr_register(dev);
+}
+
+
+/**
+ * _host_get_filled_slots - get number of device filled buffer slots
+ *
+ * @device: the device structure
+ *
+ * returns numer of filled slots
+ */
+static unsigned char _host_get_filled_slots(const struct iamt_heci_device *dev)
+{
+ char read_ptr, write_ptr;
+
+ read_ptr = (char) ((dev->host_hw_state & H_CBRP) >> 8);
+ write_ptr = (char) ((dev->host_hw_state & H_CBWP) >> 16);
+
+ return (unsigned char) (write_ptr - read_ptr);
+}
+
+/**
+ * host_buffer_is_empty - check if host buffer is empty.
+ *
+ * @dev: device object for our driver
+ *
+ * returns 1 if empty, 0 - otherwise.
+ */
+int host_buffer_is_empty(struct iamt_heci_device *dev)
+{
+ unsigned char filled_slots;
+
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+ filled_slots = _host_get_filled_slots(dev);
+
+ if (filled_slots > 0)
+ return 0;
+
+ return 1;
+}
+
+/**
+ * count_empty_write_slots - count write empty slots.
+ *
+ * @dev: device object for our driver
+ *
+ * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
+ */
+__s32 count_empty_write_slots(const struct iamt_heci_device *dev)
+{
+ unsigned char buffer_depth, filled_slots, empty_slots;
+
+ buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
+ filled_slots = _host_get_filled_slots(dev);
+ empty_slots = buffer_depth - filled_slots;
+
+ if (filled_slots > buffer_depth) {
+ /* overflow */
+ return -ESLOTS_OVERFLOW;
+ }
+
+ return (__s32) empty_slots;
+}
+
+/**
+ * heci_write_message - write a message to heci device.
+ *
+ * @dev: device object for our driver
+ * @heci_hdr: header of message
+ * @write_buffer: message buffer will be write
+ * @write_length: message size will be write
+ *
+ * returns 1 if success, 0 - otherwise.
+ */
+int heci_write_message(struct iamt_heci_device *dev,
+ struct heci_msg_hdr *header,
+ unsigned char *write_buffer,
+ unsigned long write_length)
+{
+ __u32 temp_msg = 0;
+ unsigned long bytes_written = 0;
+ unsigned char buffer_depth, filled_slots, empty_slots;
+ unsigned long dw_to_write;
+
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+ DBG("host_hw_state = 0x%08x.\n", dev->host_hw_state);
+ DBG("heci_write_message header=%08x.\n", *((__u32 *) header));
+ buffer_depth = (unsigned char) ((dev->...
[truncated message content] |
|
From: <mar...@us...> - 2008-09-12 15:08:03
|
Revision: 212
http://openamt.svn.sourceforge.net/openamt/?rev=212&view=rev
Author: marcin_obara
Date: 2008-09-12 15:08:12 +0000 (Fri, 12 Sep 2008)
Log Message:
-----------
variable size change
Modified Paths:
--------------
heci/branches/heci-5.0/src/heci_init.c
heci/trunk/src/heci_init.c
Modified: heci/branches/heci-5.0/src/heci_init.c
===================================================================
--- heci/branches/heci-5.0/src/heci_init.c 2008-07-25 20:36:18 UTC (rev 211)
+++ heci/branches/heci-5.0/src/heci_init.c 2008-09-12 15:08:12 UTC (rev 212)
@@ -601,7 +601,7 @@
struct heci_msg_hdr *heci_hdr;
struct hbm_host_enum_request *host_enum_req;
int err = 0;
- __u8 i, j;
+ int i, j;
heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
/* enumerate clients */
Modified: heci/trunk/src/heci_init.c
===================================================================
--- heci/trunk/src/heci_init.c 2008-07-25 20:36:18 UTC (rev 211)
+++ heci/trunk/src/heci_init.c 2008-09-12 15:08:12 UTC (rev 212)
@@ -601,7 +601,7 @@
struct heci_msg_hdr *heci_hdr;
struct hbm_host_enum_request *host_enum_req;
int err = 0;
- __u8 i, j;
+ int i, j;
heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
/* enumerate clients */
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-25 20:36:11
|
Revision: 211
http://openamt.svn.sourceforge.net/openamt/?rev=211&view=rev
Author: marcin_obara
Date: 2008-07-25 20:36:18 +0000 (Fri, 25 Jul 2008)
Log Message:
-----------
[experimental code] code cleanup, fix heci_initialize_list() parameters
Modified Paths:
--------------
heci/branches/testing/src/heci.h
heci/branches/testing/src/heci_init.c
Modified: heci/branches/testing/src/heci.h
===================================================================
--- heci/branches/testing/src/heci.h 2008-07-25 20:22:33 UTC (rev 210)
+++ heci/branches/testing/src/heci.h 2008-07-25 20:36:18 UTC (rev 211)
@@ -99,8 +99,7 @@
void put_heci_device(struct iamt_heci_device *dev);
#define get_heci_device(dev) atomic_inc(&dev->refcnt)
#define free_heci_device put_heci_device
-void heci_initialize_list(struct heci_io_list *list,
- struct iamt_heci_device *dev);
+void heci_initialize_list(struct heci_io_list *list);
int heci_flush_list(struct heci_io_list *list,
struct heci_connection *conn,
struct heci_cb_private *priv_cb);
Modified: heci/branches/testing/src/heci_init.c
===================================================================
--- heci/branches/testing/src/heci_init.c 2008-07-25 20:22:33 UTC (rev 210)
+++ heci/branches/testing/src/heci_init.c 2008-07-25 20:36:18 UTC (rev 211)
@@ -81,10 +81,8 @@
* heci_initialize_list - Sets up a queue list.
*
* @list: An instance of our list structure
- * @dev: Device object for our driver
*/
-void heci_initialize_list(struct heci_io_list *list,
- struct iamt_heci_device *dev)
+void heci_initialize_list(struct heci_io_list *list)
{
/* initialize our queue list */
INIT_LIST_HEAD(&list->cb_list);
@@ -274,14 +272,14 @@
INIT_LIST_HEAD(&dev->conn_list);
INIT_LIST_HEAD(&dev->file_list);
- heci_initialize_list(&dev->read_list, dev);
- heci_initialize_list(&dev->read_cmpl_list, dev);
- heci_initialize_list(&dev->ctrl_rd_list, dev);
- heci_initialize_list(&dev->ctrl_wr_list, dev);
- heci_initialize_list(&dev->write_list, dev);
- heci_initialize_list(&dev->cmpl_list, dev);
- heci_initialize_list(&dev->pthi_cmd_list, dev);
- heci_initialize_list(&dev->heci_cmd_list, dev);
+ heci_initialize_list(&dev->read_list);
+ heci_initialize_list(&dev->read_cmpl_list);
+ heci_initialize_list(&dev->ctrl_rd_list);
+ heci_initialize_list(&dev->ctrl_wr_list);
+ heci_initialize_list(&dev->write_list);
+ heci_initialize_list(&dev->cmpl_list);
+ heci_initialize_list(&dev->pthi_cmd_list);
+ heci_initialize_list(&dev->heci_cmd_list);
atomic_set(&dev->wd_stoped, 0);
atomic_set(&dev->wd_bypass, 0);
@@ -984,7 +982,7 @@
/**
* heci_find_me_client - search for ME client guid
- * sets client_id in heci_heci_connection if found
+ * sets client_id in heci_connection if found
*
* @dev: Device object for our driver
* @conn: connection data of the file object to set client_id in
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-25 20:22:24
|
Revision: 210
http://openamt.svn.sourceforge.net/openamt/?rev=210&view=rev
Author: marcin_obara
Date: 2008-07-25 20:22:33 +0000 (Fri, 25 Jul 2008)
Log Message:
-----------
sync heci/trunk with heci/branches/heci-5.0
Modified Paths:
--------------
heci/branches/heci-5.0/src/heci_main.c
heci/branches/heci-5.0/src/kcompat.h
heci/trunk/src/heci_version.h
Modified: heci/branches/heci-5.0/src/heci_main.c
===================================================================
--- heci/branches/heci-5.0/src/heci_main.c 2008-07-25 20:12:56 UTC (rev 209)
+++ heci/branches/heci-5.0/src/heci_main.c 2008-07-25 20:22:33 UTC (rev 210)
@@ -259,6 +259,9 @@
HECI_MINORS_COUNT);
}
+#ifndef HECI_DEVICE_CREATE
+#define HECI_DEVICE_CREATE device_create
+#endif
/**
* heci_sysfs_device_create - adds device entry to sysfs
*
@@ -284,7 +287,8 @@
goto err_out;
}
- tmphdev = device_create(class, NULL, heci_cdev.dev, HECI_DEV_NAME);
+ tmphdev = HECI_DEVICE_CREATE(class, NULL, heci_cdev.dev, NULL,
+ HECI_DEV_NAME);
if (IS_ERR(tmphdev)) {
err = PTR_ERR(tmphdev);
class_remove_file(class, &class_attr_version);
Modified: heci/branches/heci-5.0/src/kcompat.h
===================================================================
--- heci/branches/heci-5.0/src/kcompat.h 2008-07-25 20:12:56 UTC (rev 209)
+++ heci/branches/heci-5.0/src/kcompat.h 2008-07-25 20:22:33 UTC (rev 210)
@@ -49,10 +49,15 @@
#include <linux/interrupt.h>
#include <asm/io.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27))
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
-#define device_create(cls, parent, devt, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define device_create(cls, parent, devt, devpar, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define HECI_DEVICE_CREATE(cls, parent, devt, devpar, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
#define device_destroy class_device_destroy
+#else
+#define HECI_DEVICE_CREATE(cls, parent, devt, devpar, fmt...) device_create(cls, parent, devt, ## fmt)
#endif
+#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23))
Modified: heci/trunk/src/heci_version.h
===================================================================
--- heci/trunk/src/heci_version.h 2008-07-25 20:12:56 UTC (rev 209)
+++ heci/trunk/src/heci_version.h 2008-07-25 20:22:33 UTC (rev 210)
@@ -44,7 +44,7 @@
#define MAJOR_VERSION 5
#define MINOR_VERSION 0
#define QUICK_FIX_NUMBER 0
-#define VER_BUILD 30
+#define VER_BUILD 31
#define HECI_DRV_VER1 __stringify(MAJOR_VERSION) "." __stringify(MINOR_VERSION)
#define HECI_DRV_VER2 __stringify(QUICK_FIX_NUMBER) "." __stringify(VER_BUILD)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-25 20:12:48
|
Revision: 209
http://openamt.svn.sourceforge.net/openamt/?rev=209&view=rev
Author: marcin_obara
Date: 2008-07-25 20:12:56 +0000 (Fri, 25 Jul 2008)
Log Message:
-----------
[experimental code] connection close fix, more than 1 extra writes in bh_handler, cleanups
Modified Paths:
--------------
heci/branches/testing/src/heci_data_structures.h
heci/branches/testing/src/heci_init.c
heci/branches/testing/src/heci_interface.c
heci/branches/testing/src/heci_main.c
heci/branches/testing/src/interrupt.c
heci/branches/testing/src/io_heci.c
heci/branches/testing/src/kcompat.h
Modified: heci/branches/testing/src/heci_data_structures.h
===================================================================
--- heci/branches/testing/src/heci_data_structures.h 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/heci_data_structures.h 2008-07-25 20:12:56 UTC (rev 209)
@@ -143,7 +143,8 @@
#define DBG(format, arg...) do { \
if (heci_debug) { \
if (heci_dev) \
- dev_info(heci_dev, "%s: " format, __func__, ## arg); \
+ dev_info(heci_dev, " %s: " format, \
+ __func__, ## arg); \
else \
printk(KERN_INFO "heci: %s: " format, \
__func__, ## arg); \
@@ -171,6 +172,8 @@
/* 256 - 3 reserved */
#define HECI_MAX_OPEN_HANDLE_COUNT 253
+#define HECI_EXT_MSG_BUF_LEN 8
+
struct guid {
__u32 data1;
__u16 data2;
@@ -399,7 +402,7 @@
struct hbm_cmd cmd;
__u8 address;
__u8 status;
- __u8 reserved[1];
+ __u8 reserved;
struct heci_client_properties client_properties;
} __attribute__((packed));
@@ -421,7 +424,7 @@
struct hbm_cmd cmd;
__u8 me_addr;
__u8 host_addr;
- __u8 reserved[1];
+ __u8 reserved;
} __attribute__((packed));
struct hbm_flow_control {
@@ -522,7 +525,8 @@
__u32 extra_write_index; /* size of extra control messages */
__u32 wr_msg_buf[128]; /* msg write buffer used for control messages */
__u32 rd_msg_buf[128]; /* read buffer used for control messages */
- __u32 ext_msg_buf[8]; /* write buffer for extra control messages */
+ /* write buffer for extra control messages */
+ __u32 ext_msg_buf[HECI_EXT_MSG_BUF_LEN];
};
#endif /* _HECI_DATA_STRUCTURES_H_ */
Modified: heci/branches/testing/src/heci_init.c
===================================================================
--- heci/branches/testing/src/heci_init.c 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/heci_init.c 2008-07-25 20:12:56 UTC (rev 209)
@@ -71,8 +71,8 @@
static int host_start_message(struct iamt_heci_device *dev);
static int host_enum_clients_message(struct iamt_heci_device *dev);
static int allocate_me_clients_storage(struct iamt_heci_device *dev);
-static void host_init_wd(struct iamt_heci_device *dev);
-static void host_init_iamthif(struct iamt_heci_device *dev);
+static int host_init_wd(struct iamt_heci_device *dev);
+static int host_init_iamthif(struct iamt_heci_device *dev);
static int heci_wait_msg_timeout(struct iamt_heci_device *dev,
long timeout);
@@ -618,9 +618,13 @@
heci_check_asf_mode(dev);
/* heci initialization wd */
- host_init_wd(dev);
+ ret = host_init_wd(dev);
+ if (ret == -ERESTARTSYS)
+ return -EINTR;
/* heci initialization iamthif client */
- host_init_iamthif(dev);
+ ret = host_init_iamthif(dev);
+ if (ret == -ERESTARTSYS)
+ return -EINTR;
spin_lock_bh(&dev->device_lock);
if (dev->need_reset == 1) {
@@ -1051,16 +1055,16 @@
* @conn: connection data of the file object
* @timeout: connect timeout in seconds
*
- * returns 1 - if connected, 0 - if not
+ * returns 0 - if connected, !=0 - if not
*/
-static __u8 heci_connect_me_client(struct iamt_heci_device *dev,
+static int heci_connect_me_client(struct iamt_heci_device *dev,
struct heci_connection *conn,
long timeout)
{
int err = 0;
if ((dev == NULL) || (conn == NULL))
- return 0;
+ return -ENODEV;
if (!heci_connect(dev, conn)) {
DBG("failed to call heci_connect for client_id=%d.\n",
@@ -1069,7 +1073,7 @@
list_del_init(&conn->link);
spin_unlock_bh(&dev->conn_lock);
atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
- return 0;
+ return -ENODEV;
}
err = wait_event_interruptible_timeout(conn->cc_wait,
@@ -1082,10 +1086,12 @@
spin_unlock_bh(&dev->conn_lock);
DBG("failed to connect client_id=%d state=%d.\n",
conn->host_client_id, atomic_read(&conn->state));
- if (err)
+ atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
+ if (err) {
DBG("failed connect err=%08x\n", err);
- atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
- return 0;
+ return err;
+ }
+ return -ETIME;
}
DBG("successfully connected client_id=%d.\n",
conn->host_client_id);
@@ -1093,17 +1099,19 @@
conn->reading_state = HECI_IDLE;
conn->wr_state = HECI_IDLE;
spin_unlock_bh(&conn->file_lock);
- return 1;
+ return 0;
}
/**
* host_init_wd - heci watchdog initialization
*
* @dev: Device object for our driver
+ *
+ * returns 0 - if connected, !=0 - if not
*/
-static void host_init_wd(struct iamt_heci_device *dev)
+static int host_init_wd(struct iamt_heci_device *dev)
{
- __u8 cres = 0;
+ int ret = 0;
struct heci_connection *conn = &dev->wd_conn;
spin_lock_bh(&conn->file_lock);
@@ -1133,9 +1141,9 @@
DBG("check wd_conn\n");
if (atomic_read(&conn->state) == HECI_FILE_CONNECTING) {
spin_unlock_bh(&conn->file_lock);
- cres = heci_connect_me_client(dev, conn, HECI_CONNECT_TIMEOUT);
+ ret = heci_connect_me_client(dev, conn, HECI_CONNECT_TIMEOUT);
spin_lock_bh(&conn->file_lock);
- if (cres == 1) {
+ if (ret == 0) {
DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
if (dev->wd_timeout != 0)
dev->wd_due_counter = 1;
@@ -1149,16 +1157,20 @@
dev->wd_timer.function = &heci_wd_timer;
dev->wd_timer.data = (unsigned long) dev;
spin_unlock_bh(&conn->file_lock);
+ return ret;
}
/**
* host_init_iamthif - heci iamthif client initialization
*
* @dev: Device object for our driver
+ *
+ * returns 0 - if connected, !=0 - if not
*/
-static void host_init_iamthif(struct iamt_heci_device *dev)
+static int host_init_iamthif(struct iamt_heci_device *dev)
{
__u8 i;
+ int ret = 0;
struct heci_connection *conn = &dev->iamthif_conn;
spin_lock_bh(&conn->file_lock);
@@ -1173,13 +1185,15 @@
if (atomic_read(&conn->state) != HECI_FILE_CONNECTING) {
DBG("failed to find iamthif client.\n");
spin_unlock(&dev->mecl_lock);
- return;
+ return 0;
}
BUG_ON(dev->me_clients[i].props.max_msg_length != IAMTHIF_MTU);
spin_unlock(&dev->mecl_lock);
spin_unlock_bh(&conn->file_lock);
- if (heci_connect_me_client(dev, conn, HECI_CONNECT_TIMEOUT) == 1)
+ ret = heci_connect_me_client(dev, conn, HECI_CONNECT_TIMEOUT);
+ if (ret == 0)
DBG("connected to iamthif client.\n");
+ return ret;
}
Modified: heci/branches/testing/src/heci_interface.c
===================================================================
--- heci/branches/testing/src/heci_interface.c 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/heci_interface.c 2008-07-25 20:12:56 UTC (rev 209)
@@ -365,6 +365,11 @@
{
__u8 i;
+ if (props_res->status != 0) {
+ BUG();
+ return;
+ }
+
spin_lock(&dev->mecl_lock);
if (dev->num_heci_me_clients == 0) {
spin_unlock(&dev->mecl_lock);
@@ -665,7 +670,7 @@
atomic_inc(&dev->recvd_wrr);
wake_up_interruptible(&dev->wait_isr);
- err = wait_event_interruptible_timeout(conn->cc_wait,
+ err = wait_event_timeout(conn->cc_wait,
(atomic_read(&conn->state) == HECI_FILE_DISCONNECTED),
timeout * HZ);
if (atomic_read(&conn->state) == HECI_FILE_DISCONNECTED) {
Modified: heci/branches/testing/src/heci_main.c
===================================================================
--- heci/branches/testing/src/heci_main.c 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/heci_main.c 2008-07-25 20:12:56 UTC (rev 209)
@@ -233,6 +233,9 @@
HECI_MINORS_COUNT);
}
+#ifndef HECI_DEVICE_CREATE
+#define HECI_DEVICE_CREATE device_create
+#endif
#ifndef HECI_STRUCT_DEVICE_PTR
#define HECI_STRUCT_DEVICE_PTR(ptr) ptr
#endif
@@ -261,7 +264,8 @@
goto err_out;
}
- tmphdev = device_create(class, NULL, heci_cdev.dev, HECI_DEV_NAME);
+ tmphdev = HECI_DEVICE_CREATE(class, NULL, heci_cdev.dev, NULL,
+ HECI_DEV_NAME);
if (IS_ERR(tmphdev)) {
err = PTR_ERR(tmphdev);
class_remove_file(class, &class_attr_version);
@@ -703,6 +707,7 @@
struct heci_connection *conn = NULL;
struct iamt_heci_device *dev;
+ DBG("entry\n");
if (heci_device == NULL)
return -ENODEV;
@@ -779,6 +784,7 @@
struct heci_connection *conn = NULL;
struct iamt_heci_device *dev;
+ DBG("entry\n");
if (heci_device == NULL)
return -ENODEV;
@@ -859,6 +865,7 @@
struct heci_cb_private *priv_cb = NULL;
struct iamt_heci_device *dev;
+ DBG("entry\n");
if (heci_device == NULL)
return -ENODEV;
@@ -1021,6 +1028,7 @@
struct heci_cb_private *priv_cb = NULL;
struct iamt_heci_device *dev;
+ DBG("entry\n");
if (heci_device == NULL)
return -ENODEV;
@@ -1125,6 +1133,7 @@
list_add_tail(&priv_cb->cb_list, &dev->heci_cmd_list.cb_list);
spin_unlock_bh(&dev->cmdl_lock);
atomic_inc(&dev->recvd_wrr);
+ DBG("write go\n");
wake_up_interruptible(&dev->wait_isr);
return length;
Modified: heci/branches/testing/src/interrupt.c
===================================================================
--- heci/branches/testing/src/interrupt.c 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/interrupt.c 2008-07-25 20:12:56 UTC (rev 209)
@@ -79,7 +79,7 @@
if (slots == NULL) {
if (atomic_cmpxchg(&dev->host_buffer_is_empty, 1, 0) != 1)
return -EMESSAGE_NOT_COMPLETE;
- } else {
+ } else {
if (!heci_have_slots(slots,
sizeof(struct hbm_client_disconnect_request)))
return -EMESSAGE_NOT_COMPLETE;
@@ -240,7 +240,7 @@
spin_unlock(&conn->file_lock);
- DBG("HECI WRITE COMPLETE\n");
+ DBG("write complete\n");
if (priv_cb->major_file_operations == HECI_READ) {
spin_lock(&dev->crrdl_lock);
list_move_tail(&priv_cb->cb_list, &dev->ctrl_wr_list.cb_list);
@@ -298,10 +298,7 @@
{
int ret = 0;
- DBG("bh_ctrl pre\n");
spin_lock(&conn->file_lock);
- DBG("bh_ctrl in\n");
-
switch (priv_cb->major_file_operations) {
case HECI_CLOSE:
ret = _heci_bh_close(dev, slots, priv_cb, conn);
@@ -315,9 +312,7 @@
default:
BUG();
}
-
spin_unlock(&conn->file_lock);
- DBG("bh_ctrl out\n");
return ret;
}
@@ -442,7 +437,6 @@
if (oper == HECI_READ) {
spin_lock(&conn->file_lock);
conn->read_cb = NULL;
- DBG("STALL 0 READ CMPL\n");
conn->stall_timer = 0;
spin_unlock(&conn->file_lock);
}
@@ -539,6 +533,7 @@
dev->host_hw_state |= (H_IE | H_IG | H_RDY);
heci_set_csr_register(dev);
spin_unlock(&dev->hw_lock);
+ spin_unlock_bh(&dev->device_lock);
/* check if driver is initializing */
if (heci_state == HECI_INITIALIZING) {
@@ -547,6 +542,7 @@
return 3;
}
+ set_current_state(TASK_INTERRUPTIBLE);
/* establish communication with heci FW clients */
tsk = kthread_run(heci_task_initialize_clients,
dev, "heci_reinit");
@@ -657,22 +653,25 @@
*
* @dev: Device object for our driver
* @rs: connect response bus message
+ *
+ * returns 0 on success, <0 on failure.
*/
-static void heci_client_connect_response(struct iamt_heci_device *dev,
+static int heci_client_connect_response(struct iamt_heci_device *dev,
struct hbm_client_connect_response *rs)
{
struct heci_connection *conn;
struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
+ int ret = -ENODEV;
/* if WD or iamthif client treat specially */
if ((heci_is_client_connect_msg(&(dev->wd_conn), rs)) ||
(heci_is_client_connect_msg(&(dev->iamthif_conn), rs)))
- return;
+ return 0;
spin_lock(&dev->crrdl_lock);
if (list_empty(&dev->ctrl_rd_list.cb_list)) {
spin_unlock(&dev->crrdl_lock);
- return;
+ return ret;
}
list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
@@ -683,11 +682,13 @@
if (heci_is_client_connect_msg(conn, rs)) {
list_del_init(&priv_cb_pos->cb_list);
heci_free_io_cb(priv_cb_pos);
+ ret = 0;
break;
}
}
}
spin_unlock(&dev->crrdl_lock);
+ return ret;
}
/**
@@ -708,11 +709,11 @@
return;
}
+ DBG("list_for_each_entry_safe in ctrl_rd_list.\n");
list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
&dev->ctrl_rd_list.cb_list, cb_list) {
conn = priv_cb_pos->conn;
BUG_ON(conn == NULL);
- DBG("list_for_each_entry_safe in ctrl_rd_list.\n");
if (heci_same_conn_addr(conn, rs)) {
spin_lock(&conn->file_lock);
if (rs->status == 0) {
@@ -724,7 +725,7 @@
list_del_init(&priv_cb_pos->cb_list);
spin_unlock(&conn->file_lock);
if (waitqueue_active(&conn->cc_wait))
- wake_up_interruptible(&conn->cc_wait);
+ wake_up(&conn->cc_wait);
if (conn == &dev->wd_conn)
_heci_confirm_wd_stoped(dev);
heci_free_io_cb(priv_cb_pos);
@@ -754,12 +755,15 @@
*
* @file: connection data ot the file object.
* @flow: flow control.
+ *
+ * returns 0 on success, <0 on failure.
*/
-static void add_single_flow_creds(struct iamt_heci_device *dev,
+static int add_single_flow_creds(struct iamt_heci_device *dev,
struct hbm_flow_control *flow)
{
struct heci_me_client *client;
int i;
+ int ret = -ENODEV;
spin_lock(&dev->mecl_lock);
for (i = 0; i < dev->num_heci_me_clients; i++) {
@@ -770,9 +774,11 @@
DBG("recv flow ctrl msg ME %d (single).\n"
"flow control credentials=%d.\n",
flow->me_addr, client->flow_ctrl_creds);
+ ret = 0;
}
}
spin_unlock(&dev->mecl_lock);
+ return ret;
}
/**
@@ -780,27 +786,29 @@
*
* @dev: Device object for our driver
* @flow_control: flow control response bus message
+ *
+ * returns 0 on success, <0 on failure.
*/
-static void heci_client_flow_control_response(struct iamt_heci_device *dev,
+static int heci_client_flow_control_response(struct iamt_heci_device *dev,
struct hbm_flow_control *flow_control)
{
struct heci_connection *conn_pos = NULL;
struct heci_connection *conn_next = NULL;
+ int ret = -ENODEV;
if (flow_control->host_addr == 0) {
/* single receive buffer */
- add_single_flow_creds(dev, flow_control);
- return;
+ ret = add_single_flow_creds(dev, flow_control);
+ return ret;
}
/* normal connection */
spin_lock(&dev->conn_lock);
+ DBG("flow ctrl msg for host %d ME %d.\n",
+ flow_control->host_addr, flow_control->me_addr);
list_for_each_entry_safe(conn_pos, conn_next, &dev->conn_list, link) {
- DBG("list_for_each_entry_safe in conn_list "
- "conn of host client %d ME client %d.\n",
+ DBG("conn of host client %d ME client %d.\n",
conn_pos->host_client_id, conn_pos->me_client_id);
- DBG("flow ctrl msg for host %d ME %d.\n",
- flow_control->host_addr, flow_control->me_addr);
if (heci_same_flow_addr(conn_pos, flow_control)) {
DBG("recv ctrl msg for host %d ME %d.\n",
flow_control->host_addr, flow_control->me_addr);
@@ -809,10 +817,12 @@
DBG("flow control credentials=%d.\n",
conn_pos->flow_ctrl_creds);
spin_unlock(&conn_pos->file_lock);
+ ret = 0;
break;
}
}
spin_unlock(&dev->conn_lock);
+ return ret;
}
/**
@@ -831,6 +841,93 @@
}
/**
+ * heci_stop_req - prepare stop request in extra message buffer
+ *
+ * @dev: Device object for our driver
+ */
+static void heci_stop_req(struct iamt_heci_device *dev)
+{
+ struct heci_msg_hdr *heci_hdr;
+ struct hbm_host_stop_request *h_stop_req;
+
+ heci_hdr = (struct heci_msg_hdr *)
+ &dev->ext_msg_buf[dev->extra_write_index];
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_host_stop_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ h_stop_req = (struct hbm_host_stop_request *)
+ &dev->ext_msg_buf[dev->extra_write_index + 1];
+ memset(h_stop_req, 0, sizeof(struct hbm_host_stop_request));
+ h_stop_req->cmd.cmd = HOST_STOP_REQ_CMD;
+ h_stop_req->reason = DRIVER_STOP_REQUEST;
+ dev->extra_write_index += 2;
+}
+
+/**
+ * heci_disconnect_req - prepare disconnect request in extra message buffer
+ *
+ * @dev: Device object for our driver
+ * @host_client_id: host client id for request
+ * @host_client_id: me client id for request
+ */
+static void heci_disconnect_req(struct iamt_heci_device *dev,
+ __u8 host_client_id, __u8 me_client_id)
+{
+ struct heci_msg_hdr *heci_hdr;
+ struct hbm_client_disconnect_request *heci_cli_disconnect;
+
+ heci_hdr = (struct heci_msg_hdr *)
+ &dev->ext_msg_buf[dev->extra_write_index];
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_client_disconnect_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ heci_cli_disconnect = (struct hbm_client_disconnect_request *)
+ &dev->ext_msg_buf[dev->extra_write_index + 1];
+ memset(heci_cli_disconnect, 0,
+ sizeof(struct hbm_client_disconnect_request));
+ heci_cli_disconnect->host_addr = host_client_id;
+ heci_cli_disconnect->me_addr = me_client_id;
+ heci_cli_disconnect->cmd.cmd = CLIENT_DISCONNECT_REQ_CMD;
+ dev->extra_write_index += 2;
+}
+
+/**
+ * heci_disconnect_resp - prepare disconnect response in extra message buffer
+ *
+ * @dev: Device object for our driver
+ * @host_client_id: host client id for response
+ * @host_client_id: me client id for response
+ */
+static void heci_disconnect_resp(struct iamt_heci_device *dev,
+ __u8 host_client_id, __u8 me_client_id)
+{
+ struct heci_msg_hdr *heci_hdr;
+ struct hbm_client_connect_response *disconnect_res;
+
+ heci_hdr = (struct heci_msg_hdr *)
+ &dev->ext_msg_buf[dev->extra_write_index];
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_client_connect_response);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
+
+ disconnect_res = (struct hbm_client_connect_response *)
+ &dev->ext_msg_buf[dev->extra_write_index + 1];
+ disconnect_res->host_addr = host_client_id;
+ disconnect_res->me_addr = me_client_id;
+ *(__u8 *) (&disconnect_res->cmd) = CLIENT_DISCONNECT_RES_CMD;
+ disconnect_res->status = 0;
+ dev->extra_write_index += 2;
+}
+
+/**
* heci_client_disconnect_request - disconnect request bh routine
*
* @dev: Device object for our driver.
@@ -839,8 +936,6 @@
static void heci_client_disconnect_request(struct iamt_heci_device *dev,
struct hbm_client_disconnect_request *disconnect_req)
{
- struct heci_msg_hdr *heci_hdr;
- struct hbm_client_connect_response *disconnect_res;
struct heci_connection *conn_pos = NULL;
struct heci_connection *conn_next = NULL;
@@ -860,24 +955,9 @@
spin_unlock(&conn_pos->file_lock);
/* prepare disconnect response */
- heci_hdr =
- (struct heci_msg_hdr *) &dev->ext_msg_buf[0];
- heci_hdr->host_addr = 0;
- heci_hdr->me_addr = 0;
- heci_hdr->length =
- sizeof(struct hbm_client_connect_response);
- heci_hdr->msg_complete = 1;
- heci_hdr->reserved = 0;
-
- disconnect_res =
- (struct hbm_client_connect_response *)
- &dev->ext_msg_buf[1];
- disconnect_res->host_addr = conn_pos->host_client_id;
- disconnect_res->me_addr = conn_pos->me_client_id;
- *(__u8 *) (&disconnect_res->cmd) =
- CLIENT_DISCONNECT_RES_CMD;
- disconnect_res->status = 0;
- dev->extra_write_index = 2;
+ heci_disconnect_resp(dev,
+ conn_pos->host_client_id,
+ conn_pos->me_client_id);
break;
}
}
@@ -885,6 +965,16 @@
}
+static void heci_set_version(struct iamt_heci_device *dev,
+ struct hbm_host_version_response *version_res)
+{
+ if (version_res->host_version_supported) {
+ dev->version.major_version = HBM_MAJOR_VERSION;
+ dev->version.minor_version = HBM_MINOR_VERSION;
+ } else
+ dev->version = version_res->me_max_version;
+}
+
/**
* heci_bh_read_bus_message - bottom half read routine after ISR to
* handle the read bus message cmd processing.
@@ -896,31 +986,20 @@
struct heci_msg_hdr *heci_hdr)
{
struct heci_bus_message *heci_msg;
- struct hbm_host_version_response *version_res;
struct hbm_client_connect_response *connect_res;
- struct hbm_client_connect_response *disconnect_res;
struct hbm_flow_control *flow_control;
- struct hbm_props_response *props_res;
- struct hbm_host_enum_response *enum_res;
- struct hbm_client_disconnect_request *disconnect_req;
- struct hbm_host_stop_request *h_stop_req;
- unsigned char *buffer;
+ int ret = 0;
+ unsigned char *buffer = (unsigned char *) dev->rd_msg_buf;
- /* read the message to our buffer */
- buffer = (unsigned char *) dev->rd_msg_buf;
+ /* read the message to our buffer */
BUG_ON(heci_hdr->length >= sizeof(dev->rd_msg_buf));
heci_read_slots(dev, buffer, heci_hdr->length);
heci_msg = (struct heci_bus_message *) buffer;
switch (*(__u8 *) heci_msg) {
case HOST_START_RES_CMD:
- version_res = (struct hbm_host_version_response *) heci_msg;
- if (version_res->host_version_supported) {
- dev->version.major_version = HBM_MAJOR_VERSION;
- dev->version.minor_version = HBM_MINOR_VERSION;
- } else {
- dev->version = version_res->me_max_version;
- }
+ heci_set_version(dev,
+ (struct hbm_host_version_response *) heci_msg);
atomic_set(&dev->recvd_msg, HECI_MSGINIT_START);
DBG("host start response message received.\n");
break;
@@ -928,37 +1007,41 @@
case CLIENT_CONNECT_RES_CMD:
connect_res =
(struct hbm_client_connect_response *) heci_msg;
- heci_client_connect_response(dev, connect_res);
+ ret = heci_client_connect_response(dev, connect_res);
DBG("client connect response message received.\n");
+ if (ret != 0)
+ heci_disconnect_req(dev,
+ connect_res->host_addr,
+ connect_res->me_addr);
break;
case CLIENT_DISCONNECT_RES_CMD:
- disconnect_res =
- (struct hbm_client_connect_response *) heci_msg;
- heci_client_disconnect_response(dev, disconnect_res);
+ heci_client_disconnect_response(dev,
+ (struct hbm_client_connect_response *) heci_msg);
DBG("client disconnect response message received.\n");
break;
case HECI_FLOW_CONTROL_CMD:
flow_control = (struct hbm_flow_control *) heci_msg;
- heci_client_flow_control_response(dev, flow_control);
+ ret = heci_client_flow_control_response(dev, flow_control);
DBG("client flow control response message received.\n");
+ if (ret != 0)
+ heci_disconnect_req(dev,
+ flow_control->host_addr,
+ flow_control->me_addr);
break;
case HOST_CLIENT_PROPERTEIS_RES_CMD:
- props_res = (struct hbm_props_response *) heci_msg;
- if (props_res->status != 0) {
- BUG();
- break;
- }
- heci_client_set_props(dev, props_res);
+ heci_client_set_props(dev,
+ (struct hbm_props_response *) heci_msg);
atomic_set(&dev->recvd_msg, HECI_MSGINIT_CLIENT_PROPS);
break;
case HOST_ENUM_RES_CMD:
- enum_res = (struct hbm_host_enum_response *) heci_msg;
spin_lock(&dev->mecl_lock);
- memcpy(dev->heci_me_clients, enum_res->valid_addresses, 32);
+ memcpy(dev->heci_me_clients,
+ ((struct hbm_host_enum_response *)
+ heci_msg)->valid_addresses, 32);
spin_unlock(&dev->mecl_lock);
atomic_set(&dev->recvd_msg, HECI_MSGINIT_ENUM_CLIENTS);
break;
@@ -970,26 +1053,12 @@
break;
case CLIENT_DISCONNECT_REQ_CMD:
- /* search for client */
- disconnect_req =
- (struct hbm_client_disconnect_request *) heci_msg;
- heci_client_disconnect_request(dev, disconnect_req);
+ heci_client_disconnect_request(dev,
+ (struct hbm_client_disconnect_request *) heci_msg);
break;
case ME_STOP_REQ_CMD:
- /* prepare stop request */
- heci_hdr = (struct heci_msg_hdr *) &dev->ext_msg_buf[0];
- heci_hdr->host_addr = 0;
- heci_hdr->me_addr = 0;
- heci_hdr->length = sizeof(struct hbm_host_stop_request);
- heci_hdr->msg_complete = 1;
- heci_hdr->reserved = 0;
- h_stop_req =
- (struct hbm_host_stop_request *) &dev->ext_msg_buf[1];
- memset(h_stop_req, 0, sizeof(struct hbm_host_stop_request));
- h_stop_req->cmd.cmd = HOST_STOP_REQ_CMD;
- h_stop_req->reason = DRIVER_STOP_REQUEST;
- dev->extra_write_index = 2;
+ heci_stop_req(dev);
break;
default:
@@ -1072,7 +1141,6 @@
priv_cb->read_time = get_seconds();
conn->status = 0;
conn->stall_timer = 0;
- DBG("STALL 0 READ CMPL1\n");
if (conn->canceled == 0)
conn->reading_state = HECI_READ_COMPLETE;
@@ -1305,30 +1373,30 @@
int ret;
host_buffer_is_empty(dev, slots);
- if (*slots < 8) {
- DBG("host buffer is full.\n");
- return 0;
- }
-
- DBG("bh write.\n");
- if (dev->extra_write_index != 0) {
+ while ((dev->extra_write_index > 0) && (*slots >= 2)) {
DBG("extra_write_index =%d.\n", dev->extra_write_index);
heci_write_message(dev,
(struct heci_msg_hdr *) &dev->ext_msg_buf[0],
(unsigned char *) &dev->ext_msg_buf[1],
- (dev->extra_write_index - 1) * sizeof(__u32));
- *slots -= dev->extra_write_index;
- dev->extra_write_index = 0;
+ sizeof(__u32));
+ *slots -= 2;
+ dev->extra_write_index -= 2;
+ if (dev->extra_write_index > 0)
+ memmove(&dev->ext_msg_buf[0], &dev->ext_msg_buf[2],
+ dev->extra_write_index);
}
+ if (*slots < 8) {
+ DBG("host buffer is full.\n");
+ return 0;
+ }
+
if (atomic_read(&dev->heci_state) == HECI_ENABLED) {
spin_lock(&dev->wd_conn.file_lock);
if (dev->wd_pending == 1)
heci_wd(dev, slots);
if ((dev->wd_stop == 1) && (dev->wd_pending == 0))
dev->wd_stop = 2;
- DBG("bh WD WDPEND:%d STOP:%d.\n",
- dev->wd_pending, dev->wd_stop);
spin_unlock(&dev->wd_conn.file_lock);
}
@@ -1386,8 +1454,9 @@
* processing.
*
* @dev: Device object for our driver
+ * @have_is: call reason - 1 - isr, 2 - user
*/
-static void heci_bh_handler(struct iamt_heci_device *dev)
+static void heci_bh_handler(struct iamt_heci_device *dev, int have_is)
{
__s32 slots;
int rets;
@@ -1400,9 +1469,12 @@
return;
spin_lock_bh(&dev->device_lock);
+ if (have_is != 1)
+ goto write;
rets = heci_bh_check_ready(dev);
if (rets != 0) {
- spin_unlock_bh(&dev->device_lock);
+ if (rets < 3)
+ spin_unlock_bh(&dev->device_lock);
return;
}
@@ -1410,7 +1482,8 @@
slots = count_full_read_slots(dev);
DBG("slots =%08x extra_write_index =%08x.\n",
slots, dev->extra_write_index);
- while ((slots > 0) && (!dev->extra_write_index)) {
+ while ((slots > 0) &&
+ (dev->extra_write_index < HECI_EXT_MSG_BUF_LEN)) {
DBG("slots =%08x extra_write_index =%08x.\n", slots,
dev->extra_write_index);
DBG("call heci_bh_read_handler.\n");
@@ -1418,6 +1491,7 @@
if (rets != 0)
goto end;
}
+write:
rets = heci_bh_write_handler(&dev->cmpl_list, dev, &slots);
end:
DBG("end of bottom half function.\n");
@@ -1426,7 +1500,6 @@
if ((atomic_read(&dev->recvd_msg) != HECI_MSGINIT_NONE)
&& waitqueue_active(&dev->wait_recvd_msg)) {
DBG("received waiting bus message\n");
- DBG("wake up dev->wait_recvd_msg\n");
wake_up_interruptible(&dev->wait_recvd_msg);
}
@@ -1481,7 +1554,7 @@
spin_lock(&dev->iamthif_conn.file_lock);
if (dev->iamthif_conn.stall_timer != 0) {
- DBG("STALL %d WD\n", dev->iamthif_conn.stall_timer);
+ DBG("stall %d WD\n", dev->iamthif_conn.stall_timer);
if (--dev->iamthif_conn.stall_timer == 0) {
spin_unlock(&dev->iamthif_conn.file_lock);
DBG("reseting because of hang to PTHI.\n");
@@ -1534,7 +1607,7 @@
have_is = 0;
if (atomic_read(&dev->recvd_isr) > 0) {
- atomic_dec(&dev->recvd_isr);
+ atomic_set(&dev->recvd_isr, 0);
spin_lock_bh(&dev->hw_lock);
dev->host_hw_state = read_heci_register(dev, H_CSR);
@@ -1546,9 +1619,9 @@
spin_unlock_bh(&dev->hw_lock);
} else if (atomic_read(&dev->recvd_wrr) > 0)
- have_is = 1;
+ have_is = 2;
if (have_is != 0)
- heci_bh_handler(dev);
+ heci_bh_handler(dev, have_is);
}
tend:
@@ -1579,7 +1652,6 @@
return IRQ_NONE;
DBG("ISR\n");
-
atomic_inc(&dev->recvd_isr);
wake_up_interruptible(&dev->wait_isr);
Modified: heci/branches/testing/src/io_heci.c
===================================================================
--- heci/branches/testing/src/io_heci.c 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/io_heci.c 2008-07-25 20:12:56 UTC (rev 209)
@@ -120,6 +120,7 @@
__u8 i;
int err = 0;
+ DBG("entry\n");
if ((dev == NULL) || (file_ext == NULL))
return -ENODEV;
@@ -257,6 +258,8 @@
" connect message fw response message.\n");
}
rets = -EFAULT;
+ if (err == -ERESTARTSYS)
+ rets = -EINTR;
if (priv_cb != NULL) {
err = heci_flush_ctrl_lists(dev, conn, priv_cb);
if (err != 0)
@@ -276,11 +279,13 @@
if (put_user(sizeof(struct heci_client), &u_msg->size))
return -EFAULT;
+ DBG("return %d\n", rets);
return rets;
free:
DBG("free connect cb memory.");
heci_free_io_cb(priv_cb);
+ DBG("return %d\n", rets);
return rets;
}
@@ -298,6 +303,7 @@
int rets = 0;
struct heci_message_data req_msg; /* in kernel on the stack */
+ DBG("entry\n");
if (k_msg.size != HECI_WATCHDOG_DATA_SIZE) {
DBG("user buffer has invalid size.\n");
return -EMSGSIZE;
@@ -348,6 +354,7 @@
spin_unlock_bh(&dev->wd_conn.file_lock);
end:
kfree(req_msg.data);
+ DBG("return %d\n", rets);
return rets;
}
@@ -365,6 +372,7 @@
{
__u8 flag = 0;
+ DBG("entry\n");
if (k_msg.size < 1) {
DBG("user buffer less than HECI_WATCHDOG_DATA_SIZE.\n");
return -EMSGSIZE;
@@ -755,29 +763,3 @@
return 0;
}
-/*
-int heci_cmd(struct iamt_heci_device *dev)
-{
- struct heci_io_list tmpcmpll;
- struct heci_cb_private *cb_pos = NULL, *cb_next = NULL;
- int ret = 0;
-
- heci_initialize_list(&tmpcmpll, dev);
-
- if (atomic_cmpxchg(&dev->host_buffer_is_empty, 1, 0) != 1)
- return -EMESSAGE_NOT_COMPLETE;
-
- ret = _heci_bh_cmd(dev, NULL, priv_cb, conn, &tmpcmpll);
-
- if (!list_empty(&tmpcmpll.cb_list)) {
- list_for_each_entry_safe(cb_pos, cb_next, &tmpcmpll.cb_list,
- cb_list) {
- list_del_init(&cb_pos->cb_list);
- heci_free_io_cb(cb_pos);
- cb_pos = NULL;
- }
- }
-
- return ret;
-}
-*/
Modified: heci/branches/testing/src/kcompat.h
===================================================================
--- heci/branches/testing/src/kcompat.h 2008-07-23 18:26:41 UTC (rev 208)
+++ heci/branches/testing/src/kcompat.h 2008-07-25 20:12:56 UTC (rev 209)
@@ -49,11 +49,16 @@
#include <linux/interrupt.h>
#include <asm/io.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27))
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
-#define device_create(cls, parent, devt, fmt...) (void *)class_device_create(cls, parent, devt, NULL, ## fmt)
+#define device_create(cls, parent, devt, devpar, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define HECI_DEVICE_CREATE(cls, parent, devt, devpar, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
#define device_destroy class_device_destroy
#define HECI_STRUCT_DEVICE_PTR(ptr) NULL
+#else
+#define HECI_DEVICE_CREATE(cls, parent, devt, devpar, fmt...) device_create(cls, parent, devt, ## fmt)
#endif
+#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23))
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-23 18:26:33
|
Revision: 208
http://openamt.svn.sourceforge.net/openamt/?rev=208&view=rev
Author: marcin_obara
Date: 2008-07-23 18:26:41 +0000 (Wed, 23 Jul 2008)
Log Message:
-----------
kernel 2.6.27 API change by Greg Kroah-Hartman (21 Jul 2008) - one more argument for device_create() since 2.6.27
Modified Paths:
--------------
heci/trunk/src/heci_main.c
heci/trunk/src/kcompat.h
Modified: heci/trunk/src/heci_main.c
===================================================================
--- heci/trunk/src/heci_main.c 2008-07-22 17:20:27 UTC (rev 207)
+++ heci/trunk/src/heci_main.c 2008-07-23 18:26:41 UTC (rev 208)
@@ -259,6 +259,9 @@
HECI_MINORS_COUNT);
}
+#ifndef HECI_DEVICE_CREATE
+#define HECI_DEVICE_CREATE device_create
+#endif
/**
* heci_sysfs_device_create - adds device entry to sysfs
*
@@ -284,7 +287,8 @@
goto err_out;
}
- tmphdev = device_create(class, NULL, heci_cdev.dev, HECI_DEV_NAME);
+ tmphdev = HECI_DEVICE_CREATE(class, NULL, heci_cdev.dev, NULL,
+ HECI_DEV_NAME);
if (IS_ERR(tmphdev)) {
err = PTR_ERR(tmphdev);
class_remove_file(class, &class_attr_version);
Modified: heci/trunk/src/kcompat.h
===================================================================
--- heci/trunk/src/kcompat.h 2008-07-22 17:20:27 UTC (rev 207)
+++ heci/trunk/src/kcompat.h 2008-07-23 18:26:41 UTC (rev 208)
@@ -49,10 +49,15 @@
#include <linux/interrupt.h>
#include <asm/io.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27))
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
-#define device_create(cls, parent, devt, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define device_create(cls, parent, devt, devpar, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define HECI_DEVICE_CREATE(cls, parent, devt, devpar, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
#define device_destroy class_device_destroy
+#else
+#define HECI_DEVICE_CREATE(cls, parent, devt, devpar, fmt...) device_create(cls, parent, devt, ## fmt)
#endif
+#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23))
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-22 17:20:18
|
Revision: 207
http://openamt.svn.sourceforge.net/openamt/?rev=207&view=rev
Author: marcin_obara
Date: 2008-07-22 17:20:27 +0000 (Tue, 22 Jul 2008)
Log Message:
-----------
experimental code with changed driver architecture
Modified Paths:
--------------
heci/branches/testing/README
heci/branches/testing/src/Makefile
heci/branches/testing/src/heci.h
heci/branches/testing/src/heci_data_structures.h
heci/branches/testing/src/heci_init.c
heci/branches/testing/src/heci_interface.c
heci/branches/testing/src/heci_interface.h
heci/branches/testing/src/heci_main.c
heci/branches/testing/src/heci_version.h
heci/branches/testing/src/interrupt.c
heci/branches/testing/src/io_heci.c
heci/branches/testing/src/kcompat.h
Modified: heci/branches/testing/README
===================================================================
--- heci/branches/testing/README 2008-07-22 17:13:05 UTC (rev 206)
+++ heci/branches/testing/README 2008-07-22 17:20:27 UTC (rev 207)
@@ -8,6 +8,11 @@
//
//----------------------------------------------------------------------------
+ THIS IS EXPERIMENTAL, UNTESTED AND POSSIBLY UNSTABLE
+ version of MEI driver
+ USE OFFICIAL ONE INSTEAD OF THIS
+
+
Intel(R) Manageability Engine Interface Driver
===========================
Modified: heci/branches/testing/src/Makefile
===================================================================
--- heci/branches/testing/src/Makefile 2008-07-22 17:13:05 UTC (rev 206)
+++ heci/branches/testing/src/Makefile 2008-07-22 17:20:27 UTC (rev 207)
@@ -40,6 +40,15 @@
#
################################################################################
+$(warning **************************************************************)
+$(warning *** ***)
+$(warning *** THIS IS EXPERIMENTAL, UNTESTED AND POSSIBLY UNSTABLE ***)
+$(warning *** version of MEI driver ***)
+$(warning *** ***)
+$(warning *** USE OFFICIAL ONE INSTEAD OF THIS ***)
+$(warning *** ***)
+$(warning **************************************************************)
+
###########################################################################
# Driver files
@@ -223,6 +232,8 @@
endif
endif
+else
+ $(error Linux kernel 2.6 (>=2.6.16) required)
endif # ifeq ($(K_VERSION),2.6)
install: default
Modified: heci/branches/testing/src/heci.h
===================================================================
--- heci/branches/testing/src/heci.h 2008-07-22 17:13:05 UTC (rev 206)
+++ heci/branches/testing/src/heci.h 2008-07-22 17:20:27 UTC (rev 207)
@@ -41,17 +41,8 @@
#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"
+#include "heci_interface.h"
extern const struct guid heci_pthi_guid;
extern const struct guid heci_wd_guid;
@@ -91,6 +82,7 @@
#define HECI_DEV_ID_ICH10_2 0x2E14 /* Eaglelake */
#define HECI_DEV_ID_ICH10_3 0x2E24 /* Eaglelake */
#define HECI_DEV_ID_ICH10_4 0x2E34 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_5 0x2E44 /* Eaglelake */
/*
* heci init function prototypes
@@ -100,19 +92,19 @@
int heci_hw_init(struct iamt_heci_device *dev);
int heci_task_initialize_clients(void *data);
int heci_initialize_clients(struct iamt_heci_device *dev);
-struct heci_file_private *heci_alloc_file_private(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 heci_file_priv *heci_alloc_file_priv(struct file *file);
+struct heci_connection *heci_alloc_heci_connection(struct file *file);
+void heci_put_heci_connection(struct heci_connection *conn);
+#define heci_free_heci_connection heci_put_heci_connection
+void put_heci_device(struct iamt_heci_device *dev);
+#define get_heci_device(dev) atomic_inc(&dev->refcnt)
+#define free_heci_device put_heci_device
+void heci_initialize_list(struct heci_io_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);
+int heci_flush_list(struct heci_io_list *list,
+ struct heci_connection *conn,
+ struct heci_cb_private *priv_cb);
-void heci_remove_client_from_file_list(struct iamt_heci_device *dev,
- __u8 host_client_id);
-
/*
* interrupt function prototype
*/
@@ -120,54 +112,69 @@
void heci_wd_timer(unsigned long data);
+int heci_isr_thread(void *data);
+
/*
* input output function prototype
*/
-int heci_ioctl_get_version(struct iamt_heci_device *dev, int if_num,
+int heci_ioctl_get_version(struct iamt_heci_device *dev,
struct heci_message_data *u_msg,
- struct heci_message_data k_msg,
- struct heci_file_private *file_ext);
+ struct heci_message_data k_msg);
-int heci_ioctl_connect_client(struct iamt_heci_device *dev, int if_num,
+int heci_ioctl_connect_client(struct iamt_heci_device *dev,
struct heci_message_data *u_msg,
struct heci_message_data k_msg,
- struct file *file);
+ struct heci_file_priv *file_ext);
-int heci_ioctl_wd(struct iamt_heci_device *dev, int if_num,
- struct heci_message_data k_msg,
- struct heci_file_private *file_ext);
+int heci_ioctl_wd(struct iamt_heci_device *dev,
+ struct heci_message_data k_msg);
-int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
- struct heci_message_data k_msg,
- struct heci_file_private *file_ext);
+int heci_ioctl_bypass_wd(struct iamt_heci_device *dev,
+ struct heci_message_data k_msg);
-int heci_start_read(struct iamt_heci_device *dev, int if_num,
- struct heci_file_private *file_ext);
+int heci_have_slots(__s32 *slots, __u32 datalen);
-int pthi_write(struct iamt_heci_device *dev,
- struct heci_cb_private *priv_cb);
+int heci_start_read_flow(struct iamt_heci_device *dev,
+ struct heci_connection *conn,
+ struct heci_cb_private *priv_cb,
+ __s32 *slots);
-int pthi_read(struct iamt_heci_device *dev, int if_num, struct file *file,
- char *ubuf, size_t length, loff_t *offset);
+__u32 heci_len_to_slots(__u32 datalen);
-struct heci_cb_private *find_pthi_read_list_entry(
- struct iamt_heci_device *dev,
- struct file *file);
+int heci_write_buf(struct iamt_heci_device *dev,
+ struct heci_cb_private *priv_cb,
+ struct heci_connection *conn,
+ __u32 wrspace, __u32 maxwrspace, __s32 *slots);
-void run_next_iamthif_cmd(struct iamt_heci_device *dev);
+int heci_read_raw(struct iamt_heci_device *dev,
+ struct heci_file_priv *file_ext,
+ struct heci_cb_private *priv_cb,
+ char *ubuf, size_t length, loff_t *offset,
+ unsigned long timeout, int *needfree);
-void heci_free_cb_private(struct heci_cb_private *priv_cb);
+struct heci_cb_private *heci_find_list_conn_entry(
+ struct heci_io_list *list,
+ struct heci_connection *conn);
+struct heci_cb_private *heci_find_list_file_entry(
+ struct heci_io_list *list,
+ struct file *file);
+
+struct heci_cb_private *heci_find_read_entry(struct iamt_heci_device *dev,
+ struct file *file, __u8 *rcomplete);
+
+int heci_wd(struct iamt_heci_device *dev, __s32 *slots);
+
/**
- * heci_fe_same_id - tell if file private data have same id
+ * heci_fe_same_id - tell if file connection data have same id
*
- * @fe1: private data of 1. file object
- * @fe2: private data of 2. file object
+ * @fe1: connection data of 1. file object
+ * @fe2: connection data of 2. file object
*
* returns !=0 - if ids are the same, 0 - if differ.
*/
-static inline int heci_fe_same_id(const struct heci_file_private *fe1,
- const struct heci_file_private *fe2)
+static inline int heci_fe_same_id(const struct heci_connection *fe1,
+ const struct heci_connection *fe2)
{
return ((fe1->host_client_id == fe2->host_client_id)
&& (fe1->me_client_id == fe2->me_client_id));
Modified: heci/branches/testing/src/heci_data_structures.h
===================================================================
--- heci/branches/testing/src/heci_data_structures.h 2008-07-22 17:13:05 UTC (rev 206)
+++ heci/branches/testing/src/heci_data_structures.h 2008-07-22 17:20:27 UTC (rev 207)
@@ -41,32 +41,36 @@
#ifndef _HECI_DATA_STRUCTURES_H_
#define _HECI_DATA_STRUCTURES_H_
-#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.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 <linux/errno.h>
+#include <linux/ioctl.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/kthread.h>
+#include <linux/poll.h>
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/moduleparam.h>
+#include "kcompat.h"
/*
* error code definition
*/
#define ESLOTS_OVERFLOW 1
#define ECORRUPTED_MESSAGE_HEADER 1000
-#define ECOMPLETE_MESSAGE 1001
+#define EMESSAGE_NOT_COMPLETE 1001
+#define EMESSAGE_WILL_SPLIT 1002
#define HECI_FC_MESSAGE_RESERVED_LENGTH 5
/*
- * Number of queue lists used by this driver
- */
-#define HECI_IO_LISTS_NUMBER 7
-
-/*
* Maximum transmission unit (MTU) of heci messages
*/
#define IAMTHIF_MTU 4160
@@ -129,16 +133,21 @@
#define HECI_MINORS_COUNT 1
#define HECI_MINOR_NUMBER 1
-#define HECI_MAX_OPEN_HANDLE_COUNT 253
/*
* debug kernel print macro define
*/
extern int heci_debug;
+extern struct device *heci_dev;
#define DBG(format, arg...) do { \
- if (heci_debug) \
- printk(KERN_INFO "heci: %s: " format, __func__, ## arg); \
+ if (heci_debug) { \
+ if (heci_dev) \
+ dev_info(heci_dev, "%s: " format, __func__, ## arg); \
+ else \
+ printk(KERN_INFO "heci: %s: " format, \
+ __func__, ## arg); \
+ } \
} while (0)
@@ -153,10 +162,14 @@
#define HECI_WATCHDOG_DATA_SIZE 16
#define HECI_START_WD_DATA_SIZE 20
#define HECI_WD_PARAMS_SIZE 4
-#define HECI_WD_STATE_INDEPENDENCE_MSG_SENT (1 << 0)
+#define HECI_WD_STATE_INDEP 1
+/* reserved host client ids (0,1,2) */
#define HECI_WD_HOST_CLIENT_ID 1
#define HECI_IAMTHIF_HOST_CLIENT_ID 2
+#define HECI_LAST_FIX_HOST_CLIENT_ID HECI_IAMTHIF_HOST_CLIENT_ID
+/* 256 - 3 reserved */
+#define HECI_MAX_OPEN_HANDLE_COUNT 253
struct guid {
__u32 data1;
@@ -182,24 +195,19 @@
HECI_DISABLED,
HECI_RECOVERING_FROM_RESET,
HECI_POWER_DOWN,
- HECI_POWER_UP
+ HECI_POWER_UP,
+ HECI_REMOVING
};
-enum iamthif_states {
- HECI_IAMTHIF_IDLE,
- HECI_IAMTHIF_WRITING,
- HECI_IAMTHIF_FLOW_CONTROL,
- HECI_IAMTHIF_READING,
- HECI_IAMTHIF_READ_COMPLETE
-};
-
+/* file operation states */
enum heci_file_transaction_states {
- HECI_IDLE,
+ HECI_IDLE = 0,
HECI_WRITING,
HECI_WRITE_COMPLETE,
HECI_FLOW_CONTROL,
HECI_READING,
- HECI_READ_COMPLETE
+ HECI_READ_COMPLETE,
+ HECI_CANCELED
};
/* HECI CB */
@@ -211,58 +219,85 @@
HECI_CLOSE
};
+/* received HECI init message types */
+enum heci_received_init_msg_types {
+ HECI_MSGINIT_NONE = 0,
+ HECI_MSGINIT_INTEROP,
+ HECI_MSGINIT_START,
+ HECI_MSGINIT_ENUM_CLIENTS,
+ HECI_MSGINIT_CLIENT_PROPS
+};
+
+/* read completion states */
+enum heci_completion_states {
+ HECI_WAIT_START = 0,
+ HECI_IN_PROGRESS,
+ HECI_COMPLETED
+};
+
/* HECI user data struct */
struct heci_message_data {
__u32 size;
char *data;
} __attribute__((packed));
-#define HECI_CONNECT_TIMEOUT 3 /* at least 2 seconds */
-#define IAMTHIF_STALL_TIMER 12 /* seconds */
+#define HECI_CONNECT_TIMEOUT 15 /* seconds */
+#define HECI_STALL_TIMER 12 /* seconds */
#define IAMTHIF_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 {
+/* heci connection struct */
+struct heci_connection {
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;
+ atomic_t state;
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;
+ __u8 canceled;
+ int status;
enum heci_file_transaction_states reading_state;
- enum heci_file_transaction_states writing_state;
- int sm_state;
+ enum heci_file_transaction_states wr_state;
+ struct file *file;
struct heci_cb_private *read_cb;
+ __u32 stall_timer;
+ __u32 max_msg_length;
+ atomic_t refcnt;
+ wait_queue_head_t cc_wait; /* wait for connect or close */
};
-struct io_heci_list {
- struct heci_cb_private heci_cb;
+struct heci_file_priv {
+ struct list_head link;
+ struct file *file;
+ struct heci_connection *conn;
+ wait_queue_head_t tx_wait;
+ wait_queue_head_t rx_wait;
+ atomic_t sm_state;
int status;
- struct iamt_heci_device *device_extension;
+ atomic_t r_state;
+ atomic_t w_state;
+ __u8 host_client_id;
};
+struct heci_cb_private {
+ struct list_head cb_list;
+ enum heci_cb_major_types major_file_operations;
+ struct heci_connection *conn;
+ struct file *file_object;
+ struct heci_file_priv *file_ext;
+ struct heci_message_data request_buffer;
+ struct heci_message_data response_buffer;
+ unsigned long information;
+ unsigned long read_time;
+ atomic_t refcnt;
+};
+
+struct heci_io_list {
+ struct list_head cb_list;
+};
+
struct heci_driver_version {
__u8 major;
__u8 minor;
@@ -404,127 +439,90 @@
/* private device struct */
struct iamt_heci_device {
+ atomic_t refcnt;
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[HECI_IO_LISTS_NUMBER];
- 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 reading 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
+ * heci device state
*/
- spinlock_t device_lock; /* device lock*/
- struct work_struct work;
- int recvd_msg;
-
- struct task_struct *reinit_tsk;
-
- struct timer_list wd_timer;
+ atomic_t heci_state;
+ struct hbm_version version;
/*
* 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;
+ atomic_t host_buffer_is_empty;
+ spinlock_t hw_lock; /* device hw access lock */
- __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 */
+ struct heci_me_client *me_clients; /* Note:memory has to be allocated */
__u8 num_heci_me_clients;
- __u8 heci_host_clients[32]; /* list of existing clients */
+ __u8 heci_me_clients[32]; /* list of existing clients */
+ spinlock_t mecl_lock; /* lock for me_clients */
+
+ long open_handle_count;
__u8 current_host_client_id;
+ __u8 heci_host_clients[32]; /* bit list of existing clients (32*8) */
+ struct list_head conn_list; /* list of heci connections */
+ struct list_head file_list; /* list of connected files */
+ spinlock_t conn_lock; /* lock for host_clients, conn_list, file_list */
- 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];
+ struct heci_io_list pthi_cmd_list; /* PTHI list for cmd waiting */
+ struct heci_io_list heci_cmd_list; /* write waiting cmd list */
+ spinlock_t cmdl_lock; /* lock for *_cmd_list */
+ struct heci_io_list ctrl_wr_list; /* managed write IOCTL list */
+ struct heci_io_list ctrl_rd_list; /* managed read IOCTL list */
+ struct heci_io_list read_list; /* driver read queue */
+ spinlock_t crrdl_lock; /* lock for ctrl_*_list and read_list */
+
+ struct heci_io_list read_cmpl_list; /* read completed list */
+ spinlock_t rdcpl_lock; /* lock for read_cmpl_list */
+
+ struct heci_io_list write_list; /* driver write queue */
+ struct heci_io_list cmpl_list; /* nonread completed list */
+
+ __u8 need_reset;
+ __u8 asf_mode;
+ spinlock_t device_lock; /* device lock */
+
+ struct heci_connection wd_conn;
+ struct timer_list wd_timer;
+ wait_queue_head_t wait_stop_wd;
+ atomic_t wd_stoped;
+ atomic_t wd_bypass; /* if 1, don't refresh watchdog ME client */
+ __u8 wd_pending;
+ __u8 wd_stop;
+ __u16 wd_timeout; /* seconds ((wd_data[1] << 8) + wd_data[0]) */
__u16 wd_due_counter;
- int asf_mode;
- int wd_bypass; /* if 1, don't refresh watchdog ME client */
+ unsigned char wd_data[HECI_START_WD_DATA_SIZE];
- struct file *iamthif_file_object;
- struct heci_file_private iamthif_file_ext;
- int iamthif_ioctl;
- int iamthif_canceled;
- __u32 iamthif_timer;
- __u32 iamthif_stall_timer;
- unsigned char iamthif_msg_buf[IAMTHIF_MTU];
- __u32 iamthif_msg_buf_size;
- __u32 iamthif_msg_buf_index;
- int iamthif_flow_control_pending;
- enum iamthif_states iamthif_state;
+ struct heci_connection iamthif_conn;
- struct heci_cb_private *iamthif_current_cb;
- __u8 write_hang;
- int need_reset;
- long open_handle_count;
-};
+ struct task_struct *isr_thread; /* isr processing thread */
+ wait_queue_head_t wait_isr; /* wait queue for isr */
+ atomic_t recvd_isr; /* isr process request counter */
+ atomic_t recvd_wrr; /* write request counter */
-/**
- * read_heci_register - Read a byte from the heci device
- *
- * @dev: the device structure
- * @offset: offset from which to read the data
- *
- * returns the byte read.
- */
-static inline __u32 read_heci_register(struct iamt_heci_device *dev,
- unsigned long offset)
-{
- return readl(dev->mem_addr + offset);
-}
+ struct task_struct *reinit_tsk; /* device reinitialization task */
+ struct semaphore reinit_sem; /* reinit task semaphore */
+ wait_queue_head_t wait_recvd_msg; /* wait queue for messages from FW */
+ atomic_t recvd_msg;
-/**
- * write_heci_register - Write 4 bytes to the heci device
- *
- * @dev: the device structure
- * @offset: offset from which to write the data
- * @value: the byte to write
- */
-static inline void write_heci_register(struct iamt_heci_device *dev,
- unsigned long offset, __u32 value)
-{
- writel(value, dev->mem_addr + offset);
-}
+ spinlock_t write_lock; /* device msg write lock */
+ __u32 rd_msg_hdr; /* read message header */
+ __u32 extra_write_index; /* size of extra control messages */
+ __u32 wr_msg_buf[128]; /* msg write buffer used for control messages */
+ __u32 rd_msg_buf[128]; /* read buffer used for control messages */
+ __u32 ext_msg_buf[8]; /* write buffer for extra control messages */
+};
+
#endif /* _HECI_DATA_STRUCTURES_H_ */
Modified: heci/branches/testing/src/heci_init.c
===================================================================
--- heci/branches/testing/src/heci_init.c 2008-07-22 17:13:05 UTC (rev 206)
+++ heci/branches/testing/src/heci_init.c 2008-07-22 17:20:27 UTC (rev 207)
@@ -38,20 +38,6 @@
*
*/
-#include <linux/module.h>
-#include <linux/pci.h>
-#include <linux/reboot.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 <linux/kthread.h>
-#include "kcompat.h"
-
-#include "heci_data_structures.h"
-#include "heci_interface.h"
#include "heci.h"
@@ -87,7 +73,7 @@
static int allocate_me_clients_storage(struct iamt_heci_device *dev);
static void host_init_wd(struct iamt_heci_device *dev);
static void host_init_iamthif(struct iamt_heci_device *dev);
-static int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
+static int heci_wait_msg_timeout(struct iamt_heci_device *dev,
long timeout);
@@ -97,91 +83,162 @@
* @list: An instance of our list structure
* @dev: Device object for our driver
*/
-void heci_initialize_list(struct io_heci_list *list,
+void heci_initialize_list(struct heci_io_list *list,
struct iamt_heci_device *dev)
{
/* initialize our queue list */
- INIT_LIST_HEAD(&list->heci_cb.cb_list);
- list->status = 0;
- list->device_extension = dev;
+ INIT_LIST_HEAD(&list->cb_list);
}
/**
- * heci_flush_queues - flush our queues list belong to file_ext.
+ * heci_flush_list - remove list entry belong to heci connection.
*
- * @dev: Device object for our driver
- * @file_ext: private data of the file object
+ * @list: An instance of our list structure
+ * @conn: connection data of the file object
+ * @priv_cb: callback block
+ *
+ * returns 1 if flushed, 0 if not
*/
-void heci_flush_queues(struct iamt_heci_device *dev,
- struct heci_file_private *file_ext)
+int heci_flush_list(struct heci_io_list *list,
+ struct heci_connection *conn,
+ struct heci_cb_private *priv_cb)
{
- int i;
+ struct heci_cb_private *priv_cb_pos = NULL;
+ struct heci_cb_private *priv_cb_next = NULL;
+ int ret = 0;
- if (!dev || !file_ext)
- return;
+ if ((list == NULL) || (conn == NULL))
+ return 0;
- /* flush our queue list belong to file_ext */
- for (i = 0; i < HECI_IO_LISTS_NUMBER; i++) {
- DBG("remove list entry belong to file_ext\n");
- heci_flush_list(dev->io_list_array[i], file_ext);
+ if (list_empty(&list->cb_list))
+ return 0;
+
+ list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
+ &list->cb_list, cb_list) {
+ if (priv_cb_pos->conn == conn) {
+ if ((priv_cb == NULL) || (priv_cb_pos == priv_cb)) {
+ list_del_init(&priv_cb_pos->cb_list);
+ ret = 1;
+ }
+ }
}
+ return ret;
}
+/**
+ * heci_reset_file_priv - resets private file structure.
+ *
+ * @file_ext: private data of the file object to be reset
+ * @file: the file structure
+ */
+static void heci_reset_file_priv(struct heci_file_priv *file_ext,
+ struct file *file)
+{
+ INIT_LIST_HEAD(&file_ext->link);
+ init_waitqueue_head(&file_ext->rx_wait);
+ init_waitqueue_head(&file_ext->tx_wait);
+ DBG("file_ext->rx_wait =%p\n", &file_ext->rx_wait);
+ atomic_set(&file_ext->sm_state, 0);
+ file_ext->file = file;
+ atomic_set(&file_ext->r_state, HECI_IDLE);
+ atomic_set(&file_ext->w_state, HECI_IDLE);
+}
/**
- * heci_flush_list - remove list entry belong to file_ext.
+ * heci_reset_heci_connection - resets connection structure.
*
- * @list: An instance of our list structure
- * @file_ext: private data of the file object
+ * @conn: connection data of the file object to be reset
+ * @file: the file structure
*/
-void heci_flush_list(struct io_heci_list *list,
- struct heci_file_private *file_ext)
+static void heci_reset_heci_connection(struct heci_connection *conn,
+ struct file *file)
{
- struct heci_file_private *file_ext_tmp;
- struct heci_cb_private *priv_cb_pos = NULL;
- struct heci_cb_private *priv_cb_next = NULL;
+ INIT_LIST_HEAD(&conn->link);
+ init_waitqueue_head(&conn->cc_wait);
+ atomic_set(&conn->state, HECI_FILE_INITIALIZING);
+ atomic_set(&conn->refcnt, 0);
+ conn->reading_state = HECI_IDLE;
+ conn->wr_state = HECI_IDLE;
+ conn->file = file;
+}
- if (!list || !file_ext)
- return;
+/**
+ * heci_init_file_priv - initializes private file structure.
+ *
+ * @file_ext: private data of the file object to be initialized
+ * @file: the file structure
+ */
+static void heci_init_file_priv(struct heci_file_priv *file_ext,
+ struct file *file)
+{
+ memset(file_ext, 0, sizeof(struct heci_file_priv));
+ heci_reset_file_priv(file_ext, file);
+}
- if (list->status != 0)
- return;
+/**
+ * heci_init_heci_connection - initializes connection structure.
+ *
+ * @conn: connection data of the file object to be initialized
+ * @file: the file structure
+ */
+static void heci_init_heci_connection(struct heci_connection *conn,
+ struct file *file)
+{
+ memset(conn, 0, sizeof(struct heci_connection));
+ spin_lock_init(&conn->file_lock);
+ heci_reset_heci_connection(conn, file);
+}
- if (list_empty(&list->heci_cb.cb_list))
- return;
+/**
+ * heci_alloc_file_priv - allocates a private file structure and set it up.
+ * @file: the file structure
+ *
+ * returns The allocated file connection data or NULL on failure
+ */
+struct heci_file_priv *heci_alloc_file_priv(struct file *file)
+{
+ struct heci_file_priv *file_ext;
- 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 (heci_fe_same_id(file_ext, file_ext_tmp))
- list_del(&priv_cb_pos->cb_list);
- }
- }
- }
+ file_ext = kmalloc(sizeof(struct heci_file_priv), GFP_KERNEL);
+ if (file_ext == NULL)
+ return NULL;
+
+ heci_init_file_priv(file_ext, file);
+
+ return file_ext;
}
/**
- * heci_reset_iamthif_params - initializes heci device iamthif
+ * heci_alloc_heci_connection - allocates connection structure and set it up.
+ * @file: the file structure
*
- * @dev: The heci device structure
+ * returns The allocated file connection data or NULL on failure
*/
-static void heci_reset_iamthif_params(struct iamt_heci_device *dev)
+struct heci_connection *heci_alloc_heci_connection(struct file *file)
{
- /* reset iamthif parameters. */
- dev->iamthif_current_cb = NULL;
- dev->iamthif_msg_buf_size = 0;
- dev->iamthif_msg_buf_index = 0;
- dev->iamthif_canceled = 0;
- dev->iamthif_file_ext.file = NULL;
- dev->iamthif_ioctl = 0;
- dev->iamthif_state = HECI_IAMTHIF_IDLE;
- dev->iamthif_timer = 0;
+ struct heci_connection *conn;
+
+ conn = kmalloc(sizeof(struct heci_connection), GFP_KERNEL);
+ if (conn == NULL)
+ return NULL;
+
+ heci_init_heci_connection(conn, file);
+
+ return conn;
}
/**
+ * heci_put_heci_connection - free connection structure.
+ *
+ * @conn: connection data of the file object
+ */
+void heci_put_heci_connection(struct heci_connection *conn)
+{
+ if (atomic_dec_and_test(&conn->refcnt))
+ kfree(conn);
+}
+
+/**
* init_heci_device - allocates and initializes the heci device structure
*
* @pdev: The pci device structure
@@ -190,46 +247,86 @@
*/
struct iamt_heci_device *init_heci_device(struct pci_dev *pdev)
{
- int i;
struct iamt_heci_device *dev;
dev = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
- if (!dev)
+ if (dev == NULL)
return NULL;
- /* setup our list array */
- dev->io_list_array[0] = &dev->read_list;
- dev->io_list_array[1] = &dev->write_list;
- dev->io_list_array[2] = &dev->write_waiting_list;
- dev->io_list_array[3] = &dev->ctrl_wr_list;
- dev->io_list_array[4] = &dev->ctrl_rd_list;
- dev->io_list_array[5] = &dev->pthi_cmd_list;
- dev->io_list_array[6] = &dev->pthi_read_complete_list;
- INIT_LIST_HEAD(&dev->file_list);
- INIT_LIST_HEAD(&dev->wd_file_ext.link);
- INIT_LIST_HEAD(&dev->iamthif_file_ext.link);
spin_lock_init(&dev->device_lock);
+ spin_lock_init(&dev->crrdl_lock);
+ spin_lock_init(&dev->rdcpl_lock);
+ spin_lock_init(&dev->cmdl_lock);
+ spin_lock_init(&dev->mecl_lock);
+ spin_lock_init(&dev->conn_lock);
+ spin_lock_init(&dev->hw_lock);
+ spin_lock_init(&dev->write_lock);
init_waitqueue_head(&dev->wait_recvd_msg);
init_waitqueue_head(&dev->wait_stop_wd);
- dev->heci_state = HECI_INITIALIZING;
- dev->iamthif_state = HECI_IAMTHIF_IDLE;
+ init_waitqueue_head(&dev->wait_isr);
+ atomic_set(&dev->recvd_isr, 0);
+ atomic_set(&dev->recvd_msg, 0);
+ atomic_set(&dev->recvd_wrr, 0);
+ init_MUTEX(&dev->reinit_sem);
+ atomic_set(&dev->heci_state, HECI_INITIALIZING);
+ atomic_set(&dev->host_buffer_is_empty, 1);
- /* init work for schedule work */
- INIT_WORK(&dev->work, NULL);
- for (i = 0; i < HECI_IO_LISTS_NUMBER; i++)
- heci_initialize_list(dev->io_list_array[i], dev);
+ INIT_LIST_HEAD(&dev->conn_list);
+ INIT_LIST_HEAD(&dev->file_list);
+
+ heci_initialize_list(&dev->read_list, dev);
+ heci_initialize_list(&dev->read_cmpl_list, dev);
+ heci_initialize_list(&dev->ctrl_rd_list, dev);
+ heci_initialize_list(&dev->ctrl_wr_list, dev);
+ heci_initialize_list(&dev->write_list, dev);
+ heci_initialize_list(&dev->cmpl_list, dev);
+ heci_initialize_list(&dev->pthi_cmd_list, dev);
+ heci_initialize_list(&dev->heci_cmd_list, dev);
+
+ atomic_set(&dev->wd_stoped, 0);
+ atomic_set(&dev->wd_bypass, 0);
+ heci_init_heci_connection(&dev->wd_conn, NULL);
+ atomic_inc(&dev->wd_conn.refcnt);
+ heci_init_heci_connection(&dev->iamthif_conn, NULL);
+ atomic_inc(&dev->iamthif_conn.refcnt);
+
+ atomic_set(&dev->refcnt, 1);
+
dev->pdev = pdev;
return dev;
}
+/**
+ * put_heci_device - free unreferenced heci device structure
+ *
+ * @dev: Device object for our driver
+ */
+void put_heci_device(struct iamt_heci_device *dev)
+{
+ if (dev == NULL)
+ return;
+ if (!atomic_dec_and_test(&dev->refcnt))
+ return;
+ if (dev->mem_addr != NULL)
+ iounmap(dev->mem_addr);
+ kfree(dev);
+}
-static int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
- long timeout)
+/**
+ * heci_wait_msg_timeout - wait for heci response
+ *
+ * @dev: Device object for our driver
+ * @timeout: maximum wait timeout
+ *
+ * returns 0 if timeout, >0 if received, <0 on error
+ */
+static int heci_wait_msg_timeout(struct iamt_heci_device *dev, long timeout)
{
return wait_event_interruptible_timeout(dev->wait_recvd_msg,
- (dev->recvd_msg), timeout);
+ (atomic_read(&dev->recvd_msg) != HECI_MSGINIT_NONE),
+ timeout);
}
/**
@@ -243,64 +340,88 @@
{
int err = 0;
+ spin_lock_bh(&dev->device_lock);
+ spin_lock(&dev->hw_lock);
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 */
+ /* acknowledge interrupt */
heci_set_csr_register(dev);
}
- dev->recvd_msg = 0;
+ spin_unlock(&dev->hw_lock);
+
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+
DBG("reset in start the heci device.\n");
-
heci_reset(dev, 1);
DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
dev->host_hw_state, dev->me_hw_state);
+ spin_unlock_bh(&dev->device_lock);
/* wait for ME to turn on ME_RDY */
- if (!dev->recvd_msg)
- err = heci_wait_event_int_timeout(dev, HECI_INTEROP_TIMEOUT);
+ if (atomic_read(&dev->recvd_msg) != HECI_MSGINIT_INTEROP)
+ err = heci_wait_msg_timeout(dev, HECI_INTEROP_TIMEOUT);
- if (!err && !dev->recvd_msg) {
- dev->heci_state = HECI_DISABLED;
+ if (err == -ERESTARTSYS) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout interrupted"
+ " on wait for ME to turn on ME_RDY.\n");
+ return -EINTR;
+ }
+ if ((err == 0)
+ || (atomic_read(&dev->recvd_msg) != HECI_MSGINIT_INTEROP)) {
+ if (err == 0)
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
DBG("wait_event_interruptible_timeout failed"
- "on wait for ME to turn on ME_RDY.\n");
+ " 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);
+ }
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
- if (!(dev->host_hw_state & H_RDY) != H_RDY)
- DBG("host turn off H_RDY.\n");
+ spin_lock_bh(&dev->hw_lock);
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+ dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
+ if (((dev->host_hw_state & H_RDY) != H_RDY)
+ || ((dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)) {
+ atomic_set(&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->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
- DBG("ME turn off ME_RDY.\n");
+ if ((dev->host_hw_state & H_RDY) != H_RDY)
+ DBG("host turn off H_RDY.\n");
- printk(KERN_ERR
- "heci: link layer initialization failed.\n");
- return -ENODEV;
- }
+ if ((dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
+ DBG("ME turn off ME_RDY.\n");
+
+ spin_unlock_bh(&dev->hw_lock);
+ printk(KERN_ERR
+ "heci: link layer initialization failed.\n");
+ return -ENODEV;
}
- dev->recvd_msg = 0;
+
DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
dev->host_hw_state, dev->me_hw_state);
+ spin_unlock_bh(&dev->hw_lock);
+
DBG("ME turn on ME_RDY and host turn on H_RDY.\n");
printk(KERN_INFO "heci: link layer has been established.\n");
return 0;
}
/**
- * heci_hw_reset - reset fw via heci csr register.
+ * heci_hw_reset - reset fw via heci csr register.
*
* @dev: Device object for our driver
* @interrupts: if interrupt should be enable after reset.
+ *
+ * NOTE: called under hw_lock
*/
static void heci_hw_reset(struct iamt_heci_device *dev, int interrupts)
{
@@ -316,37 +437,99 @@
}
/**
- * heci_reset - reset host and fw.
+ * heci_reset_io_list - clear list and free entries.
*
+ * @list: An instance of our list structure
+ */
+static void heci_reset_io_list(struct heci_io_list *list)
+{
+ struct heci_cb_private *priv_cb_pos = NULL;
+ struct heci_cb_private *priv_cb_next = NULL;
+
+ if (list_empty(&list->cb_list))
+ return;
+
+ list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
+ &list->cb_list, cb_list) {
+ list_del_init(&priv_cb_pos->cb_list);
+ heci_free_io_cb(priv_cb_pos);
+ }
+}
+
+/**
+ * heci_reset_io - resets IO operations.
+ *
* @dev: Device object for our driver
+ *
+ * NOTE: called under device_lock
+ */
+static void heci_reset_io(struct iamt_heci_device *dev)
+{
+ struct heci_connection *conn_pos = NULL;
+ struct heci_connection *conn_next = NULL;
+
+ spin_lock(&dev->conn_lock);
+ list_for_each_entry_safe(conn_pos, conn_next, &dev->conn_list, link) {
+ spin_lock(&conn_pos->file_lock);
+ atomic_set(&conn_pos->state, HECI_FILE_DISCONNECTED);
+ conn_pos->flow_ctrl_creds = 0;
+ conn_pos->canceled = 1;
+ conn_pos->read_cb = NULL;
+ conn_pos->reading_state = HECI_IDLE;
+ conn_pos->wr_state = HECI_IDLE;
+ if (conn_pos == &dev->iamthif_conn)
+ conn_pos->file = NULL;
+ spin_unlock(&conn_pos->file_lock);
+ }
+ /* remove entry if already in list */
+ DBG("list del iamthif and wd conn list.\n");
+ list_del_init(&dev->wd_conn.link);
+ list_del_init(&dev->iamthif_conn.link);
+ spin_unlock(&dev->conn_lock);
+
+ /* remove all waiting requests */
+ heci_reset_io_list(&dev->write_list);
+ spin_lock(&dev->crrdl_lock);
+ heci_reset_io_list(&dev->read_list);
+ spin_unlock(&dev->crrdl_lock);
+}
+
+/**
+ * heci_reset - reset host and fw.
+ *
+ * @dev: Device object for our driver
* @interrupts: if interrupt should be enable after reset.
+ *
+ * NOTE: called under device_lock
*/
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;
+ struct heci_file_priv *file_pos = NULL;
+ struct heci_file_priv *file_next = NULL;
int unexpected = 0;
+ enum heci_states heci_state;
- if (dev->heci_state == HECI_RECOVERING_FROM_RESET) {
+ heci_state = atomic_read(&dev->heci_state);
+ if (heci_state == HECI_RECOVERING_FROM_RESET) {
dev->need_reset = 1;
return;
}
+ if ((heci_state != HECI_INITIALIZING) &&
+ (heci_state != HECI_DISABLED) &&
+ (heci_state != HECI_POWER_DOWN) &&
+ (heci_state != HECI_REMOVING)) {
+ if (heci_state != HECI_POWER_UP)
+ unexpected = 1;
+ atomic_set(&dev->heci_state, HECI_RESETING);
+ }
- if (dev->heci_state != HECI_INITIALIZING &&
- dev->heci_state != HECI_DISABLED &&
- dev->heci_state != HECI_POWER_DOWN &&
- dev->heci_state != HECI_POWER_UP)
- unexpected = 1;
-
if (dev->reinit_tsk != NULL) {
- kthread_stop(dev->reinit_tsk);
- dev->reinit_tsk = NULL;
+ set_tsk_thread_flag(dev->reinit_tsk, TIF_SIGPENDING);
+ wake_up_process(dev->reinit_tsk);
}
+ spin_lock(&dev->hw_lock);
dev->host_hw_state = read_heci_register(dev, H_CSR);
-
DBG("before reset host_hw_state = 0x%08x.\n",
dev->host_hw_state);
@@ -354,166 +537,148 @@
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);
+ spin_unlock(&dev->hw_lock);
dev->need_reset = 0;
- if (dev->heci_state != HECI_INITIALIZING) {
- if ((dev->heci_state != HECI_DISABLED) &&
- (dev->heci_state != HECI_POWER_DOWN))
- dev->heci_state = HECI_RESETING;
+ if (atomic_read(&dev->heci_state) != HECI_INITIALIZING)
+ heci_reset_io(dev);
- 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 */
- DBG("list del iamthif and wd file list.\n");
- heci_remove_client_from_file_list(dev,
- dev->wd_file_ext.host_client_id);
+ spin_lock(&dev->mecl_lock);
+ dev->num_heci_me_clients = 0;
+ spin_unlock(&dev->mecl_lock);
- heci_remove_client_from_file_list(dev,
- dev->iamthif_file_ext.host_client_id);
-
- heci_reset_iamthif_params(dev);
- dev->wd_due_counter = 0;
- dev->extra_write_index = 0;
- }
-
- dev->num_heci_me_clients = 0;
dev->rd_msg_hdr = 0;
- dev->stop = 0;
+ dev->wd_stop = 0;
dev->wd_pending = 0;
+ dev->wd_due_counter = 0;
+ dev->extra_write_index = 0;
+ spin_lock(&dev->hw_lock);
/* update the state of the registers after reset */
- dev->host_hw_state = read_heci_register(dev, H_CSR);
- dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
-
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+ dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
DBG("after reset host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
dev->host_hw_state, dev->me_hw_state);
+ spin_unlock(&dev->hw_lock);
if (unexpected)
printk(KERN_WARNING "heci: unexpected reset.\n");
- /* Wake up all readings so they can be interrupted */
+ spin_lock(&dev->conn_lock);
+ /* Wake up all readings and writings so they can be interrupted */
list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
- if (&file_pos->rx_wait &&
- waitqueue_active(&file_pos->rx_wait)) {
- printk(KERN_INFO "heci: Waking up client!\n");
+ if (waitqueue_active(&file_pos->rx_wait)) {
+ printk(KERN_INFO "heci: waking up client\n");
wake_up_interruptible(&file_pos->rx_wait);
}
- }
- /* remove all waiting requests */
- if (dev->write_list.status == 0 &&
- !list_empty(&dev->write_list.heci_cb.cb_list)) {
- list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
- &dev->write_list.heci_cb.cb_list, cb_list) {
- if (priv_cb_pos) {
- list_del(&priv_cb_pos->cb_list);
- heci_free_cb_private(priv_cb_pos);
- }
+ if (waitqueue_active(&file_pos->tx_wait)) {
+ printk(KERN_INFO "heci: waking up writing client\n");
+ wake_up_interruptible(&file_pos->tx_wait);
}
}
+ spin_unlock(&dev->conn_lock);
}
/**
- * heci_initialize_clients - heci communication initialization.
+ * heci_initialize_clients - initializes heci communication.
*
* @dev: Device object for our driver
+ *
+ * returns 0 on success, !=0 on failure
*/
int heci_initialize_clients(struct iamt_heci_device *dev)
{
- int status;
+ int ret;
msleep(100); /* FW needs time to be ready to talk with us */
DBG("link is established start sending messages.\n");
/* link is established start sending messages. */
- status = host_start_message(dev);
- if (status != 0) {
- spin_lock_bh(&dev->device_lock);
- dev->heci_state = HECI_DISABLED;
- spin_unlock_bh(&dev->device_lock);
+ ret = host_start_message(dev);
+ if (ret != 0) {
DBG("start sending messages failed.\n");
- return status;
+ return ret;
}
+ /* enumerate clients */
- /* enumerate clients */
- status = host_enum_clients_message(dev);
- if (status != 0) {
- spin_lock_bh(&dev->device_lock);
- dev->heci_state = HECI_DISABLED;
- spin_unlock_bh(&dev->device_lock);
+ ret = host_enum_clients_message(dev);
+ if (ret != 0) {
DBG("enum clients failed.\n");
- return status;
+ return ret;
}
/* allocate storage for ME clients representation */
- status = allocate_me_clients_storage(dev);
- if (status != 0) {
- spin_lock_bh(&dev->device_lock);
- dev->num_heci_me_clients = 0;
- dev->heci_state = HECI_DISABLED;
- spin_unlock_bh(&dev->device_lock);
+ ret = allocate_me_clients_storage(dev);
+ if (ret != 0) {
DBG("allocate clients failed.\n");
- return status;
+ return ret;
}
heci_check_asf_mode(dev);
- /*heci initialization wd */
+ /* heci initialization wd */
host_init_wd(dev);
- /*heci initialization iamthif client */
+ /* heci initialization iamthif client */
host_init_iamthif(dev);
spin_lock_bh(&dev->device_lock);
- if (dev->need_reset) {
+ if (dev->need_reset == 1) {
dev->need_reset = 0;
- dev->heci_state = HECI_DISABLED;
+ atomic_set(&dev->heci_state, HECI_DISABLED);
spin_unlock_bh(&dev->device_lock);
return -ENODEV;
}
+ spin_lock(&dev->conn_lock);
memset(dev->heci_host_clients, 0, sizeof(dev->heci_host_clients));
dev->open_handle_count = 0;
dev->heci_host_clients[0] |= 7;
- dev->current_host_client_id = 3;
- dev->heci_state = HECI_ENABLED;
+ dev->current_host_client_id = HECI_LAST_FIX_HOST_CLIENT_ID;
+ spin_unlock(&dev->conn_lock);
+
+ atomic_set(&dev->heci_state, HECI_ENABLED);
spin_unlock_bh(&dev->device_lock);
DBG("initialization heci clients successful.\n");
return 0;
}
+
+#ifndef HECI_TASK_NONFREEZABLE
+#define HECI_TASK_NONFREEZABLE
+#endif
+
/**
- * heci_task_initialize_clients - heci reinitialization task
+ * heci_task_initialize_clients - heci reinitialization task.
*
* @data: Device object for our driver
+ *
+ * returns 0 on success, !=0 on failure
*/
int heci_task_initialize_clients(void *data)
{
int ret;
struct iamt_heci_device *dev = (struct iamt_heci_device *) data;
- spin_lock_bh(&dev->device_lock);
- if (dev->reinit_tsk != NULL) {
- spin_unlock_bh(&dev->device_lock);
+ if (down_trylock(&dev->reinit_sem)) {
DBG("reinit task already started.\n");
return 0;
}
+
+ spin_lock_bh(&dev->device_lock);
dev->reinit_tsk = current;
- current->flags |= PF_NOFREEZE;
spin_unlock_bh(&dev->device_lock);
+ HECI_TASK_NONFREEZABLE;
+
ret = heci_initialize_clients(dev);
spin_lock_bh(&dev->device_lock);
dev->reinit_tsk = NULL;
spin_unlock_bh(&dev->device_lock);
+ up(&dev->reinit_sem);
+
return ret;
}
@@ -533,6 +698,7 @@
struct hbm_host_stop_request *host_stop_req;
int err = 0;
+ spin_lock_bh(&dev->write_lock);
/* host start message */
heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
heci_hdr->host_addr = 0;
@@ -547,22 +713,41 @@
host_start_req->cmd.cmd = HOST_START_REQ_CMD;
host_start_req->host_version.major_version = HBM_MAJOR_VERSION;
host_start_req->host_version.minor_version = HBM_MINOR_VERSION;
- dev->recvd_msg = 0;
+
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
if (!heci_write_message(dev, heci_hdr,
- (unsigned char *) (host_start_req),
- heci_hdr->length)) {
+ (unsigned char *) (host_start_req),
+ heci_hdr->length)) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ spin_unlock_bh(&dev->write_lock);
DBG("send version to fw fail.\n");
return -ENODEV;
}
+ spin_unlock_bh(&dev->write_lock);
+
DBG("call wait_event_interruptible_timeout for response message.\n");
/* wait for response */
- err = heci_wait_event_int_timeout(dev, timeout * HZ);
- if (!err && !dev->recvd_msg) {
- DBG("wait_timeout failed on host start response message.\n");
+ err = heci_wait_msg_timeout(dev, timeout * HZ);
+ if (err == -ERESTARTSYS) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout interrupted"
+ " on host start response message.\n");
+ return -EINTR;
+ }
+ if ((err == 0)
+ || (atomic_read(&dev->recvd_msg) != HECI_MSGINIT_START)) {
+ if (err == 0)
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout failed"
+ " on host start response message.\n");
return -ENODEV;
}
- dev->recvd_msg = 0;
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
DBG("wait_timeout successful on host start response message.\n");
+
+ spin_lock_bh(&dev->write_lock);
if ((dev->version.major_version != HBM_MAJOR_VERSION) ||
(dev->version.minor_version != HBM_MINOR_VERSION)) {
/* send stop message */
@@ -581,9 +766,12 @@
heci_write_message(dev, heci_hdr,
(unsigned char *) (host_stop_req),
heci_hdr->length);
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ spin_unlock_bh(&dev->write_lock);
DBG("version mismatch.\n");
return -ENODEV;
}
+ spin_unlock_bh(&dev->write_lock);
return 0;
}
@@ -597,12 +785,13 @@
*/
static int host_enum_clients_message(struct iamt_heci_device *dev)
{
- long timeout = 5; /*5 second */
+ long timeout = 5; /* 5 second */
struct heci_msg_hdr *heci_hdr;
struct hbm_host_enum_request *host_enum_req;
int err = 0;
__u8 i, j;
+ spin_lock_bh(&dev->write_lock);
heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
/* enumerate clients */
heci_hdr->host_addr = 0;
@@ -614,23 +803,39 @@
host_enum_req = (struct hbm_host_enum_request *) &dev->wr_msg_buf[1];
memset(host_enum_req, 0, sizeof(struct hbm_host_enum_request));
host_enum_req->cmd.cmd = HOST_ENUM_REQ_CMD;
+
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
if (!heci_write_message(dev, heci_hdr,
- (unsigned char *) (host_enum_req),
- heci_hdr->length)) {
+ (unsigned char *) (host_enum_req),
+ heci_hdr->length)) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ spin_unlock_bh(&dev->write_lock);
DBG("send enumeration request failed.\n");
return -ENODEV;
}
+ spin_unlock_bh(&dev->write_lock);
+
/* wait for response */
- dev->recvd_msg = 0;
- err = heci_wait_event_int_timeout(dev, timeout * HZ);
- if (!err && !dev->recvd_msg) {
- DBG("wait_event_interruptible_timeout failed "
- "on enumeration clients response message.\n");
+ err = heci_wait_msg_timeout(dev, timeout * HZ);
+ if (err == -ERESTARTSYS) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout interrupted"
+ " on enumeration clients response message.\n");
+ return -EINTR;
+ }
+ if ((err == 0)
+ || (atomic_read(&dev->recvd_msg) != HECI_MSGINIT_ENUM_CLIENTS)) {
+ if (err == 0)
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout failed"
+ " on enumeration clients response message.\n");
return -ENODEV;
}
- dev->recvd_msg = 0;
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
- spin_lock_bh(&dev->device_lock);
+ spin_lock_bh(&dev->mecl_lock);
/* count how many ME clients we have */
for (i = 0; i < sizeof(dev->heci_me_clients); i++) {
for (j = 0; j < 8; j++) {
@@ -639,7 +844,7 @@
}
}
- spin_unlock_bh(&dev->device_lock);
+ spin_unlock_bh(&dev->mecl_lock);
return 0;
}
@@ -656,10 +861,12 @@
static int host_client_properties(struct iamt_heci_device *dev,
struct heci_me_client *client)
{
+ long timeout = 10; /* 10 second */
struct heci_msg_hdr *heci_hdr;
struct hbm_props_request *host_cli_req;
int err;
+ spin_lock_bh(&dev->write_lock);
heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
heci_hdr->host_addr = 0;
heci_hdr->me_addr = 0;
@@ -671,20 +878,38 @@
memset(host_cli_req, 0, sizeof(struct hbm_props_request));
host_cli_req->cmd.cmd = HOST_CLIENT_PROPERTEIS_REQ_CMD;
host_cli_req->address = client->client_id;
+
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
if (!heci_write_message(dev, heci_hdr,
(unsigned char *) (host_cli_req),
heci_hdr->length)) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ spin_unlock_bh(&dev->write_lock);
DBG("send props request failed.\n");
return -ENODEV;
}
+ spin_unlock_bh(&dev->write_lock);
+
/* wait for response */
- dev->recvd_msg = 0;
- err = heci_wait_event_int_timeout(dev, 10 * HZ);
- if (!err && !dev->recvd_msg) {
- DBG("wait failed on props resp msg.\n");
+ err = heci_wait_msg_timeout(dev, timeout * HZ);
+ if (err == -ERESTARTSYS) {
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout interrupted"
+ " on props resp msg.\n");
+ return -EINTR;
+ }
+ if ((err == 0)
+ || (atomic_read(&dev->recvd_msg) != HECI_MSGINIT_CLIENT_PROPS)) {
+ if (err == 0)
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+ DBG("wait_event_interruptible_timeout failed"
+ " on props resp msg.\n");
return -ENODEV;
}
- dev->recvd_msg = 0;
+ atomic_set(&dev->recvd_msg, HECI_MSGINIT_NONE);
+
return 0;
}
@@ -702,26 +927,32 @@
__u8 num, i, j;
int err;
- if (dev->num_heci_me_clients <= 0)
+ spin_lock_bh(&dev->mecl_lock);
+ if (dev->num_heci_me_clients <= 0) {
+ kfree(dev->me_clients);
+ dev->me_clients = NULL;
+ dev->num_heci_me_clients = 0;
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ spin_unlock_bh(&dev->mecl_lock);
return 0;
+ }
+ spin_unlock_bh(&dev->mecl_lock);
- spin_lock_bh(&dev->device_lock);
- kfree(dev->me_clients);
- dev->me_clients = NULL;
- spin_unlock_bh(&dev->device_lock);
-
/* allocate storage for ME clients representation */
clients = kcalloc(dev->num_heci_me_clients,
sizeof(struct heci_me_client), GFP_KERNEL);
- if (!clients) {
+
+ spin_lock_bh(&dev->mecl_lock);
+ kfree(dev->me_clients);
+ dev->me_clients = clients;
+ if (clients == NULL) {
+ dev->num_heci_me_clients = 0;
+ atomic_set(&dev->heci_state, HECI_DISABLED);
+ spin_unlock_bh(&dev->mecl_lock);
DBG("memory allocation for ME clients failed.\n");
return -ENOMEM;
}
- spin_lock_bh(&dev->device_lock);
- dev->me_clients = clients;
- spin_unlock_bh(&dev->device_lock);
-
num = 0;
for (i = 0; i < sizeof(dev->heci_me_clients); i++) {
for (j = 0; j < 8; j++) {
@@ -729,72 +960,57 @@
client = &dev->me_clients[num];
client->client_id = (i * 8) + j;
client->flow_ctrl_creds = 0;
+ spin_unlock_bh(&dev->mecl_lock);
err = host_client_properties(dev, client);
+ spin_lock_bh(&dev->mecl_lock);
if (err != 0) {
- spin_lock_bh(&dev->device_lock);
kfree(dev->me_clients);
dev->me_clients = NULL;
- spin_unlock_bh(&dev->device_lock);
+ dev->num_heci_me_clients = 0;
+ spin_unlock_bh(&dev->mecl_lock);
return err;
}
num++;
}
}
}
-
+ spin_unlock_bh(&dev->mecl_lock);
return 0;
}
/**
- * heci_init_file_private - initializes private file structure.
+ * heci_find_me_client - search for ME client guid
+ * sets client_id in heci_heci_connection if found
*
- * @priv: private file structure to be initialized
- * @file: the file structure
- */
-static void heci_init_file_private(struct heci_file_private *priv,
- struct file *file)
-{
- memset(priv, 0, sizeof(struct heci_file_private));
- spin_lock_init(&priv->file_lock);
- spin_lock_init(&priv->read_io_lock);
- spin_lock_init(&priv->write_io_lock);
- init_waitqueue_head(&priv->wait);
- init_waitqueue_head(&priv->rx_wait);
- DBG("priv->rx_wait =%p\n", &priv->rx_wait);
- init_waitqueue_head(&priv->tx_wait);
- INIT_LIST_HEAD(&priv->link);
- priv->reading_state = HECI_IDLE;
- priv->writing_state = HECI_IDLE;
-}
-
-/**
- * heci_find_me_client - search for ME client guid
- * sets client_id in heci_file_private if found
* @dev: Device object for our driver
- * @priv: private file structure to set client_id in
+ * @conn: connection data of the file object to set client_id in
* @cguid: searched guid of ME client
* @client_id: id of host client to be set in file private structure
*
* returns ME client index
*/
static __u8 heci_find_me_client(struct iamt_heci_device *dev,
- struct heci_file_private *priv,
+ struct heci_connection *conn,
const struct guid *cguid, __u8 client_id)
{
__u8 i;
- if ((dev == NULL) || (priv == NULL) || (cguid == NULL))
+ if ((dev == NULL) || (conn == NULL) || (cguid == NULL))
return 0;
for (i = 0; i < dev->num_heci_me_clients; i++) {
if (memcmp(cguid,
&dev->me_clients[i].props.protocol_name,
sizeof(struct guid)) == 0) {
- priv->me_client_id = dev->me_clients[i].client_id;
- priv->state = HECI_FILE_CONNECTING;
- priv->host_client_id = client_id;
+ conn->me_client_id = dev->me_clients[i].client_id;
+ conn->max_msg_length =
+ dev->me_clients[i].props.max_msg_length;
+ atomic_set(&conn->state, HECI_FILE_CONNECTING);
+ conn->host_client_id = client_id;
- list_add_tail(&priv->link, &dev->file_list);
+ spin_lock(&dev->conn_lock);
+ list_add_tail(&conn->link, &dev->conn_list);
+ spin_unlock(&dev->conn_lock);
return i;
}
}
@@ -810,7 +1026,7 @@
{
__u8 i;
- spin_lock_bh(&dev->device_lock);
+ spin_lock_bh(&dev->mecl_lock);
dev->asf_mode = 0;
/* find ME ASF client - otherwise assume AMT mode */
DBG("find ME ASF client - otherwise assume AMT mode.\n");
@@ -819,77 +1035,86 @@
&dev->me_clients[i].props.protocol_name,
sizeof(struct guid)) == 0) {
dev->asf_mode = 1;
- spin_unlock_bh(&dev->device_lock);
+ spin_unlock_bh(&dev->mecl_lock);
DBG("found ME ASF client.\n");
return;
}
}
- spin_unlock_bh(&dev->device_lock);
+ spin_unlock_bh(&dev->mecl_lock);
DBG("assume AMT mode.\n");
}
/**
* heci_connect_me_client - connect ME client
+ *
* @dev: Device object for our driver
- * @priv: private file structure
+ * @conn: connection data of the file object
* @timeout: connect timeout in seconds
*
* returns 1 - if connected, 0 - if not
*/
static __u8 heci_connect_me_client(struct iamt_heci_device *dev,
- struct heci_file_private *priv,
+ struct heci_connection *conn,
long timeout)
{
int err = 0;
- if ((dev == NULL) || (priv == NULL))
+ if ((dev == NULL) || (conn == NULL))
return 0;
- if (!heci_connect(dev, priv)) {
+ if (!heci_connect(dev, conn)) {
DBG("failed to call heci_connect for client_id=%d.\n",
- priv->host_client_id);
- spin_lock_bh(&dev->device_lock);
- heci_remove_client_from_file_list(dev, priv->host_client_id);
- priv->state = HECI_FILE_DISCONNECTED;
- spin_unlock_bh(&dev->device_lock);
+ conn->host_client_id);
+ spin_lock_bh(&dev->conn_lock);
+ list_del_init(&conn->link);
+ spin_unlock_bh(&dev->conn_lock);
+ atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
return 0;
}
- err = wait_event_timeout(dev->wait_recvd_msg,
- (HECI_FILE_CONNECTED == priv->state ||
- HECI_FILE_DISCONNECTED == priv->state),
- timeout * HZ);
- if (HECI_FILE_CONNECTED != priv->state) {
- spin_lock_bh(&dev->device_lock);
- heci_remove_client_from_file_list(dev, priv->host_client_id);
+ err = wait_event_interruptible_timeout(conn->cc_wait,
+ ((atomic_read(&conn->state) == HECI_FILE_CONNECTED) ||
+ (atomic_read(&conn->state) == HECI_FILE_DISCONNECTED)),
+ timeout * HZ);
+ if (atomic_read(&conn->state) != HECI_FILE_CONNECTED) {
+ spin_lock_bh(&dev->conn_lock);
+ list_del_init(&conn->link);
+ spin_unlock_bh(&dev->conn_lock);
DBG("failed to connect client_id=%d state=%d.\n",
- priv->host_client_id, priv->state);
+ conn->host_client_id, atomic_read(&conn->state));
if (err)
DBG("failed connect err=%08x\n", err);
- priv->state = HECI_FILE_DISCONNECTED;
- spin_unlock_bh(&dev->device_lock);
+ atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
return 0;
}
DBG("successfully connected client_id=%d.\n",
- priv->host_client_id);
+ conn->host_client_id);
+ spin_lock_bh(&conn->file_lock);
+ conn->reading_state = HECI_IDLE;
+ conn->wr_state = HECI_IDLE;
+ spin_unlock_bh(&conn->file_lock);
return 1;
}
/**
- * host_init_wd - heci initialization wd.
+ * host_init_wd - heci watchdog initialization
*
* @dev: Device object for our driver
*/
static void host_init_wd(struct iamt_heci_device *dev)
{
- spin_lock_bh(&dev->device_lock);
+ __u8 cres = 0;
+ struct heci_connection *conn = &dev->wd_conn;
- heci_init_file_private(&dev->wd_file_ext, NULL);
+ spin_lock_bh(&conn->file_lock);
+ heci_reset_heci_connection(conn, NULL);
+ atomic_inc(&conn->refcnt);
+ atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
/* look for WD client and connect to it */
- dev->wd_file_ext.state = HECI_FILE_DISCONNECTED;
dev->wd_timeout = 0;
+ memset(dev->wd_data, 0, HECI_START_WD_DATA_SIZE);
if (dev->asf_mode) {
memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
} else {
@@ -901,14 +1126,16 @@
&dev->wd_timeout, sizeof(__u16));
}
+ spin_lock(&dev->mecl_lock);
/* find ME WD client */
- heci_find_me_client(dev, &dev->wd_file_ext,
- &heci_wd_guid, HECI_WD_HOST_CLIENT_ID);
- spin_unlock_bh(&dev->device_lock);
-
- DBG("check wd_file_ext\n");
- if (HECI_FILE_CONNECTING == dev->wd_file_ext.state) {
- if (heci_connect_me_client(dev, &dev->wd_file_ext, 15) == 1) {
+ heci_find_me_client(dev, conn, &heci_wd_guid, HECI_WD_HOST_CLIENT_ID);
+ spin_unlock(&dev->mecl_lock);
+ DBG("check wd_conn\n");
+ if (atomic_read(&conn->state) == HECI_FILE_CONNECTING) {
+ spin_unlock_bh(&conn->file_lock);
+ cres = heci_connect_me_client(dev, conn, HECI_CONNECT_TIMEOUT);
+ spin_lock_bh(&conn->file_lock);
+ if (cres == 1) {
DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
if (dev->wd_timeout != 0)
dev->wd_due_counter = 1;
@@ -919,160 +1146,40 @@
} else
DBG("failed to find WD client.\n");
-
- spin_lock_bh(&dev->device_lock);
dev->wd_timer.function = &heci_wd_timer;
dev->wd_timer.data = (unsigned long) dev;
- spin_unlock_bh(&dev->device_lock);
+ spin_unlock_bh(&conn->file_lock);
}
-
/**
- * host_init_iamthif - heci initialization iamthif client.
+ * host_init_iamthif - heci iamthif client initialization
*
* @dev: Device object for our driver
- *
*/
static void host_init_iamthif(struct iamt_heci_device *dev)
{
__u8 i;
+ struct heci_connection *conn = &dev->iamthif_conn;
- spin_lock_bh(&dev->device_lock);
+ spin_lock_bh(&conn->file_lock);
+ heci_reset_heci_connection(conn, NULL);
+ atomic_inc(&conn->refcnt);
+ atomic_set(&conn->state, HECI_FILE_DISCONNECTED);
- heci_init_file_private(&dev->iamthif_file_ext, NULL);
- dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTED;
-
+ spin_lock(&dev->mecl_loc...
[truncated message content] |
|
From: <mar...@us...> - 2008-07-22 17:12:57
|
Revision: 206
http://openamt.svn.sourceforge.net/openamt/?rev=206&view=rev
Author: marcin_obara
Date: 2008-07-22 17:13:05 +0000 (Tue, 22 Jul 2008)
Log Message:
-----------
5.0 base for testing code
Modified Paths:
--------------
heci/branches/testing/COPYING
heci/branches/testing/README
heci/branches/testing/src/Makefile
heci/branches/testing/src/heci.h
heci/branches/testing/src/heci_data_structures.h
heci/branches/testing/src/heci_init.c
heci/branches/testing/src/heci_interface.c
heci/branches/testing/src/heci_interface.h
heci/branches/testing/src/heci_main.c
heci/branches/testing/src/interrupt.c
heci/branches/testing/src/io_heci.c
heci/branches/testing/src/kcompat.h
Added Paths:
-----------
heci/branches/testing/src/heci_version.h
Removed Paths:
-------------
heci/branches/testing/scripts/
heci/branches/testing/src/version.h
Modified: heci/branches/testing/COPYING
===================================================================
--- heci/branches/testing/COPYING 2008-07-22 16:25:37 UTC (rev 205)
+++ heci/branches/testing/COPYING 2008-07-22 17:13:05 UTC (rev 206)
@@ -1,7 +1,7 @@
/*
* Part of "Intel(R) Manageability Engine Interface" Linux driver
*
- * Copyright (c) 2007 Intel Corp.
+ * Copyright (c) 2003 - 2008 Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
Modified: heci/branches/testing/README
===================================================================
--- heci/branches/testing/README 2008-07-22 16:25:37 UTC (rev 205)
+++ heci/branches/testing/README 2008-07-22 17:13:05 UTC (rev 206)
@@ -1,6 +1,6 @@
/+---------------------------------------------------------------------------
//
-// Copyright (C) Intel Corporation, 2003 - 2007.
+// Copyright (C) Intel Corporation, 2003 - 2008.
//
// File: README
//
@@ -26,17 +26,14 @@
Building and installing the Intel(R) Manageability Engine Interface driver:
-----------------------------
In order to build and install the Intel(R) Manageability Engine Interface driver,
-call "make install" from the /src directory. This builds the Intel(R)
-Manageability Engine Interface driver, installs it and the startup script.
+call "make install".
Call "make uninstall" to uninstall and remove the Intel(R) Manageability Engine
-Interface driver and the startup script. In order to load and use the driver
-call "modprobe heci" or "insmod heci.ko" and call make_node script from
-scripts/ directory. To start heci driver at system boot, startup script need
-to be added to desired runlevel.
+Interface driver.
+In order to load and use the driver call "modprobe heci" or "insmod heci.ko".
The Intel(R) Manageability Engine Interface driver may also be built and
-installed manually, by first calling "make", then "insmod heci.ko", followed
-by "./make_node". Remove by calling "rmmod heci.ko".
+installed manually, by first calling "make", then "insmod heci.ko".
+Remove by calling "rmmod heci.ko".
Accessing The FW Via Intel(R) Manageability Engine Interface driver:
-----------------------------
Modified: heci/branches/testing/src/Makefile
===================================================================
--- heci/branches/testing/src/Makefile 2008-07-22 16:25:37 UTC (rev 205)
+++ heci/branches/testing/src/Makefile 2008-07-22 17:13:05 UTC (rev 206)
@@ -3,7 +3,7 @@
#
# Part of Intel(R) Manageability Engine Interface Linux driver
#
-# Copyright (c) 2003 - 2007 Intel Corp.
+# Copyright (c) 2003 - 2008 Intel Corp.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -45,15 +45,11 @@
# core driver files
CFILES = heci_init.c interrupt.c heci_interface.c io_heci.c heci_main.c
-HFILES = heci.h heci_interface.h
+HFILES = heci.h heci_interface.h heci_structures,h heci_version.h kcompat.h
ifeq (,$(BUILD_KERNEL))
BUILD_KERNEL = $(shell uname -r)
endif
-INIT_SCRIPT_PATH = /etc/init.d
-INIT_SCRIPT_SRC = ../scripts/heci.sh
-INIT_SCRIPT = heci
-
###########################################################################
# Environment tests
@@ -129,27 +125,27 @@
# some additional features are only built on Intel platforms
ARCH := $(shell uname -m | sed 's/i.86/i386/')
ifeq ($(ARCH),alpha)
- CFLAGS += -ffixed-8 -mno-fp-regs
+ EXTRA_CFLAGS += -ffixed-8 -mno-fp-regs
endif
ifeq ($(ARCH),x86_64)
- CFLAGS += -mcmodel=kernel -mno-red-zone
+ EXTRA_CFLAGS += -mcmodel=kernel -mno-red-zone
endif
ifeq ($(ARCH),ppc)
- CFLAGS += -msoft-float
+ EXTRA_CFLAGS += -msoft-float
endif
ifeq ($(ARCH),ppc64)
- CFLAGS += -m64 -msoft-float
+ EXTRA_CFLAGS += -m64 -msoft-float
LDFLAGS += -melf64ppc
endif
# standard flags for module builds
-CFLAGS += -DLINUX -D__KERNEL__ -DMODULE -O2 -pipe -Wall
-CFLAGS += -I$(KSRC)/include -I.
-CFLAGS += $(shell [ -f $(KSRC)/include/linux/modversions.h ] && \
+EXTRA_CFLAGS += -DLINUX -D__KERNEL__ -DMODULE -O2 -pipe -Wall
+EXTRA_CFLAGS += -I$(KSRC)/include -I.
+EXTRA_CFLAGS += $(shell [ -f $(KSRC)/include/linux/modversions.h ] && \
echo "-DMODVERSIONS -DEXPORT_SYMTAB \
-include $(KSRC)/include/linux/modversions.h")
-CFLAGS += $(CFLAGS_EXTRA)
+EXTRA_CFLAGS += $(CFLAGS_EXTRA)
RHC := $(KSRC)/include/linux/rhconfig.h
ifneq (,$(wildcard $(RHC)))
@@ -200,7 +196,7 @@
endif
ifeq ($(SMP),1)
- CFLAGS += -D__SMP__
+ EXTRA_CFLAGS += -D__SMP__
endif
@@ -233,6 +229,9 @@
# remove all old versions of the driver
find $(INSTALL_MOD_PATH)/lib/modules/$(KVER) -name $(TARGET) -exec rm -f {} \; || true
find $(INSTALL_MOD_PATH)/lib/modules/$(KVER) -name $(TARGET).gz -exec rm -f {} \; || true
+ if [ -e /etc/init.d/heci ] ; then \
+ rm -f /etc/init.d/heci ; \
+ fi
install -D -m 644 $(TARGET) $(INSTALL_MOD_PATH)$(INSTDIR)/$(TARGET)
ifeq (,$(INSTALL_MOD_PATH))
/sbin/depmod -a || true
@@ -243,13 +242,11 @@
/sbin/depmod -b $(INSTALL_MOD_PATH) -a -n > /dev/null || true
endif
endif
- #copy init script to init.d
- install ${INIT_SCRIPT_SRC} ${INIT_SCRIPT_PATH}/${INIT_SCRIPT}
.PHONY: clean install uninstall test
clean:
- rm -rf $(TARGET) $(TARGET:.ko=.o) $(TARGET:.ko=.mod.o) $(TARGET:.ko=.mod.c) $(CFILES:.c=.o) .*cmd .tmp_versions Module.symvers
+ rm -rf $(TARGET) $(TARGET:.ko=.o) $(TARGET:.ko=.mod.o) $(TARGET:.ko=.mod.c) $(CFILES:.c=.o) .*cmd .tmp_versions Module.symvers Modules.symvers
test:
@echo $(KVER)
@@ -258,7 +255,3 @@
if [ -e $(INSTDIR)/$(TARGET) ]; then \
rm -f ${INSTDIR}/$(TARGET) ; \
fi
- #remove init script from init.d
- if [ -e ${INIT_SCRIPT_PATH}/${INIT_SCRIPT} ] ; then \
- rm -f ${INIT_SCRIPT_PATH}/${INIT_SCRIPT} ; \
- fi
Modified: heci/branches/testing/src/heci.h
===================================================================
--- heci/branches/testing/src/heci.h 2008-07-22 16:25:37 UTC (rev 205)
+++ heci/branches/testing/src/heci.h 2008-07-22 17:13:05 UTC (rev 206)
@@ -1,7 +1,7 @@
/*
* Part of Intel(R) Manageability Engine Interface Linux driver
*
- * Copyright (c) 2003 - 2007 Intel Corp.
+ * Copyright (c) 2003 - 2008 Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -53,82 +53,124 @@
#include <linux/types.h>
#include "heci_data_structures.h"
-
extern const struct guid heci_pthi_guid;
-extern const __u8 start_wd_params[];
-extern const __u8 stop_wd_params[];
+extern const struct guid heci_wd_guid;
+extern const __u8 heci_start_wd_params[];
+extern const __u8 heci_stop_wd_params[];
+extern const __u8 heci_wd_state_independence_msg[3][4];
-/**
- * memory IO BAR definition
+/*
+ * heci device ID
*/
-#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 HECI_DEV_ID_82946GZ 0x2974 /* 82946GZ/GL */
+#define HECI_DEV_ID_82G35 0x2984 /* 82G35 Express */
+#define HECI_DEV_ID_82Q965 0x2994 /* 82Q963/Q965 */
+#define HECI_DEV_ID_82G965 0x29A4 /* 82P965/G965 */
-/**
+#define HECI_DEV_ID_82GM965 0x2A04 /* Mobile PM965/GM965 */
+#define HECI_DEV_ID_82GME965 0x2A14 /* Mobile GME965/GLE960 */
+
+#define HECI_DEV_ID_ICH9_82Q35 0x29B4 /* 82Q35 Express */
+#define HECI_DEV_ID_ICH9_82G33 0x29C4 /* 82G33/G31/P35/P31 Express */
+#define HECI_DEV_ID_ICH9_82Q33 0x29D4 /* 82Q33 Express */
+#define HECI_DEV_ID_ICH9_82X38 0x29E4 /* 82X38/X48 Express */
+#define HECI_DEV_ID_ICH9_3200 0x29F4 /* 3200/3210 Server */
+
+#define HECI_DEV_ID_ICH9_6 0x28B4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_7 0x28C4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_8 0x28D4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_9 0x28E4 /* Bearlake */
+#define HECI_DEV_ID_ICH9_10 0x28F4 /* Bearlake */
+
+#define HECI_DEV_ID_ICH9M_1 0x2A44 /* Cantiga */
+#define HECI_DEV_ID_ICH9M_2 0x2A54 /* Cantiga */
+#define HECI_DEV_ID_ICH9M_3 0x2A64 /* Cantiga */
+#define HECI_DEV_ID_ICH9M_4 0x2A74 /* Cantiga */
+
+#define HECI_DEV_ID_ICH10_1 0x2E04 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_2 0x2E14 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_3 0x2E24 /* Eaglelake */
+#define HECI_DEV_ID_ICH10_4 0x2E34 /* Eaglelake */
+
+/*
* heci init function prototypes
*/
struct iamt_heci_device *init_heci_device(struct pci_dev *pdev);
-void heci_reset(struct iamt_heci_device * device_object, int interrupts);
-int heci_hw_init(struct iamt_heci_device * device_object);
-int heci_initialize_clients(void *data);
-struct heci_file_private *alloc_priv(struct file *file);
-int heci_disconnect_host_client(struct iamt_heci_device * device_object,
- struct heci_file_private * file_extension);
+void heci_reset(struct iamt_heci_device *dev, int interrupts);
+int heci_hw_init(struct iamt_heci_device *dev);
+int heci_task_initialize_clients(void *data);
+int heci_initialize_clients(struct iamt_heci_device *dev);
+struct heci_file_private *heci_alloc_file_private(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 * device_object);
+ struct iamt_heci_device *dev);
void heci_flush_list(struct io_heci_list *list,
- struct heci_file_private * file_extension);
-void heci_flush_queues(struct iamt_heci_device * device_object,
- struct heci_file_private * file_extension);
+ 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 * device_object,
+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,
+int heci_ioctl_get_version(struct iamt_heci_device *dev, int if_num,
struct heci_message_data *u_msg,
struct heci_message_data k_msg,
- struct heci_file_private * file_extension);
-int heci_ioctl_connect_client(struct iamt_heci_device * device, int if_num,
+ struct heci_file_private *file_ext);
+
+int heci_ioctl_connect_client(struct iamt_heci_device *dev, 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,
+
+int heci_ioctl_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
- struct heci_file_private * file_extension);
-int legacy_ioctl_send_message(struct iamt_heci_device * device, int if_num,
- struct heci_message_data k_msg,
- struct file *file);
-int legacy_ioctl_receive_message(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_extension);
-int pthi_write(struct iamt_heci_device * device,
- struct heci_cb_private *kernel_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_extension);
-void run_next_legacy_cmd(struct iamt_heci_device * device);
+ struct heci_file_private *file_ext);
-#endif /* _HECI_H_ */
+int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
+ struct heci_message_data k_msg,
+ struct heci_file_private *file_ext);
+
+int heci_start_read(struct iamt_heci_device *dev, int if_num,
+ struct heci_file_private *file_ext);
+
+int pthi_write(struct iamt_heci_device *dev,
+ struct heci_cb_private *priv_cb);
+
+int pthi_read(struct iamt_heci_device *dev, 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 *dev,
+ struct file *file);
+
+void run_next_iamthif_cmd(struct iamt_heci_device *dev);
+
+void heci_free_cb_private(struct heci_cb_private *priv_cb);
+
+/**
+ * heci_fe_same_id - tell if file private data have same id
+ *
+ * @fe1: private data of 1. file object
+ * @fe2: private data of 2. file object
+ *
+ * returns !=0 - if ids are the same, 0 - if differ.
+ */
+static inline int heci_fe_same_id(const struct heci_file_private *fe1,
+ const struct heci_file_private *fe2)
+{
+ return ((fe1->host_client_id == fe2->host_client_id)
+ && (fe1->me_client_id == fe2->me_client_id));
+}
+
+#endif /* _HECI_H_ */
Modified: heci/branches/testing/src/heci_data_structures.h
===================================================================
--- heci/branches/testing/src/heci_data_structures.h 2008-07-22 16:25:37 UTC (rev 205)
+++ heci/branches/testing/src/heci_data_structures.h 2008-07-22 17:13:05 UTC (rev 206)
@@ -1,7 +1,7 @@
/*
* Part of Intel(R) Manageability Engine Interface Linux driver
*
- * Copyright (c) 2003 - 2007 Intel Corp.
+ * Copyright (c) 2003 - 2008 Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -52,116 +52,112 @@
#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
-/**
+#define HECI_FC_MESSAGE_RESERVED_LENGTH 5
+
+/*
* Number of queue lists used by this driver
*/
-#define NUMBER_OF_LISTS 7
+#define HECI_IO_LISTS_NUMBER 7
-#define LEGACY_MTU 4160
-#pragma pack(1)
+/*
+ * Maximum transmission unit (MTU) of heci messages
+ */
+#define IAMTHIF_MTU 4160
-/**
+/*
* HECI HW Section
*/
-/* HECI addresses and defines */
+/* HECI registers */
+/* H_CB_WW - Host Circular Buffer (CB) Write Window register */
#define H_CB_WW 0
+/* H_CSR - Host Control Status register */
#define H_CSR 4
+/* ME_CB_RW - ME Circular Buffer Read Window register (read only) */
#define ME_CB_RW 8
+/* ME_CSR_HA - ME Control Status Host Access register (read only) */
#define ME_CSR_HA 0xC
-/* register bits - H_CSR */
-
+/* register bits of H_CSR (Host Control Status register) */
+/* Host Circular Buffer Depth - maximum number of 32-bit entries in CB */
#define H_CBD 0xFF000000
+/* Host Circular Buffer Write Pointer */
#define H_CBWP 0x00FF0000
+/* Host Circular Buffer Read Pointer */
#define H_CBRP 0x0000FF00
+/* Host Reset */
#define H_RST 0x00000010
+/* Host Ready */
#define H_RDY 0x00000008
+/* Host Interrupt Generate */
#define H_IG 0x00000004
+/* Host Interrupt Status */
#define H_IS 0x00000002
+/* Host Interrupt Enable */
#define H_IE 0x00000001
-/* register bits - ME_CSR_HA */
+/* register bits of ME_CSR_HA (ME Control Status Host Access register) */
+/* ME CB (Circular Buffer) Depth HRA (Host Read Access)
+ * - host read only access to ME_CBD */
#define ME_CBD_HRA 0xFF000000
+/* ME CB Write Pointer HRA - host read only access to ME_CBWP */
#define ME_CBWP_HRA 0x00FF0000
+/* ME CB Read Pointer HRA - host read only access to ME_CBRP */
#define ME_CBRP_HRA 0x0000FF00
+/* ME Reset HRA - host read only access to ME_RST */
#define ME_RST_HRA 0x00000010
+/* ME Ready HRA - host read only access to ME_RDY */
#define ME_RDY_HRA 0x00000008
+/* ME Interrupt Generate HRA - host read only access to ME_IG */
#define ME_IG_HRA 0x00000004
+/* ME Interrupt Status HRA - host read only access to ME_IS */
#define ME_IS_HRA 0x00000002
+/* ME Interrupt Enable HRA - host read only access to ME_IE */
#define ME_IE_HRA 0x00000001
-/**
- * heci driver use additional char device for legacy mode
- */
-#define MINORS_COUNT 2
+#define HECI_MINORS_BASE 1
+#define HECI_MINORS_COUNT 1
-#define LEGACY_MINOR_NUMBER 0
#define HECI_MINOR_NUMBER 1
-#define MAX_OPEN_HANDLE_COUNT 253
-/**
+#define HECI_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)
+extern int heci_debug;
-
-/* 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); \
+#define DBG(format, arg...) do { \
+ if (heci_debug) \
+ printk(KERN_INFO "heci: %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
+/*
+ * time to wait HECI become ready after init
*/
#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_STATE_INDEPENDENCE_MSG_SENT (1 << 0)
-
#define HECI_WD_HOST_CLIENT_ID 1
-#define HECI_LEGACY_HOST_CLIENT_ID 2
+#define HECI_IAMTHIF_HOST_CLIENT_ID 2
-#undef FALSE
-#undef TRUE
-#define TRUE 1
-#define FALSE 0
-
struct guid {
__u32 data1;
__u16 data2;
@@ -178,8 +174,8 @@
HECI_FILE_DISCONNECTED
};
-/* HECI states */
-enum heci_states{
+/* HECI device states */
+enum heci_states {
HECI_INITIALIZING = 0,
HECI_ENABLED,
HECI_RESETING,
@@ -189,12 +185,12 @@
HECI_POWER_UP
};
-enum legacy_states {
- HECI_LEGACY_IDLE,
- HECI_LEGACY_WRITING,
- HECI_LEGACY_FLOW_CONTROL,
- HECI_LEGACY_READING,
- HECI_LEGACY_READ_COMPLETE
+enum iamthif_states {
+ HECI_IAMTHIF_IDLE,
+ HECI_IAMTHIF_WRITING,
+ HECI_IAMTHIF_FLOW_CONTROL,
+ HECI_IAMTHIF_READING,
+ HECI_IAMTHIF_READ_COMPLETE
};
enum heci_file_transaction_states {
@@ -219,14 +215,12 @@
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
+} __attribute__((packed));
-#define CONNECT_TIMEOUT 3 /* at least 2 seconds */
+#define HECI_CONNECT_TIMEOUT 3 /* at least 2 seconds */
-#define LEGACY_STALL_TIMER 12 /* seconds */
+#define IAMTHIF_STALL_TIMER 12 /* seconds */
+#define IAMTHIF_READ_TIMER 15 /* seconds */
struct heci_cb_private {
struct list_head cb_list;
@@ -235,6 +229,7 @@
struct heci_message_data request_buffer;
struct heci_message_data response_buffer;
unsigned long information;
+ unsigned long read_time;
struct file *file_object;
};
@@ -246,18 +241,19 @@
wait_queue_head_t tx_wait;
wait_queue_head_t rx_wait;
wait_queue_head_t wait;
- spinlock_t file_lock;
- spinlock_t read_io_lock;
- spinlock_t write_io_lock;
+ 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_control_credentials;
+ __u8 flow_ctrl_creds;
__u8 timer_count;
enum heci_file_transaction_states reading_state;
enum heci_file_transaction_states writing_state;
+ int sm_state;
struct heci_cb_private *read_cb;
};
@@ -272,138 +268,139 @@
__u8 minor;
__u8 hotfix;
__u16 build;
-};
+} __attribute__((packed));
struct heci_client {
- __u32 max_message_length;
+ __u32 max_msg_length;
__u8 protocol_version;
-};
+} __attribute__((packed));
+
/*
* HECI BUS Interface Section
*/
-struct heci_message_header {
- __u32 me_address:8;
- __u32 host_address:8;
+struct heci_msg_hdr {
+ __u32 me_addr:8;
+ __u32 host_addr:8;
__u32 length:9;
__u32 reserved:6;
- __u32 message_complete:1;
-};
+ __u32 msg_complete:1;
+} __attribute__((packed));
-struct hbm_command {
- __u8 command:7;
+struct hbm_cmd {
+ __u8 cmd:7;
__u8 is_response:1;
-};
+} __attribute__((packed));
struct heci_bus_message {
- struct hbm_command command;
+ struct hbm_cmd cmd;
__u8 command_specific_data[];
-};
+} __attribute__((packed));
struct hbm_version {
__u8 minor_version;
__u8 major_version;
-};
+} __attribute__((packed));
struct hbm_host_version_request {
- struct hbm_command command;
+ struct hbm_cmd cmd;
__u8 reserved;
struct hbm_version host_version;
-};
+} __attribute__((packed));
struct hbm_host_version_response {
- struct hbm_command command;
+ struct hbm_cmd cmd;
int host_version_supported;
struct hbm_version me_max_version;
-};
+} __attribute__((packed));
struct hbm_host_stop_request {
- struct hbm_command command;
+ struct hbm_cmd cmd;
__u8 reason;
__u8 reserved[2];
-};
+} __attribute__((packed));
struct hbm_host_stop_response {
- struct hbm_command command;
+ struct hbm_cmd cmd;
__u8 reserved[3];
-};
+} __attribute__((packed));
struct hbm_me_stop_request {
- struct hbm_command command;
+ struct hbm_cmd cmd;
__u8 reason;
__u8 reserved[2];
-};
+} __attribute__((packed));
-struct hbm_host_enumeration_request {
- struct hbm_command command;
+struct hbm_host_enum_request {
+ struct hbm_cmd cmd;
__u8 reserved[3];
-};
+} __attribute__((packed));
-struct hbm_host_enumeration_response {
- struct hbm_command command;
+struct hbm_host_enum_response {
+ struct hbm_cmd cmd;
__u8 reserved[3];
__u8 valid_addresses[32];
-};
+} __attribute__((packed));
struct heci_client_properties {
struct guid protocol_name;
__u8 protocol_version;
__u8 max_number_of_connections;
__u8 fixed_address;
- __u8 single_receive_buffer;
- __u32 max_message_length;
-};
+ __u8 single_recv_buf;
+ __u32 max_msg_length;
+} __attribute__((packed));
-struct hbm_host_client_properties_request {
- struct hbm_command command;
+struct hbm_props_request {
+ struct hbm_cmd cmd;
__u8 address;
__u8 reserved[2];
-};
+} __attribute__((packed));
-struct hbm_host_client_properties_response {
- struct hbm_command command;
+struct hbm_props_response {
+ struct hbm_cmd cmd;
__u8 address;
__u8 status;
__u8 reserved[1];
struct heci_client_properties client_properties;
-};
+} __attribute__((packed));
struct hbm_client_connect_request {
- struct hbm_command command;
- __u8 me_address;
- __u8 host_address;
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
__u8 reserved;
-};
+} __attribute__((packed));
struct hbm_client_connect_response {
- struct hbm_command command;
- __u8 me_address;
- __u8 host_address;
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
__u8 status;
-};
+} __attribute__((packed));
struct hbm_client_disconnect_request {
- struct hbm_command command;
- __u8 me_address;
- __u8 host_address;
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
__u8 reserved[1];
-};
+} __attribute__((packed));
struct hbm_flow_control {
- struct hbm_command command;
- __u8 me_address;
- __u8 host_address;
- __u8 reserved[FC_MESSAGE_RESERVED_LENGTH];
-};
+ struct hbm_cmd cmd;
+ __u8 me_addr;
+ __u8 host_addr;
+ __u8 reserved[HECI_FC_MESSAGE_RESERVED_LENGTH];
+} __attribute__((packed));
struct heci_me_client {
- struct heci_client_properties properteis;
+ struct heci_client_properties props;
__u8 client_id;
- __u8 flow_control_credentials;
-};
+ __u8 flow_ctrl_creds;
+} __attribute__((packed));
/* private device struct */
struct iamt_heci_device {
@@ -411,14 +408,17 @@
/*
* lists of queues
*/
- struct io_heci_list *io_list_array[NUMBER_OF_LISTS]; /* array of pointers to aio lists */
- struct io_heci_list read_list; /* driver read queue */
+ /* array of pointers to aio lists */
+ struct io_heci_list *io_list_array[HECI_IO_LISTS_NUMBER];
+ 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; /* driver write waiting queue */
- struct io_heci_list control_write_list; /* driver managed write IOCTL list */
- struct io_heci_list control_read_list; /* driver managed read IOCTL list */
- struct io_heci_list pthi_cmd_list; /* driver managed PTHI list for cmd waiting */
- struct io_heci_list pthi_read_complete_list; /* driver managed PTHI list for read completed pthi command data */
+ 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 reading completed pthi cmd data */
+ struct io_heci_list pthi_read_complete_list;
/*
* list of files
*/
@@ -432,16 +432,12 @@
/*
* lock for the device
*/
- spinlock_t device_lock;
- spinlock_t extra_lock;
- /*
- * intterupts
- */
- int irq;
+ spinlock_t device_lock; /* device lock*/
struct work_struct work;
- int received_message;
+ int recvd_msg;
- struct timer_list timer;
+ struct task_struct *reinit_tsk;
+
struct timer_list wd_timer;
/*
* hw states of host and fw(ME)
@@ -451,28 +447,25 @@
/*
* waiting queue for receive message from FW
*/
- wait_queue_head_t wait_received_message;
+ 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 read_message_buffer[128]; /* used for control messages */
- __u32 write_message_buffer[128]; /* used for control messages */
- __u32 extra_message_buffer[8]; /* for control responses */
- __u32 read_message_header;
+ __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_extension;
- struct heci_me_client *me_clients; /* Note: memory has to be allocated */
+ 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 */
@@ -486,21 +479,21 @@
__u16 wd_due_counter;
int asf_mode;
+ int wd_bypass; /* if 1, don't refresh watchdog ME client */
- /* maybe this is not required */
- struct file *legacy_file_object;
- struct heci_file_private legacy_file_extension;
- int legacy_ioctl;
- int legacy_canceled;
- __u32 legacy_timer;
- __u32 legacy_stall_timer;
- unsigned char legacy_message_buffer[LEGACY_MTU];
- __u32 legacy_message_buffer_size;
- __u32 legacy_message_buffer_index;
- int legacy_flow_control_pending;
- enum legacy_states legacy_state;
+ struct file *iamthif_file_object;
+ struct heci_file_private iamthif_file_ext;
+ int iamthif_ioctl;
+ int iamthif_canceled;
+ __u32 iamthif_timer;
+ __u32 iamthif_stall_timer;
+ unsigned char iamthif_msg_buf[IAMTHIF_MTU];
+ __u32 iamthif_msg_buf_size;
+ __u32 iamthif_msg_buf_index;
+ int iamthif_flow_control_pending;
+ enum iamthif_states iamthif_state;
- struct heci_cb_private *legacy_current_cb;
+ struct heci_cb_private *iamthif_current_cb;
__u8 write_hang;
int need_reset;
long open_handle_count;
@@ -509,23 +502,29 @@
/**
* read_heci_register - Read a byte from the heci device
- * @device: the device structure
+ *
+ * @dev: the device structure
* @offset: offset from which to read the data
*
- * Return:
- * the byte read.
+ * returns the byte read.
*/
-__u32 read_heci_register(struct iamt_heci_device * device,
- unsigned long offset);
+static inline __u32 read_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset)
+{
+ return readl(dev->mem_addr + offset);
+}
/**
* write_heci_register - Write 4 bytes to the heci device
- * @device: the device structure
- * @offset: offset from which to write the data
*
+ * @dev: 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);
+static inline void write_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset, __u32 value)
+{
+ writel(value, dev->mem_addr + offset);
+}
-#endif /* _HECI_DATA_STRUCTURES_H_ */
+#endif /* _HECI_DATA_STRUCTURES_H_ */
Modified: heci/branches/testing/src/heci_init.c
===================================================================
--- heci/branches/testing/src/heci_init.c 2008-07-22 16:25:37 UTC (rev 205)
+++ heci/branches/testing/src/heci_init.c 2008-07-22 17:13:05 UTC (rev 206)
@@ -1,7 +1,7 @@
/*
* Part of Intel(R) Manageability Engine Interface Linux driver
*
- * Copyright (c) 2007 Intel Corp.
+ * Copyright (c) 2003 - 2008 Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -41,919 +41,932 @@
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/reboot.h>
-#include <asm/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 <linux/kthread.h>
#include "kcompat.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} };
+const __u8 heci_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
+const __u8 heci_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
+const __u8 heci_wd_state_independence_msg[3][4] = {
+ {0x05, 0x02, 0x51, 0x10},
+ {0x05, 0x02, 0x52, 0x10},
+ {0x07, 0x02, 0x01, 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 * device_object);
-int host_enum_clients_message(struct iamt_heci_device * device_object);
-int allocate_me_clents_storage(struct iamt_heci_device * device_object);
-void heci_disable(struct iamt_heci_device * device_object);
-void host_init_wd(struct iamt_heci_device * device_object);
-void host_init_legacy(struct iamt_heci_device * device_object);
+static void heci_check_asf_mode(struct iamt_heci_device *dev);
+static int host_start_message(struct iamt_heci_device *dev);
+static int host_enum_clients_message(struct iamt_heci_device *dev);
+static int allocate_me_clients_storage(struct iamt_heci_device *dev);
+static void host_init_wd(struct iamt_heci_device *dev);
+static void host_init_iamthif(struct iamt_heci_device *dev);
+static int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
+ long timeout);
/**
- * heci_initialize_list - Sets up a queue list.
+ * heci_initialize_list - Sets up a queue list.
*
- * @list - An instance of our list structure
- * @device_object -Device object for our driver
- *
- * @return :
- * none;
+ * @list: An instance of our list structure
+ * @dev: Device object for our driver
*/
void heci_initialize_list(struct io_heci_list *list,
- struct iamt_heci_device * device_object)
+ struct iamt_heci_device *dev)
{
/* initialize our queue list */
INIT_LIST_HEAD(&list->heci_cb.cb_list);
- list->status = ESUCCESS;
- list->device_extension = device_object;
- return;
+ list->status = 0;
+ list->device_extension = dev;
}
/**
- * heci_flush_queues - flush our queues list belong to file_extension.
+ * heci_flush_queues - flush our queues list belong to file_ext.
*
- * @device_object -Device object for our driver
- *
- * @return :
- * none;
+ * @dev: Device object for our driver
+ * @file_ext: private data of the file object
*/
-void heci_flush_queues(struct iamt_heci_device * device_object,
- struct heci_file_private * file_extension)
+void heci_flush_queues(struct iamt_heci_device *dev,
+ struct heci_file_private *file_ext)
{
int i;
- if (!device_object || !file_extension)
+
+ if (!dev || !file_ext)
return;
- /* flush our queue list belong to file_extension */
- for (i = 0; i < NUMBER_OF_LISTS; i++) {
- DBG("remove list etnry belong to file_extension\n");
- heci_flush_list(device_object->io_list_array[i],
- file_extension);
- }
+ /* flush our queue list belong to file_ext */
+ for (i = 0; i < HECI_IO_LISTS_NUMBER; i++) {
+ DBG("remove list entry belong to file_ext\n");
+ heci_flush_list(dev->io_list_array[i], file_ext);
+ }
}
/**
- * heci_flush_list - remove list etnry belong to file_extension.
+ * heci_flush_list - remove list entry belong to file_ext.
*
- * @list - An instance of our list structure
- * @file_extension -extension of the file object
-
- * @return :
- * none;
+ * @list: An instance of our list structure
+ * @file_ext: private data of the file object
*/
void heci_flush_list(struct io_heci_list *list,
- struct heci_file_private * file_extension)
+ struct heci_file_private *file_ext)
{
- struct heci_file_private *file_extension_temp = NULL;
- struct heci_cb_private *kernel_priv_cb_pos = NULL, *kernel_priv_cb_next = NULL;
+ struct heci_file_private *file_ext_tmp;
+ struct heci_cb_private *priv_cb_pos = NULL;
+ struct heci_cb_private *priv_cb_next = NULL;
- if (!list || !file_extension)
+ if (!list || !file_ext)
return;
- if (list->status == ESUCCESS
- && !list_empty(&list->heci_cb.cb_list)) {
- list_for_each_entry_safe(kernel_priv_cb_pos, kernel_priv_cb_next, &list->heci_cb.cb_list, cb_list){
- if (kernel_priv_cb_pos) {
- file_extension_temp =
- (struct heci_file_private *)
- kernel_priv_cb_pos->file_private;
- }
- if (file_extension_temp) {
- if ((file_extension->host_client_id == file_extension_temp-> host_client_id)
- && (file_extension->me_client_id == file_extension_temp-> me_client_id))
- list_del(&kernel_priv_cb_pos->cb_list);
- }
+ if (list->status != 0)
+ return;
+ if (list_empty(&list->heci_cb.cb_list))
+ return;
+
+ 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 (heci_fe_same_id(file_ext, file_ext_tmp))
+ list_del(&priv_cb_pos->cb_list);
+ }
}
}
- return;
}
/**
+ * heci_reset_iamthif_params - initializes heci device iamthif
+ *
+ * @dev: The heci device structure
+ */
+static void heci_reset_iamthif_params(struct iamt_heci_device *dev)
+{
+ /* reset iamthif parameters. */
+ dev->iamthif_current_cb = NULL;
+ dev->iamthif_msg_buf_size = 0;
+ dev->iamthif_msg_buf_index = 0;
+ dev->iamthif_canceled = 0;
+ dev->iamthif_file_ext.file = NULL;
+ dev->iamthif_ioctl = 0;
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
+ dev->iamthif_timer = 0;
+}
+
+/**
* 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.
+ * returns The heci_device_device pointer on success, NULL on failure.
*/
-struct iamt_heci_device *init_heci_device(struct pci_dev * pdev)
+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) {
+ struct iamt_heci_device *dev;
+
+ dev = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
+ if (!dev)
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->control_write_list;
- device->io_list_array[4] = &device->control_read_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_extension.link);
- INIT_LIST_HEAD(&device->legacy_file_extension.link);
- spin_lock_init(&device->device_lock);
- init_waitqueue_head(&device->wait_received_message);
- 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->read_message_header = 0;
- device->mem_addr = NULL;
- device->asf_mode = FALSE;
- device->need_reset = FALSE;
- device->received_message = FALSE;
- device->heci_state = HECI_INITIALIZING;
+ dev->io_list_array[0] = &dev->read_list;
+ dev->io_list_array[1] = &dev->write_list;
+ dev->io_list_array[2] = &dev->write_waiting_list;
+ dev->io_list_array[3] = &dev->ctrl_wr_list;
+ dev->io_list_array[4] = &dev->ctrl_rd_list;
+ dev->io_list_array[5] = &dev->pthi_cmd_list;
+ dev->io_list_array[6] = &dev->pthi_read_complete_list;
+ INIT_LIST_HEAD(&dev->file_list);
+ INIT_LIST_HEAD(&dev->wd_file_ext.link);
+ INIT_LIST_HEAD(&dev->iamthif_file_ext.link);
+ spin_lock_init(&dev->device_lock);
+ init_waitqueue_head(&dev->wait_recvd_msg);
+ init_waitqueue_head(&dev->wait_stop_wd);
+ dev->heci_state = HECI_INITIALIZING;
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
- 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_message_buffer_index = 0;
- device->wd_pending = FALSE;
- device->wd_stoped = 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;
+ INIT_WORK(&dev->work, NULL);
+ for (i = 0; i < HECI_IO_LISTS_NUMBER; i++)
+ heci_initialize_list(dev->io_list_array[i], dev);
+ dev->pdev = pdev;
+ return dev;
}
+
+
+
+static int heci_wait_event_int_timeout(struct iamt_heci_device *dev,
+ long timeout)
+{
+ return wait_event_interruptible_timeout(dev->wait_recvd_msg,
+ (dev->recvd_msg), timeout);
+}
+
/**
* heci_hw_init - init host and fw to start work.
*
- * @device_object -Device object for our driver
+ * @dev: Device object for our driver
*
- *@return:
- * 0 on success.
- * negative on failure
+ * returns 0 on success, <0 on failure.
*/
-int heci_hw_init(struct iamt_heci_device * device_object)
+int heci_hw_init(struct iamt_heci_device *dev)
{
int err = 0;
- device_object->host_hw_state =
- read_heci_register(device_object, H_CSR);
- device_object->me_hw_state =
- read_heci_register(device_object, ME_CSR_HA);
+
+ 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",
- device_object->host_hw_state, device_object->me_hw_state);
+ dev->host_hw_state, dev->me_hw_state);
- if ((device_object->host_hw_state & H_IS) == H_IS) {
+ if ((dev->host_hw_state & H_IS) == H_IS) {
/* acknowledge interrupt and stop interupts */
- write_heci_register(device_object, H_CSR,
- device_object->host_hw_state);
+ heci_set_csr_register(dev);
}
- device_object->received_message = FALSE;
+ dev->recvd_msg = 0;
DBG("reset in start the heci device.\n");
- heci_reset(device_object, TRUE);
+ heci_reset(dev, 1);
DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
- device_object->host_hw_state, device_object->me_hw_state);
+ dev->host_hw_state, dev->me_hw_state);
/* wait for ME to turn on ME_RDY */
- if (!device_object->received_message) {
- err =
- wait_event_interruptible_timeout(device_object->
- wait_received_message,
- (device_object->
- received_message),
- HECI_INTEROP_TIMEOUT);
- }
+ if (!dev->recvd_msg)
+ err = heci_wait_event_int_timeout(dev, HECI_INTEROP_TIMEOUT);
- if (!err && !device_object->received_message) {
- device_object->heci_state = HECI_DISABLED;
- DBG("wait_event_interruptible_timeout failed on wait for ME to turn on ME_RDY.\n");
+ 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 (!(((device_object->host_hw_state & H_RDY) == H_RDY)
- && ((device_object->me_hw_state & ME_RDY_HRA) ==
- ME_RDY_HRA))) {
- device_object->heci_state = HECI_DISABLED;
+ 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",
- device_object->host_hw_state,
- device_object->me_hw_state);
+ dev->host_hw_state,
+ dev->me_hw_state);
- if (!(device_object->host_hw_state & H_RDY) != H_RDY)
+ if (!(dev->host_hw_state & H_RDY) != H_RDY)
DBG("host turn off H_RDY.\n");
- if (!(device_object->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
+
+ if (!(dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
DBG("ME turn off ME_RDY.\n");
- ERR("link layer initialization failed.\n");
+
+ printk(KERN_ERR
+ "heci: link layer initialization failed.\n");
return -ENODEV;
}
}
- device_object->received_message = FALSE;
+ dev->recvd_msg = 0;
DBG("host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
- device_object->host_hw_state, device_object->me_hw_state);
+ 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;
+ printk(KERN_INFO "heci: link layer has been established.\n");
+ return 0;
}
/**
- * heci_reset - reset host and fw.
+ * heci_hw_reset - reset fw via heci csr register.
*
- * @device_object -Device object for our driver
- * @interrupts - if interrupt should be enable after reset.
+ * @dev: Device object for our driver
+ * @interrupts: if interrupt should be enable after reset.
+ */
+static void heci_hw_reset(struct iamt_heci_device *dev, int interrupts)
+{
+ dev->host_hw_state |= (H_RST | H_IG);
+
+ if (interrupts)
+ heci_csr_enable_interrupts(dev);
+ else
+ heci_csr_disable_interrupts(dev);
+
+ BUG_ON((dev->host_hw_state & H_RST) != H_RST);
+ BUG_ON((dev->host_hw_state & H_RDY) != 0);
+}
+
+/**
+ * heci_reset - reset host and fw.
*
- * @return:
- * none;
+ * @dev: Device object for our driver
+ * @interrupts: if interrupt should be enable after reset.
*/
-void heci_reset(struct iamt_heci_device * device_object, int interrupts)
+void heci_reset(struct iamt_heci_device *dev, int interrupts)
{
- struct heci_file_private *file_extension_pos = NULL;
- struct heci_file_private *file_extension_next = NULL;
- struct heci_cb_private *kernel_priv_cb_pos = NULL,
- *kernel_priv_cb_next = NULL;
+ 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;
+ int unexpected = 0;
- if (device_object->heci_state == HECI_RECOVERING_FROM_RESET) {
- device_object->need_reset = TRUE;
+ if (dev->heci_state == HECI_RECOVERING_FROM_RESET) {
+ dev->need_reset = 1;
return;
}
- device_object->host_hw_state =
- read_heci_register(device_object, H_CSR);
- DBG("before reset host_hw_state = 0x%08x.\n",
- device_object->host_hw_state);
+ if (dev->heci_state != HECI_INITIALIZING &&
+ dev->heci_state != HECI_DISABLED &&
+ dev->heci_state != HECI_POWER_DOWN &&
+ dev->heci_state != HECI_POWER_UP)
+ unexpected = 1;
- device_object->host_hw_state |= (H_RST | H_IG);
+ if (dev->reinit_tsk != NULL) {
+ kthread_stop(dev->reinit_tsk);
+ dev->reinit_tsk = NULL;
+ }
- if (interrupts)
- device_object->host_hw_state |= (H_IE);
- else
- device_object->host_hw_state &= ~(H_IE);
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
- write_heci_register(device_object, H_CSR,
- device_object->host_hw_state);
+ DBG("before reset host_hw_state = 0x%08x.\n",
+ dev->host_hw_state);
- device_object->host_hw_state =
- read_heci_register(device_object, H_CSR);
- BUG_ON((device_object->host_hw_state & H_RST) != H_RST);
- BUG_ON((device_object->host_hw_state & H_RDY) != 0);
+ heci_hw_reset(dev, interrupts);
- device_object->host_hw_state &= ~H_RST;
- device_object->host_hw_state |= H_IG;
+ dev->host_hw_state &= ~H_RST;
+ dev->host_hw_state |= H_IG;
- write_heci_register(device_object, H_CSR,
- device_object->host_hw_state);
+ write_heci_register(dev, H_CSR, dev->host_hw_state);
DBG("currently saved host_hw_state = 0x%08x.\n",
- device_object->host_hw_state);
+ dev->host_hw_state);
- device_object->need_reset = FALSE;
+ dev->need_reset = 0;
- if (device_object->heci_state != HECI_INITIALIZING) {
- if (device_object->heci_state != HECI_DISABLED) {
- device_object->heci_state = HECI_RESETING;
+ if (dev->heci_state != HECI_INITIALIZING) {
+ if ((dev->heci_state != HECI_DISABLED) &&
+ (dev->heci_state != HECI_POWER_DOWN))
+ 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;
}
- list_for_each_entry_safe(file_extension_pos, file_extension_next, &device_object->file_list, link) {
- file_extension_pos->state = HECI_FILE_DISCONNECTED;
- file_extension_pos->flow_control_credentials = 0;
- file_extension_pos->read_cb = NULL;
- file_extension_pos->timer_count = 0;
- }
/* remove entry if already in list */
- DBG("list del legacy and wd file list.\n");
- heci_remove_client_from_file_list(device_object,
- device_object->
- wd_file_extension.
- host_client_id);
+ DBG("list del iamthif and wd file list.\n");
+ heci_remove_client_from_file_list(dev,
+ dev->wd_file_ext.host_client_id);
- heci_remove_client_from_file_list(device_object,
- device_object->
- legacy_file_extension.
- host_client_id);
- /* reset legacy parameters. */
- device_object->legacy_current_cb = NULL;
- device_object->legacy_message_buffer_size = 0;
- device_object->legacy_message_buffer_index = 0;
- device_object->legacy_canceled = FALSE;
- device_object->legacy_file_extension.file = NULL;
- device_object->legacy_ioctl = FALSE;
- device_object->legacy_state = HECI_LEGACY_IDLE;
- device_object->legacy_timer = 0;
- device_object->wd_due_counter = 0;
- device_object->extra_write_index = 0;
- device_object->wd_pending = FALSE;
+ heci_remove_client_from_file_list(dev,
+ dev->iamthif_file_ext.host_client_id);
+
+ heci_reset_iamthif_params(dev);
+ dev->wd_due_counter = 0;
+ dev->extra_write_index = 0;
}
- device_object->num_heci_me_clients = 0;
- device_object->read_message_header = 0;
- device_object->stop = FALSE;
- device_object->wd_pending = 0;
+ dev->num_heci_me_clients = 0;
+ dev->rd_msg_hdr = 0;
+ dev->stop = 0;
+ dev->wd_pending = 0;
/* update the state of the registers after reset */
- device_object->host_hw_state =
- read_heci_register(device_object, H_CSR);
- device_object->me_hw_state =
- read_heci_register(device_object, ME_CSR_HA);
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
+ dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
DBG("after reset host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
- device_object->host_hw_state, device_object->me_hw_state);
+ dev->host_hw_state, dev->me_hw_state);
- if (device_object->heci_state != HECI_INITIALIZING &&
- device_object->heci_state != HECI_DISABLED)
- ERR("unexpected heci reset.\n");
- //Wake up all readings so they can be interrupted
- list_for_each_entry_safe(file_extension_pos,file_extension_next, &device_object->file_list,link) {
- if (&file_extension_pos->rx_wait &&
- waitqueue_active (&file_extension_pos->rx_wait)) {
- INFO("Waking up client!\n");
- wake_up_interruptible(&file_extension_pos->rx_wait);
- }
+ if (unexpected)
+ printk(KERN_WARNING "heci: unexpected reset.\n");
+
+ /* Wake up all readings so they can be interrupted */
+ list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
+ if (&file_pos->rx_wait &&
+ waitqueue_active(&file_pos->rx_wait)) {
+ printk(KERN_INFO "heci: Waking up client!\n");
+ wake_up_interruptible(&file_pos->rx_wait);
}
- // remove all waiting requests
- if (device_object->write_list.status == ESUCCESS && !list_empty(&device_object->write_list.heci_cb.cb_list)) {
- list_for_each_entry_safe(kernel_priv_cb_pos, kernel_priv_cb_next, &device_object->write_list.heci_cb.cb_list, cb_list){
- if (kernel_priv_cb_pos) {
- list_del(&kernel_priv_cb_pos->cb_list);
- kfree(kernel_priv_cb_pos->request_buffer.data);
- kernel_priv_cb_pos->request_buffer.data = NULL;
- kfree(kernel_priv_cb_pos->response_buffer.data);
- kernel_priv_cb_pos->response_buffer.data = NULL;
- kfree(kernel_priv_cb_pos);
- kernel_priv_cb_pos = NULL;
+ }
+ /* remove all waiting requests */
+ if (dev->write_list.status == 0 &&
+ !list_empty(&dev->write_list.heci_cb.cb_list)) {
+ list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
+ &dev->write_list.heci_cb.cb_list, cb_list) {
+ if (priv_cb_pos) {
+ list_del(&priv_cb_pos->cb_list);
+ heci_free_cb_private(priv_cb_pos);
}
}
}
-
-
}
/**
- * heci_disable - reseting in disable routine.
+ * heci_initialize_clients - heci communication initialization.
*
- * @device_object -Device object for our driver
- *
- * @return:
- * none;
+ * @dev: Device object for our driver
*/
-void heci_disable(struct iamt_heci_device * device_object)
+int heci_initialize_clients(struct iamt_heci_device *dev)
{
- if (device_object->heci_state != HECI_INITIALIZING)
- ERR("driver stop request heci state is disable.\n");
- device_object->heci_state = HECI_DISABLED;
-}
-
-/**
- * heci_initialize_clients - routine.
- *
- * @device_object -Device object for our driver
- *
- * @return:
- * none;
- */
-int heci_initialize_clients(void *data)
-{
-
int status;
- struct iamt_heci_device *device_object = (struct iamt_heci_device *) data;
+
+ msleep(100); /* FW needs time to be ready to talk with us */
DBG("link is established start sending messages.\n");
/* link is established start sending messages. */
- status = host_start_message(device_object);
- if (status) {
+ status = host_start_message(dev);
+ if (status != 0) {
+ spin_lock_bh(&dev->device_lock);
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
DBG("start sending messages failed.\n");
- return -ENODEV;
+ return status;
}
- /* enumerate clients */
- status = host_enum_clients_message(device_object);
- if (status) {
+ /* enumerate clients */
+ status = host_enum_clients_message(dev);
+ if (status != 0) {
+ spin_lock_bh(&dev->device_lock);
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
DBG("enum clients failed.\n");
- return -ENODEV;
+ return status;
}
/* allocate storage for ME clients representation */
- status = allocate_me_clents_storage(device_object);
- if (status) {
+ status = allocate_me_clients_storage(dev);
+ if (status != 0) {
+ spin_lock_bh(&dev->device_lock);
+ dev->num_heci_me_clients = 0;
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
DBG("allocate clients failed.\n");
- return -ENODEV;
+ return status;
}
+
+ heci_check_asf_mode(dev);
/*heci initialization wd */
- host_init_wd(device_object);
- /*heci initialization legacy client */
- host_init_legacy(device_object);
- if (device_object->need_reset) {
- device_object->need_reset = FALSE;
- device_object->heci_state = HECI_DISABLED;
+ host_init_wd(dev);
+ /*heci initialization iamthif client */
+ host_init_iamthif(dev);
+
+ spin_lock_bh(&dev->device_lock);
+ if (dev->need_reset) {
+ dev->need_reset = 0;
+ dev->heci_state = HECI_DISABLED;
+ spin_unlock_bh(&dev->device_lock);
return -ENODEV;
}
- memset(device_object->heci_host_clients, 0,
- sizeof(device_object->heci_host_clients));
- device_object->open_handle_count = 0;
- device_object->heci_host_clients[0] |= 7;
- device_object->current_host_client_id = 3;
- device_object->heci_state = HECI_ENABLED;
+ memset(dev->heci_host_clients, 0, sizeof(dev->heci_host_clients));
+ dev->open_handle_count = 0;
+ dev->heci_host_clients[0] |= 7;
+ dev->current_host_client_id = 3;
+ dev->heci_state = HECI_ENABLED;
+ spin_unlock_bh(&dev->device_lock);
DBG("initialization heci clients successful.\n");
- return ESUCCESS;
+ return 0;
}
/**
+ * heci_task_initialize_clients - heci reinitialization task
+ *
+ * @data: Device object for our driver
+ */
+int heci_task_initialize_clients(void *data)
+{
+ int ret;
+ struct iamt_heci_device *dev = (struct iamt_heci_device *) data;
+
+ spin_lock_bh(&dev->device_lock);
+ if (dev->reinit_tsk != NULL) {
+ spin_unlock_bh(&dev->device_lock);
+ DBG("reinit task already started.\n");
+ return 0;
+ }
+ dev->reinit_tsk = current;
+ current->flags |= PF_NOFREEZE;
+ spin_unlock_bh(&dev->device_lock);
+
+ ret = heci_initialize_clients(dev);
+
+ spin_lock_bh(&dev->device_lock);
+ dev->reinit_tsk = NULL;
+ spin_unlock_bh(&dev->device_lock);
+
+ return ret;
+}
+
+/**
* host_start_message - heci host send start message.
*
- * @device_object - Device object for our driver
+ * @dev: Device object for our driver
*
- * @return :
- * 0 on success,
- * negative on failure.
+ * returns 0 on success, <0 on failure.
*/
-int host_start_message(struct iamt_heci_device * device_object)
+static int host_start_message(struct iamt_heci_device *dev)
{
- long timeout = 10; /* 10 second */
+ long timeout = 60; /* 60 second */
- struct heci_message_header *heci_header;
+ struct heci_msg_hdr *heci_hdr;
struct hbm_host_version_request *host_start_req;
struct hbm_host_stop_request *host_stop_req;
int err = 0;
+
/* host start message */
- msleep(100);
- heci_header =
- (struct heci_message_header *) & device_object->
- write_message_buffer[0];
- heci_header->host_address = 0;
- heci_header->me_address = 0;
- heci_header->length = sizeof(struct hbm_host_version_request);
- heci_header->message_complete = 1;
- heci_header->reserved = 0;
+ heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_host_version_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
host_start_req =
- (struct hbm_host_version_request *) & device_object->
- write_message_buffer[1];
- memset(host_start_req, 0, sizeof(host_start_req));
- host_start_req->command.command = HOST_START_REQ_CMD;
- host_start_req->reserved = 0;
+ (struct hbm_host_version_request *) &dev->wr_msg_buf[1];
+ memset(host_start_req, 0, sizeof(struct hbm_host_version_request));
+ host_start_req->cmd.cmd = HOST_START_REQ_CMD;
host_start_req->host_version.major_version = HBM_MAJOR_VERSION;
host_start_req->host_version.minor_version = HBM_MINOR_VERSION;
- device_object->received_message = FALSE;
- if (!heci_write_message(device_object, heci_header,
+ dev->recvd_msg = 0;
+ if (!heci_write_message(dev, heci_hdr,
(unsigned char *) (host_start_req),
- heci_header->length)) {
- device_object->heci_state = HECI_DISABLED;
+ heci_hdr->length)) {
DBG("send version to fw fail.\n");
return -ENODEV;
}
- DBG("call wait_event_interruptible_timeout for response message. \n");
+ DBG("call wait_event_interruptible_timeout for response message.\n");
/* wait for response */
- err =
- wait_event_interruptible_timeout(device_object->
- wait_received_message,
- (device_object->
- received_message),
- timeout * HZ);
- if (!err && !device_object->received_message) {
- device_object->heci_state = HECI_DISABLED;
- DBG("wait_event_interruptible_timeout failed on host start response message. \n");
+ err = heci_wait_event_int_timeout(dev, timeout * HZ);
+ if (!err && !dev->recvd_msg) {
+ DBG("wait_timeout failed on host start response message.\n");
return -ENODEV;
}
- device_object->received_message = FALSE;
- DBG("wait_event_interruptible_timeout successful on host start response message. \n");
- if ((device_object->version.major_version != HBM_MAJOR_VERSION) ||
- (device_object->version.minor_version != HBM_MINOR_VERSION)) {
+ dev->recvd_msg = 0;
+ DBG("wait_timeout successful on host start response message.\n");
+ if ((dev->version.major_version != HBM_MAJOR_VERSION) ||
+ (dev->version.minor_version != HBM_MINOR_VERSION)) {
/* send stop message */
- heci_header->host_address = 0;
- heci_header->me_address = 0;
- heci_header->length = sizeof(struct hbm_host_stop_request);
- heci_header->message_complete = 1;
- heci_header->reserved = 0;
+ heci_hdr->host_addr = 0;
+ heci_hdr->me_addr = 0;
+ heci_hdr->length = sizeof(struct hbm_host_stop_request);
+ heci_hdr->msg_complete = 1;
+ heci_hdr->reserved = 0;
host_stop_req =
- (struct hbm_host_stop_request *) & device_object->
- write_message_buffer[1];
+ (struct hbm_host_stop_request *) &dev->wr_msg_buf[1];
- memset(host_stop_req, 0, sizeof(host_stop_req));
- host_st...
[truncated message content] |
|
From: <mar...@us...> - 2008-07-22 16:25:29
|
Revision: 205
http://openamt.svn.sourceforge.net/openamt/?rev=205&view=rev
Author: marcin_obara
Date: 2008-07-22 16:25:37 +0000 (Tue, 22 Jul 2008)
Log Message:
-----------
fixed minor issues raised on lkml
Modified Paths:
--------------
heci/branches/heci-5.0/src/heci.h
heci/branches/heci-5.0/src/heci_data_structures.h
heci/branches/heci-5.0/src/heci_init.c
heci/branches/heci-5.0/src/heci_interface.c
heci/branches/heci-5.0/src/heci_interface.h
heci/branches/heci-5.0/src/heci_main.c
heci/branches/heci-5.0/src/heci_version.h
heci/branches/heci-5.0/src/interrupt.c
heci/branches/heci-5.0/src/io_heci.c
heci/branches/heci-5.0/src/kcompat.h
Modified: heci/branches/heci-5.0/src/heci.h
===================================================================
--- heci/branches/heci-5.0/src/heci.h 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci.h 2008-07-22 16:25:37 UTC (rev 205)
@@ -55,11 +55,11 @@
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[];
+extern const __u8 heci_start_wd_params[];
+extern const __u8 heci_stop_wd_params[];
extern const __u8 heci_wd_state_independence_msg[3][4];
-/**
+/*
* heci device ID
*/
#define HECI_DEV_ID_82946GZ 0x2974 /* 82946GZ/GL */
@@ -92,7 +92,7 @@
#define HECI_DEV_ID_ICH10_3 0x2E24 /* Eaglelake */
#define HECI_DEV_ID_ICH10_4 0x2E34 /* Eaglelake */
-/**
+/*
* heci init function prototypes
*/
struct iamt_heci_device *init_heci_device(struct pci_dev *pdev);
@@ -113,48 +113,48 @@
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);
-/**
+/*
* input output function prototype
*/
-int heci_ioctl_get_version(struct iamt_heci_device *device, int if_num,
+int heci_ioctl_get_version(struct iamt_heci_device *dev, 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,
+int heci_ioctl_connect_client(struct iamt_heci_device *dev, 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,
+int heci_ioctl_wd(struct iamt_heci_device *dev, 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,
+int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
struct heci_file_private *file_ext);
-int heci_start_read(struct iamt_heci_device *device, int if_num,
+int heci_start_read(struct iamt_heci_device *dev, int if_num,
struct heci_file_private *file_ext);
-int pthi_write(struct iamt_heci_device *device,
+int pthi_write(struct iamt_heci_device *dev,
struct heci_cb_private *priv_cb);
-int pthi_read(struct iamt_heci_device *device, int if_num, struct file *file,
+int pthi_read(struct iamt_heci_device *dev, 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 iamt_heci_device *dev,
struct file *file);
-void run_next_iamthif_cmd(struct iamt_heci_device *device);
+void run_next_iamthif_cmd(struct iamt_heci_device *dev);
void heci_free_cb_private(struct heci_cb_private *priv_cb);
@@ -164,10 +164,10 @@
* @fe1: private data of 1. file object
* @fe2: private data of 2. file object
*
- * @return !=0 - if ids are the same, 0 - if differ.
+ * returns !=0 - if ids are the same, 0 - if differ.
*/
-static inline int heci_fe_same_id(struct heci_file_private *fe1,
- struct heci_file_private *fe2)
+static inline int heci_fe_same_id(const struct heci_file_private *fe1,
+ const struct heci_file_private *fe2)
{
return ((fe1->host_client_id == fe2->host_client_id)
&& (fe1->me_client_id == fe2->me_client_id));
Modified: heci/branches/heci-5.0/src/heci_data_structures.h
===================================================================
--- heci/branches/heci-5.0/src/heci_data_structures.h 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci_data_structures.h 2008-07-22 16:25:37 UTC (rev 205)
@@ -52,7 +52,7 @@
#include <linux/aio.h>
#include <linux/types.h>
-/**
+/*
* error code definition
*/
#define ESLOTS_OVERFLOW 1
@@ -61,18 +61,18 @@
#define HECI_FC_MESSAGE_RESERVED_LENGTH 5
-/**
+/*
* Number of queue lists used by this driver
*/
#define HECI_IO_LISTS_NUMBER 7
-/**
+/*
* Maximum transmission unit (MTU) of heci messages
*/
#define IAMTHIF_MTU 4160
-/**
+/*
* HECI HW Section
*/
@@ -131,23 +131,23 @@
#define HECI_MINOR_NUMBER 1
#define HECI_MAX_OPEN_HANDLE_COUNT 253
-/**
+/*
* debug kernel print macro define
*/
extern int heci_debug;
#define DBG(format, arg...) do { \
if (heci_debug) \
- printk(KERN_ERR "%s: " format , __func__ , ## arg); \
+ printk(KERN_INFO "heci: %s: " format, __func__, ## arg); \
} while (0)
-/**
+/*
* time to wait HECI become ready after init
*/
#define HECI_INTEROP_TIMEOUT (HZ * 7)
-/**
+/*
* watch dog definition
*/
#define HECI_WATCHDOG_DATA_SIZE 16
@@ -163,7 +163,7 @@
__u16 data2;
__u16 data3;
__u8 data4[8];
-} __attribute__((packed));
+};
/* File state */
enum file_state {
@@ -503,22 +503,28 @@
/**
* read_heci_register - Read a byte from the heci device
*
- * @device: the device structure
+ * @dev: the device structure
* @offset: offset from which to read the data
*
- * @return the byte read.
+ * returns the byte read.
*/
-__u32 read_heci_register(struct iamt_heci_device *device,
- unsigned long offset);
+static inline __u32 read_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset)
+{
+ return readl(dev->mem_addr + offset);
+}
/**
* write_heci_register - Write 4 bytes to the heci device
*
- * @device: the device structure
+ * @dev: 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);
+static inline void write_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset, __u32 value)
+{
+ writel(value, dev->mem_addr + offset);
+}
#endif /* _HECI_DATA_STRUCTURES_H_ */
Modified: heci/branches/heci-5.0/src/heci_init.c
===================================================================
--- heci/branches/heci-5.0/src/heci_init.c 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci_init.c 2008-07-22 16:25:37 UTC (rev 205)
@@ -55,11 +55,8 @@
#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 __u8 heci_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
+const __u8 heci_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
const __u8 heci_wd_state_independence_msg[3][4] = {
{0x05, 0x02, 0x51, 0x10},
@@ -81,7 +78,7 @@
};
-/**
+/*
* heci init function prototypes
*/
static void heci_check_asf_mode(struct iamt_heci_device *dev);
@@ -95,7 +92,7 @@
/**
- * heci_initialize_list - Sets up a queue list.
+ * heci_initialize_list - Sets up a queue list.
*
* @list: An instance of our list structure
* @dev: Device object for our driver
@@ -114,7 +111,6 @@
*
* @dev: Device object for our driver
* @file_ext: private data of the file object
- *
*/
void heci_flush_queues(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -169,6 +165,7 @@
/**
* heci_reset_iamthif_params - initializes heci device iamthif
+ *
* @dev: The heci device structure
*/
static void heci_reset_iamthif_params(struct iamt_heci_device *dev)
@@ -186,42 +183,43 @@
/**
* 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.
+ * returns 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;
+ struct iamt_heci_device *dev;
- device = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
- if (!device)
+ dev = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
+ if (!dev)
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->iamthif_file_ext.link);
- spin_lock_init(&device->device_lock);
- init_waitqueue_head(&device->wait_recvd_msg);
- init_waitqueue_head(&device->wait_stop_wd);
- device->heci_state = HECI_INITIALIZING;
- device->iamthif_state = HECI_IAMTHIF_IDLE;
+ dev->io_list_array[0] = &dev->read_list;
+ dev->io_list_array[1] = &dev->write_list;
+ dev->io_list_array[2] = &dev->write_waiting_list;
+ dev->io_list_array[3] = &dev->ctrl_wr_list;
+ dev->io_list_array[4] = &dev->ctrl_rd_list;
+ dev->io_list_array[5] = &dev->pthi_cmd_list;
+ dev->io_list_array[6] = &dev->pthi_read_complete_list;
+ INIT_LIST_HEAD(&dev->file_list);
+ INIT_LIST_HEAD(&dev->wd_file_ext.link);
+ INIT_LIST_HEAD(&dev->iamthif_file_ext.link);
+ spin_lock_init(&dev->device_lock);
+ init_waitqueue_head(&dev->wait_recvd_msg);
+ init_waitqueue_head(&dev->wait_stop_wd);
+ dev->heci_state = HECI_INITIALIZING;
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
/* init work for schedule work */
- INIT_WORK(&device->work, NULL);
+ INIT_WORK(&dev->work, NULL);
for (i = 0; i < HECI_IO_LISTS_NUMBER; i++)
- heci_initialize_list(device->io_list_array[i], device);
- device->pdev = pdev;
- return device;
+ heci_initialize_list(dev->io_list_array[i], dev);
+ dev->pdev = pdev;
+ return dev;
}
@@ -239,7 +237,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_hw_init(struct iamt_heci_device *dev)
{
@@ -299,7 +297,7 @@
}
/**
- * heci_hw_reset - reset fw via heci csr register.
+ * heci_hw_reset - reset fw via heci csr register.
*
* @dev: Device object for our driver
* @interrupts: if interrupt should be enable after reset.
@@ -318,7 +316,7 @@
}
/**
- * heci_reset - reset host and fw.
+ * heci_reset - reset host and fw.
*
* @dev: Device object for our driver
* @interrupts: if interrupt should be enable after reset.
@@ -402,7 +400,7 @@
dev->host_hw_state, dev->me_hw_state);
if (unexpected)
- printk(KERN_WARNING "unexpected heci reset.\n");
+ printk(KERN_WARNING "heci: unexpected reset.\n");
/* Wake up all readings so they can be interrupted */
list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
@@ -426,10 +424,9 @@
}
/**
- * heci_initialize_clients - routine.
+ * heci_initialize_clients - heci communication initialization.
*
* @dev: Device object for our driver
- *
*/
int heci_initialize_clients(struct iamt_heci_device *dev)
{
@@ -446,8 +443,8 @@
DBG("start sending messages failed.\n");
return status;
}
- /* enumerate clients */
+ /* enumerate clients */
status = host_enum_clients_message(dev);
if (status != 0) {
spin_lock_bh(&dev->device_lock);
@@ -492,10 +489,9 @@
}
/**
- * heci_task_initialize_clients - routine.
+ * heci_task_initialize_clients - heci reinitialization task
*
* @data: Device object for our driver
- *
*/
int heci_task_initialize_clients(void *data)
{
@@ -526,7 +522,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int host_start_message(struct iamt_heci_device *dev)
{
@@ -596,7 +592,8 @@
* host_enum_clients_message - host send enumeration client request message.
*
* @dev: Device object for our driver
- * @return 0 on success, <0 on failure.
+ *
+ * returns 0 on success, <0 on failure.
*/
static int host_enum_clients_message(struct iamt_heci_device *dev)
{
@@ -654,7 +651,7 @@
* @idx: client index in me client array
* @client_id: id of the client
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int host_client_properties(struct iamt_heci_device *dev,
struct heci_me_client *client)
@@ -696,7 +693,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int allocate_me_clients_storage(struct iamt_heci_device *dev)
{
@@ -753,7 +750,6 @@
*
* @priv: private file structure to be initialized
* @file: the file structure
- *
*/
static void heci_init_file_private(struct heci_file_private *priv,
struct file *file)
@@ -779,7 +775,7 @@
* @cguid: searched guid of ME client
* @client_id: id of host client to be set in file private structure
*
- * @return ME client index
+ * returns ME client index
*/
static __u8 heci_find_me_client(struct iamt_heci_device *dev,
struct heci_file_private *priv,
@@ -809,7 +805,6 @@
* heci_check_asf_mode - check for ASF client
*
* @dev: Device object for our driver
- *
*/
static void heci_check_asf_mode(struct iamt_heci_device *dev)
{
@@ -839,7 +834,7 @@
* @priv: private file structure
* @timeout: connect timeout in seconds
*
- * @return 1 - if connected, 0 - if not
+ * returns 1 - if connected, 0 - if not
*/
static __u8 heci_connect_me_client(struct iamt_heci_device *dev,
struct heci_file_private *priv,
@@ -884,11 +879,9 @@
* host_init_wd - heci initialization wd.
*
* @dev: Device object for our driver
- *
*/
static void host_init_wd(struct iamt_heci_device *dev)
{
-
spin_lock_bh(&dev->device_lock);
heci_init_file_private(&dev->wd_file_ext, NULL);
@@ -898,12 +891,12 @@
dev->wd_timeout = 0;
if (dev->asf_mode) {
- memcpy(dev->wd_data, stop_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
} else {
/* AMT mode */
dev->wd_timeout = AMT_WD_VALUE;
DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
- memcpy(dev->wd_data, start_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data, heci_start_wd_params, HECI_WD_PARAMS_SIZE);
memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
&dev->wd_timeout, sizeof(__u16));
}
@@ -971,7 +964,7 @@
* heci_alloc_file_private - allocates a private file structure and set it up.
* @file: the file structure
*
- * @return The allocated file or NULL on failure
+ * returns The allocated file or NULL on failure
*/
struct heci_file_private *heci_alloc_file_private(struct file *file)
{
@@ -989,12 +982,12 @@
/**
- * heci_disconnect_host_client - send disconnect message to fw from host client.
+ * heci_disconnect_host_client - send disconnect message to fw from host client.
*
* @dev: Device object for our driver
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_disconnect_host_client(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -1062,12 +1055,11 @@
}
/**
- * heci_remove_client_from_file_list -
+ * heci_remove_client_from_file_list -
* remove file private data from device file list
*
* @dev: Device object for our driver
* @host_client_id: host client id to be removed
- *
*/
void heci_remove_client_from_file_list(struct iamt_heci_device *dev,
__u8 host_client_id)
Modified: heci/branches/heci-5.0/src/heci_interface.c
===================================================================
--- heci/branches/heci-5.0/src/heci_interface.c 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci_interface.c 2008-07-22 16:25:37 UTC (rev 205)
@@ -43,39 +43,7 @@
#include "heci_interface.h"
-
-static const __u8 interface_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10};
-static const __u8 interface_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10};
-
/**
- * 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)
-{
- return readl(device->mem_addr + 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)
-{
- writel(value, device->mem_addr + offset);
-}
-
-
-/**
* heci_set_csr_register - write H_CSR register to the heci device
*
* @dev: device object for our driver
@@ -114,9 +82,9 @@
*
* @device: the device structure
*
- * @return numer of filled slots
+ * returns numer of filled slots
*/
-static unsigned char _host_get_filled_slots(struct iamt_heci_device *dev)
+static unsigned char _host_get_filled_slots(const struct iamt_heci_device *dev)
{
char read_ptr, write_ptr;
@@ -131,7 +99,7 @@
*
* @dev: device object for our driver
*
- * @return 1 if empty, 0 - otherwise.
+ * returns 1 if empty, 0 - otherwise.
*/
int host_buffer_is_empty(struct iamt_heci_device *dev)
{
@@ -151,9 +119,9 @@
*
* @dev: device object for our driver
*
- * @return -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
+ * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
*/
-__s32 count_empty_write_slots(struct iamt_heci_device *dev)
+__s32 count_empty_write_slots(const struct iamt_heci_device *dev)
{
unsigned char buffer_depth, filled_slots, empty_slots;
@@ -177,7 +145,7 @@
* @write_buffer: message buffer will be write
* @write_length: message size will be write
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_write_message(struct iamt_heci_device *dev,
struct heci_msg_hdr *header,
@@ -231,7 +199,7 @@
*
* @dev: device object for our driver
*
- * @return -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
+ * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
*/
__s32 count_full_read_slots(struct iamt_heci_device *dev)
{
@@ -288,7 +256,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if flow_ctrl_creds >0, 0 - otherwise.
+ * returns 1 if flow_ctrl_creds >0, 0 - otherwise.
*/
int flow_ctrl_creds(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -353,7 +321,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_send_flow_control(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -388,19 +356,19 @@
/**
* other_client_is_connecting - check if other
- * client with the same client id is connected.
+ * client with the same client id is connected.
*
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if other client is connected, 0 - otherwise.
+ * returns 1 if other client is connected, 0 - otherwise.
*/
int other_client_is_connecting(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
{
-
struct heci_file_private *file_pos = NULL;
struct heci_file_private *file_next = NULL;
+
list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
if ((file_pos->state == HECI_FILE_CONNECTING)
&& (file_pos != file_ext)
@@ -416,7 +384,7 @@
*
* @dev: device object for our driver
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_send_wd(struct iamt_heci_device *dev)
{
@@ -428,11 +396,11 @@
heci_hdr->msg_complete = 1;
heci_hdr->reserved = 0;
- if (!memcmp(dev->wd_data, interface_start_wd_params,
+ if (!memcmp(dev->wd_data, heci_start_wd_params,
HECI_WD_PARAMS_SIZE)) {
heci_hdr->length = HECI_START_WD_DATA_SIZE;
} else {
- BUG_ON(memcmp(dev->wd_data, interface_stop_wd_params,
+ BUG_ON(memcmp(dev->wd_data, heci_stop_wd_params,
HECI_WD_PARAMS_SIZE));
heci_hdr->length = HECI_WD_PARAMS_SIZE;
}
@@ -449,7 +417,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_disconnect(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -486,7 +454,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_connect(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
Modified: heci/branches/heci-5.0/src/heci_interface.h
===================================================================
--- heci/branches/heci-5.0/src/heci_interface.h 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci_interface.h 2008-07-22 16:25:37 UTC (rev 205)
@@ -128,7 +128,7 @@
};
-/**
+/*
* heci interface function prototypes
*/
void heci_set_csr_register(struct iamt_heci_device *dev);
@@ -147,7 +147,7 @@
__s32 count_full_read_slots(struct iamt_heci_device *dev);
-__s32 count_empty_write_slots(struct iamt_heci_device *dev);
+__s32 count_empty_write_slots(const struct iamt_heci_device *dev);
int flow_ctrl_creds(struct iamt_heci_device *dev,
struct heci_file_private *file_ext);
Modified: heci/branches/heci-5.0/src/heci_main.c
===================================================================
--- heci/branches/heci-5.0/src/heci_main.c 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci_main.c 2008-07-22 16:25:37 UTC (rev 205)
@@ -69,7 +69,7 @@
#define HECI_DRIVER_NAME "heci"
-/**
+/*
* heci driver strings
*/
char heci_driver_name[] = HECI_DRIVER_NAME;
@@ -98,7 +98,6 @@
static struct pci_dev *heci_device;
struct class *heci_class;
-struct class_device *heci_class_dev;
/* heci_pci_tbl - PCI Device ID Table */
@@ -133,7 +132,7 @@
MODULE_DEVICE_TABLE(pci, heci_pci_tbl);
-/**
+/*
* Local Function Prototypes
*/
static int __init heci_init_module(void);
@@ -161,7 +160,7 @@
#define heci_suspend NULL
#define heci_resume NULL
#endif
-/**
+/*
* PCI driver structure
*/
static struct pci_driver heci_driver = {
@@ -174,7 +173,7 @@
.resume = heci_resume
};
-/**
+/*
* file operations structure will be use heci char device.
*/
static struct file_operations heci_fops = {
@@ -188,13 +187,13 @@
};
/**
- * Set up the cdev structure for heci device.
+ * heci_registration_cdev - set up the cdev structure for heci device.
*
* @dev: char device struct
* @hminor: minor number for registration char device
* @fops: file operations structure
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_registration_cdev(struct cdev *dev, int hminor,
struct file_operations *fops)
@@ -222,67 +221,78 @@
static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
/**
- * heci_sysfs_create - creates a struct class to contain heci info
+ * heci_register_cdev - registers heci char device
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
-static int heci_sysfs_create(void)
+static int heci_register_cdev(void)
{
- struct class *class;
- int err = 0;
+ int ret;
+ dev_t dev;
- class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
- if (IS_ERR(class)) {
- err = PTR_ERR(class);
- printk(KERN_ERR "heci: Error creating heci class.\n");
- goto err_out;
+ /* registration of char devices */
+ ret = alloc_chrdev_region(&dev, HECI_MINORS_BASE, HECI_MINORS_COUNT,
+ HECI_DRIVER_NAME);
+ if (ret) {
+ printk(KERN_ERR "heci: Error allocating char device region.\n");
+ return ret;
}
- err = class_create_file(class, &class_attr_version);
- if (err) {
- class_destroy(class);
- printk(KERN_ERR "heci: Error creating heci class file.\n");
- goto err_out;
- }
+ heci_major = MAJOR(dev);
- heci_class = class;
-err_out:
- return err;
+ ret = heci_registration_cdev(&heci_cdev, HECI_MINOR_NUMBER,
+ &heci_fops);
+ if (ret)
+ unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
+ HECI_MINORS_COUNT);
+
+ return ret;
}
/**
- * heci_sysfs_destroy - destroys a struct class of heci info
+ * heci_unregister_cdev - unregisters heci char device
*/
-static void heci_sysfs_destroy(void)
+static void heci_unregister_cdev(void)
{
- if ((heci_class == NULL) || (IS_ERR(heci_class)))
- return;
-
- class_remove_file(heci_class, &class_attr_version);
- class_destroy(heci_class);
+ cdev_del(&heci_cdev);
+ unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
+ HECI_MINORS_COUNT);
}
/**
- * heci_sysfs_device_create - adds device to sysfs for character devices
+ * heci_sysfs_device_create - adds device entry to sysfs
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_sysfs_device_create(void)
{
+ struct class *class;
+ void *tmphdev;
int err = 0;
- if ((heci_class == NULL) || (IS_ERR(heci_class))) {
- err = -EINVAL;
+ class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
+ if (IS_ERR(class)) {
+ err = PTR_ERR(class);
+ printk(KERN_ERR "heci: Error creating heci class.\n");
goto err_out;
}
- heci_class_dev = class_device_create(heci_class, NULL,
- heci_cdev.dev,
- NULL,
- HECI_DEV_NAME);
- if (IS_ERR(heci_class_dev))
- err = PTR_ERR(heci_class_dev);
+ err = class_create_file(class, &class_attr_version);
+ if (err) {
+ class_destroy(class);
+ printk(KERN_ERR "heci: Error creating heci class file.\n");
+ goto err_out;
+ }
+ tmphdev = device_create(class, NULL, heci_cdev.dev, HECI_DEV_NAME);
+ if (IS_ERR(tmphdev)) {
+ err = PTR_ERR(tmphdev);
+ class_remove_file(class, &class_attr_version);
+ class_destroy(class);
+ goto err_out;
+ }
+
+ heci_class = class;
err_out:
return err;
}
@@ -292,8 +302,12 @@
*/
static void heci_sysfs_device_remove(void)
{
- if (heci_class_dev)
- class_device_unregister(heci_class_dev);
+ if ((heci_class == NULL) || (IS_ERR(heci_class)))
+ return;
+
+ device_destroy(heci_class, heci_cdev.dev);
+ class_remove_file(heci_class, &class_attr_version);
+ class_destroy(heci_class);
}
/**
@@ -302,12 +316,11 @@
* heci_init_module is the first routine called when the driver is
* loaded. All it does is register with the PCI subsystem.
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int __init heci_init_module(void)
{
int ret = 0;
- dev_t dev;
printk(KERN_INFO "heci: %s - version %s\n", heci_driver_string,
heci_driver_version);
@@ -320,39 +333,18 @@
goto end;
}
- /* registration of char devices */
- ret = alloc_chrdev_region(&dev, HECI_MINORS_BASE, HECI_MINORS_COUNT,
- HECI_DRIVER_NAME);
- if (ret) {
- printk(KERN_ERR "heci: Error allocating char device region.\n");
+ ret = heci_register_cdev();
+ if (ret)
goto unregister_pci;
- }
- heci_major = MAJOR(dev);
-
- /* registration in sysfs interface */
- ret = heci_sysfs_create();
+ ret = heci_sysfs_device_create();
if (ret)
- goto unregister;
+ goto unregister_cdev;
- ret = heci_registration_cdev(&heci_cdev, HECI_MINOR_NUMBER,
- &heci_fops);
- if (ret)
- goto destroy_sysfs;
-
- if (heci_sysfs_device_create()) {
- cdev_del(&heci_cdev);
- ret = -EAGAIN;
- goto destroy_sysfs;
- }
-
return ret;
-destroy_sysfs:
- heci_sysfs_destroy();
-unregister:
- unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
- HECI_MINORS_COUNT);
+unregister_cdev:
+ heci_unregister_cdev();
unregister_pci:
pci_unregister_driver(&heci_driver);
end:
@@ -371,12 +363,8 @@
static void __exit heci_exit_module(void)
{
pci_unregister_driver(&heci_driver);
- /* Now unregister cdev. */
- cdev_del(&heci_cdev);
heci_sysfs_device_remove();
- heci_sysfs_destroy();
- unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
- HECI_MINORS_COUNT);
+ heci_unregister_cdev();
}
module_exit(heci_exit_module);
@@ -388,7 +376,7 @@
* @pdev: PCI device information struct
* @ent: entry in kcs_pci_tbl
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int __devinit heci_probe(struct pci_dev *pdev,
const struct pci_device_id *ent)
@@ -425,7 +413,7 @@
if (pci_resource_len(pdev, i) == 0)
continue;
if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
- printk(KERN_ERR "heci has IO ports.\n");
+ printk(KERN_ERR "heci: heci has IO ports.\n");
goto free_device;
} else if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
if (dev->mem_base) {
@@ -544,7 +532,7 @@
&& dev->wd_timeout) {
dev->wd_timeout = 0;
dev->wd_due_counter = 0;
- memcpy(dev->wd_data, stop_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
dev->stop = 1;
if (dev->host_buffer_is_empty &&
flow_ctrl_creds(dev, &dev->wd_file_ext)) {
@@ -628,7 +616,7 @@
* heci_clear_list is called to clear resources associated with file
* when application calls close function or Ctrl-C was pressed
*
- * @return 1 if callback removed from the list, 0 otherwise
+ * returns 1 if callback removed from the list, 0 otherwise
*/
static int heci_clear_list(struct iamt_heci_device *dev,
struct file *file, struct list_head *heci_cb_list)
@@ -670,7 +658,7 @@
* heci_clear_lists is called to clear resources associated with file
* when application calls close function or Ctrl-C was pressed
*
- * @return 1 if callback removed from the list, 0 otherwise
+ * returns 1 if callback removed from the list, 0 otherwise
*/
static int heci_clear_lists(struct iamt_heci_device *dev, struct file *file)
{
@@ -709,6 +697,11 @@
/**
* heci_open - the open function
+ *
+ * @inode: pointer to inode structure
+ * @file: pointer to file structure
+ *
+ * returns 0 on success, <0 on error
*/
static int heci_open(struct inode *inode, struct file *file)
{
@@ -766,6 +759,11 @@
/**
* heci_release - the release function
+ *
+ * @inode: pointer to inode structure
+ * @file: pointer to file structure
+ *
+ * returns 0 on success, <0 on error
*/
static int heci_release(struct inode *inode, struct file *file)
{
@@ -881,6 +879,13 @@
/**
* heci_read - the read client message function.
+ *
+ * @file: pointer to file structure
+ * @ubuf: pointer to user buffer
+ * @length: buffer length
+ * @offset: data offset in buffer
+ *
+ * returns >=0 data length on success , <0 on error
*/
static ssize_t heci_read(struct file *file, char __user *ubuf,
size_t length, loff_t *offset)
@@ -1043,6 +1048,13 @@
/**
* heci_write - the write function.
+ *
+ * @file: pointer to file structure
+ * @ubuf: pointer to user buffer
+ * @length: buffer length
+ * @offset: data offset in buffer
+ *
+ * returns >=0 data length on success , <0 on error
*/
static ssize_t heci_write(struct file *file, const char __user *ubuf,
size_t length, loff_t *offset)
@@ -1301,6 +1313,13 @@
/**
* heci_ioctl - the IOCTL function
+ *
+ * @inode: pointer to inode structure
+ * @file: pointer to file structure
+ * @cmd: ioctl command
+ * @data: pointer to heci message structure
+ *
+ * returns 0 on success , <0 on error
*/
static int heci_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long data)
@@ -1369,6 +1388,11 @@
/**
* heci_poll - the poll function
+ *
+ * @file: pointer to file structure
+ * @wait: pointer to poll_table structure
+ *
+ * returns poll mask
*/
static unsigned int heci_poll(struct file *file, poll_table *wait)
{
@@ -1420,45 +1444,46 @@
#ifdef CONFIG_PM
static int heci_suspend(struct pci_dev *pdev, pm_message_t state)
{
- struct iamt_heci_device *device = pci_get_drvdata(pdev);
+ struct iamt_heci_device *dev = pci_get_drvdata(pdev);
int err = 0;
- spin_lock_bh(&device->device_lock);
- if (device->reinit_tsk != NULL) {
- kthread_stop(device->reinit_tsk);
- device->reinit_tsk = NULL;
+ spin_lock_bh(&dev->device_lock);
+ if (dev->reinit_tsk != NULL) {
+ kthread_stop(dev->reinit_tsk);
+ dev->reinit_tsk = NULL;
}
- spin_unlock_bh(&device->device_lock);
+ spin_unlock_bh(&dev->device_lock);
/* Stop watchdog if exists */
- del_timer_sync(&device->wd_timer);
- if (device->wd_file_ext.state == HECI_FILE_CONNECTED
- && device->wd_timeout) {
- spin_lock_bh(&device->device_lock);
- g_sus_wd_timeout = device->wd_timeout;
- device->wd_timeout = 0;
- device->wd_due_counter = 0;
- memcpy(device->wd_data, stop_wd_params, HECI_WD_PARAMS_SIZE);
- device->stop = 1;
- if (device->host_buffer_is_empty &&
- flow_ctrl_creds(device, &device->wd_file_ext)) {
- device->host_buffer_is_empty = 0;
- if (!heci_send_wd(device))
+ del_timer_sync(&dev->wd_timer);
+ if (dev->wd_file_ext.state == HECI_FILE_CONNECTED
+ && dev->wd_timeout) {
+ spin_lock_bh(&dev->device_lock);
+ g_sus_wd_timeout = dev->wd_timeout;
+ dev->wd_timeout = 0;
+ dev->wd_due_counter = 0;
+ memcpy(dev->wd_data, heci_stop_wd_params,
+ HECI_WD_PARAMS_SIZE);
+ dev->stop = 1;
+ if (dev->host_buffer_is_empty &&
+ flow_ctrl_creds(dev, &dev->wd_file_ext)) {
+ dev->host_buffer_is_empty = 0;
+ if (!heci_send_wd(dev))
DBG("send stop WD failed\n");
else
- flow_ctrl_reduce(device, &device->wd_file_ext);
+ flow_ctrl_reduce(dev, &dev->wd_file_ext);
- device->wd_pending = 0;
+ dev->wd_pending = 0;
} else {
- device->wd_pending = 1;
+ dev->wd_pending = 1;
}
- spin_unlock_bh(&device->device_lock);
- device->wd_stoped = 0;
+ spin_unlock_bh(&dev->device_lock);
+ dev->wd_stoped = 0;
- err = wait_event_interruptible_timeout(device->wait_stop_wd,
- (device->wd_stoped),
+ err = wait_event_interruptible_timeout(dev->wait_stop_wd,
+ (dev->wd_stoped),
10 * HZ);
- if (!device->wd_stoped)
+ if (!dev->wd_stoped)
DBG("stop wd failed to complete.\n");
else {
DBG("stop wd complete %d.\n", err);
@@ -1466,18 +1491,18 @@
}
}
/* Set new heci state */
- spin_lock_bh(&device->device_lock);
- if (device->heci_state == HECI_ENABLED ||
- device->heci_state == HECI_RECOVERING_FROM_RESET) {
- device->heci_state = HECI_POWER_DOWN;
- heci_reset(device, 0);
+ spin_lock_bh(&dev->device_lock);
+ if (dev->heci_state == HECI_ENABLED ||
+ dev->heci_state == HECI_RECOVERING_FROM_RESET) {
+ dev->heci_state = HECI_POWER_DOWN;
+ heci_reset(dev, 0);
}
- spin_unlock_bh(&device->device_lock);
+ spin_unlock_bh(&dev->device_lock);
pci_save_state(pdev);
pci_disable_device(pdev);
- free_irq(pdev->irq, device);
+ free_irq(pdev->irq, dev);
pci_set_power_state(pdev, PCI_D3hot);
@@ -1486,41 +1511,42 @@
static int heci_resume(struct pci_dev *pdev)
{
- struct iamt_heci_device *device;
+ struct iamt_heci_device *dev;
int err = 0;
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
- device = pci_get_drvdata(pdev);
- if (!device)
+ dev = pci_get_drvdata(pdev);
+ if (!dev)
return -ENODEV;
/* request and enable interrupt */
err = request_irq(pdev->irq, heci_isr_interrupt, IRQF_SHARED,
- heci_driver_name, device);
+ heci_driver_name, dev);
if (err) {
printk(KERN_ERR "heci: Request_irq failure. irq = %d \n",
pdev->irq);
return err;
}
- spin_lock_bh(&device->device_lock);
- device->heci_state = HECI_POWER_UP;
- heci_reset(device, 1);
- spin_unlock_bh(&device->device_lock);
+ spin_lock_bh(&dev->device_lock);
+ dev->heci_state = HECI_POWER_UP;
+ heci_reset(dev, 1);
+ spin_unlock_bh(&dev->device_lock);
/* Start watchdog if stopped in suspend */
if (g_sus_wd_timeout != 0) {
- device->wd_timeout = g_sus_wd_timeout;
+ dev->wd_timeout = g_sus_wd_timeout;
- memcpy(device->wd_data, start_wd_params, HECI_WD_PARAMS_SIZE);
- memcpy(device->wd_data + HECI_WD_PARAMS_SIZE,
- &device->wd_timeout, sizeof(__u16));
- device->wd_due_counter = 1;
+ memcpy(dev->wd_data, heci_start_wd_params,
+ HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
+ &dev->wd_timeout, sizeof(__u16));
+ dev->wd_due_counter = 1;
- if (device->wd_timeout)
- mod_timer(&device->wd_timer, jiffies);
+ if (dev->wd_timeout)
+ mod_timer(&dev->wd_timer, jiffies);
g_sus_wd_timeout = 0;
}
Modified: heci/branches/heci-5.0/src/heci_version.h
===================================================================
--- heci/branches/heci-5.0/src/heci_version.h 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/heci_version.h 2008-07-22 16:25:37 UTC (rev 205)
@@ -44,7 +44,7 @@
#define MAJOR_VERSION 5
#define MINOR_VERSION 0
#define QUICK_FIX_NUMBER 0
-#define VER_BUILD 30
+#define VER_BUILD 31
#define HECI_DRV_VER1 __stringify(MAJOR_VERSION) "." __stringify(MINOR_VERSION)
#define HECI_DRV_VER2 __stringify(QUICK_FIX_NUMBER) "." __stringify(VER_BUILD)
Modified: heci/branches/heci-5.0/src/interrupt.c
===================================================================
--- heci/branches/heci-5.0/src/interrupt.c 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/interrupt.c 2008-07-22 16:25:37 UTC (rev 205)
@@ -44,7 +44,7 @@
#include "heci.h"
#include "heci_interface.h"
-/**
+/*
* interrupt function prototypes
*/
static void heci_bh_handler(struct work_struct *work);
@@ -78,29 +78,29 @@
* @irq: The irq number
* @dev_id: pointer to the device structure
*
- * @return irqreturn_t
+ * returns irqreturn_t
*/
irqreturn_t heci_isr_interrupt(int irq, void *dev_id)
{
int err;
- struct iamt_heci_device *device = (struct iamt_heci_device *) dev_id;
+ struct iamt_heci_device *dev = (struct iamt_heci_device *) dev_id;
- device->host_hw_state = read_heci_register(device, H_CSR);
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
- if ((device->host_hw_state & H_IS) != H_IS)
+ if ((dev->host_hw_state & H_IS) != H_IS)
return IRQ_NONE;
/* disable interrupts */
- heci_csr_disable_interrupts(device);
+ heci_csr_disable_interrupts(dev);
- /**
+ /*
* Our device interrupted, schedule work the heci_bh_handler
* to handle the interrupt processing. This needs to be a
* workqueue item since the handler can sleep.
*/
- PREPARE_WORK(&device->work, heci_bh_handler);
+ PREPARE_WORK(&dev->work, heci_bh_handler);
DBG("schedule work the heci_bh_handler.\n");
- err = schedule_work(&device->work);
+ err = schedule_work(&dev->work);
if (!err) {
printk(KERN_ERR "heci: schedule the heci_bh_handler"
" failed error=%x\n", err);
@@ -109,7 +109,7 @@
}
/**
- * _heci_cmpl: process completed operation.
+ * _heci_cmpl - process completed operation.
*
* @file_ext: private data of the file object.
* @priv_cb_pos: callback block.
@@ -138,7 +138,7 @@
}
/**
- * _heci_cmpl_iamthif: process completed iamthif operation.
+ * _heci_cmpl_iamthif - process completed iamthif operation.
*
* @dev: Device object for our driver.
* @priv_cb_pos: callback block.
@@ -303,7 +303,7 @@
* @dev: Device object for our driver
* @slots: slots to read.
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_read_handler(struct io_heci_list *cmpl_list,
struct iamt_heci_device *dev,
@@ -525,7 +525,7 @@
* @dev: Device object for our driver
* @heci_hdr: header of pthi message
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_read_pthi_message(struct io_heci_list *complete_list,
struct iamt_heci_device *dev,
@@ -583,7 +583,7 @@
* @file_ext: private data of the file object
* @heci_hdr: header of heci client message
*
- * @return !=0 if matches, 0 if no match.
+ * returns !=0 if matches, 0 if no match.
*/
static int _heci_bh_state_ok(struct heci_file_private *file_ext,
struct heci_msg_hdr *heci_hdr)
@@ -602,7 +602,7 @@
* @dev: Device object for our driver
* @heci_hdr: header of heci client message
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_read_client_message(struct io_heci_list *complete_list,
struct iamt_heci_device *dev,
@@ -684,12 +684,12 @@
}
/**
- * _heci_bh_iamthif_read: prepare to read iamthif data.
+ * _heci_bh_iamthif_read - prepare to read iamthif data.
*
* @dev: Device object for our driver.
* @slots: free slots.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_iamthif_read(struct iamt_heci_device *dev, __s32 *slots)
{
@@ -716,7 +716,7 @@
}
/**
- * _heci_bh_close: process close related operation.
+ * _heci_bh_close - process close related operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -724,7 +724,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_close(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -759,7 +759,7 @@
}
/**
- * _heci_hb_close: process read related operation.
+ * _heci_hb_close - process read related operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -767,7 +767,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_read(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -799,7 +799,7 @@
/**
- * _heci_bh_ioctl: process ioctl related operation.
+ * _heci_bh_ioctl - process ioctl related operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -807,7 +807,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_ioctl(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -839,7 +839,7 @@
}
/**
- * _heci_bh_cmpl: process completed and no-iamthif operation.
+ * _heci_bh_cmpl - process completed and no-iamthif operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -847,7 +847,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_cmpl(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -932,7 +932,7 @@
}
/**
- * _heci_bh_cmpl_iamthif: process completed iamthif operation.
+ * _heci_bh_cmpl_iamthif - process completed iamthif operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -940,7 +940,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_cmpl_iamthif(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -1022,7 +1022,7 @@
* @dev: Device object for our driver
* @slots: slots to write.
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_write_handler(struct io_heci_list *cmpl_list,
struct iamt_heci_device *dev,
@@ -1225,7 +1225,7 @@
* @rs: connect response bus message
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int is_treat_specially_client(struct heci_file_private *file_ext,
struct hbm_client_connect_response *rs)
@@ -1338,7 +1338,7 @@
* @file: private data of the file object.
* @flow: flow control.
*
- * @return !=0, same; 0,not.
+ * returns !=0, same; 0,not.
*/
static int same_flow_addr(struct heci_file_private *file,
struct hbm_flow_control *flow)
@@ -1375,6 +1375,7 @@
}
}
}
+
/**
* heci_client_flow_control_response - flow control response bh routine
*
@@ -1421,7 +1422,7 @@
* @file: private data of the file object.
* @disconn: disconnection request.
*
- * @return !=0, same; 0,not.
+ * returns !=0, same; 0,not.
*/
static int same_disconn_addr(struct heci_file_private *file,
struct hbm_client_disconnect_request *disconn)
@@ -1504,7 +1505,7 @@
spin_unlock_bh(&dev->device_lock);
return;
}
- /*** Watchdog ***/
+ /* Watchdog */
if ((dev->wd_due_counter != 0) && (dev->wd_bypass == 0)) {
if (--dev->wd_due_counter == 0) {
if (dev->host_buffer_is_empty &&
Modified: heci/branches/heci-5.0/src/io_heci.c
===================================================================
--- heci/branches/heci-5.0/src/io_heci.c 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/io_heci.c 2008-07-22 16:25:37 UTC (rev 205)
@@ -74,14 +74,13 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_get_version(struct iamt_heci_device *dev, int if_num,
struct heci_message_data *u_msg,
struct heci_message_data k_msg,
struct heci_file_private *file_ext)
{
-
int rets = 0;
struct heci_driver_version *version;
struct heci_message_data res_msg;
@@ -135,14 +134,13 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_connect_client(struct iamt_heci_device *dev, int if_num,
struct heci_message_data *u_msg,
struct heci_message_data k_msg,
struct file *file)
{
-
int rets = 0;
struct heci_message_data req_msg, res_msg;
struct heci_cb_private *priv_cb = NULL;
@@ -366,7 +364,7 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
@@ -426,10 +424,10 @@
dev->wd_pending = 0;
dev->wd_due_counter = 1; /* next timer */
if (dev->wd_timeout == 0) {
- memcpy(dev->wd_data, &stop_wd_params,
+ memcpy(dev->wd_data, heci_stop_wd_params,
HECI_WD_PARAMS_SIZE);
} else {
- memcpy(dev->wd_data, &start_wd_params,
+ memcpy(dev->wd_data, heci_start_wd_params,
HECI_WD_PARAMS_SIZE);
mod_timer(&dev->wd_timer, jiffies);
}
@@ -448,7 +446,7 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
@@ -486,7 +484,7 @@
* @dev: Device object for our driver
* @file: pointer to file object
*
- * @return returned a list entry on success, NULL on failure.
+ * returns returned a list entry on success, NULL on failure.
*/
struct heci_cb_private *find_pthi_read_list_entry(
struct iamt_heci_device *dev,
@@ -521,7 +519,7 @@
* @length: data length to read
* @offset: data read offset
*
- * @return
+ * returns
* returned data length on success,
* zero if no data to read,
* negative on failure.
@@ -529,7 +527,6 @@
int pthi_read(struct iamt_heci_device *dev, int if_num, struct file *file,
char *ubuf, size_t length, loff_t *offset)
{
-
int rets = 0;
struct heci_cb_private *priv_cb = NULL;
struct heci_file_private *file_ext = file->private_data;
@@ -622,7 +619,7 @@
* @if_num: minor number
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_start_read(struct iamt_heci_device *dev, int if_num,
struct heci_file_private *file_ext)
@@ -707,12 +704,12 @@
}
/**
- * pthi_write: write iamthif data to pthi client
+ * pthi_write - write iamthif data to pthi client
*
* @dev: Device object for our driver
* @priv_cb: heci call back struct
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int pthi_write(struct iamt_heci_device *dev,
struct heci_cb_private *priv_cb)
@@ -790,7 +787,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
void run_next_iamthif_cmd(struct iamt_heci_device *dev)
{
Modified: heci/branches/heci-5.0/src/kcompat.h
===================================================================
--- heci/branches/heci-5.0/src/kcompat.h 2008-07-22 16:11:38 UTC (rev 204)
+++ heci/branches/heci-5.0/src/kcompat.h 2008-07-22 16:25:37 UTC (rev 205)
@@ -49,6 +49,17 @@
#include <linux/interrupt.h>
#include <asm/io.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
+#define device_create(cls, parent, devt, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define device_destroy class_device_destroy
+#endif
+
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23))
+#define HECI_TASK_NONFREEZABLE current->flags |= PF_NOFREEZE;
+#endif
+
+
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 17))
#include <asm/uaccess.h>
#else
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-22 16:11:29
|
Revision: 204
http://openamt.svn.sourceforge.net/openamt/?rev=204&view=rev
Author: marcin_obara
Date: 2008-07-22 16:11:38 +0000 (Tue, 22 Jul 2008)
Log Message:
-----------
2.6.17 backward compatybility - removed global pointer to struct device (NULL on older kernels, valid since 2.6.18)
Modified Paths:
--------------
heci/trunk/src/heci_data_structures.h
heci/trunk/src/heci_main.c
Modified: heci/trunk/src/heci_data_structures.h
===================================================================
--- heci/trunk/src/heci_data_structures.h 2008-07-22 16:06:21 UTC (rev 203)
+++ heci/trunk/src/heci_data_structures.h 2008-07-22 16:11:38 UTC (rev 204)
@@ -135,16 +135,10 @@
* debug kernel print macro define
*/
extern int heci_debug;
-extern struct device *heci_dev;
#define DBG(format, arg...) do { \
- if (heci_debug) { \
- if (heci_dev) \
- dev_info(heci_dev, "%s: " format, __func__, ## arg); \
- else \
- printk(KERN_INFO "heci: %s: " format, \
- __func__, ## arg); \
- } \
+ if (heci_debug) \
+ printk(KERN_INFO "heci: %s: " format, __func__, ## arg); \
} while (0)
Modified: heci/trunk/src/heci_main.c
===================================================================
--- heci/trunk/src/heci_main.c 2008-07-22 16:06:21 UTC (rev 203)
+++ heci/trunk/src/heci_main.c 2008-07-22 16:11:38 UTC (rev 204)
@@ -98,7 +98,6 @@
static struct pci_dev *heci_device;
struct class *heci_class;
-struct device *heci_dev;
/* heci_pci_tbl - PCI Device ID Table */
@@ -293,7 +292,6 @@
goto err_out;
}
- heci_dev = NULL; /*tmphdev;*/
heci_class = class;
err_out:
return err;
@@ -307,7 +305,6 @@
if ((heci_class == NULL) || (IS_ERR(heci_class)))
return;
- heci_dev = NULL;
device_destroy(heci_class, heci_cdev.dev);
class_remove_file(heci_class, &class_attr_version);
class_destroy(heci_class);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-22 16:06:13
|
Revision: 203
http://openamt.svn.sourceforge.net/openamt/?rev=203&view=rev
Author: marcin_obara
Date: 2008-07-22 16:06:21 +0000 (Tue, 22 Jul 2008)
Log Message:
-----------
2.6.17 backward compatybility - minimal required change - this pointer is used only for debugging but device_create is available since 2.6.18
Modified Paths:
--------------
heci/trunk/src/heci_main.c
Modified: heci/trunk/src/heci_main.c
===================================================================
--- heci/trunk/src/heci_main.c 2008-07-18 20:33:18 UTC (rev 202)
+++ heci/trunk/src/heci_main.c 2008-07-22 16:06:21 UTC (rev 203)
@@ -268,7 +268,7 @@
static int heci_sysfs_device_create(void)
{
struct class *class;
- struct device *tmphdev;
+ void *tmphdev;
int err = 0;
class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
@@ -293,7 +293,7 @@
goto err_out;
}
- heci_dev = tmphdev;
+ heci_dev = NULL; /*tmphdev;*/
heci_class = class;
err_out:
return err;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-18 20:33:10
|
Revision: 202
http://openamt.svn.sourceforge.net/openamt/?rev=202&view=rev
Author: marcin_obara
Date: 2008-07-18 20:33:18 +0000 (Fri, 18 Jul 2008)
Log Message:
-----------
kernel 2.6.27 changes - fixed ioctl_wd
Modified Paths:
--------------
heci/trunk/src/io_heci.c
Modified: heci/trunk/src/io_heci.c
===================================================================
--- heci/trunk/src/io_heci.c 2008-07-18 19:50:55 UTC (rev 201)
+++ heci/trunk/src/io_heci.c 2008-07-18 20:33:18 UTC (rev 202)
@@ -424,10 +424,10 @@
dev->wd_pending = 0;
dev->wd_due_counter = 1; /* next timer */
if (dev->wd_timeout == 0) {
- memcpy(dev->wd_data, &heci_stop_wd_params,
+ memcpy(dev->wd_data, heci_stop_wd_params,
HECI_WD_PARAMS_SIZE);
} else {
- memcpy(dev->wd_data, &heci_start_wd_params,
+ memcpy(dev->wd_data, heci_start_wd_params,
HECI_WD_PARAMS_SIZE);
mod_timer(&dev->wd_timer, jiffies);
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-18 19:50:47
|
Revision: 201
http://openamt.svn.sourceforge.net/openamt/?rev=201&view=rev
Author: marcin_obara
Date: 2008-07-18 19:50:55 +0000 (Fri, 18 Jul 2008)
Log Message:
-----------
kernel 2.6.27 changes - cleanups
Modified Paths:
--------------
heci/trunk/src/heci.h
heci/trunk/src/heci_data_structures.h
heci/trunk/src/heci_init.c
heci/trunk/src/heci_interface.c
heci/trunk/src/heci_interface.h
heci/trunk/src/heci_main.c
heci/trunk/src/interrupt.c
heci/trunk/src/io_heci.c
Modified: heci/trunk/src/heci.h
===================================================================
--- heci/trunk/src/heci.h 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/heci.h 2008-07-18 19:50:55 UTC (rev 201)
@@ -55,11 +55,11 @@
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[];
+extern const __u8 heci_start_wd_params[];
+extern const __u8 heci_stop_wd_params[];
extern const __u8 heci_wd_state_independence_msg[3][4];
-/**
+/*
* heci device ID
*/
#define HECI_DEV_ID_82946GZ 0x2974 /* 82946GZ/GL */
@@ -92,7 +92,7 @@
#define HECI_DEV_ID_ICH10_3 0x2E24 /* Eaglelake */
#define HECI_DEV_ID_ICH10_4 0x2E34 /* Eaglelake */
-/**
+/*
* heci init function prototypes
*/
struct iamt_heci_device *init_heci_device(struct pci_dev *pdev);
@@ -113,48 +113,48 @@
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);
-/**
+/*
* input output function prototype
*/
-int heci_ioctl_get_version(struct iamt_heci_device *device, int if_num,
+int heci_ioctl_get_version(struct iamt_heci_device *dev, 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,
+int heci_ioctl_connect_client(struct iamt_heci_device *dev, 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,
+int heci_ioctl_wd(struct iamt_heci_device *dev, 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,
+int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
struct heci_file_private *file_ext);
-int heci_start_read(struct iamt_heci_device *device, int if_num,
+int heci_start_read(struct iamt_heci_device *dev, int if_num,
struct heci_file_private *file_ext);
-int pthi_write(struct iamt_heci_device *device,
+int pthi_write(struct iamt_heci_device *dev,
struct heci_cb_private *priv_cb);
-int pthi_read(struct iamt_heci_device *device, int if_num, struct file *file,
+int pthi_read(struct iamt_heci_device *dev, 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 iamt_heci_device *dev,
struct file *file);
-void run_next_iamthif_cmd(struct iamt_heci_device *device);
+void run_next_iamthif_cmd(struct iamt_heci_device *dev);
void heci_free_cb_private(struct heci_cb_private *priv_cb);
@@ -164,10 +164,10 @@
* @fe1: private data of 1. file object
* @fe2: private data of 2. file object
*
- * @return !=0 - if ids are the same, 0 - if differ.
+ * returns !=0 - if ids are the same, 0 - if differ.
*/
-static inline int heci_fe_same_id(struct heci_file_private *fe1,
- struct heci_file_private *fe2)
+static inline int heci_fe_same_id(const struct heci_file_private *fe1,
+ const struct heci_file_private *fe2)
{
return ((fe1->host_client_id == fe2->host_client_id)
&& (fe1->me_client_id == fe2->me_client_id));
Modified: heci/trunk/src/heci_data_structures.h
===================================================================
--- heci/trunk/src/heci_data_structures.h 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/heci_data_structures.h 2008-07-18 19:50:55 UTC (rev 201)
@@ -52,7 +52,7 @@
#include <linux/aio.h>
#include <linux/types.h>
-/**
+/*
* error code definition
*/
#define ESLOTS_OVERFLOW 1
@@ -61,18 +61,18 @@
#define HECI_FC_MESSAGE_RESERVED_LENGTH 5
-/**
+/*
* Number of queue lists used by this driver
*/
#define HECI_IO_LISTS_NUMBER 7
-/**
+/*
* Maximum transmission unit (MTU) of heci messages
*/
#define IAMTHIF_MTU 4160
-/**
+/*
* HECI HW Section
*/
@@ -131,23 +131,29 @@
#define HECI_MINOR_NUMBER 1
#define HECI_MAX_OPEN_HANDLE_COUNT 253
-/**
+/*
* debug kernel print macro define
*/
extern int heci_debug;
+extern struct device *heci_dev;
#define DBG(format, arg...) do { \
- if (heci_debug) \
- printk(KERN_ERR "%s: " format , __func__ , ## arg); \
+ if (heci_debug) { \
+ if (heci_dev) \
+ dev_info(heci_dev, "%s: " format, __func__, ## arg); \
+ else \
+ printk(KERN_INFO "heci: %s: " format, \
+ __func__, ## arg); \
+ } \
} while (0)
-/**
+/*
* time to wait HECI become ready after init
*/
#define HECI_INTEROP_TIMEOUT (HZ * 7)
-/**
+/*
* watch dog definition
*/
#define HECI_WATCHDOG_DATA_SIZE 16
@@ -163,7 +169,7 @@
__u16 data2;
__u16 data3;
__u8 data4[8];
-} __attribute__((packed));
+};
/* File state */
enum file_state {
@@ -503,22 +509,28 @@
/**
* read_heci_register - Read a byte from the heci device
*
- * @device: the device structure
+ * @dev: the device structure
* @offset: offset from which to read the data
*
- * @return the byte read.
+ * returns the byte read.
*/
-__u32 read_heci_register(struct iamt_heci_device *device,
- unsigned long offset);
+static inline __u32 read_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset)
+{
+ return readl(dev->mem_addr + offset);
+}
/**
* write_heci_register - Write 4 bytes to the heci device
*
- * @device: the device structure
+ * @dev: 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);
+static inline void write_heci_register(struct iamt_heci_device *dev,
+ unsigned long offset, __u32 value)
+{
+ writel(value, dev->mem_addr + offset);
+}
#endif /* _HECI_DATA_STRUCTURES_H_ */
Modified: heci/trunk/src/heci_init.c
===================================================================
--- heci/trunk/src/heci_init.c 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/heci_init.c 2008-07-18 19:50:55 UTC (rev 201)
@@ -55,11 +55,8 @@
#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 __u8 heci_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
+const __u8 heci_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
const __u8 heci_wd_state_independence_msg[3][4] = {
{0x05, 0x02, 0x51, 0x10},
@@ -81,7 +78,7 @@
};
-/**
+/*
* heci init function prototypes
*/
static void heci_check_asf_mode(struct iamt_heci_device *dev);
@@ -95,7 +92,7 @@
/**
- * heci_initialize_list - Sets up a queue list.
+ * heci_initialize_list - Sets up a queue list.
*
* @list: An instance of our list structure
* @dev: Device object for our driver
@@ -114,7 +111,6 @@
*
* @dev: Device object for our driver
* @file_ext: private data of the file object
- *
*/
void heci_flush_queues(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -169,6 +165,7 @@
/**
* heci_reset_iamthif_params - initializes heci device iamthif
+ *
* @dev: The heci device structure
*/
static void heci_reset_iamthif_params(struct iamt_heci_device *dev)
@@ -186,42 +183,43 @@
/**
* 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.
+ * returns 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;
+ struct iamt_heci_device *dev;
- device = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
- if (!device)
+ dev = kzalloc(sizeof(struct iamt_heci_device), GFP_KERNEL);
+ if (!dev)
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->iamthif_file_ext.link);
- spin_lock_init(&device->device_lock);
- init_waitqueue_head(&device->wait_recvd_msg);
- init_waitqueue_head(&device->wait_stop_wd);
- device->heci_state = HECI_INITIALIZING;
- device->iamthif_state = HECI_IAMTHIF_IDLE;
+ dev->io_list_array[0] = &dev->read_list;
+ dev->io_list_array[1] = &dev->write_list;
+ dev->io_list_array[2] = &dev->write_waiting_list;
+ dev->io_list_array[3] = &dev->ctrl_wr_list;
+ dev->io_list_array[4] = &dev->ctrl_rd_list;
+ dev->io_list_array[5] = &dev->pthi_cmd_list;
+ dev->io_list_array[6] = &dev->pthi_read_complete_list;
+ INIT_LIST_HEAD(&dev->file_list);
+ INIT_LIST_HEAD(&dev->wd_file_ext.link);
+ INIT_LIST_HEAD(&dev->iamthif_file_ext.link);
+ spin_lock_init(&dev->device_lock);
+ init_waitqueue_head(&dev->wait_recvd_msg);
+ init_waitqueue_head(&dev->wait_stop_wd);
+ dev->heci_state = HECI_INITIALIZING;
+ dev->iamthif_state = HECI_IAMTHIF_IDLE;
/* init work for schedule work */
- INIT_WORK(&device->work, NULL);
+ INIT_WORK(&dev->work, NULL);
for (i = 0; i < HECI_IO_LISTS_NUMBER; i++)
- heci_initialize_list(device->io_list_array[i], device);
- device->pdev = pdev;
- return device;
+ heci_initialize_list(dev->io_list_array[i], dev);
+ dev->pdev = pdev;
+ return dev;
}
@@ -239,7 +237,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_hw_init(struct iamt_heci_device *dev)
{
@@ -299,7 +297,7 @@
}
/**
- * heci_hw_reset - reset fw via heci csr register.
+ * heci_hw_reset - reset fw via heci csr register.
*
* @dev: Device object for our driver
* @interrupts: if interrupt should be enable after reset.
@@ -318,7 +316,7 @@
}
/**
- * heci_reset - reset host and fw.
+ * heci_reset - reset host and fw.
*
* @dev: Device object for our driver
* @interrupts: if interrupt should be enable after reset.
@@ -402,7 +400,7 @@
dev->host_hw_state, dev->me_hw_state);
if (unexpected)
- printk(KERN_WARNING "unexpected heci reset.\n");
+ printk(KERN_WARNING "heci: unexpected reset.\n");
/* Wake up all readings so they can be interrupted */
list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
@@ -426,10 +424,9 @@
}
/**
- * heci_initialize_clients - routine.
+ * heci_initialize_clients - heci communication initialization.
*
* @dev: Device object for our driver
- *
*/
int heci_initialize_clients(struct iamt_heci_device *dev)
{
@@ -446,8 +443,8 @@
DBG("start sending messages failed.\n");
return status;
}
- /* enumerate clients */
+ /* enumerate clients */
status = host_enum_clients_message(dev);
if (status != 0) {
spin_lock_bh(&dev->device_lock);
@@ -492,10 +489,9 @@
}
/**
- * heci_task_initialize_clients - routine.
+ * heci_task_initialize_clients - heci reinitialization task
*
* @data: Device object for our driver
- *
*/
int heci_task_initialize_clients(void *data)
{
@@ -526,7 +522,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int host_start_message(struct iamt_heci_device *dev)
{
@@ -596,7 +592,8 @@
* host_enum_clients_message - host send enumeration client request message.
*
* @dev: Device object for our driver
- * @return 0 on success, <0 on failure.
+ *
+ * returns 0 on success, <0 on failure.
*/
static int host_enum_clients_message(struct iamt_heci_device *dev)
{
@@ -654,7 +651,7 @@
* @idx: client index in me client array
* @client_id: id of the client
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int host_client_properties(struct iamt_heci_device *dev,
struct heci_me_client *client)
@@ -696,7 +693,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int allocate_me_clients_storage(struct iamt_heci_device *dev)
{
@@ -753,7 +750,6 @@
*
* @priv: private file structure to be initialized
* @file: the file structure
- *
*/
static void heci_init_file_private(struct heci_file_private *priv,
struct file *file)
@@ -779,7 +775,7 @@
* @cguid: searched guid of ME client
* @client_id: id of host client to be set in file private structure
*
- * @return ME client index
+ * returns ME client index
*/
static __u8 heci_find_me_client(struct iamt_heci_device *dev,
struct heci_file_private *priv,
@@ -809,7 +805,6 @@
* heci_check_asf_mode - check for ASF client
*
* @dev: Device object for our driver
- *
*/
static void heci_check_asf_mode(struct iamt_heci_device *dev)
{
@@ -839,7 +834,7 @@
* @priv: private file structure
* @timeout: connect timeout in seconds
*
- * @return 1 - if connected, 0 - if not
+ * returns 1 - if connected, 0 - if not
*/
static __u8 heci_connect_me_client(struct iamt_heci_device *dev,
struct heci_file_private *priv,
@@ -884,11 +879,9 @@
* host_init_wd - heci initialization wd.
*
* @dev: Device object for our driver
- *
*/
static void host_init_wd(struct iamt_heci_device *dev)
{
-
spin_lock_bh(&dev->device_lock);
heci_init_file_private(&dev->wd_file_ext, NULL);
@@ -898,12 +891,12 @@
dev->wd_timeout = 0;
if (dev->asf_mode) {
- memcpy(dev->wd_data, stop_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
} else {
/* AMT mode */
dev->wd_timeout = AMT_WD_VALUE;
DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
- memcpy(dev->wd_data, start_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data, heci_start_wd_params, HECI_WD_PARAMS_SIZE);
memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
&dev->wd_timeout, sizeof(__u16));
}
@@ -971,7 +964,7 @@
* heci_alloc_file_private - allocates a private file structure and set it up.
* @file: the file structure
*
- * @return The allocated file or NULL on failure
+ * returns The allocated file or NULL on failure
*/
struct heci_file_private *heci_alloc_file_private(struct file *file)
{
@@ -989,12 +982,12 @@
/**
- * heci_disconnect_host_client - send disconnect message to fw from host client.
+ * heci_disconnect_host_client - send disconnect message to fw from host client.
*
* @dev: Device object for our driver
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_disconnect_host_client(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -1062,12 +1055,11 @@
}
/**
- * heci_remove_client_from_file_list -
+ * heci_remove_client_from_file_list -
* remove file private data from device file list
*
* @dev: Device object for our driver
* @host_client_id: host client id to be removed
- *
*/
void heci_remove_client_from_file_list(struct iamt_heci_device *dev,
__u8 host_client_id)
Modified: heci/trunk/src/heci_interface.c
===================================================================
--- heci/trunk/src/heci_interface.c 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/heci_interface.c 2008-07-18 19:50:55 UTC (rev 201)
@@ -43,39 +43,7 @@
#include "heci_interface.h"
-
-static const __u8 interface_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10};
-static const __u8 interface_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10};
-
/**
- * 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)
-{
- return readl(device->mem_addr + 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)
-{
- writel(value, device->mem_addr + offset);
-}
-
-
-/**
* heci_set_csr_register - write H_CSR register to the heci device
*
* @dev: device object for our driver
@@ -114,9 +82,9 @@
*
* @device: the device structure
*
- * @return numer of filled slots
+ * returns numer of filled slots
*/
-static unsigned char _host_get_filled_slots(struct iamt_heci_device *dev)
+static unsigned char _host_get_filled_slots(const struct iamt_heci_device *dev)
{
char read_ptr, write_ptr;
@@ -131,7 +99,7 @@
*
* @dev: device object for our driver
*
- * @return 1 if empty, 0 - otherwise.
+ * returns 1 if empty, 0 - otherwise.
*/
int host_buffer_is_empty(struct iamt_heci_device *dev)
{
@@ -151,9 +119,9 @@
*
* @dev: device object for our driver
*
- * @return -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
+ * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
*/
-__s32 count_empty_write_slots(struct iamt_heci_device *dev)
+__s32 count_empty_write_slots(const struct iamt_heci_device *dev)
{
unsigned char buffer_depth, filled_slots, empty_slots;
@@ -177,7 +145,7 @@
* @write_buffer: message buffer will be write
* @write_length: message size will be write
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_write_message(struct iamt_heci_device *dev,
struct heci_msg_hdr *header,
@@ -231,7 +199,7 @@
*
* @dev: device object for our driver
*
- * @return -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
+ * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
*/
__s32 count_full_read_slots(struct iamt_heci_device *dev)
{
@@ -288,7 +256,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if flow_ctrl_creds >0, 0 - otherwise.
+ * returns 1 if flow_ctrl_creds >0, 0 - otherwise.
*/
int flow_ctrl_creds(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -353,7 +321,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_send_flow_control(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -388,19 +356,19 @@
/**
* other_client_is_connecting - check if other
- * client with the same client id is connected.
+ * client with the same client id is connected.
*
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if other client is connected, 0 - otherwise.
+ * returns 1 if other client is connected, 0 - otherwise.
*/
int other_client_is_connecting(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
{
-
struct heci_file_private *file_pos = NULL;
struct heci_file_private *file_next = NULL;
+
list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
if ((file_pos->state == HECI_FILE_CONNECTING)
&& (file_pos != file_ext)
@@ -416,7 +384,7 @@
*
* @dev: device object for our driver
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_send_wd(struct iamt_heci_device *dev)
{
@@ -428,11 +396,11 @@
heci_hdr->msg_complete = 1;
heci_hdr->reserved = 0;
- if (!memcmp(dev->wd_data, interface_start_wd_params,
+ if (!memcmp(dev->wd_data, heci_start_wd_params,
HECI_WD_PARAMS_SIZE)) {
heci_hdr->length = HECI_START_WD_DATA_SIZE;
} else {
- BUG_ON(memcmp(dev->wd_data, interface_stop_wd_params,
+ BUG_ON(memcmp(dev->wd_data, heci_stop_wd_params,
HECI_WD_PARAMS_SIZE));
heci_hdr->length = HECI_WD_PARAMS_SIZE;
}
@@ -449,7 +417,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_disconnect(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
@@ -486,7 +454,7 @@
* @dev: device object for our driver
* @file_ext: private data of the file object
*
- * @return 1 if success, 0 - otherwise.
+ * returns 1 if success, 0 - otherwise.
*/
int heci_connect(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
Modified: heci/trunk/src/heci_interface.h
===================================================================
--- heci/trunk/src/heci_interface.h 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/heci_interface.h 2008-07-18 19:50:55 UTC (rev 201)
@@ -128,7 +128,7 @@
};
-/**
+/*
* heci interface function prototypes
*/
void heci_set_csr_register(struct iamt_heci_device *dev);
@@ -147,7 +147,7 @@
__s32 count_full_read_slots(struct iamt_heci_device *dev);
-__s32 count_empty_write_slots(struct iamt_heci_device *dev);
+__s32 count_empty_write_slots(const struct iamt_heci_device *dev);
int flow_ctrl_creds(struct iamt_heci_device *dev,
struct heci_file_private *file_ext);
Modified: heci/trunk/src/heci_main.c
===================================================================
--- heci/trunk/src/heci_main.c 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/heci_main.c 2008-07-18 19:50:55 UTC (rev 201)
@@ -69,7 +69,7 @@
#define HECI_DRIVER_NAME "heci"
-/**
+/*
* heci driver strings
*/
char heci_driver_name[] = HECI_DRIVER_NAME;
@@ -98,7 +98,7 @@
static struct pci_dev *heci_device;
struct class *heci_class;
-struct class_device *heci_class_dev;
+struct device *heci_dev;
/* heci_pci_tbl - PCI Device ID Table */
@@ -133,7 +133,7 @@
MODULE_DEVICE_TABLE(pci, heci_pci_tbl);
-/**
+/*
* Local Function Prototypes
*/
static int __init heci_init_module(void);
@@ -161,7 +161,7 @@
#define heci_suspend NULL
#define heci_resume NULL
#endif
-/**
+/*
* PCI driver structure
*/
static struct pci_driver heci_driver = {
@@ -174,7 +174,7 @@
.resume = heci_resume
};
-/**
+/*
* file operations structure will be use heci char device.
*/
static struct file_operations heci_fops = {
@@ -188,13 +188,13 @@
};
/**
- * Set up the cdev structure for heci device.
+ * heci_registration_cdev - set up the cdev structure for heci device.
*
* @dev: char device struct
* @hminor: minor number for registration char device
* @fops: file operations structure
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_registration_cdev(struct cdev *dev, int hminor,
struct file_operations *fops)
@@ -224,7 +224,7 @@
/**
* heci_register_cdev - registers heci char device
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_register_cdev(void)
{
@@ -263,12 +263,12 @@
/**
* heci_sysfs_device_create - adds device entry to sysfs
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_sysfs_device_create(void)
{
struct class *class;
- void *tmphdev;
+ struct device *tmphdev;
int err = 0;
class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
@@ -285,8 +285,7 @@
goto err_out;
}
- tmphdev = (void *) device_create(class, NULL, heci_cdev.dev,
- HECI_DEV_NAME);
+ tmphdev = device_create(class, NULL, heci_cdev.dev, HECI_DEV_NAME);
if (IS_ERR(tmphdev)) {
err = PTR_ERR(tmphdev);
class_remove_file(class, &class_attr_version);
@@ -294,6 +293,7 @@
goto err_out;
}
+ heci_dev = tmphdev;
heci_class = class;
err_out:
return err;
@@ -307,6 +307,7 @@
if ((heci_class == NULL) || (IS_ERR(heci_class)))
return;
+ heci_dev = NULL;
device_destroy(heci_class, heci_cdev.dev);
class_remove_file(heci_class, &class_attr_version);
class_destroy(heci_class);
@@ -318,7 +319,7 @@
* heci_init_module is the first routine called when the driver is
* loaded. All it does is register with the PCI subsystem.
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int __init heci_init_module(void)
{
@@ -378,7 +379,7 @@
* @pdev: PCI device information struct
* @ent: entry in kcs_pci_tbl
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int __devinit heci_probe(struct pci_dev *pdev,
const struct pci_device_id *ent)
@@ -415,7 +416,7 @@
if (pci_resource_len(pdev, i) == 0)
continue;
if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
- printk(KERN_ERR "heci has IO ports.\n");
+ printk(KERN_ERR "heci: heci has IO ports.\n");
goto free_device;
} else if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
if (dev->mem_base) {
@@ -534,7 +535,7 @@
&& dev->wd_timeout) {
dev->wd_timeout = 0;
dev->wd_due_counter = 0;
- memcpy(dev->wd_data, stop_wd_params, HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
dev->stop = 1;
if (dev->host_buffer_is_empty &&
flow_ctrl_creds(dev, &dev->wd_file_ext)) {
@@ -618,7 +619,7 @@
* heci_clear_list is called to clear resources associated with file
* when application calls close function or Ctrl-C was pressed
*
- * @return 1 if callback removed from the list, 0 otherwise
+ * returns 1 if callback removed from the list, 0 otherwise
*/
static int heci_clear_list(struct iamt_heci_device *dev,
struct file *file, struct list_head *heci_cb_list)
@@ -660,7 +661,7 @@
* heci_clear_lists is called to clear resources associated with file
* when application calls close function or Ctrl-C was pressed
*
- * @return 1 if callback removed from the list, 0 otherwise
+ * returns 1 if callback removed from the list, 0 otherwise
*/
static int heci_clear_lists(struct iamt_heci_device *dev, struct file *file)
{
@@ -699,6 +700,11 @@
/**
* heci_open - the open function
+ *
+ * @inode: pointer to inode structure
+ * @file: pointer to file structure
+ *
+ * returns 0 on success, <0 on error
*/
static int heci_open(struct inode *inode, struct file *file)
{
@@ -756,6 +762,11 @@
/**
* heci_release - the release function
+ *
+ * @inode: pointer to inode structure
+ * @file: pointer to file structure
+ *
+ * returns 0 on success, <0 on error
*/
static int heci_release(struct inode *inode, struct file *file)
{
@@ -871,6 +882,13 @@
/**
* heci_read - the read client message function.
+ *
+ * @file: pointer to file structure
+ * @ubuf: pointer to user buffer
+ * @length: buffer length
+ * @offset: data offset in buffer
+ *
+ * returns >=0 data length on success , <0 on error
*/
static ssize_t heci_read(struct file *file, char __user *ubuf,
size_t length, loff_t *offset)
@@ -1033,6 +1051,13 @@
/**
* heci_write - the write function.
+ *
+ * @file: pointer to file structure
+ * @ubuf: pointer to user buffer
+ * @length: buffer length
+ * @offset: data offset in buffer
+ *
+ * returns >=0 data length on success , <0 on error
*/
static ssize_t heci_write(struct file *file, const char __user *ubuf,
size_t length, loff_t *offset)
@@ -1291,6 +1316,13 @@
/**
* heci_ioctl - the IOCTL function
+ *
+ * @inode: pointer to inode structure
+ * @file: pointer to file structure
+ * @cmd: ioctl command
+ * @data: pointer to heci message structure
+ *
+ * returns 0 on success , <0 on error
*/
static int heci_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long data)
@@ -1359,6 +1391,11 @@
/**
* heci_poll - the poll function
+ *
+ * @file: pointer to file structure
+ * @wait: pointer to poll_table structure
+ *
+ * returns poll mask
*/
static unsigned int heci_poll(struct file *file, poll_table *wait)
{
@@ -1410,45 +1447,46 @@
#ifdef CONFIG_PM
static int heci_suspend(struct pci_dev *pdev, pm_message_t state)
{
- struct iamt_heci_device *device = pci_get_drvdata(pdev);
+ struct iamt_heci_device *dev = pci_get_drvdata(pdev);
int err = 0;
- spin_lock_bh(&device->device_lock);
- if (device->reinit_tsk != NULL) {
- kthread_stop(device->reinit_tsk);
- device->reinit_tsk = NULL;
+ spin_lock_bh(&dev->device_lock);
+ if (dev->reinit_tsk != NULL) {
+ kthread_stop(dev->reinit_tsk);
+ dev->reinit_tsk = NULL;
}
- spin_unlock_bh(&device->device_lock);
+ spin_unlock_bh(&dev->device_lock);
/* Stop watchdog if exists */
- del_timer_sync(&device->wd_timer);
- if (device->wd_file_ext.state == HECI_FILE_CONNECTED
- && device->wd_timeout) {
- spin_lock_bh(&device->device_lock);
- g_sus_wd_timeout = device->wd_timeout;
- device->wd_timeout = 0;
- device->wd_due_counter = 0;
- memcpy(device->wd_data, stop_wd_params, HECI_WD_PARAMS_SIZE);
- device->stop = 1;
- if (device->host_buffer_is_empty &&
- flow_ctrl_creds(device, &device->wd_file_ext)) {
- device->host_buffer_is_empty = 0;
- if (!heci_send_wd(device))
+ del_timer_sync(&dev->wd_timer);
+ if (dev->wd_file_ext.state == HECI_FILE_CONNECTED
+ && dev->wd_timeout) {
+ spin_lock_bh(&dev->device_lock);
+ g_sus_wd_timeout = dev->wd_timeout;
+ dev->wd_timeout = 0;
+ dev->wd_due_counter = 0;
+ memcpy(dev->wd_data, heci_stop_wd_params,
+ HECI_WD_PARAMS_SIZE);
+ dev->stop = 1;
+ if (dev->host_buffer_is_empty &&
+ flow_ctrl_creds(dev, &dev->wd_file_ext)) {
+ dev->host_buffer_is_empty = 0;
+ if (!heci_send_wd(dev))
DBG("send stop WD failed\n");
else
- flow_ctrl_reduce(device, &device->wd_file_ext);
+ flow_ctrl_reduce(dev, &dev->wd_file_ext);
- device->wd_pending = 0;
+ dev->wd_pending = 0;
} else {
- device->wd_pending = 1;
+ dev->wd_pending = 1;
}
- spin_unlock_bh(&device->device_lock);
- device->wd_stoped = 0;
+ spin_unlock_bh(&dev->device_lock);
+ dev->wd_stoped = 0;
- err = wait_event_interruptible_timeout(device->wait_stop_wd,
- (device->wd_stoped),
+ err = wait_event_interruptible_timeout(dev->wait_stop_wd,
+ (dev->wd_stoped),
10 * HZ);
- if (!device->wd_stoped)
+ if (!dev->wd_stoped)
DBG("stop wd failed to complete.\n");
else {
DBG("stop wd complete %d.\n", err);
@@ -1456,18 +1494,18 @@
}
}
/* Set new heci state */
- spin_lock_bh(&device->device_lock);
- if (device->heci_state == HECI_ENABLED ||
- device->heci_state == HECI_RECOVERING_FROM_RESET) {
- device->heci_state = HECI_POWER_DOWN;
- heci_reset(device, 0);
+ spin_lock_bh(&dev->device_lock);
+ if (dev->heci_state == HECI_ENABLED ||
+ dev->heci_state == HECI_RECOVERING_FROM_RESET) {
+ dev->heci_state = HECI_POWER_DOWN;
+ heci_reset(dev, 0);
}
- spin_unlock_bh(&device->device_lock);
+ spin_unlock_bh(&dev->device_lock);
pci_save_state(pdev);
pci_disable_device(pdev);
- free_irq(pdev->irq, device);
+ free_irq(pdev->irq, dev);
pci_set_power_state(pdev, PCI_D3hot);
@@ -1476,41 +1514,42 @@
static int heci_resume(struct pci_dev *pdev)
{
- struct iamt_heci_device *device;
+ struct iamt_heci_device *dev;
int err = 0;
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
- device = pci_get_drvdata(pdev);
- if (!device)
+ dev = pci_get_drvdata(pdev);
+ if (!dev)
return -ENODEV;
/* request and enable interrupt */
err = request_irq(pdev->irq, heci_isr_interrupt, IRQF_SHARED,
- heci_driver_name, device);
+ heci_driver_name, dev);
if (err) {
printk(KERN_ERR "heci: Request_irq failure. irq = %d \n",
pdev->irq);
return err;
}
- spin_lock_bh(&device->device_lock);
- device->heci_state = HECI_POWER_UP;
- heci_reset(device, 1);
- spin_unlock_bh(&device->device_lock);
+ spin_lock_bh(&dev->device_lock);
+ dev->heci_state = HECI_POWER_UP;
+ heci_reset(dev, 1);
+ spin_unlock_bh(&dev->device_lock);
/* Start watchdog if stopped in suspend */
if (g_sus_wd_timeout != 0) {
- device->wd_timeout = g_sus_wd_timeout;
+ dev->wd_timeout = g_sus_wd_timeout;
- memcpy(device->wd_data, start_wd_params, HECI_WD_PARAMS_SIZE);
- memcpy(device->wd_data + HECI_WD_PARAMS_SIZE,
- &device->wd_timeout, sizeof(__u16));
- device->wd_due_counter = 1;
+ memcpy(dev->wd_data, heci_start_wd_params,
+ HECI_WD_PARAMS_SIZE);
+ memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
+ &dev->wd_timeout, sizeof(__u16));
+ dev->wd_due_counter = 1;
- if (device->wd_timeout)
- mod_timer(&device->wd_timer, jiffies);
+ if (dev->wd_timeout)
+ mod_timer(&dev->wd_timer, jiffies);
g_sus_wd_timeout = 0;
}
Modified: heci/trunk/src/interrupt.c
===================================================================
--- heci/trunk/src/interrupt.c 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/interrupt.c 2008-07-18 19:50:55 UTC (rev 201)
@@ -44,7 +44,7 @@
#include "heci.h"
#include "heci_interface.h"
-/**
+/*
* interrupt function prototypes
*/
static void heci_bh_handler(struct work_struct *work);
@@ -78,29 +78,29 @@
* @irq: The irq number
* @dev_id: pointer to the device structure
*
- * @return irqreturn_t
+ * returns irqreturn_t
*/
irqreturn_t heci_isr_interrupt(int irq, void *dev_id)
{
int err;
- struct iamt_heci_device *device = (struct iamt_heci_device *) dev_id;
+ struct iamt_heci_device *dev = (struct iamt_heci_device *) dev_id;
- device->host_hw_state = read_heci_register(device, H_CSR);
+ dev->host_hw_state = read_heci_register(dev, H_CSR);
- if ((device->host_hw_state & H_IS) != H_IS)
+ if ((dev->host_hw_state & H_IS) != H_IS)
return IRQ_NONE;
/* disable interrupts */
- heci_csr_disable_interrupts(device);
+ heci_csr_disable_interrupts(dev);
- /**
+ /*
* Our device interrupted, schedule work the heci_bh_handler
* to handle the interrupt processing. This needs to be a
* workqueue item since the handler can sleep.
*/
- PREPARE_WORK(&device->work, heci_bh_handler);
+ PREPARE_WORK(&dev->work, heci_bh_handler);
DBG("schedule work the heci_bh_handler.\n");
- err = schedule_work(&device->work);
+ err = schedule_work(&dev->work);
if (!err) {
printk(KERN_ERR "heci: schedule the heci_bh_handler"
" failed error=%x\n", err);
@@ -109,7 +109,7 @@
}
/**
- * _heci_cmpl: process completed operation.
+ * _heci_cmpl - process completed operation.
*
* @file_ext: private data of the file object.
* @priv_cb_pos: callback block.
@@ -138,7 +138,7 @@
}
/**
- * _heci_cmpl_iamthif: process completed iamthif operation.
+ * _heci_cmpl_iamthif - process completed iamthif operation.
*
* @dev: Device object for our driver.
* @priv_cb_pos: callback block.
@@ -303,7 +303,7 @@
* @dev: Device object for our driver
* @slots: slots to read.
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_read_handler(struct io_heci_list *cmpl_list,
struct iamt_heci_device *dev,
@@ -525,7 +525,7 @@
* @dev: Device object for our driver
* @heci_hdr: header of pthi message
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_read_pthi_message(struct io_heci_list *complete_list,
struct iamt_heci_device *dev,
@@ -583,7 +583,7 @@
* @file_ext: private data of the file object
* @heci_hdr: header of heci client message
*
- * @return !=0 if matches, 0 if no match.
+ * returns !=0 if matches, 0 if no match.
*/
static int _heci_bh_state_ok(struct heci_file_private *file_ext,
struct heci_msg_hdr *heci_hdr)
@@ -602,7 +602,7 @@
* @dev: Device object for our driver
* @heci_hdr: header of heci client message
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_read_client_message(struct io_heci_list *complete_list,
struct iamt_heci_device *dev,
@@ -684,12 +684,12 @@
}
/**
- * _heci_bh_iamthif_read: prepare to read iamthif data.
+ * _heci_bh_iamthif_read - prepare to read iamthif data.
*
* @dev: Device object for our driver.
* @slots: free slots.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_iamthif_read(struct iamt_heci_device *dev, __s32 *slots)
{
@@ -716,7 +716,7 @@
}
/**
- * _heci_bh_close: process close related operation.
+ * _heci_bh_close - process close related operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -724,7 +724,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_close(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -759,7 +759,7 @@
}
/**
- * _heci_hb_close: process read related operation.
+ * _heci_hb_close - process read related operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -767,7 +767,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_read(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -799,7 +799,7 @@
/**
- * _heci_bh_ioctl: process ioctl related operation.
+ * _heci_bh_ioctl - process ioctl related operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -807,7 +807,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_ioctl(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -839,7 +839,7 @@
}
/**
- * _heci_bh_cmpl: process completed and no-iamthif operation.
+ * _heci_bh_cmpl - process completed and no-iamthif operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -847,7 +847,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_cmpl(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -932,7 +932,7 @@
}
/**
- * _heci_bh_cmpl_iamthif: process completed iamthif operation.
+ * _heci_bh_cmpl_iamthif - process completed iamthif operation.
*
* @dev: Device object for our driver.
* @slots: free slots.
@@ -940,7 +940,7 @@
* @file_ext: private data of the file object.
* @cmpl_list: complete list.
*
- * @return 0, OK; otherwise, error.
+ * returns 0, OK; otherwise, error.
*/
static int _heci_bh_cmpl_iamthif(struct iamt_heci_device *dev, __s32 *slots,
struct heci_cb_private *priv_cb_pos,
@@ -1022,7 +1022,7 @@
* @dev: Device object for our driver
* @slots: slots to write.
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int heci_bh_write_handler(struct io_heci_list *cmpl_list,
struct iamt_heci_device *dev,
@@ -1225,7 +1225,7 @@
* @rs: connect response bus message
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
static int is_treat_specially_client(struct heci_file_private *file_ext,
struct hbm_client_connect_response *rs)
@@ -1338,7 +1338,7 @@
* @file: private data of the file object.
* @flow: flow control.
*
- * @return !=0, same; 0,not.
+ * returns !=0, same; 0,not.
*/
static int same_flow_addr(struct heci_file_private *file,
struct hbm_flow_control *flow)
@@ -1375,6 +1375,7 @@
}
}
}
+
/**
* heci_client_flow_control_response - flow control response bh routine
*
@@ -1421,7 +1422,7 @@
* @file: private data of the file object.
* @disconn: disconnection request.
*
- * @return !=0, same; 0,not.
+ * returns !=0, same; 0,not.
*/
static int same_disconn_addr(struct heci_file_private *file,
struct hbm_client_disconnect_request *disconn)
@@ -1504,7 +1505,7 @@
spin_unlock_bh(&dev->device_lock);
return;
}
- /*** Watchdog ***/
+ /* Watchdog */
if ((dev->wd_due_counter != 0) && (dev->wd_bypass == 0)) {
if (--dev->wd_due_counter == 0) {
if (dev->host_buffer_is_empty &&
Modified: heci/trunk/src/io_heci.c
===================================================================
--- heci/trunk/src/io_heci.c 2008-07-17 18:31:29 UTC (rev 200)
+++ heci/trunk/src/io_heci.c 2008-07-18 19:50:55 UTC (rev 201)
@@ -74,14 +74,13 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_get_version(struct iamt_heci_device *dev, int if_num,
struct heci_message_data *u_msg,
struct heci_message_data k_msg,
struct heci_file_private *file_ext)
{
-
int rets = 0;
struct heci_driver_version *version;
struct heci_message_data res_msg;
@@ -135,14 +134,13 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_connect_client(struct iamt_heci_device *dev, int if_num,
struct heci_message_data *u_msg,
struct heci_message_data k_msg,
struct file *file)
{
-
int rets = 0;
struct heci_message_data req_msg, res_msg;
struct heci_cb_private *priv_cb = NULL;
@@ -366,7 +364,7 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
@@ -426,10 +424,10 @@
dev->wd_pending = 0;
dev->wd_due_counter = 1; /* next timer */
if (dev->wd_timeout == 0) {
- memcpy(dev->wd_data, &stop_wd_params,
+ memcpy(dev->wd_data, &heci_stop_wd_params,
HECI_WD_PARAMS_SIZE);
} else {
- memcpy(dev->wd_data, &start_wd_params,
+ memcpy(dev->wd_data, &heci_start_wd_params,
HECI_WD_PARAMS_SIZE);
mod_timer(&dev->wd_timer, jiffies);
}
@@ -448,7 +446,7 @@
* @k_msg: data in kernel on the stack
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_ioctl_bypass_wd(struct iamt_heci_device *dev, int if_num,
struct heci_message_data k_msg,
@@ -486,7 +484,7 @@
* @dev: Device object for our driver
* @file: pointer to file object
*
- * @return returned a list entry on success, NULL on failure.
+ * returns returned a list entry on success, NULL on failure.
*/
struct heci_cb_private *find_pthi_read_list_entry(
struct iamt_heci_device *dev,
@@ -521,7 +519,7 @@
* @length: data length to read
* @offset: data read offset
*
- * @return
+ * returns
* returned data length on success,
* zero if no data to read,
* negative on failure.
@@ -529,7 +527,6 @@
int pthi_read(struct iamt_heci_device *dev, int if_num, struct file *file,
char *ubuf, size_t length, loff_t *offset)
{
-
int rets = 0;
struct heci_cb_private *priv_cb = NULL;
struct heci_file_private *file_ext = file->private_data;
@@ -622,7 +619,7 @@
* @if_num: minor number
* @file_ext: private data of the file object
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int heci_start_read(struct iamt_heci_device *dev, int if_num,
struct heci_file_private *file_ext)
@@ -707,12 +704,12 @@
}
/**
- * pthi_write: write iamthif data to pthi client
+ * pthi_write - write iamthif data to pthi client
*
* @dev: Device object for our driver
* @priv_cb: heci call back struct
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
int pthi_write(struct iamt_heci_device *dev,
struct heci_cb_private *priv_cb)
@@ -790,7 +787,7 @@
*
* @dev: Device object for our driver
*
- * @return 0 on success, <0 on failure.
+ * returns 0 on success, <0 on failure.
*/
void run_next_iamthif_cmd(struct iamt_heci_device *dev)
{
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-07-17 18:31:25
|
Revision: 200
http://openamt.svn.sourceforge.net/openamt/?rev=200&view=rev
Author: marcin_obara
Date: 2008-07-17 18:31:29 +0000 (Thu, 17 Jul 2008)
Log Message:
-----------
kernel 2.6.27 changes - removed class_device_create
Modified Paths:
--------------
heci/trunk/src/heci_main.c
heci/trunk/src/kcompat.h
Modified: heci/trunk/src/heci_main.c
===================================================================
--- heci/trunk/src/heci_main.c 2008-07-08 17:48:34 UTC (rev 199)
+++ heci/trunk/src/heci_main.c 2008-07-17 18:31:29 UTC (rev 200)
@@ -222,67 +222,79 @@
static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
/**
- * heci_sysfs_create - creates a struct class to contain heci info
+ * heci_register_cdev - registers heci char device
*
* @return 0 on success, <0 on failure.
*/
-static int heci_sysfs_create(void)
+static int heci_register_cdev(void)
{
- struct class *class;
- int err = 0;
+ int ret;
+ dev_t dev;
- class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
- if (IS_ERR(class)) {
- err = PTR_ERR(class);
- printk(KERN_ERR "heci: Error creating heci class.\n");
- goto err_out;
+ /* registration of char devices */
+ ret = alloc_chrdev_region(&dev, HECI_MINORS_BASE, HECI_MINORS_COUNT,
+ HECI_DRIVER_NAME);
+ if (ret) {
+ printk(KERN_ERR "heci: Error allocating char device region.\n");
+ return ret;
}
- err = class_create_file(class, &class_attr_version);
- if (err) {
- class_destroy(class);
- printk(KERN_ERR "heci: Error creating heci class file.\n");
- goto err_out;
- }
+ heci_major = MAJOR(dev);
- heci_class = class;
-err_out:
- return err;
+ ret = heci_registration_cdev(&heci_cdev, HECI_MINOR_NUMBER,
+ &heci_fops);
+ if (ret)
+ unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
+ HECI_MINORS_COUNT);
+
+ return ret;
}
/**
- * heci_sysfs_destroy - destroys a struct class of heci info
+ * heci_unregister_cdev - unregisters heci char device
*/
-static void heci_sysfs_destroy(void)
+static void heci_unregister_cdev(void)
{
- if ((heci_class == NULL) || (IS_ERR(heci_class)))
- return;
-
- class_remove_file(heci_class, &class_attr_version);
- class_destroy(heci_class);
+ cdev_del(&heci_cdev);
+ unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
+ HECI_MINORS_COUNT);
}
/**
- * heci_sysfs_device_create - adds device to sysfs for character devices
+ * heci_sysfs_device_create - adds device entry to sysfs
*
* @return 0 on success, <0 on failure.
*/
static int heci_sysfs_device_create(void)
{
+ struct class *class;
+ void *tmphdev;
int err = 0;
- if ((heci_class == NULL) || (IS_ERR(heci_class))) {
- err = -EINVAL;
+ class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
+ if (IS_ERR(class)) {
+ err = PTR_ERR(class);
+ printk(KERN_ERR "heci: Error creating heci class.\n");
goto err_out;
}
- heci_class_dev = class_device_create(heci_class, NULL,
- heci_cdev.dev,
- NULL,
- HECI_DEV_NAME);
- if (IS_ERR(heci_class_dev))
- err = PTR_ERR(heci_class_dev);
+ err = class_create_file(class, &class_attr_version);
+ if (err) {
+ class_destroy(class);
+ printk(KERN_ERR "heci: Error creating heci class file.\n");
+ goto err_out;
+ }
+ tmphdev = (void *) device_create(class, NULL, heci_cdev.dev,
+ HECI_DEV_NAME);
+ if (IS_ERR(tmphdev)) {
+ err = PTR_ERR(tmphdev);
+ class_remove_file(class, &class_attr_version);
+ class_destroy(class);
+ goto err_out;
+ }
+
+ heci_class = class;
err_out:
return err;
}
@@ -292,8 +304,12 @@
*/
static void heci_sysfs_device_remove(void)
{
- if (heci_class_dev)
- class_device_unregister(heci_class_dev);
+ if ((heci_class == NULL) || (IS_ERR(heci_class)))
+ return;
+
+ device_destroy(heci_class, heci_cdev.dev);
+ class_remove_file(heci_class, &class_attr_version);
+ class_destroy(heci_class);
}
/**
@@ -307,7 +323,6 @@
static int __init heci_init_module(void)
{
int ret = 0;
- dev_t dev;
printk(KERN_INFO "heci: %s - version %s\n", heci_driver_string,
heci_driver_version);
@@ -320,39 +335,18 @@
goto end;
}
- /* registration of char devices */
- ret = alloc_chrdev_region(&dev, HECI_MINORS_BASE, HECI_MINORS_COUNT,
- HECI_DRIVER_NAME);
- if (ret) {
- printk(KERN_ERR "heci: Error allocating char device region.\n");
+ ret = heci_register_cdev();
+ if (ret)
goto unregister_pci;
- }
- heci_major = MAJOR(dev);
-
- /* registration in sysfs interface */
- ret = heci_sysfs_create();
+ ret = heci_sysfs_device_create();
if (ret)
- goto unregister;
+ goto unregister_cdev;
- ret = heci_registration_cdev(&heci_cdev, HECI_MINOR_NUMBER,
- &heci_fops);
- if (ret)
- goto destroy_sysfs;
-
- if (heci_sysfs_device_create()) {
- cdev_del(&heci_cdev);
- ret = -EAGAIN;
- goto destroy_sysfs;
- }
-
return ret;
-destroy_sysfs:
- heci_sysfs_destroy();
-unregister:
- unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
- HECI_MINORS_COUNT);
+unregister_cdev:
+ heci_unregister_cdev();
unregister_pci:
pci_unregister_driver(&heci_driver);
end:
@@ -371,12 +365,8 @@
static void __exit heci_exit_module(void)
{
pci_unregister_driver(&heci_driver);
- /* Now unregister cdev. */
- cdev_del(&heci_cdev);
heci_sysfs_device_remove();
- heci_sysfs_destroy();
- unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
- HECI_MINORS_COUNT);
+ heci_unregister_cdev();
}
module_exit(heci_exit_module);
Modified: heci/trunk/src/kcompat.h
===================================================================
--- heci/trunk/src/kcompat.h 2008-07-08 17:48:34 UTC (rev 199)
+++ heci/trunk/src/kcompat.h 2008-07-17 18:31:29 UTC (rev 200)
@@ -49,6 +49,17 @@
#include <linux/interrupt.h>
#include <asm/io.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
+#define device_create(cls, parent, devt, fmt...) class_device_create(cls, parent, devt, NULL, ## fmt)
+#define device_destroy class_device_destroy
+#endif
+
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23))
+#define HECI_TASK_NONFREEZABLE current->flags |= PF_NOFREEZE;
+#endif
+
+
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 17))
#include <asm/uaccess.h>
#else
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-06-02 17:12:24
|
Revision: 589
http://openamt.svn.sourceforge.net/openamt/?rev=589&view=rev
Author: marcin_obara
Date: 2008-06-02 10:12:32 -0700 (Mon, 02 Jun 2008)
Log Message:
-----------
update messages
Modified Paths:
--------------
ZTCLocalAgent/branches/ztc-5.0/src/StatusStrings.str
ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp
ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.str
ZTCLocalAgent/branches/ztc-5.0/src/resource.h
Modified: ZTCLocalAgent/branches/ztc-5.0/src/StatusStrings.str
===================================================================
--- ZTCLocalAgent/branches/ztc-5.0/src/StatusStrings.str 2008-06-02 17:10:05 UTC (rev 588)
+++ ZTCLocalAgent/branches/ztc-5.0/src/StatusStrings.str 2008-06-02 17:12:32 UTC (rev 589)
@@ -30,77 +30,77 @@
#include "StatusCodeDefinitions.h"
- PT_STATUS_SUCCESS "PT_STATUS_SUCCESS: The request succeeded."
- PT_STATUS_INTERNAL_ERROR "PT_STATUS_INTERNAL_ERROR: An internal error in the Intel(R) AMT device has occurred."
- PT_STATUS_NOT_READY "PT_STATUS_NOT_READY: Intel(R) AMT device has not progressed far enough in its initialization to process the command."
- PT_STATUS_INVALID_PT_MODE "PT_STATUS_INVALID_PT_MODE: Command is not permitted in current operating mode."
- PT_STATUS_INVALID_MESSAGE_LENGTH "PT_STATUS_INVALID_MESSAGE_LENGTH: Length field of header is invalid."
- PT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE "PT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE: The requested hardware asset inventory table checksum is not available."
- PT_STATUS_INTEGRITY_CHECK_FAILED "PT_STATUS_INTEGRITY_CHECK_FAILED: The Integrity Check Value field of the request message sent by Intel(R) AMT enabled device is invalid."
- PT_STATUS_UNSUPPORTED_ISVS_VERSION "PT_STATUS_UNSUPPORTED_ISVS_VERSION: The specified ISV version is not supported."
- PT_STATUS_APPLICATION_NOT_REGISTERED "PT_STATUS_APPLICATION_NOT_REGISTERED: The specified queried application is not registered."
- PT_STATUS_INVALID_REGISTRATION_DATA "PT_STATUS_INVALID_REGISTRATION_DATA: Either an invalid name or a not previously registered Enterprise name was specified."
- PT_STATUS_APPLICATION_DOES_NOT_EXIST "PT_STATUS_APPLICATION_DOES_NOT_EXIST: The application handle provided in the request message has never been allocated."
- PT_STATUS_NOT_ENOUGH_STORAGE "PT_STATUS_NOT_ENOUGH_STORAGE: The requested number of bytes cannot be allocated in ISV storage."
- PT_STATUS_INVALID_NAME "PT_STATUS_INVALID_NAME: The specified name is invalid."
- PT_STATUS_BLOCK_DOES_NOT_EXIST "PT_STATUS_BLOCK_DOES_NOT_EXIST: The specified block does not exist."
- PT_STATUS_INVALID_BYTE_OFFSET "PT_STATUS_INVALID_BYTE_OFFSET: The specified byte offset is invalid."
- PT_STATUS_INVALID_BYTE_COUNT "PT_STATUS_INVALID_BYTE_COUNT: The specified byte count is invalid."
- PT_STATUS_NOT_PERMITTED "PT_STATUS_NOT_PERMITTED: The requesting application is not permitted to request execution of the specified operation."
- PT_STATUS_NOT_OWNER "PT_STATUS_NOT_OWNER: The requesting application is not the owner of the block as required for the requested operation."
- PT_STATUS_BLOCK_LOCKED_BY_OTHER "PT_STATUS_BLOCK_LOCKED_BY_OTHER: The specified block is locked by another application."
- PT_STATUS_BLOCK_NOT_LOCKED "PT_STATUS_BLOCK_NOT_LOCKED: The specified block is not locked."
- PT_STATUS_INVALID_GROUP_PERMISSIONS "PT_STATUS_INVALID_GROUP_PERMISSIONS: The specified group permission bits are invalid."
- PT_STATUS_GROUP_DOES_NOT_EXIST "PT_STATUS_GROUP_DOES_NOT_EXIST: The specified group does not exist."
- PT_STATUS_INVALID_MEMBER_COUNT "PT_STATUS_INVALID_MEMBER_COUNT: The specified member count is invalid."
- PT_STATUS_MAX_LIMIT_REACHED "PT_STATUS_MAX_LIMIT_REACHED: The request cannot be satisfied because a maximum limit associated with the request has been reached."
- PT_STATUS_INVALID_AUTH_TYPE "PT_STATUS_INVALID_AUTH_TYPE: The specified key algorithm is invalid."
- PT_STATUS_AUTHENTICATION_FAILED "PT_STATUS_AUTHENTICATION_FAILED: Authentication failed."
- PT_STATUS_INVALID_DHCP_MODE "PT_STATUS_INVALID_DHCP_MODE: The specified DHCP mode is invalid."
- PT_STATUS_INVALID_IP_ADDRESS "PT_STATUS_INVALID_IP_ADDRESS: The specified IP address is not a valid IP unicast address."
- PT_STATUS_INVALID_DOMAIN_NAME "PT_STATUS_INVALID_DOMAIN_NAME: The specified domain name is not a valid domain name."
- PT_STATUS_UNSUPPORTED_VERSION "PT_STATUS_UNSUPPORTED_VERSION: Unsupported version."
- PT_STATUS_REQUEST_UNEXPECTED "PT_STATUS_REQUEST_UNEXPECTED: The requested operation cannot be performed because a prerequisite request message has not been received."
- PT_STATUS_INVALID_TABLE_TYPE "PT_STATUS_INVALID_TABLE_TYPE: Invalid Table type."
- PT_STATUS_INVALID_PROVISIONING_STATE "PT_STATUS_INVALID_PROVISIONING_STATE: The specified provisioning mode code is undefined."
- PT_STATUS_UNSUPPORTED_OBJECT "PT_STATUS_UNSUPPORTED_OBJECT: Unsupported object."
- PT_STATUS_INVALID_TIME "PT_STATUS_INVALID_TIME: The specified time was not accepted by the Intel(R) AMT device since it is earlier than the baseline time set for the device."
- PT_STATUS_INVALID_INDEX "PT_STATUS_INVALID_INDEX: Starting Index is invalid."
- PT_STATUS_INVALID_PARAMETER "PT_STATUS_INVALID_PARAMETER: Specified parameter is invalid."
- PT_STATUS_INVALID_NETMASK "PT_STATUS_INVALID_NETMASK: An invalid netmask was supplied (a valid netmask is an IP address in which all '1's are before the '0' - e.g. FFFC0000h is valid, FF0C0000h is invalid)."
- PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED "PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED: The operation failed because the Flash wear-out protection mechanism prevented a write to an NVRAM sector."
- PT_STATUS_INVALID_IMAGE_LENGTH "PT_STATUS_INVALID_IMAGE_LENGTH: ME FW did not receive the entire image file."
- PT_STATUS_INVALID_IMAGE_SIGNATURE "PT_STATUS_INVALID_IMAGE_SIGNATURE: ME FW received an image file with an invalid signature."
- PT_STATUS_PROPOSE_ANOTHER_VERSION "PT_STATUS_PROPOSE_ANOTHER_VERSION: LME can not support the requested version."
- PT_STATUS_INVALID_PID_FORMAT "PT_STATUS_INVALID_PID_FORMAT: The PID must be a 64 bit quantity made up of ASCII codes of some combination of 8 characters - capital letters (A-Z), and numbers (0-9)."
- PT_STATUS_INVALID_PPS_FORMAT "PT_STATUS_INVALID_PPS_FORMAT: The PPS must be a 256 bit quantity made up of ASCII codes of some combination of 32 characters - capital letters (A-Z), and numbers (0-9)."
- PT_STATUS_BIST_COMMAND_BLOCKED "PT_STATUS_BIST_COMMAND_BLOCKED: Full BIST test has been blocked."
- PT_STATUS_CONNECTION_FAILED "PT_STATUS_CONNECTION_FAILED: A TCP/IP connection could not be opened on with the selected port."
- PT_STATUS_CONNECTION_TOO_MANY "PT_STATUS_CONNECTION_TOO_MANY: Max number of connections reached. LME can not open the requested connection."
- PT_STATUS_RNG_GENERATION_IN_PROGRESS "PT_STATUS_RNG_GENERATION_IN_PROGRESS: Random key generation is in progress."
- PT_STATUS_UNSUPPORTED_OEM_NUMBER "PT_STATUS_UNSUPPORTED_OEM_NUMBER: The OEM number specified in the remote control command is not supported by the Intel(R) AMT device."
- PT_STATUS_UNSUPPORTED_BOOT_OPTION "PT_STATUS_UNSUPPORTED_BOOT_OPTION: The boot option specified in the remote control command is not supported by the Intel(R) AMT device."
- PT_STATUS_INVALID_COMMAND "PT_STATUS_INVALID_COMMAND: The command specified in the remote control command is not supported by the Intel(R) AMT device."
- PT_STATUS_INVALID_SPECIAL_COMMAND "PT_STATUS_INVALID_SPECIAL_COMMAND: The special command specified in the remote control command is not supported by the Intel(R) AMT device."
- PT_STATUS_INVALID_HANDLE "PT_STATUS_INVALID_HANDLE: The handle specified in the command is invalid."
- PT_STATUS_INVALID_PASSWORD "PT_STATUS_INVALID_PASSWORD: The password specified in the User ACL is invalid."
- PT_STATUS_INVALID_REALM "PT_STATUS_INVALID_REALM: The realm specified in the User ACL is invalid."
- PT_STATUS_STORAGE_ACL_ENTRY_IN_USE "PT_STATUS_STORAGE_ACL_ENTRY_IN_USE: The FPACL or EACL entry is used by an active registration and cannot be removed or modified."
- PT_STATUS_DATA_MISSING "PT_STATUS_DATA_MISSING: Essential data is missing on CommitChanges command."
- PT_STATUS_DUPLICATE "PT_STATUS_DUPLICATE: The parameter specified is a duplicate of an existing value."
- PT_STATUS_EVENTLOG_FROZEN "PT_STATUS_EVENTLOG_FROZEN: Event Log operation failed due to the current freeze status of the log."
- PT_STATUS_PKI_MISSING_KEYS "PT_STATUS_PKI_MISSING_KEYS: The device is missing private key material."
- PT_STATUS_PKI_GENERATING_KEYS "PT_STATUS_PKI_GENERATING_KEYS: The device is currently generating a keypair. Caller may try repeating this operation at a later time."
- PT_STATUS_INVALID_KEY "PT_STATUS_INVALID_KEY: An invalid Key was entered."
- PT_STATUS_INVALID_CERT "PT_STATUS_INVALID_CERT: An invalid X.509 certificate was entered."
- PT_STATUS_CERT_KEY_NOT_MATCH "PT_STATUS_CERT_KEY_NOT_MATCH: Certificate Chain and Private Key do not match."
- PT_STATUS_MAX_KERB_DOMAIN_REACHED "PT_STATUS_MAX_KERB_DOMAIN_REACHED: The request cannot be satisfied because the maximum number of allowed Kerberos domains has been reached. (The domain is determined by the first 24 Bytes of the SID.)"
- PT_STATUS_UNSUPPORTED "PT_STATUS_UNSUPPORTED: The requested configuration is unsupported."
- PT_STATUS_INVALID_PRIORITY "PT_STATUS_INVALID_PRIORITY: A profile with the requested priority already exists."
- PT_STATUS_NOT_FOUND "PT_STATUS_NOT_FOUND: Unable to find specified element."
- PT_STATUS_INVALID_CREDENTIALS "PT_STATUS_INVALID_CREDENTIALS: Invalid User credentials."
- PT_STATUS_INVALID_PASSPHRASE "PT_STATUS_INVALID_PASSPHRASE: Passphrase is invalid."
- PT_STATUS_NO_ASSOCIATION "PT_STATUS_NO_ASSOCIATION: A certificate handle must be chosen before the operation can be completed."
+ AMT_STATUS_SUCCESS "AMT_STATUS_SUCCESS: The request succeeded."
+ AMT_STATUS_INTERNAL_ERROR "AMT_STATUS_INTERNAL_ERROR: An internal error in the Intel(R) AMT device has occurred."
+ AMT_STATUS_NOT_READY "AMT_STATUS_NOT_READY: Intel(R) AMT device has not progressed far enough in its initialization to process the command."
+ AMT_STATUS_INVALID_PT_MODE "AMT_STATUS_INVALID_PT_MODE: Command is not permitted in current operating mode."
+ AMT_STATUS_INVALID_MESSAGE_LENGTH "AMT_STATUS_INVALID_MESSAGE_LENGTH: Length field of header is invalid."
+ AMT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE "AMT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE: The requested hardware asset inventory table checksum is not available."
+ AMT_STATUS_INTEGRITY_CHECK_FAILED "AMT_STATUS_INTEGRITY_CHECK_FAILED: The Integrity Check Value field of the request message sent by Intel(R) AMT enabled device is invalid."
+ AMT_STATUS_UNSUPPORTED_ISVS_VERSION "AMT_STATUS_UNSUPPORTED_ISVS_VERSION: The specified ISV version is not supported."
+ AMT_STATUS_APPLICATION_NOT_REGISTERED "AMT_STATUS_APPLICATION_NOT_REGISTERED: The specified queried application is not registered."
+ AMT_STATUS_INVALID_REGISTRATION_DATA "AMT_STATUS_INVALID_REGISTRATION_DATA: Either an invalid name or a not previously registered Enterprise name was specified."
+ AMT_STATUS_APPLICATION_DOES_NOT_EXIST "AMT_STATUS_APPLICATION_DOES_NOT_EXIST: The application handle provided in the request message has never been allocated."
+ AMT_STATUS_NOT_ENOUGH_STORAGE "AMT_STATUS_NOT_ENOUGH_STORAGE: The requested number of bytes cannot be allocated in ISV storage."
+ AMT_STATUS_INVALID_NAME "AMT_STATUS_INVALID_NAME: The specified name is invalid."
+ AMT_STATUS_BLOCK_DOES_NOT_EXIST "AMT_STATUS_BLOCK_DOES_NOT_EXIST: The specified block does not exist."
+ AMT_STATUS_INVALID_BYTE_OFFSET "AMT_STATUS_INVALID_BYTE_OFFSET: The specified byte offset is invalid."
+ AMT_STATUS_INVALID_BYTE_COUNT "AMT_STATUS_INVALID_BYTE_COUNT: The specified byte count is invalid."
+ AMT_STATUS_NOT_PERMITTED "AMT_STATUS_NOT_PERMITTED: The requesting application is not permitted to request execution of the specified operation."
+ AMT_STATUS_NOT_OWNER "AMT_STATUS_NOT_OWNER: The requesting application is not the owner of the block as required for the requested operation."
+ AMT_STATUS_BLOCK_LOCKED_BY_OTHER "AMT_STATUS_BLOCK_LOCKED_BY_OTHER: The specified block is locked by another application."
+ AMT_STATUS_BLOCK_NOT_LOCKED "AMT_STATUS_BLOCK_NOT_LOCKED: The specified block is not locked."
+ AMT_STATUS_INVALID_GROUP_PERMISSIONS "AMT_STATUS_INVALID_GROUP_PERMISSIONS: The specified group permission bits are invalid."
+ AMT_STATUS_GROUP_DOES_NOT_EXIST "AMT_STATUS_GROUP_DOES_NOT_EXIST: The specified group does not exist."
+ AMT_STATUS_INVALID_MEMBER_COUNT "AMT_STATUS_INVALID_MEMBER_COUNT: The specified member count is invalid."
+ AMT_STATUS_MAX_LIMIT_REACHED "AMT_STATUS_MAX_LIMIT_REACHED: The request cannot be satisfied because a maximum limit associated with the request has been reached."
+ AMT_STATUS_INVALID_AUTH_TYPE "AMT_STATUS_INVALID_AUTH_TYPE: The specified key algorithm is invalid."
+ AMT_STATUS_AUTHENTICATION_FAILED "AMT_STATUS_AUTHENTICATION_FAILED: Authentication failed."
+ AMT_STATUS_INVALID_DHCP_MODE "AMT_STATUS_INVALID_DHCP_MODE: The specified DHCP mode is invalid."
+ AMT_STATUS_INVALID_IP_ADDRESS "AMT_STATUS_INVALID_IP_ADDRESS: The specified IP address is not a valid IP unicast address."
+ AMT_STATUS_INVALID_DOMAIN_NAME "AMT_STATUS_INVALID_DOMAIN_NAME: The specified domain name is not a valid domain name."
+ AMT_STATUS_UNSUPPORTED_VERSION "AMT_STATUS_UNSUPPORTED_VERSION: Unsupported version."
+ AMT_STATUS_REQUEST_UNEXPECTED "AMT_STATUS_REQUEST_UNEXPECTED: The requested operation cannot be performed because a prerequisite request message has not been received."
+ AMT_STATUS_INVALID_TABLE_TYPE "AMT_STATUS_INVALID_TABLE_TYPE: Invalid Table type."
+ AMT_STATUS_INVALID_PROVISIONING_STATE "AMT_STATUS_INVALID_PROVISIONING_STATE: The specified provisioning mode code is undefined."
+ AMT_STATUS_UNSUPPORTED_OBJECT "AMT_STATUS_UNSUPPORTED_OBJECT: Unsupported object."
+ AMT_STATUS_INVALID_TIME "AMT_STATUS_INVALID_TIME: The specified time was not accepted by the Intel(R) AMT device since it is earlier than the baseline time set for the device."
+ AMT_STATUS_INVALID_INDEX "AMT_STATUS_INVALID_INDEX: Starting Index is invalid."
+ AMT_STATUS_INVALID_PARAMETER "AMT_STATUS_INVALID_PARAMETER: Specified parameter is invalid."
+ AMT_STATUS_INVALID_NETMASK "AMT_STATUS_INVALID_NETMASK: An invalid netmask was supplied (a valid netmask is an IP address in which all '1's are before the '0' - e.g. FFFC0000h is valid, FF0C0000h is invalid)."
+ AMT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED "AMT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED: The operation failed because the Flash wear-out protection mechanism prevented a write to an NVRAM sector."
+ AMT_STATUS_INVALID_IMAGE_LENGTH "AMT_STATUS_INVALID_IMAGE_LENGTH: ME FW did not receive the entire image file."
+ AMT_STATUS_INVALID_IMAGE_SIGNATURE "AMT_STATUS_INVALID_IMAGE_SIGNATURE: ME FW received an image file with an invalid signature."
+ AMT_STATUS_PROPOSE_ANOTHER_VERSION "AMT_STATUS_PROPOSE_ANOTHER_VERSION: LME can not support the requested version."
+ AMT_STATUS_INVALID_PID_FORMAT "AMT_STATUS_INVALID_PID_FORMAT: The PID must be a 64 bit quantity made up of ASCII codes of some combination of 8 characters - capital letters (A-Z), and numbers (0-9)."
+ AMT_STATUS_INVALID_PPS_FORMAT "AMT_STATUS_INVALID_PPS_FORMAT: The PPS must be a 256 bit quantity made up of ASCII codes of some combination of 32 characters - capital letters (A-Z), and numbers (0-9)."
+ AMT_STATUS_BIST_COMMAND_BLOCKED "AMT_STATUS_BIST_COMMAND_BLOCKED: Full BIST test has been blocked."
+ AMT_STATUS_CONNECTION_FAILED "AMT_STATUS_CONNECTION_FAILED: A TCP/IP connection could not be opened on with the selected port."
+ AMT_STATUS_CONNECTION_TOO_MANY "AMT_STATUS_CONNECTION_TOO_MANY: Max number of connections reached. LME can not open the requested connection."
+ AMT_STATUS_RNG_GENERATION_IN_PROGRESS "AMT_STATUS_RNG_GENERATION_IN_PROGRESS: Random key generation is in progress."
+ AMT_STATUS_UNSUPPORTED_OEM_NUMBER "AMT_STATUS_UNSUPPORTED_OEM_NUMBER: The OEM number specified in the remote control command is not supported by the Intel(R) AMT device."
+ AMT_STATUS_UNSUPPORTED_BOOT_OPTION "AMT_STATUS_UNSUPPORTED_BOOT_OPTION: The boot option specified in the remote control command is not supported by the Intel(R) AMT device."
+ AMT_STATUS_INVALID_COMMAND "AMT_STATUS_INVALID_COMMAND: The command specified in the remote control command is not supported by the Intel(R) AMT device."
+ AMT_STATUS_INVALID_SPECIAL_COMMAND "AMT_STATUS_INVALID_SPECIAL_COMMAND: The special command specified in the remote control command is not supported by the Intel(R) AMT device."
+ AMT_STATUS_INVALID_HANDLE "AMT_STATUS_INVALID_HANDLE: The handle specified in the command is invalid."
+ AMT_STATUS_INVALID_PASSWORD "AMT_STATUS_INVALID_PASSWORD: The password specified in the User ACL is invalid."
+ AMT_STATUS_INVALID_REALM "AMT_STATUS_INVALID_REALM: The realm specified in the User ACL is invalid."
+ AMT_STATUS_STORAGE_ACL_ENTRY_IN_USE "AMT_STATUS_STORAGE_ACL_ENTRY_IN_USE: The FPACL or EACL entry is used by an active registration and cannot be removed or modified."
+ AMT_STATUS_DATA_MISSING "AMT_STATUS_DATA_MISSING: Essential data is missing on CommitChanges command."
+ AMT_STATUS_DUPLICATE "AMT_STATUS_DUPLICATE: The parameter specified is a duplicate of an existing value."
+ AMT_STATUS_EVENTLOG_FROZEN "AMT_STATUS_EVENTLOG_FROZEN: Event Log operation failed due to the current freeze status of the log."
+ AMT_STATUS_PKI_MISSING_KEYS "AMT_STATUS_PKI_MISSING_KEYS: The device is missing private key material."
+ AMT_STATUS_PKI_GENERATING_KEYS "AMT_STATUS_PKI_GENERATING_KEYS: The device is currently generating a keypair. Caller may try repeating this operation at a later time."
+ AMT_STATUS_INVALID_KEY "AMT_STATUS_INVALID_KEY: An invalid Key was entered."
+ AMT_STATUS_INVALID_CERT "AMT_STATUS_INVALID_CERT: An invalid X.509 certificate was entered."
+ AMT_STATUS_CERT_KEY_NOT_MATCH "AMT_STATUS_CERT_KEY_NOT_MATCH: Certificate Chain and Private Key do not match."
+ AMT_STATUS_MAX_KERB_DOMAIN_REACHED "AMT_STATUS_MAX_KERB_DOMAIN_REACHED: The request cannot be satisfied because the maximum number of allowed Kerberos domains has been reached. (The domain is determined by the first 24 Bytes of the SID.)"
+ AMT_STATUS_UNSUPPORTED "AMT_STATUS_UNSUPPORTED: The requested configuration is unsupported."
+ AMT_STATUS_INVALID_PRIORITY "AMT_STATUS_INVALID_PRIORITY: A profile with the requested priority already exists."
+ AMT_STATUS_NOT_FOUND "AMT_STATUS_NOT_FOUND: Unable to find specified element."
+ AMT_STATUS_INVALID_CREDENTIALS "AMT_STATUS_INVALID_CREDENTIALS: Invalid User credentials."
+ AMT_STATUS_INVALID_PASSPHRASE "AMT_STATUS_INVALID_PASSPHRASE: Passphrase is invalid."
+ AMT_STATUS_NO_ASSOCIATION "AMT_STATUS_NO_ASSOCIATION: A certificate handle must be chosen before the operation can be completed."
PTSDK_STATUS_INTERNAL_ERROR "PTSDK_STATUS_INTERNAL_ERROR: The application has identified an internal error."
PTSDK_STATUS_NOT_INITIALIZED "PTSDK_STATUS_NOT_INITIALIZED: An ISV operation was called while the library is not initialized."
PTSDK_STATUS_LIB_VERSION_UNSUPPORTED "PTSDK_STATUS_LIB_VERSION_UNSUPPORTED: The requested library I/F is not supported by the current library implementation."
@@ -112,8 +112,8 @@
PTSDK_STATUS_PARAM_BUFFER_TOO_SHORT "PTSDK_STATUS_PARAM_BUFFER_TOO_SHORT: Specified container can not hold the requested string."
PTSDK_STATUS_COM_NOT_INITIALIZED_IN_THREAD "PTSDK_STATUS_COM_NOT_INITIALIZED_IN_THREAD: ISVS_InitializeCOMinThread was not called by the current thread."
PTSDK_STATUS_URL_REQUIRED "PTSDK_STATUS_URL_REQUIRED: URL required."
- PT_STATUS_RNG_NOT_READY "PT_STATUS_RNG_NOT_READY: A randomly generated key does not exist."
- PT_STATUS_CERTIFICATE_NOT_READY "PT_STATUS_CERTIFICATE_NOT_READY: Self-generated AMT certificate does not exist."
+ AMT_STATUS_RNG_NOT_READY "AMT_STATUS_RNG_NOT_READY: A randomly generated key does not exist."
+ AMT_STATUS_CERTIFICATE_NOT_READY "AMT_STATUS_CERTIFICATE_NOT_READY: Self-generated AMT certificate does not exist."
// English (U.S.) resources strings
/////////////////////////////////////////////////////////////////////////////
Modified: ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp
===================================================================
--- ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp 2008-06-02 17:10:05 UTC (rev 588)
+++ ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp 2008-06-02 17:12:32 UTC (rev 589)
@@ -202,7 +202,7 @@
if (true != command.PTHIClient.Init()) {
if (true != command.PTHIClient.GetHeciVersion(hver)) {
- DisplayErrorMessage(LA_HECI_NOT_INSTALLED_ERROR);
+ DisplayErrorMessage(OPEN_HECI_FAILURE);
status = AMT_STATUS_INTERNAL_ERROR;
return status;
}
Modified: ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.str
===================================================================
--- ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.str 2008-06-02 17:10:05 UTC (rev 588)
+++ ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.str 2008-06-02 17:12:32 UTC (rev 589)
@@ -37,9 +37,9 @@
USAGE "Usage:"
ERROR_MESSAGE "Error: "
VERSION_MESSAGE "Intel(R) ZTCLocalAgent Version: "
- HECI_ERROR_MESSAGE "HECI Error: "
+ HECI_ERROR_MESSAGE "MEI Error: "
UNKNOWN "Unknown"
- HECI_CONNECT_TO_FWU_CLIENT_FAILURE "Failed to connect to HECI FW Update client"
+ HECI_CONNECT_TO_FWU_CLIENT_FAILURE "Failed to connect to MEI FW Update client"
WRITE_FILE_TIME_OUT "WriteFile timed out"
ME_FW_INFO "ME FW Info\n"
ME_MODE "SKU:"
@@ -49,21 +49,21 @@
GET_CLASS_DEVS "SetupDiGetClassDevs "
GET_INTERFACE_DETAIL "Get interface detail"
ICH_VERSION "ICH Version:"
- FIND_HECI_FAILURE "Cannot find HECI device."
- CREATE_HECI_FILE_FAILURE "Cannot establish a handle to the HECI driver."
- GET_HECI_DRIVER_VERSION_FAILURE "Failed to get HECI driver version."
+ FIND_HECI_FAILURE "Cannot find MEI device."
+ OPEN_HECI_FAILURE "Cannot establish a handle to the MEI driver."
+ GET_HECI_DRIVER_VERSION_FAILURE "Failed to get MEI driver version."
LA_STATUS_INTERNAL_ERROR "An internal error has occurred."
- HECI_CONNECT_TO_PTHI_CLIENT_FAILURE "Failed to connect to HECI PTHI client."
- LA_HECI_ERROR "A HECI error has occurred."
+ HECI_CONNECT_TO_PTHI_CLIENT_FAILURE "Failed to connect to MEI PTHI client."
+ LA_HECI_ERROR "A MEI error has occurred."
ALLOCATE_MEMORY_ERROR "Memory Allocation Error"
- LA_HECI_NOT_INSTALLED_ERROR "HECI driver is not installed."
+ LA_HECI_NOT_INSTALLED_ERROR "MEI driver is not installed."
FW_BUFFER_IS_TO_SMALL "FW supported buffer size is too small."
SEND_DATA_TO_FW_FAILURE "Failed to send data to FW."
RECEIVE_DATA_FROM_FW_FAILURE "Failed to receive data from FW."
- GET_INFO_FROM_HECI_FAILURE "Cannot get info from HECI FW update client."
+ GET_INFO_FROM_HECI_FAILURE "Cannot get info from MEI FW update client."
MCH_VERSION "MCH Version:"
OEM_VENDOR "OEM Vendor:"
- HECI_DRIVER_VERSION "Connected to HECI driver, version:"
+ HECI_DRIVER_VERSION "Connected to MEI driver, version:"
CODE_MAJOR_VERSION "Code Major Version:"
CODE_MINOR_VERSION "Code Minor Version:"
CODE_HOTFIX_VERSION "Code Hotfix Version:"
@@ -108,7 +108,7 @@
WORD_FAILURE "failure"
WORD_NOT_READY "NOT READY"
HASH_ENTRY "Certificate hash entry:"
- HECI_CONNECT_TO_WD_CLIENT_FAILURE "Failed to connect to HECI WD client."
+ HECI_CONNECT_TO_WD_CLIENT_FAILURE "Failed to connect to MEI WD client."
CHANGE_TO_AMT_FAILURE "Changing to Intel AMT mode is not allowed."
WORD_CHANGE_TO_AMT "Change to Intel AMT mode:"
FOUND "Found"
Modified: ZTCLocalAgent/branches/ztc-5.0/src/resource.h
===================================================================
--- ZTCLocalAgent/branches/ztc-5.0/src/resource.h 2008-06-02 17:10:05 UTC (rev 588)
+++ ZTCLocalAgent/branches/ztc-5.0/src/resource.h 2008-06-02 17:12:32 UTC (rev 589)
@@ -47,8 +47,7 @@
#define GET_INTERFACE_DETAIL 14
#define ICH_VERSION 15
#define FIND_HECI_FAILURE 16
-#define CREATE_HECI_FILE 17
-#define CREATE_HECI_FILE_FAILURE 17
+#define OPEN_HECI_FAILURE 17
#define GET_HECI_DRIVER_VERSION_FAILURE 18
#define LA_STATUS_INTERNAL_ERROR 19
#define HECI_CONNECT_TO_PTHI_CLIENT_FAILURE 20
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-06-02 17:10:03
|
Revision: 588
http://openamt.svn.sourceforge.net/openamt/?rev=588&view=rev
Author: marcin_obara
Date: 2008-06-02 10:10:05 -0700 (Mon, 02 Jun 2008)
Log Message:
-----------
update prefix in logged messages
Modified Paths:
--------------
uns/branches/uns-5.0/README
uns/branches/uns-5.0/UNSEventLogger.cpp
uns/branches/uns-5.0/UNSEventLogger.h
Modified: uns/branches/uns-5.0/README
===================================================================
--- uns/branches/uns-5.0/README 2008-06-02 17:07:24 UTC (rev 587)
+++ uns/branches/uns-5.0/README 2008-06-02 17:10:05 UTC (rev 588)
@@ -18,7 +18,7 @@
policies are applied by the ME FW.
The service is meant to be run as a daemon. Messages from the service will be
-sent to the syslog. The UNS messages will be marked with a source of "Intel(R) AT".
+sent to the syslog. The UNS messages will be marked with a source of "Intel(R) ME".
Required libraries/tools:
-------------------------
Modified: uns/branches/uns-5.0/UNSEventLogger.cpp
===================================================================
--- uns/branches/uns-5.0/UNSEventLogger.cpp 2008-06-02 17:07:24 UTC (rev 587)
+++ uns/branches/uns-5.0/UNSEventLogger.cpp 2008-06-02 17:10:05 UTC (rev 588)
@@ -71,7 +71,7 @@
#ifdef WITH_TPM
#define UNS_TPM_COMMAND_ERROR "TPM command failed"
#endif
-#define UNS_SET_AT_STATUS_ERROR "Failed to set AT Status"
+#define UNS_SET_AT_STATUS_ERROR "Failed to set ME Status"
#define UNS_UPDATE_EVENT_HISTORY_ERROR "Failed to update Event History"
// Constructor
Modified: uns/branches/uns-5.0/UNSEventLogger.h
===================================================================
--- uns/branches/uns-5.0/UNSEventLogger.h 2008-06-02 17:07:24 UTC (rev 587)
+++ uns/branches/uns-5.0/UNSEventLogger.h 2008-06-02 17:10:05 UTC (rev 588)
@@ -59,7 +59,7 @@
#include "UNSMessageFile.h"
#endif
-#define EVENT_LOG_SOURCE_NAME "Intel(R) AT"
+#define EVENT_LOG_SOURCE_NAME "Intel(R) ME"
#define EVENT_LOG_UNS_SOURCE_NAME "UNS"
#define EVENT_LOG_AMT_SOURCE_NAME "Intel(R) AMT"
#define EVENT_LOG_LOG_NAME "Application"
@@ -121,7 +121,7 @@
void TPMCommandFailedError();
#endif
- //Record "Failed to set AT status" error
+ //Record "Failed to set ME status" error
void SetATStatusFailedError();
//Record "Event History update failed" error
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-06-02 17:07:15
|
Revision: 587
http://openamt.svn.sourceforge.net/openamt/?rev=587&view=rev
Author: marcin_obara
Date: 2008-06-02 10:07:24 -0700 (Mon, 02 Jun 2008)
Log Message:
-----------
add comments to heci registers defines
Modified Paths:
--------------
heci/trunk/src/heci_data_structures.h
Modified: heci/trunk/src/heci_data_structures.h
===================================================================
--- heci/trunk/src/heci_data_structures.h 2008-06-02 17:05:58 UTC (rev 586)
+++ heci/trunk/src/heci_data_structures.h 2008-06-02 17:07:24 UTC (rev 587)
@@ -76,32 +76,53 @@
* HECI HW Section
*/
-/* HECI addresses and defines */
+/* HECI registers */
+/* H_CB_WW - Host Circular Buffer (CB) Write Window register */
#define H_CB_WW 0
+/* H_CSR - Host Control Status register */
#define H_CSR 4
+/* ME_CB_RW - ME Circular Buffer Read Window register (read only) */
#define ME_CB_RW 8
+/* ME_CSR_HA - ME Control Status Host Access register (read only) */
#define ME_CSR_HA 0xC
-/* register bits - H_CSR */
+/* register bits of H_CSR (Host Control Status register) */
+/* Host Circular Buffer Depth - maximum number of 32-bit entries in CB */
#define H_CBD 0xFF000000
+/* Host Circular Buffer Write Pointer */
#define H_CBWP 0x00FF0000
+/* Host Circular Buffer Read Pointer */
#define H_CBRP 0x0000FF00
+/* Host Reset */
#define H_RST 0x00000010
+/* Host Ready */
#define H_RDY 0x00000008
+/* Host Interrupt Generate */
#define H_IG 0x00000004
+/* Host Interrupt Status */
#define H_IS 0x00000002
+/* Host Interrupt Enable */
#define H_IE 0x00000001
-/* register bits - ME_CSR_HA */
+/* register bits of ME_CSR_HA (ME Control Status Host Access register) */
+/* ME CB (Circular Buffer) Depth HRA (Host Read Access)
+ * - host read only access to ME_CBD */
#define ME_CBD_HRA 0xFF000000
+/* ME CB Write Pointer HRA - host read only access to ME_CBWP */
#define ME_CBWP_HRA 0x00FF0000
+/* ME CB Read Pointer HRA - host read only access to ME_CBRP */
#define ME_CBRP_HRA 0x0000FF00
+/* ME Reset HRA - host read only access to ME_RST */
#define ME_RST_HRA 0x00000010
+/* ME Ready HRA - host read only access to ME_RDY */
#define ME_RDY_HRA 0x00000008
+/* ME Interrupt Generate HRA - host read only access to ME_IG */
#define ME_IG_HRA 0x00000004
+/* ME Interrupt Status HRA - host read only access to ME_IS */
#define ME_IS_HRA 0x00000002
+/* ME Interrupt Enable HRA - host read only access to ME_IE */
#define ME_IE_HRA 0x00000001
#define HECI_MINORS_BASE 1
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-06-02 17:05:59
|
Revision: 586
http://openamt.svn.sourceforge.net/openamt/?rev=586&view=rev
Author: marcin_obara
Date: 2008-06-02 10:05:58 -0700 (Mon, 02 Jun 2008)
Log Message:
-----------
fix includes to c++
Modified Paths:
--------------
lms/branches/lms-5.0/src/tools/ATNetworkTool.cpp
lms/branches/lms-5.0/src/tools/ATNetworkTool.h
Modified: lms/branches/lms-5.0/src/tools/ATNetworkTool.cpp
===================================================================
--- lms/branches/lms-5.0/src/tools/ATNetworkTool.cpp 2008-06-02 15:02:21 UTC (rev 585)
+++ lms/branches/lms-5.0/src/tools/ATNetworkTool.cpp 2008-06-02 17:05:58 UTC (rev 586)
@@ -33,7 +33,6 @@
#endif
#include "ATNetworkTool.h"
-#include <cstring>
#include <sstream>
#include <algorithm>
#include <cerrno>
Modified: lms/branches/lms-5.0/src/tools/ATNetworkTool.h
===================================================================
--- lms/branches/lms-5.0/src/tools/ATNetworkTool.h 2008-06-02 15:02:21 UTC (rev 585)
+++ lms/branches/lms-5.0/src/tools/ATNetworkTool.h 2008-06-02 17:05:58 UTC (rev 586)
@@ -35,7 +35,7 @@
#include <set>
#include <vector>
#include <map>
-#include <string.h>
+#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <na...@us...> - 2008-06-02 15:02:52
|
Revision: 585
http://openamt.svn.sourceforge.net/openamt/?rev=585&view=rev
Author: nashif
Date: 2008-06-02 08:02:21 -0700 (Mon, 02 Jun 2008)
Log Message:
-----------
added string.h needed for memset and other functions
Modified Paths:
--------------
lms/branches/lms-5.0/src/tools/ATNetworkTool.h
Modified: lms/branches/lms-5.0/src/tools/ATNetworkTool.h
===================================================================
--- lms/branches/lms-5.0/src/tools/ATNetworkTool.h 2008-06-02 14:58:21 UTC (rev 584)
+++ lms/branches/lms-5.0/src/tools/ATNetworkTool.h 2008-06-02 15:02:21 UTC (rev 585)
@@ -35,6 +35,7 @@
#include <set>
#include <vector>
#include <map>
+#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
@@ -375,7 +376,7 @@
* @return int ==0 if success, !=0 on error
*/
static int SetNonBlocking(int s, bool block = true);
-
+
/* Creates socket
* @param addr socket parameters
* @param error [out] error code
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <na...@us...> - 2008-06-02 14:59:44
|
Revision: 584
http://openamt.svn.sourceforge.net/openamt/?rev=584&view=rev
Author: nashif
Date: 2008-06-02 07:58:21 -0700 (Mon, 02 Jun 2008)
Log Message:
-----------
added bootstrap script
Added Paths:
-----------
lms/branches/lms-5.0/bootstrap
Added: lms/branches/lms-5.0/bootstrap
===================================================================
--- lms/branches/lms-5.0/bootstrap (rev 0)
+++ lms/branches/lms-5.0/bootstrap 2008-06-02 14:58:21 UTC (rev 584)
@@ -0,0 +1,6 @@
+#!/bin/sh
+libtoolize --copy --force --automake
+aclocal
+autoheader
+automake --add-missing --copy --foreign
+autoconf
Property changes on: lms/branches/lms-5.0/bootstrap
___________________________________________________________________
Name: svn:executable
+ *
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-05-30 20:09:24
|
Revision: 583
http://openamt.svn.sourceforge.net/openamt/?rev=583&view=rev
Author: marcin_obara
Date: 2008-05-30 13:09:31 -0700 (Fri, 30 May 2008)
Log Message:
-----------
fix ioctl heci definitions, and handle deleted executables, increase pthi timeout, handle SB mode
Modified Paths:
--------------
ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp
ZTCLocalAgent/branches/ztc-5.0/src/heci/HECILinux.cpp
Modified: ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp
===================================================================
--- ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp 2008-05-30 20:06:01 UTC (rev 582)
+++ ZTCLocalAgent/branches/ztc-5.0/src/ZTCLocalAgent.cpp 2008-05-30 20:09:31 UTC (rev 583)
@@ -140,7 +140,7 @@
atexit(ztc_exitcleanup);
}
- PTHICommand command(_verbose);
+ PTHICommand command(_verbose, 3000);
status = DiscoveryTest(command, param, lState);
if ((AMT_STATUS_SUCCESS == status) && (true == param.Activate)) {
status = Activate(command, param, lState);
@@ -272,9 +272,13 @@
}
//enumerate hash handles
- status = command.EnumerateHashHandles(HashHandles);
- if (AMT_STATUS_SUCCESS != status) {
- return status;
+ if (CFG_PROVISIONING_MODE_ENTERPRISE == mode) {
+ status = command.EnumerateHashHandles(HashHandles);
+ if (AMT_STATUS_SUCCESS != status) {
+ return status;
+ }
+ } else {
+ HashHandles.Length = 0;
}
// print all handles in here if any
Modified: ZTCLocalAgent/branches/ztc-5.0/src/heci/HECILinux.cpp
===================================================================
--- ZTCLocalAgent/branches/ztc-5.0/src/heci/HECILinux.cpp 2008-05-30 20:06:01 UTC (rev 582)
+++ ZTCLocalAgent/branches/ztc-5.0/src/heci/HECILinux.cpp 2008-05-30 20:09:31 UTC (rev 583)
@@ -55,15 +55,15 @@
#undef IOCTL_HECI_GET_VERSION
#undef IOCTL_HECI_CONNECT_CLIENT
#undef IOCTL_HECI_WD
-#define HECI_IOCTL_LETTER 'H'
+#define HECI_IOCTL_TYPE 0x48
#define IOCTL_HECI_GET_VERSION \
- _IOWR(HECI_IOCTL_LETTER ,0x800, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x0, heci_ioctl_data_t)
#define IOCTL_HECI_CONNECT_CLIENT \
- _IOWR(HECI_IOCTL_LETTER ,0x801, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x01, heci_ioctl_data_t)
#define IOCTL_HECI_WD \
- _IOWR(HECI_IOCTL_LETTER ,0x802, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x02, heci_ioctl_data_t)
#define IAMT_HECI_GET_RECEIVED_MESSAGE_DATA \
- _IOW(HECI_IOCTL_LETTER, 0x803, heci_ioctl_data_t)
+ _IOW(HECI_IOCTL_TYPE, 0x03, heci_ioctl_data_t)
#pragma pack(0)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-05-30 20:05:57
|
Revision: 582
http://openamt.svn.sourceforge.net/openamt/?rev=582&view=rev
Author: marcin_obara
Date: 2008-05-30 13:06:01 -0700 (Fri, 30 May 2008)
Log Message:
-----------
fix ioctl heci definitions, and handle deleted executables
Modified Paths:
--------------
uns/branches/uns-5.0/AMTStatus/ATVersion.cpp
uns/branches/uns-5.0/AMTStatus/MEIAMTStatus.cpp
uns/branches/uns-5.0/AMTStatus/heci/Linux/HECILinux.cpp
Modified: uns/branches/uns-5.0/AMTStatus/ATVersion.cpp
===================================================================
--- uns/branches/uns-5.0/AMTStatus/ATVersion.cpp 2008-05-30 20:03:01 UTC (rev 581)
+++ uns/branches/uns-5.0/AMTStatus/ATVersion.cpp 2008-05-30 20:06:01 UTC (rev 582)
@@ -205,6 +205,10 @@
return "";
}
+ if (NULL != strstr(exe_buf, " (deleted)")) {
+ return "";
+ }
+
return exe_buf;
}
Modified: uns/branches/uns-5.0/AMTStatus/MEIAMTStatus.cpp
===================================================================
--- uns/branches/uns-5.0/AMTStatus/MEIAMTStatus.cpp 2008-05-30 20:03:01 UTC (rev 581)
+++ uns/branches/uns-5.0/AMTStatus/MEIAMTStatus.cpp 2008-05-30 20:06:01 UTC (rev 582)
@@ -403,7 +403,7 @@
if (isDebugEnabled()) {
std::stringstream ss;
- ss << "MEResetReason: " << resetReason;
+ ss << "MEResetReason: " << (unsigned int)resetReason;
debugLog(ss.str().c_str());
}
@@ -431,7 +431,7 @@
if (isDebugEnabled()) {
std::stringstream ss;
- ss << "LastHostResetReason: " << resetReason;
+ ss << "LastHostResetReason: " << (unsigned int)resetReason;
debugLog(ss.str().c_str());
}
Modified: uns/branches/uns-5.0/AMTStatus/heci/Linux/HECILinux.cpp
===================================================================
--- uns/branches/uns-5.0/AMTStatus/heci/Linux/HECILinux.cpp 2008-05-30 20:03:01 UTC (rev 581)
+++ uns/branches/uns-5.0/AMTStatus/heci/Linux/HECILinux.cpp 2008-05-30 20:06:01 UTC (rev 582)
@@ -65,15 +65,15 @@
#undef IOCTL_HECI_GET_VERSION
#undef IOCTL_HECI_CONNECT_CLIENT
#undef IOCTL_HECI_WD
-#define HECI_IOCTL_LETTER 'H'
+#define HECI_IOCTL_TYPE 0x48
#define IOCTL_HECI_GET_VERSION \
- _IOWR(HECI_IOCTL_LETTER ,0x800, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x0, heci_ioctl_data_t)
#define IOCTL_HECI_CONNECT_CLIENT \
- _IOWR(HECI_IOCTL_LETTER ,0x801, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x01, heci_ioctl_data_t)
#define IOCTL_HECI_WD \
- _IOWR(HECI_IOCTL_LETTER ,0x802, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x02, heci_ioctl_data_t)
#define IAMT_HECI_GET_RECEIVED_MESSAGE_DATA \
- _IOW(HECI_IOCTL_LETTER, 0x803, heci_ioctl_data_t)
+ _IOW(HECI_IOCTL_TYPE, 0x03, heci_ioctl_data_t)
#pragma pack(0)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-05-30 20:02:54
|
Revision: 581
http://openamt.svn.sourceforge.net/openamt/?rev=581&view=rev
Author: marcin_obara
Date: 2008-05-30 13:03:01 -0700 (Fri, 30 May 2008)
Log Message:
-----------
fix ioctl heci definitions, and handle deleted executables
Modified Paths:
--------------
lms/branches/lms-5.0/src/heci/HECILinux.cpp
lms/branches/lms-5.0/src/tools/ATVersion.cpp
Modified: lms/branches/lms-5.0/src/heci/HECILinux.cpp
===================================================================
--- lms/branches/lms-5.0/src/heci/HECILinux.cpp 2008-05-30 19:56:26 UTC (rev 580)
+++ lms/branches/lms-5.0/src/heci/HECILinux.cpp 2008-05-30 20:03:01 UTC (rev 581)
@@ -55,15 +55,15 @@
#undef IOCTL_HECI_GET_VERSION
#undef IOCTL_HECI_CONNECT_CLIENT
#undef IOCTL_HECI_WD
-#define HECI_IOCTL_LETTER 'H'
+#define HECI_IOCTL_TYPE 0x48
#define IOCTL_HECI_GET_VERSION \
- _IOWR(HECI_IOCTL_LETTER ,0x800, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x0, heci_ioctl_data_t)
#define IOCTL_HECI_CONNECT_CLIENT \
- _IOWR(HECI_IOCTL_LETTER ,0x801, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x01, heci_ioctl_data_t)
#define IOCTL_HECI_WD \
- _IOWR(HECI_IOCTL_LETTER ,0x802, heci_ioctl_data_t)
+ _IOWR(HECI_IOCTL_TYPE, 0x02, heci_ioctl_data_t)
#define IAMT_HECI_GET_RECEIVED_MESSAGE_DATA \
- _IOW(HECI_IOCTL_LETTER, 0x803, heci_ioctl_data_t)
+ _IOW(HECI_IOCTL_TYPE, 0x03, heci_ioctl_data_t)
#pragma pack(0)
Modified: lms/branches/lms-5.0/src/tools/ATVersion.cpp
===================================================================
--- lms/branches/lms-5.0/src/tools/ATVersion.cpp 2008-05-30 19:56:26 UTC (rev 580)
+++ lms/branches/lms-5.0/src/tools/ATVersion.cpp 2008-05-30 20:03:01 UTC (rev 581)
@@ -195,6 +195,10 @@
return "";
}
+ if (NULL != strstr(exe_buf, " (deleted)")) {
+ return "";
+ }
+
return exe_buf;
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-05-30 19:56:19
|
Revision: 580
http://openamt.svn.sourceforge.net/openamt/?rev=580&view=rev
Author: marcin_obara
Date: 2008-05-30 12:56:26 -0700 (Fri, 30 May 2008)
Log Message:
-----------
simplify module initialization API
Modified Paths:
--------------
heci/trunk/src/heci_main.c
heci/trunk/src/heci_version.h
Modified: heci/trunk/src/heci_main.c
===================================================================
--- heci/trunk/src/heci_main.c 2008-05-27 17:19:49 UTC (rev 579)
+++ heci/trunk/src/heci_main.c 2008-05-30 19:56:26 UTC (rev 580)
@@ -221,65 +221,60 @@
/**
* heci_sysfs_create - creates a struct class to contain heci info
- * @owner: pointer to the module that is to "own" heci sysfs class
- * @name: pointer to a string for the name of this class
*
- * @return valid pointer to a struct class on success, false
- * pointer on failure
+ * @return 0 on success, <0 on failure.
*/
-static struct class *heci_sysfs_create(struct module *owner, char *name)
+static int heci_sysfs_create(void)
{
struct class *class;
int err = 0;
- class = class_create(owner, name);
+ class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
if (IS_ERR(class)) {
err = PTR_ERR(class);
- goto error;
+ printk(KERN_ERR "heci: Error creating heci class.\n");
+ goto err_out;
}
err = class_create_file(class, &class_attr_version);
- if (err)
- goto destroy_class;
+ if (err) {
+ class_destroy(class);
+ printk(KERN_ERR "heci: Error creating heci class file.\n");
+ goto err_out;
+ }
- return class;
-
-destroy_class:
- class_destroy(class);
-error:
- return ERR_PTR(err);
+ heci_class = class;
+err_out:
+ return err;
}
/**
* heci_sysfs_destroy - destroys a struct class of heci info
- *
- * @cs: pointer to the struct class that is to be destroyed
*/
-static void heci_sysfs_destroy(struct class *class)
+static void heci_sysfs_destroy(void)
{
- if ((class == NULL) || (IS_ERR(class)))
+ if ((heci_class == NULL) || (IS_ERR(heci_class)))
return;
- class_remove_file(class, &class_attr_version);
- class_destroy(class);
+ class_remove_file(heci_class, &class_attr_version);
+ class_destroy(heci_class);
}
/**
- * heci_sysfs_device_create - adds two devices to sysfs for chararcter devices
- * @cs: pointer to the struct class that the device to be registered on
+ * heci_sysfs_device_create - adds device to sysfs for character devices
*
* @return 0 on success, <0 on failure.
*/
-static int heci_sysfs_device_create(struct class *cs)
+static int heci_sysfs_device_create(void)
{
int err = 0;
- if ((cs == NULL) || (IS_ERR(cs))) {
+ if ((heci_class == NULL) || (IS_ERR(heci_class))) {
err = -EINVAL;
goto err_out;
}
- heci_class_dev = class_device_create(cs, NULL,
+ heci_class_dev = class_device_create(heci_class, NULL,
heci_cdev.dev,
NULL,
HECI_DEV_NAME);
@@ -291,7 +286,7 @@
}
/**
- * heci_sysfs_device_remove - unregisters the two device entries on sysfs
+ * heci_sysfs_device_remove - unregisters the device entry on sysfs
*/
static void heci_sysfs_device_remove(void)
{
@@ -318,29 +313,32 @@
/* init pci module */
ret = pci_register_driver(&heci_driver);
- if (ret < 0)
+ if (ret < 0) {
+ printk(KERN_ERR "heci: Error registering driver.\n");
goto end;
+ }
/* registration of char devices */
ret = alloc_chrdev_region(&dev, HECI_MINORS_BASE, HECI_MINORS_COUNT,
HECI_DRIVER_NAME);
+ if (ret) {
+ printk(KERN_ERR "heci: Error allocating char device region.\n");
+ goto unregister_pci;
+ }
heci_major = MAJOR(dev);
- /* rgisteration in sysfs interface */
- heci_class = heci_sysfs_create(THIS_MODULE, HECI_DRIVER_NAME);
- if (IS_ERR(heci_class)) {
- printk(KERN_ERR "heci: Error creating heci class.\n");
- ret = PTR_ERR(heci_class);
+ /* registration in sysfs interface */
+ ret = heci_sysfs_create();
+ if (ret)
goto unregister;
- }
ret = heci_registration_cdev(&heci_cdev, HECI_MINOR_NUMBER,
&heci_fops);
if (ret)
goto destroy_sysfs;
- if (heci_sysfs_device_create(heci_class)) {
+ if (heci_sysfs_device_create()) {
cdev_del(&heci_cdev);
ret = -EAGAIN;
goto destroy_sysfs;
@@ -349,12 +347,12 @@
return ret;
destroy_sysfs:
- heci_sysfs_destroy(heci_class);
-
+ heci_sysfs_destroy();
unregister:
- pci_unregister_driver(&heci_driver);
unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
HECI_MINORS_COUNT);
+unregister_pci:
+ pci_unregister_driver(&heci_driver);
end:
return ret;
}
@@ -374,7 +372,7 @@
/* Now unregister cdev. */
cdev_del(&heci_cdev);
heci_sysfs_device_remove();
- heci_sysfs_destroy(heci_class);
+ heci_sysfs_destroy();
unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
HECI_MINORS_COUNT);
}
Modified: heci/trunk/src/heci_version.h
===================================================================
--- heci/trunk/src/heci_version.h 2008-05-27 17:19:49 UTC (rev 579)
+++ heci/trunk/src/heci_version.h 2008-05-30 19:56:26 UTC (rev 580)
@@ -44,7 +44,7 @@
#define MAJOR_VERSION 5
#define MINOR_VERSION 0
#define QUICK_FIX_NUMBER 0
-#define VER_BUILD 19
+#define VER_BUILD 23
#define HECI_DRV_VER1 __stringify(MAJOR_VERSION) "." __stringify(MINOR_VERSION)
#define HECI_DRV_VER2 __stringify(QUICK_FIX_NUMBER) "." __stringify(VER_BUILD)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <mar...@us...> - 2008-05-27 17:19:47
|
Revision: 579
http://openamt.svn.sourceforge.net/openamt/?rev=579&view=rev
Author: marcin_obara
Date: 2008-05-27 10:19:49 -0700 (Tue, 27 May 2008)
Log Message:
-----------
revert changes in count_full_read_slots()
Modified Paths:
--------------
heci/trunk/src/heci_interface.c
Modified: heci/trunk/src/heci_interface.c
===================================================================
--- heci/trunk/src/heci_interface.c 2008-05-26 17:48:04 UTC (rev 578)
+++ heci/trunk/src/heci_interface.c 2008-05-27 17:19:49 UTC (rev 579)
@@ -235,11 +235,14 @@
*/
__s32 count_full_read_slots(struct iamt_heci_device *dev)
{
+ char read_ptr, write_ptr;
unsigned char buffer_depth, filled_slots;
dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
buffer_depth = (unsigned char)((dev->me_hw_state & ME_CBD_HRA) >> 24);
- filled_slots = _host_get_filled_slots(dev);
+ read_ptr = (char) ((dev->me_hw_state & ME_CBRP_HRA) >> 8);
+ write_ptr = (char) ((dev->me_hw_state & ME_CBWP_HRA) >> 16);
+ filled_slots = (unsigned char) (write_ptr - read_ptr);
if (filled_slots > buffer_depth) {
/* overflow */
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|