OpenSolaris_b135/uts/intel/io/heci/heci_data_structures.h

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * 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 <sys/varargs.h>
#include <sys/types.h>

#ifndef SUNOS
#define	SUNOS
#endif

/*
 * 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
#pragma pack(1)


/*
 * 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_MINOR_NUMBER	1
/* #define  HECI_PTHI_MINOR_NUMBER	0 */
#define	MAKE_MINOR_NUM(minor, instance)	(((uint_t)(minor) << 8) \
				    | ((instance) & 0xFF))
#define	HECI_MINOR_TO_INSTANCE(x)	((x) & 0xFF)
#define	HECI_MINOR_TO_IFNUM(x)		(((x) >> 8) & 0xFF)

#define	HECI_MAX_OPEN_HANDLE_COUNT	253

/*
 * debug kernel print macro define
 */
#define	PRN(...)	_PRN("%s():  "__VA_ARGS__, "")
#define	_PRN(format, ...)					\
	cmn_err(CE_CONT, format"%s", __func__, __VA_ARGS__)

#ifdef DEBUG
extern int heci_debug;
#define	DBG(...) { if (heci_debug) PRN(__VA_ARGS__); }
#else
#define	DBG
#endif

#define	assert(expr) \
	if (!(expr)) {                                   \
		cmn_err(CE_WARN, "Assertion failed! %s,%s,line=%d", #expr, \
		__FILE__, __LINE__);          \
	}

#define	list_next(p)	((p)->list_next)

#define	walk_list(p, n, h) \
	for (p = list_next(h), n = list_next(p);	\
		p != (h); \
		p = n, n = list_next(p))


#define	list_init(ptr) { \
	(ptr)->list_next = (ptr); (ptr)->list_prev = (ptr); \
}

#define	LIST_INIT_HEAD	list_init
#define	list_del_init(n)	{ \
	    list_del(n); \
	    list_init(n); \
	}

#define	list_empty(l)	((l)->list_next == (l))
#define	list_del(p)	{ (p)->list_next->list_prev = (p)->list_prev; \
	(p)->list_prev->list_next = (p)->list_next; }
#define	list_add_tail(newnode, head) { \
		(head)->list_prev->list_next = (newnode); \
		(newnode)->list_prev = (head)->list_prev; \
		(head)->list_prev = (newnode); \
		(newnode)->list_next = (head); \
	}
#define	list_relink_node(newnode, head)	{ \
		list_del(newnode); \
		list_add_tail(newnode, head); \
	}

#ifdef __GNUC__

#define	find_struct(ptr, type, member) ( \
	{ \
	const __typeof(((type *)0)->member) *__tmpp = (ptr);  \
	(type *)(void *)((char *)__tmpp - ((size_t)&((type *)0)->member)); \
	})
#else
/* type unsafe version */
#define	find_struct(ptr, type, member) \
		((type *)(void *)((char *)(ptr) \
		- ((size_t)&((type *)0)->member)))

#endif

#define	list_for_each_entry_safe(pos, n, head, member, type)                  \
	for (pos = find_struct((head)->list_next, type, member),      \
		n = find_struct(pos->member.list_next, type, member); \
		&pos->member != (head);                                    \
		pos = n, n = find_struct(n->member.list_next, type, member))

#define	HZ		drv_usectohz(1000000)
/*
 * 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 {
	uint32_t data1;
	uint16_t data2;
	uint16_t data3;
	uint8_t 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 {
	uint32_t size;
	char *data;
#ifndef  _LP64
	char *pad;
#endif
};

#define	HECI_CONNECT_TIMEOUT	3	/* at least 2 seconds */

#define	IAMTHIF_STALL_TIMER	12	/* seconds */
#define	IAMTHIF_READ_TIMER	15	/* seconds */
struct heci_file {
	void * private_data;
};

struct heci_cb_private {
	struct list_node 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 heci_file *file_object;
};


struct io_heci_list {
	struct heci_cb_private heci_cb;
	int status;
	struct iamt_heci_device *device_extension;
};

struct heci_driver_version {
	uint8_t major;
	uint8_t minor;
	uint8_t hotfix;
	uint16_t build;
};

struct heci_client {
	uint32_t max_message_length;
	uint8_t protocol_version;
};

/*
 *  HECI BUS Interface Section
 */
struct heci_msg_hdr {
	uint32_t me_addr:8;
	uint32_t host_addr:8;
	uint32_t length:9;
	uint32_t reserved:6;
	uint32_t msg_complete:1;
};


struct hbm_cmd {
	uint8_t cmd:7;
	uint8_t is_response:1;
};


struct heci_bus_message {
	struct hbm_cmd cmd;
	uint8_t command_specific_data[];
};

struct hbm_version {
	uint8_t minor_version;
	uint8_t major_version;
};

struct hbm_host_version_request {
	struct hbm_cmd cmd;
	uint8_t reserved;
	struct hbm_version host_version;
};

struct hbm_host_version_response {
	struct hbm_cmd cmd;
	int host_version_supported;
	struct hbm_version me_max_version;
};

struct hbm_host_stop_request {
	struct hbm_cmd cmd;
	uint8_t reason;
	uint8_t reserved[2];
};

struct hbm_host_stop_response {
	struct hbm_cmd cmd;
	uint8_t reserved[3];
};

struct hbm_me_stop_request {
	struct hbm_cmd cmd;
	uint8_t reason;
	uint8_t reserved[2];
};

struct hbm_host_enum_request {
	struct hbm_cmd cmd;
	uint8_t reserved[3];
};

