[deliverable/linux.git] / arch / s390 / include / asm / qdio.h

/*
 * linux/include/asm-s390/qdio.h
 *
 * Copyright 2000,2008 IBM Corp.
 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>
 *	      Jan Glauber <jang@linux.vnet.ibm.com>
 *
 */
#ifndef __QDIO_H__
#define __QDIO_H__

#include <linux/interrupt.h>
#include <asm/cio.h>
#include <asm/ccwdev.h>

/* only use 4 queues to save some cachelines */
#define QDIO_MAX_QUEUES_PER_IRQ		4
#define QDIO_MAX_BUFFERS_PER_Q		128
#define QDIO_MAX_BUFFERS_MASK		(QDIO_MAX_BUFFERS_PER_Q - 1)
#define QDIO_MAX_ELEMENTS_PER_BUFFER	16
#define QDIO_SBAL_SIZE			256

#define QDIO_QETH_QFMT			0
#define QDIO_ZFCP_QFMT			1
#define QDIO_IQDIO_QFMT			2

/**
 * struct qdesfmt0 - queue descriptor, format 0
 * @sliba: storage list information block address
 * @sla: storage list address
 * @slsba: storage list state block address
 * @akey: access key for DLIB
 * @bkey: access key for SL
 * @ckey: access key for SBALs
 * @dkey: access key for SLSB
 */
struct qdesfmt0 {
	u64 sliba;
	u64 sla;
	u64 slsba;
	u32	 : 32;
	u32 akey : 4;
	u32 bkey : 4;
	u32 ckey : 4;
	u32 dkey : 4;
	u32	 : 16;
} __attribute__ ((packed));

/**
 * struct qdr - queue description record (QDR)
 * @qfmt: queue format
 * @pfmt: implementation dependent parameter format
 * @ac: adapter characteristics
 * @iqdcnt: input queue descriptor count
 * @oqdcnt: output queue descriptor count
 * @iqdsz: inpout queue descriptor size
 * @oqdsz: output queue descriptor size
 * @qiba: queue information block address
 * @qkey: queue information block key
 * @qdf0: queue descriptions
 */
struct qdr {
	u32 qfmt   : 8;
	u32 pfmt   : 8;
	u32	   : 8;
	u32 ac	   : 8;
	u32	   : 8;
	u32 iqdcnt : 8;
	u32	   : 8;
	u32 oqdcnt : 8;
	u32	   : 8;
	u32 iqdsz  : 8;
	u32	   : 8;
	u32 oqdsz  : 8;
	/* private: */
	u32 res[9];
	/* public: */
	u64 qiba;
	u32	   : 32;
	u32 qkey   : 4;
	u32	   : 28;
	struct qdesfmt0 qdf0[126];
} __attribute__ ((packed, aligned(4096)));

#define QIB_AC_OUTBOUND_PCI_SUPPORTED	0x40
#define QIB_RFLAGS_ENABLE_QEBSM		0x80
#define QIB_RFLAGS_ENABLE_DATA_DIV	0x02

/**
 * struct qib - queue information block (QIB)
 * @qfmt: queue format
 * @pfmt: implementation dependent parameter format
 * @rflags: QEBSM
 * @ac: adapter characteristics
 * @isliba: absolute address of first input SLIB
 * @osliba: absolute address of first output SLIB
 * @ebcnam: adapter identifier in EBCDIC
 * @parm: implementation dependent parameters
 */
struct qib {
	u32 qfmt   : 8;
	u32 pfmt   : 8;
	u32 rflags : 8;
	u32 ac	   : 8;
	u32	   : 32;
	u64 isliba;
	u64 osliba;
	u32	   : 32;
	u32	   : 32;
	u8 ebcnam[8];
	/* private: */
	u8 res[88];
	/* public: */
	u8 parm[QDIO_MAX_BUFFERS_PER_Q];
} __attribute__ ((packed, aligned(256)));

/**
 * struct slibe - storage list information block element (SLIBE)
 * @parms: implementation dependent parameters
 */
