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. |