struct hbm_host_enum_response {
	struct hbm_cmd cmd;
	uint8_t reserved[3];
	uint8_t valid_addresses[32];
};

struct heci_client_properties {
	struct guid protocol_name;
	uint8_t protocol_version;
	uint8_t max_number_of_connections;
	uint8_t fixed_address;
	uint8_t single_recv_buf;
	uint32_t max_msg_length;
};

struct hbm_props_request {
	struct hbm_cmd cmd;
	uint8_t address;
	uint8_t reserved[2];
};


struct hbm_props_response {
	struct hbm_cmd cmd;
	uint8_t address;
	uint8_t status;
	uint8_t reserved[1];
	struct heci_client_properties client_properties;
};

struct hbm_client_connect_request {
	struct hbm_cmd cmd;
	uint8_t me_addr;
	uint8_t host_addr;
	uint8_t reserved;
};

struct hbm_client_connect_response {
	struct hbm_cmd cmd;
	uint8_t me_addr;
	uint8_t host_addr;
	uint8_t status;
};

struct hbm_client_disconnect_request {
	struct hbm_cmd cmd;
	uint8_t me_addr;
	uint8_t host_addr;
	uint8_t reserved[1];
};

struct hbm_flow_control {
	struct hbm_cmd cmd;
	uint8_t me_addr;
	uint8_t host_addr;
	uint8_t reserved[HECI_FC_MESSAGE_RESERVED_LENGTH];
};

struct heci_me_client {
	struct heci_client_properties props;
	uint8_t client_id;
	uint8_t flow_ctrl_creds;
};

#pragma pack()
/* Private file struct */
struct heci_file_private {
	struct list_node link;
	struct heci_file *file;
	enum file_state state;
	struct pollhead tx_pollwait;
	kcondvar_t	rx_wait;
	struct pollhead pollwait;
	kmutex_t file_lock;
	kmutex_t read_io_lock;
	kmutex_t write_io_lock;
	int read_pending;
	int status;
	/* ID of client connected */
	uint8_t host_client_id;
	uint8_t me_client_id;
	uint8_t flow_ctrl_creds;
	uint8_t 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;
};

/* private device struct */
struct iamt_heci_device {
	dev_info_t	*dip;
	ddi_acc_handle_t io_handle;
	ddi_iblock_cookie_t sc_iblk;

	/*
	 * 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_node file_list;
	/*
	 * memory of device
	 */
	char *mem_addr;
	/*
	 * lock for the device
	 */
	kmutex_t device_lock;
	ddi_taskq_t	*work;
	int recvd_msg;

	ddi_taskq_t *reinit_tsk;
	timeout_id_t wd_timer;
	/*
	 * hw states of host and fw(ME)
	 */
	uint32_t host_hw_state;
	uint32_t me_hw_state;
	/*
	 * waiting queue for receive message from FW
	 */
	kcondvar_t wait_recvd_msg;
	kcondvar_t wait_stop_wd;
	/*
	 * heci device  states
	 */
	enum heci_states heci_state;
	int stop;

	uint32_t extra_write_index;
	uint32_t rd_msg_buf[128];	/* used for control messages */
	uint32_t wr_msg_buf[128];	/* used for control messages */
	uint32_t ext_msg_buf[8];	/* for control responses    */
	uint32_t 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: need to be allocated */
	uint8_t heci_me_clients[32];	/* list of existing clients */
	uint8_t num_heci_me_clients;
	uint8_t heci_host_clients[32];	/* list of existing clients */
	uint8_t current_host_client_id;

	int wd_pending;
	int wd_stoped;
	uint16_t wd_timeout;	/* seconds ((wd_data[1] << 8) + wd_data[0]) */
	unsigned char wd_data[HECI_START_WD_DATA_SIZE];


	uint16_t wd_due_counter;
	int asf_mode;
	int wd_bypass;	/* if 1, don't refresh watchdog ME client */

	struct heci_file *iamthif_file_object;
	struct heci_file_private iamthif_file_ext;
	int iamthif_ioctl;
	int iamthif_canceled;
	uint32_t iamthif_timer;
	uint32_t iamthif_stall_timer;
	struct heci_file files[256]; /* a file handle for each client */
	unsigned char iamthif_msg_buf[IAMTHIF_MTU];
	uint32_t iamthif_msg_buf_size;
	uint32_t iamthif_msg_buf_index;
	int iamthif_flow_control_pending;
	enum iamthif_states iamthif_state;

	struct heci_cb_private *iamthif_current_cb;
	uint8_t write_hang;
	int need_reset;
	long open_handle_count;

};

/*
 * read_heci_register - Read a byte from the heci device
 *
 * @device: the device structure
 * @offset: offset from which to read the data
 *
 * @return the byte read.
 */
uint32_t read_heci_register(struct iamt_heci_device *device,
			    unsigned long offset);

/*
 * write_heci_register - Write  4 bytes to the heci device
 *
 * @device: the device structure
 * @offset: offset from which to write the data
 * @value: the byte to write
 */
void write_heci_register(struct iamt_heci_device *device, unsigned long offset,
		uint32_t value);

#define	UIO_OFFSET(p)	(((struct uio *)p)->uio_offset)
#define	UIO_LENGTH(p)	(((struct uio *)p)->uio_resid)
#define	UIO_BUFF(p)	((char *)((struct uio *)p)->uio_iov->iov_base)

#endif /* _HECI_DATA_STRUCTURES_H_ */