struct slibe {
	u64 parms;
};

/**
 * struct slib - storage list information block (SLIB)
 * @nsliba: next SLIB address (if any)
 * @sla: SL address
 * @slsba: SLSB address
 * @slibe: SLIB elements
 */
struct slib {
	u64 nsliba;
	u64 sla;
	u64 slsba;
	/* private: */
	u8 res[1000];
	/* public: */
	struct slibe slibe[QDIO_MAX_BUFFERS_PER_Q];
} __attribute__ ((packed, aligned(2048)));

/**
 * struct sbal_flags - storage block address list flags
 * @last: last entry
 * @cont: contiguous storage
 * @frag: fragmentation
 */
struct sbal_flags {
	u8	: 1;
	u8 last : 1;
	u8 cont : 1;
	u8	: 1;
	u8 frag : 2;
	u8	: 2;
} __attribute__ ((packed));

#define SBAL_FLAGS_FIRST_FRAG		0x04000000UL
#define SBAL_FLAGS_MIDDLE_FRAG		0x08000000UL
#define SBAL_FLAGS_LAST_FRAG		0x0c000000UL
#define SBAL_FLAGS_LAST_ENTRY		0x40000000UL
#define SBAL_FLAGS_CONTIGUOUS		0x20000000UL

#define SBAL_FLAGS0_DATA_CONTINUATION	0x20UL

/* Awesome OpenFCP extensions */
#define SBAL_FLAGS0_TYPE_STATUS		0x00UL
#define SBAL_FLAGS0_TYPE_WRITE		0x08UL
#define SBAL_FLAGS0_TYPE_READ		0x10UL
#define SBAL_FLAGS0_TYPE_WRITE_READ	0x18UL
#define SBAL_FLAGS0_MORE_SBALS		0x04UL
#define SBAL_FLAGS0_COMMAND		0x02UL
#define SBAL_FLAGS0_LAST_SBAL		0x00UL
#define SBAL_FLAGS0_ONLY_SBAL		SBAL_FLAGS0_COMMAND
#define SBAL_FLAGS0_MIDDLE_SBAL		SBAL_FLAGS0_MORE_SBALS
#define SBAL_FLAGS0_FIRST_SBAL SBAL_FLAGS0_MORE_SBALS | SBAL_FLAGS0_COMMAND
#define SBAL_FLAGS0_PCI			0x40

/**
 * struct sbal_sbalf_0 - sbal flags for sbale 0
 * @pci: PCI indicator
 * @cont: data continuation
 * @sbtype: storage-block type (FCP)
 */
struct sbal_sbalf_0 {
	u8	  : 1;
	u8 pci	  : 1;
	u8 cont   : 1;
	u8 sbtype : 2;
	u8	  : 3;
} __attribute__ ((packed));

/**
 * struct sbal_sbalf_1 - sbal flags for sbale 1
 * @key: storage key
 */
struct sbal_sbalf_1 {
	u8     : 4;
	u8 key : 4;
} __attribute__ ((packed));

/**
 * struct sbal_sbalf_14 - sbal flags for sbale 14
 * @erridx: error index
 */
struct sbal_sbalf_14 {
	u8	  : 4;
	u8 erridx : 4;
} __attribute__ ((packed));

/**
 * struct sbal_sbalf_15 - sbal flags for sbale 15
 * @reason: reason for error state
 */
struct sbal_sbalf_15 {
	u8 reason;
} __attribute__ ((packed));

/**
 * union sbal_sbalf - storage block address list flags
 * @i0: sbalf0
 * @i1: sbalf1
 * @i14: sbalf14
 * @i15: sblaf15
 * @value: raw value
 */
union sbal_sbalf {
	struct sbal_sbalf_0  i0;
	struct sbal_sbalf_1  i1;
	struct sbal_sbalf_14 i14;
	struct sbal_sbalf_15 i15;
	u8 value;
};

/**
 * struct qdio_buffer_element - SBAL entry
 * @flags: flags
 * @length: length
 * @addr: address
*/
struct qdio_buffer_element {
	u32 flags;
	u32 length;
#ifdef CONFIG_32BIT
	/* private: */
	void *reserved;
	/* public: */
#endif
	void *addr;
} __attribute__ ((packed, aligned(16)));

/**
 * struct qdio_buffer - storage block address list (SBAL)
 * @element: SBAL entries
 */
struct qdio_buffer {
	struct qdio_buffer_element element[QDIO_MAX_ELEMENTS_PER_BUFFER];
} __attribute__ ((packed, aligned(256)));

/**
 * struct sl_element - storage list entry
 * @sbal: absolute SBAL address
 */
struct sl_element {
#ifdef CONFIG_32BIT
	/* private: */
	unsigned long reserved;
	/* public: */
#endif
	unsigned long sbal;
} __attribute__ ((packed));

/**
 * struct sl - storage list (SL)
 * @element: SL entries
 */
struct sl {
	struct sl_element element[QDIO_MAX_BUFFERS_PER_Q];
} __attribute__ ((packed, aligned(1024)));

/**
 * struct slsb - storage list state block (SLSB)
 * @val: state per buffer
 */
struct slsb {
	u8 val[QDIO_MAX_BUFFERS_PER_Q];
} __attribute__ ((packed, aligned(256)));

#define CHSC_AC2_DATA_DIV_AVAILABLE	0x0010
#define CHSC_AC2_DATA_DIV_ENABLED	0x0002

struct qdio_ssqd_desc {
	u8 flags;
	u8:8;
	u16 sch;
	u8 qfmt;
	u8 parm;
	u8 qdioac1;
	u8 sch_class;
	u8 pcnt;
	u8 icnt;
	u8:8;
	u8 ocnt;
	u8:8;
	u8 mbccnt;
	u16 qdioac2;
	u64 sch_token;
	u8 mro;
	u8 mri;
	u8:8;
	u8 sbalic;
	u16:16;
	u8:8;
	u8 mmwc;
} __attribute__ ((packed));

/* params are: ccw_device, qdio_error, queue_number,
   first element processed, number of elements processed, int_parm */
typedef void qdio_handler_t(struct ccw_device *, unsigned int, int,
			    int, int, unsigned long);

/* qdio errors reported to the upper-layer program */
#define QDIO_ERROR_SIGA_TARGET			0x02
#define QDIO_ERROR_SIGA_ACCESS_EXCEPTION	0x10
#define QDIO_ERROR_SIGA_BUSY			0x20
#define QDIO_ERROR_ACTIVATE_CHECK_CONDITION	0x40
#define QDIO_ERROR_SLSB_STATE			0x80

/* for qdio_cleanup */
#define QDIO_FLAG_CLEANUP_USING_CLEAR		0x01
#define QDIO_FLAG_CLEANUP_USING_HALT		0x02

/**
 * struct qdio_initialize - qdio initalization data
 * @cdev: associated ccw device
 * @q_format: queue format
 * @adapter_name: name for the adapter
 * @qib_param_field_format: format for qib_parm_field
 * @qib_param_field: pointer to 128 bytes or NULL, if no param field
 * @qib_rflags: rflags to set
 * @input_slib_elements: pointer to no_input_qs * 128 words of data or NULL
 * @output_slib_elements: pointer to no_output_qs * 128 words of data or NULL
 * @no_input_qs: number of input queues
 * @no_output_qs: number of output queues
 * @input_handler: handler to be called for input queues
 * @output_handler: handler to be called for output queues
 * @int_parm: interruption parameter
 * @input_sbal_addr_array:  address of no_input_qs * 128 pointers
 * @output_sbal_addr_array: address of no_output_qs * 128 pointers
 */
struct qdio_initialize {
	struct ccw_device *cdev;
	unsigned char q_format;
	unsigned char adapter_name[8];
	unsigned int qib_param_field_format;
	unsigned char *qib_param_field;
	unsigned char qib_rflags;
	unsigned long *input_slib_elements;
	unsigned long *output_slib_elements;
	unsigned int no_input_qs;
	unsigned int no_output_qs;
	qdio_handler_t *input_handler;
	qdio_handler_t *output_handler;
	void (*queue_start_poll) (struct ccw_device *, int, unsigned long);
	unsigned long int_parm;
	void **input_sbal_addr_array;
	void **output_sbal_addr_array;
};

#define QDIO_STATE_INACTIVE		0x00000002 /* after qdio_cleanup */
#define QDIO_STATE_ESTABLISHED		0x00000004 /* after qdio_establish */
#define QDIO_STATE_ACTIVE		0x00000008 /* after qdio_activate */
#define QDIO_STATE_STOPPED		0x00000010 /* after queues went down */

#define QDIO_FLAG_SYNC_INPUT		0x01
#define QDIO_FLAG_SYNC_OUTPUT		0x02
#define QDIO_FLAG_PCI_OUT		0x10

extern int qdio_allocate(struct qdio_initialize *);
extern int qdio_establish(struct qdio_initialize *);
extern int qdio_activate(struct ccw_device *);
extern int do_QDIO(struct ccw_device *, unsigned int, int, unsigned int,
		   unsigned int);
extern int qdio_start_irq(struct ccw_device *, int);
extern int qdio_stop_irq(struct ccw_device *, int);
extern int qdio_get_next_buffers(struct ccw_device *, int, int *, int *);
extern int qdio_shutdown(struct ccw_device *, int);
extern int qdio_free(struct ccw_device *);
extern int qdio_get_ssqd_desc(struct ccw_device *, struct qdio_ssqd_desc *);

#endif /* __QDIO_H__ */
Commit	Line	Data
1da177e4	1	/*
f30c2269	2	* linux/include/asm-s390/qdio.h
1da177e4	3	*
779e6e1c	4	* Copyright 2000,2008 IBM Corp.
1da177e4	5	* Author(s): Utz Bacher <utz.bacher@de.ibm.com>
779e6e1c	6	* Jan Glauber <jang@linux.vnet.ibm.com>
1da177e4 LT	7	*
	8	*/
	9	#ifndef __QDIO_H__
	10	#define __QDIO_H__
	11
1da177e4 LT	12	#include <linux/interrupt.h>
	13	#include <asm/cio.h>
	14	#include <asm/ccwdev.h>
	15
432ac5e0 JG	16	/* only use 4 queues to save some cachelines */
432ac5e0 JG	17	#define QDIO_MAX_QUEUES_PER_IRQ 4
779e6e1c JG	18	#define QDIO_MAX_BUFFERS_PER_Q 128
	19	#define QDIO_MAX_BUFFERS_MASK (QDIO_MAX_BUFFERS_PER_Q - 1)
	20	#define QDIO_MAX_ELEMENTS_PER_BUFFER 16
	21	#define QDIO_SBAL_SIZE 256
	22
	23	#define QDIO_QETH_QFMT 0
	24	#define QDIO_ZFCP_QFMT 1
	25	#define QDIO_IQDIO_QFMT 2
	26
	27	/**
	28	* struct qdesfmt0 - queue descriptor, format 0
	29	* @sliba: storage list information block address
	30	* @sla: storage list address
	31	* @slsba: storage list state block address
	32	* @akey: access key for DLIB
	33	* @bkey: access key for SL
	34	* @ckey: access key for SBALs
	35	* @dkey: access key for SLSB
	36	*/
1da177e4	37	struct qdesfmt0 {
779e6e1c JG	38	u64 sliba;
	39	u64 sla;
	40	u64 slsba;
	41	u32 : 32;
	42	u32 akey : 4;
	43	u32 bkey : 4;
	44	u32 ckey : 4;
	45	u32 dkey : 4;
	46	u32 : 16;
1da177e4 LT	47	} __attribute__ ((packed));
1da177e4 LT	48
779e6e1c JG	49	/**
	50	* struct qdr - queue description record (QDR)
	51	* @qfmt: queue format
	52	* @pfmt: implementation dependent parameter format
	53	* @ac: adapter characteristics
	54	* @iqdcnt: input queue descriptor count
	55	* @oqdcnt: output queue descriptor count
	56	* @iqdsz: inpout queue descriptor size
	57	* @oqdsz: output queue descriptor size
	58	* @qiba: queue information block address
	59	* @qkey: queue information block key
	60	* @qdf0: queue descriptions
1da177e4 LT	61	*/
1da177e4 LT	62	struct qdr {
779e6e1c JG	63	u32 qfmt : 8;
	64	u32 pfmt : 8;
	65	u32 : 8;
	66	u32 ac : 8;
	67	u32 : 8;
	68	u32 iqdcnt : 8;
	69	u32 : 8;
	70	u32 oqdcnt : 8;
	71	u32 : 8;
	72	u32 iqdsz : 8;
	73	u32 : 8;
	74	u32 oqdsz : 8;
	75	/* private: */
	76	u32 res[9];
	77	/* public: */
	78	u64 qiba;
	79	u32 : 32;
	80	u32 qkey : 4;
	81	u32 : 28;
	82	struct qdesfmt0 qdf0[126];
	83	} __attribute__ ((packed, aligned(4096)));
	84
	85	#define QIB_AC_OUTBOUND_PCI_SUPPORTED 0x40
8129ee16	86	#define QIB_RFLAGS_ENABLE_QEBSM 0x80
dcc18f48	87	#define QIB_RFLAGS_ENABLE_DATA_DIV 0x02
8129ee16	88
779e6e1c JG	89	/**
	90	* struct qib - queue information block (QIB)
	91	* @qfmt: queue format
	92	* @pfmt: implementation dependent parameter format
	93	* @rflags: QEBSM
	94	* @ac: adapter characteristics
	95	* @isliba: absolute address of first input SLIB
	96	* @osliba: absolute address of first output SLIB
	97	* @ebcnam: adapter identifier in EBCDIC
	98	* @parm: implementation dependent parameters
	99	*/
1da177e4	100	struct qib {
779e6e1c JG	101	u32 qfmt : 8;
	102	u32 pfmt : 8;
	103	u32 rflags : 8;
	104	u32 ac : 8;
	105	u32 : 32;
	106	u64 isliba;
	107	u64 osliba;
	108	u32 : 32;
	109	u32 : 32;
	110	u8 ebcnam[8];
	111	/* private: */
	112	u8 res[88];
	113	/* public: */
	114	u8 parm[QDIO_MAX_BUFFERS_PER_Q];
	115	} __attribute__ ((packed, aligned(256)));
	116
	117	/**
	118	* struct slibe - storage list information block element (SLIBE)
	119	* @parms: implementation dependent parameters
1da177e4 LT	120	*/
1da177e4 LT	121	struct slibe {
779e6e1c	122	u64 parms;
1da177e4 LT	123	};
1da177e4 LT	124
779e6e1c JG	125	/**
	126	* struct slib - storage list information block (SLIB)
	127	* @nsliba: next SLIB address (if any)
	128	* @sla: SL address
	129	* @slsba: SLSB address
	130	* @slibe: SLIB elements
1da177e4 LT	131	*/
1da177e4 LT	132	struct slib {
779e6e1c JG	133	u64 nsliba;
	134	u64 sla;
	135	u64 slsba;
	136	/* private: */
	137	u8 res[1000];
	138	/* public: */
	139	struct slibe slibe[QDIO_MAX_BUFFERS_PER_Q];
	140	} __attribute__ ((packed, aligned(2048)));
	141
	142	/**
	143	* struct sbal_flags - storage block address list flags
	144	* @last: last entry
	145	* @cont: contiguous storage
	146	* @frag: fragmentation
	147	*/
1da177e4	148	struct sbal_flags {
779e6e1c JG	149	u8 : 1;
	150	u8 last : 1;
	151	u8 cont : 1;
	152	u8 : 1;
	153	u8 frag : 2;
	154	u8 : 2;
1da177e4 LT	155	} __attribute__ ((packed));
1da177e4 LT	156
779e6e1c JG	157	#define SBAL_FLAGS_FIRST_FRAG 0x04000000UL
	158	#define SBAL_FLAGS_MIDDLE_FRAG 0x08000000UL
	159	#define SBAL_FLAGS_LAST_FRAG 0x0c000000UL
	160	#define SBAL_FLAGS_LAST_ENTRY 0x40000000UL
	161	#define SBAL_FLAGS_CONTIGUOUS 0x20000000UL
1da177e4	162
779e6e1c	163	#define SBAL_FLAGS0_DATA_CONTINUATION 0x20UL
1da177e4 LT	164
1da177e4 LT	165	/* Awesome OpenFCP extensions */
779e6e1c JG	166	#define SBAL_FLAGS0_TYPE_STATUS 0x00UL
	167	#define SBAL_FLAGS0_TYPE_WRITE 0x08UL
	168	#define SBAL_FLAGS0_TYPE_READ 0x10UL
	169	#define SBAL_FLAGS0_TYPE_WRITE_READ 0x18UL
	170	#define SBAL_FLAGS0_MORE_SBALS 0x04UL
	171	#define SBAL_FLAGS0_COMMAND 0x02UL
	172	#define SBAL_FLAGS0_LAST_SBAL 0x00UL
	173	#define SBAL_FLAGS0_ONLY_SBAL SBAL_FLAGS0_COMMAND
	174	#define SBAL_FLAGS0_MIDDLE_SBAL SBAL_FLAGS0_MORE_SBALS
	175	#define SBAL_FLAGS0_FIRST_SBAL SBAL_FLAGS0_MORE_SBALS \| SBAL_FLAGS0_COMMAND
	176	#define SBAL_FLAGS0_PCI 0x40
	177
	178	/**
	179	* struct sbal_sbalf_0 - sbal flags for sbale 0
	180	* @pci: PCI indicator
	181	* @cont: data continuation
	182	* @sbtype: storage-block type (FCP)
	183	*/
1da177e4	184	struct sbal_sbalf_0 {
779e6e1c JG	185	u8 : 1;
	186	u8 pci : 1;
	187	u8 cont : 1;
	188	u8 sbtype : 2;
	189	u8 : 3;
1da177e4 LT	190	} __attribute__ ((packed));
1da177e4 LT	191
779e6e1c JG	192	/**
	193	* struct sbal_sbalf_1 - sbal flags for sbale 1
	194	* @key: storage key
	195	*/
1da177e4	196	struct sbal_sbalf_1 {
779e6e1c JG	197	u8 : 4;
779e6e1c JG	198	u8 key : 4;
1da177e4 LT	199	} __attribute__ ((packed));
1da177e4 LT	200
779e6e1c JG	201	/**
	202	* struct sbal_sbalf_14 - sbal flags for sbale 14
	203	* @erridx: error index
	204	*/
1da177e4	205	struct sbal_sbalf_14 {
779e6e1c JG	206	u8 : 4;
779e6e1c JG	207	u8 erridx : 4;
1da177e4 LT	208	} __attribute__ ((packed));
1da177e4 LT	209
779e6e1c JG	210	/**
	211	* struct sbal_sbalf_15 - sbal flags for sbale 15
	212	* @reason: reason for error state
	213	*/
1da177e4	214	struct sbal_sbalf_15 {
779e6e1c	215	u8 reason;
1da177e4 LT	216	} __attribute__ ((packed));
1da177e4 LT	217
779e6e1c JG	218	/**
	219	* union sbal_sbalf - storage block address list flags
	220	* @i0: sbalf0
	221	* @i1: sbalf1
	222	* @i14: sbalf14
	223	* @i15: sblaf15
	224	* @value: raw value
	225	*/
1da177e4 LT	226	union sbal_sbalf {
	227	struct sbal_sbalf_0 i0;
	228	struct sbal_sbalf_1 i1;
	229	struct sbal_sbalf_14 i14;
	230	struct sbal_sbalf_15 i15;
779e6e1c	231	u8 value;
1da177e4 LT	232	};
1da177e4 LT	233
779e6e1c JG	234	/**
	235	* struct qdio_buffer_element - SBAL entry
	236	* @flags: flags
	237	* @length: length
	238	* @addr: address
	239	*/
	240	struct qdio_buffer_element {
	241	u32 flags;
	242	u32 length;
	243	#ifdef CONFIG_32BIT
	244	/* private: */
	245	void *reserved;
	246	/* public: */
	247	#endif
	248	void *addr;
	249	} __attribute__ ((packed, aligned(16)));
1da177e4	250
779e6e1c JG	251	/**
	252	* struct qdio_buffer - storage block address list (SBAL)
	253	* @element: SBAL entries
1da177e4	254	*/
779e6e1c JG	255	struct qdio_buffer {
	256	struct qdio_buffer_element element[QDIO_MAX_ELEMENTS_PER_BUFFER];
	257	} __attribute__ ((packed, aligned(256)));
1da177e4	258
779e6e1c JG	259	/**
	260	* struct sl_element - storage list entry
	261	* @sbal: absolute SBAL address
1da177e4 LT	262	*/
1da177e4 LT	263	struct sl_element {
779e6e1c JG	264	#ifdef CONFIG_32BIT
	265	/* private: */
	266	unsigned long reserved;
	267	/* public: */
	268	#endif
	269	unsigned long sbal;
1da177e4 LT	270	} __attribute__ ((packed));
1da177e4 LT	271
779e6e1c JG	272	/**
	273	* struct sl - storage list (SL)
	274	* @element: SL entries
	275	*/
1da177e4 LT	276	struct sl {
1da177e4 LT	277	struct sl_element element[QDIO_MAX_BUFFERS_PER_Q];
779e6e1c	278	} __attribute__ ((packed, aligned(1024)));
1da177e4	279
779e6e1c JG	280	/**
	281	* struct slsb - storage list state block (SLSB)
	282	* @val: state per buffer
1da177e4	283	*/
779e6e1c JG	284	struct slsb {
	285	u8 val[QDIO_MAX_BUFFERS_PER_Q];
	286	} __attribute__ ((packed, aligned(256)));
	287
dcc18f48 CS	288	#define CHSC_AC2_DATA_DIV_AVAILABLE 0x0010
	289	#define CHSC_AC2_DATA_DIV_ENABLED 0x0002
	290
779e6e1c JG	291	struct qdio_ssqd_desc {
	292	u8 flags;
	293	u8:8;
	294	u16 sch;
	295	u8 qfmt;
	296	u8 parm;
	297	u8 qdioac1;
	298	u8 sch_class;
	299	u8 pcnt;
	300	u8 icnt;
	301	u8:8;
	302	u8 ocnt;
	303	u8:8;
	304	u8 mbccnt;
	305	u16 qdioac2;
	306	u64 sch_token;
7a0f4755 KDW	307	u8 mro;
	308	u8 mri;
	309	u8:8;
	310	u8 sbalic;
	311	u16:16;
	312	u8:8;
	313	u8 mmwc;
1da177e4 LT	314	} __attribute__ ((packed));
1da177e4 LT	315
779e6e1c JG	316	/* params are: ccw_device, qdio_error, queue_number,
	317	first element processed, number of elements processed, int_parm */
	318	typedef void qdio_handler_t(struct ccw_device *, unsigned int, int,
	319	int, int, unsigned long);
1da177e4	320
779e6e1c	321	/* qdio errors reported to the upper-layer program */
d303b6fd	322	#define QDIO_ERROR_SIGA_TARGET 0x02
779e6e1c JG	323	#define QDIO_ERROR_SIGA_ACCESS_EXCEPTION 0x10
	324	#define QDIO_ERROR_SIGA_BUSY 0x20
	325	#define QDIO_ERROR_ACTIVATE_CHECK_CONDITION 0x40
	326	#define QDIO_ERROR_SLSB_STATE 0x80
1da177e4	327
779e6e1c JG	328	/* for qdio_cleanup */
	329	#define QDIO_FLAG_CLEANUP_USING_CLEAR 0x01
	330	#define QDIO_FLAG_CLEANUP_USING_HALT 0x02
	331
	332	/**
	333	* struct qdio_initialize - qdio initalization data
	334	* @cdev: associated ccw device
	335	* @q_format: queue format
	336	* @adapter_name: name for the adapter
	337	* @qib_param_field_format: format for qib_parm_field
	338	* @qib_param_field: pointer to 128 bytes or NULL, if no param field
dcc18f48	339	* @qib_rflags: rflags to set
779e6e1c JG	340	* @input_slib_elements: pointer to no_input_qs * 128 words of data or NULL
	341	* @output_slib_elements: pointer to no_output_qs * 128 words of data or NULL
	342	* @no_input_qs: number of input queues
	343	* @no_output_qs: number of output queues
	344	* @input_handler: handler to be called for input queues
	345	* @output_handler: handler to be called for output queues
	346	* @int_parm: interruption parameter
779e6e1c JG	347	* @input_sbal_addr_array: address of no_input_qs * 128 pointers
779e6e1c JG	348	* @output_sbal_addr_array: address of no_output_qs * 128 pointers
1da177e4	349	*/
779e6e1c JG	350	struct qdio_initialize {
	351	struct ccw_device *cdev;
	352	unsigned char q_format;
	353	unsigned char adapter_name[8];
	354	unsigned int qib_param_field_format;
	355	unsigned char *qib_param_field;
dcc18f48	356	unsigned char qib_rflags;
779e6e1c JG	357	unsigned long *input_slib_elements;
	358	unsigned long *output_slib_elements;
	359	unsigned int no_input_qs;
	360	unsigned int no_output_qs;
	361	qdio_handler_t *input_handler;
	362	qdio_handler_t *output_handler;
d36deae7	363	void (queue_start_poll) (struct ccw_device , int, unsigned long);
779e6e1c	364	unsigned long int_parm;
779e6e1c JG	365	void **input_sbal_addr_array;
	366	void **output_sbal_addr_array;
	367	};
	368
	369	#define QDIO_STATE_INACTIVE 0x00000002 /* after qdio_cleanup */
	370	#define QDIO_STATE_ESTABLISHED 0x00000004 /* after qdio_establish */
	371	#define QDIO_STATE_ACTIVE 0x00000008 /* after qdio_activate */
	372	#define QDIO_STATE_STOPPED 0x00000010 /* after queues went down */
	373
	374	#define QDIO_FLAG_SYNC_INPUT 0x01
	375	#define QDIO_FLAG_SYNC_OUTPUT 0x02
	376	#define QDIO_FLAG_PCI_OUT 0x10
	377
bbd50e17 JG	378	extern int qdio_allocate(struct qdio_initialize *);
bbd50e17 JG	379	extern int qdio_establish(struct qdio_initialize *);
779e6e1c	380	extern int qdio_activate(struct ccw_device *);
d36deae7 JG	381	extern int do_QDIO(struct ccw_device *, unsigned int, int, unsigned int,
	382	unsigned int);
	383	extern int qdio_start_irq(struct ccw_device *, int);
	384	extern int qdio_stop_irq(struct ccw_device *, int);
	385	extern int qdio_get_next_buffers(struct ccw_device , int, int , int *);
	386	extern int qdio_shutdown(struct ccw_device *, int);
779e6e1c	387	extern int qdio_free(struct ccw_device *);
d36deae7	388	extern int qdio_get_ssqd_desc(struct ccw_device , struct qdio_ssqd_desc );
1da177e4 LT	389
1da177e4 LT	390	#endif /* __QDIO_H__ */