[linux-2.6-block.git] / drivers / infiniband / hw / ehca / ehca_classes.h

/*
 *  IBM eServer eHCA Infiniband device driver for Linux on POWER
 *
 *  Struct definition for eHCA internal structures
 *
 *  Authors: Heiko J Schick <schickhj@de.ibm.com>
 *           Christoph Raisch <raisch@de.ibm.com>
 *           Joachim Fenkes <fenkes@de.ibm.com>
 *
 *  Copyright (c) 2005 IBM Corporation
 *
 *  All rights reserved.
 *
 *  This source code is distributed under a dual license of GPL v2.0 and OpenIB
 *  BSD.
 *
 * OpenIB BSD License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials
 * provided with the distribution.
 *
 * 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 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 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 DAMAGE.
 */

#ifndef __EHCA_CLASSES_H__
#define __EHCA_CLASSES_H__


struct ehca_module;
struct ehca_qp;
struct ehca_cq;
struct ehca_eq;
struct ehca_mr;
struct ehca_mw;
struct ehca_pd;
struct ehca_av;

#include <linux/wait.h>

#include <rdma/ib_verbs.h>
#include <rdma/ib_user_verbs.h>

#ifdef CONFIG_PPC64
#include "ehca_classes_pSeries.h"
#endif
#include "ipz_pt_fn.h"
#include "ehca_qes.h"
#include "ehca_irq.h"

#define EHCA_EQE_CACHE_SIZE 20

struct ehca_eqe_cache_entry {
	struct ehca_eqe *eqe;
	struct ehca_cq *cq;
};

struct ehca_eq {
	u32 length;
	struct ipz_queue ipz_queue;
	struct ipz_eq_handle ipz_eq_handle;
	struct work_struct work;
	struct h_galpas galpas;
	int is_initialized;
	struct ehca_pfeq pf;
	spinlock_t spinlock;
	struct tasklet_struct interrupt_task;
	u32 ist;
	spinlock_t irq_spinlock;
	struct ehca_eqe_cache_entry eqe_cache[EHCA_EQE_CACHE_SIZE];
};

struct ehca_sport {
	struct ib_cq *ibcq_aqp1;
	struct ib_qp *ibqp_aqp1;
	enum ib_rate  rate;
	enum ib_port_state port_state;
};

struct ehca_shca {
	struct ib_device ib_device;
	struct ibmebus_dev *ibmebus_dev;
	u8 num_ports;
	int hw_level;
	struct list_head shca_list;
	struct ipz_adapter_handle ipz_hca_handle;
	struct ehca_sport sport[2];
	struct ehca_eq eq;
	struct ehca_eq neq;
	struct ehca_mr *maxmr;
	struct ehca_pd *pd;
	struct h_galpas galpas;
	struct mutex modify_mutex;
	u64 hca_cap;
	int max_mtu;
};

struct ehca_pd {
	struct ib_pd ib_pd;
	struct ipz_pd fw_pd;
	u32 ownpid;
};

enum ehca_ext_qp_type {
	EQPT_NORMAL    = 0,
	EQPT_LLQP      = 1,
	EQPT_SRQBASE   = 2,
	EQPT_SRQ       = 3,
};

struct ehca_qp {
	union {
		struct ib_qp ib_qp;
		struct ib_srq ib_srq;
	};
	u32 qp_type;
	enum ehca_ext_qp_type ext_type;
	struct ipz_queue ipz_squeue;
	struct ipz_queue ipz_rqueue;
	struct h_galpas galpas;
	u32 qkey;
	u32 real_qp_num;
	u32 token;
	spinlock_t spinlock_s;
	spinlock_t spinlock_r;
	u32 sq_max_inline_data_size;
	struct ipz_qp_handle ipz_qp_handle;
	struct ehca_pfqp pf;
	struct ib_qp_init_attr init_attr;
	struct ehca_cq *send_cq;
	struct ehca_cq *recv_cq;
	unsigned int sqerr_purgeflag;
	struct hlist_node list_entries;
	/* mmap counter for resources mapped into user space */
	u32 mm_count_squeue;
	u32 mm_count_rqueue;
	u32 mm_count_galpa;
};

#define IS_SRQ(qp) (qp->ext_type == EQPT_SRQ)
#define HAS_SQ(qp) (qp->ext_type != EQPT_SRQ)
#define HAS_RQ(qp) (qp->ext_type != EQPT_SRQBASE)

/* must be power of 2 */
#define QP_HASHTAB_LEN 8

struct ehca_cq {
	struct ib_cq ib_cq;
	struct ipz_queue ipz_queue;
	struct h_galpas galpas;
	spinlock_t spinlock;
	u32 cq_number;
	u32 token;
	u32 nr_of_entries;
	struct ipz_cq_handle ipz_cq_handle;
	struct ehca_pfcq pf;
	spinlock_t cb_lock;
	struct hlist_head qp_hashtab[QP_HASHTAB_LEN];
	struct list_head entry;
	u32 nr_callbacks; /* #events assigned to cpu by scaling code */
	u32 nr_events;    /* #events seen */
	wait_queue_head_t wait_completion;
	spinlock_t task_lock;
	u32 ownpid;
	/* mmap counter for resources mapped into user space */
	u32 mm_count_queue;
	u32 mm_count_galpa;
};

enum ehca_mr_flag {
	EHCA_MR_FLAG_FMR = 0x80000000,	 /* FMR, created with ehca_alloc_fmr */
	EHCA_MR_FLAG_MAXMR = 0x40000000, /* max-MR                           */
};

struct ehca_mr {
	union {
		struct ib_mr ib_mr;	/* must always be first in ehca_mr */
		struct ib_fmr ib_fmr;	/* must always be first in ehca_mr */
	} ib;
	struct ib_umem *umem;
	spinlock_t mrlock;

	enum ehca_mr_flag flags;
	u32 num_pages;		/* number of MR pages */
	u32 num_4k;		/* number of 4k "page" portions to form MR */
	int acl;		/* ACL (stored here for usage in reregister) */
	u64 *start;		/* virtual start address (stored here for */
	                        /* usage in reregister) */
	u64 size;		/* size (stored here for usage in reregister) */
	u32 fmr_page_size;	/* page size for FMR */
	u32 fmr_max_pages;	/* max pages for FMR */
	u32 fmr_max_maps;	/* max outstanding maps for FMR */
	u32 fmr_map_cnt;	/* map counter for FMR */
	/* fw specific data */
	struct ipz_mrmw_handle ipz_mr_handle;	/* MR handle for h-calls */
	struct h_galpas galpas;
	/* data for userspace bridge */
	u32 nr_of_pages;
	void *pagearray;
};

struct ehca_mw {
	struct ib_mw ib_mw;	/* gen2 mw, must always be first in ehca_mw */
	spinlock_t mwlock;

	u8 never_bound;		/* indication MW was never bound */
	struct ipz_mrmw_handle ipz_mw_handle;	/* MW handle for h-calls */
	struct h_galpas galpas;
};

enum ehca_mr_pgi_type {
	EHCA_MR_PGI_PHYS   = 1,  /* type of ehca_reg_phys_mr,
				  * ehca_rereg_phys_mr,
				  * ehca_reg_internal_maxmr */
	EHCA_MR_PGI_USER   = 2,  /* type of ehca_reg_user_mr */
	EHCA_MR_PGI_FMR    = 3   /* type of ehca_map_phys_fmr */
};

struct ehca_mr_pginfo {
	enum ehca_mr_pgi_type type;
	u64 num_pages;
	u64 page_cnt;
	u64 num_4k;       /* number of 4k "page" portions */
	u64 page_4k_cnt;  /* counter for 4k "page" portions */
	u64 next_4k;      /* next 4k "page" portion in buffer/chunk/listelem */

	/* type EHCA_MR_PGI_PHYS section */
	int num_phys_buf;
	struct ib_phys_buf *phys_buf_array;
	u64 next_buf;

	/* type EHCA_MR_PGI_USER section */
	struct ib_umem *region;
	struct ib_umem_chunk *next_chunk;
	u64 next_nmap;

	/* type EHCA_MR_PGI_FMR section */
	u64 *page_list;
	u64 next_listelem;
	/* next_4k also used within EHCA_MR_PGI_FMR */
};

/* output parameters for MR/FMR hipz calls */
struct ehca_mr_hipzout_parms {
	struct ipz_mrmw_handle handle;
	u32 lkey;
	u32 rkey;
	u64 len;
	u64 vaddr;
	u32 acl;
};

/* output parameters for MW hipz calls */
struct ehca_mw_hipzout_parms {
	struct ipz_mrmw_handle handle;
	u32 rkey;
};

struct ehca_av {
	struct ib_ah ib_ah;
	struct ehca_ud_av av;
};

struct ehca_ucontext {
	struct ib_ucontext ib_ucontext;
};

int ehca_init_pd_cache(void);
void ehca_cleanup_pd_cache(void);
int ehca_init_cq_cache(void);
void ehca_cleanup_cq_cache(void);
int ehca_init_qp_cache(void);
void ehca_cleanup_qp_cache(void);
int ehca_init_av_cache(void);
void ehca_cleanup_av_cache(void);
int ehca_init_mrmw_cache(void);
void ehca_cleanup_mrmw_cache(void);

extern spinlock_t ehca_qp_idr_lock;
extern spinlock_t ehca_cq_idr_lock;
extern struct idr ehca_qp_idr;
extern struct idr ehca_cq_idr;

extern int ehca_static_rate;
extern int ehca_port_act_time;
extern int ehca_use_hp_mr;
extern int ehca_scaling_code;

struct ipzu_queue_resp {
	u32 qe_size;      /* queue entry size */
	u32 act_nr_of_sg;
	u32 queue_length; /* queue length allocated in bytes */
	u32 pagesize;
	u32 toggle_state;
	u32 dummy; /* padding for 8 byte alignment */
};

struct ehca_create_cq_resp {
	u32 cq_number;
	u32 token;
	struct ipzu_queue_resp ipz_queue;
};

struct ehca_create_qp_resp {
	u32 qp_num;
	u32 token;
	u32 qp_type;
	u32 ext_type;
	u32 qkey;
	/* qp_num assigned by ehca: sqp0/1 may have got different numbers */
	u32 real_qp_num;
	u32 dummy; /* padding for 8 byte alignment */
	struct ipzu_queue_resp ipz_squeue;
	struct ipzu_queue_resp ipz_rqueue;
};

struct ehca_alloc_cq_parms {
	u32 nr_cqe;
	u32 act_nr_of_entries;
	u32 act_pages;
	struct ipz_eq_handle eq_handle;
};

enum ehca_service_type {
	ST_RC  = 0,
	ST_UC  = 1,
	ST_RD  = 2,
	ST_UD  = 3,
};

enum ehca_ll_comp_flags {
	LLQP_SEND_COMP = 0x20,
	LLQP_RECV_COMP = 0x40,
	LLQP_COMP_MASK = 0x60,
};

struct ehca_alloc_qp_parms {
/* input parameters */
	enum ehca_service_type servicetype;
	int sigtype;
	enum ehca_ext_qp_type ext_type;
	enum ehca_ll_comp_flags ll_comp_flags;

	int max_send_wr, max_recv_wr;
	int max_send_sge, max_recv_sge;
	int ud_av_l_key_ctl;

	u32 token;
	struct ipz_eq_handle eq_handle;
	struct ipz_pd pd;
	struct ipz_cq_handle send_cq_handle, recv_cq_handle;

	u32 srq_qpn, srq_token, srq_limit;

/* output parameters */
	u32 real_qp_num;
	struct ipz_qp_handle qp_handle;
	struct h_galpas galpas;

	u16 act_nr_send_wqes;
	u16 act_nr_recv_wqes;
	u8  act_nr_recv_sges;
	u8  act_nr_send_sges;

	u32 nr_rq_pages;
	u32 nr_sq_pages;
};

int ehca_cq_assign_qp(struct ehca_cq *cq, struct ehca_qp *qp);
int ehca_cq_unassign_qp(struct ehca_cq *cq, unsigned int qp_num);
struct ehca_qp* ehca_cq_get_qp(struct ehca_cq *cq, int qp_num);

#endif
Commit	Line	Data
fab97220 HS	1	/*
	2	* IBM eServer eHCA Infiniband device driver for Linux on POWER
	3	*
	4	* Struct definition for eHCA internal structures
	5	*
	6	* Authors: Heiko J Schick <schickhj@de.ibm.com>
	7	* Christoph Raisch <raisch@de.ibm.com>
a6a12947	8	* Joachim Fenkes <fenkes@de.ibm.com>
fab97220 HS	9	*
	10	* Copyright (c) 2005 IBM Corporation
	11	*
	12	* All rights reserved.
	13	*
	14	* This source code is distributed under a dual license of GPL v2.0 and OpenIB
	15	* BSD.
	16	*
	17	* OpenIB BSD License
	18	*
	19	* Redistribution and use in source and binary forms, with or without
	20	* modification, are permitted provided that the following conditions are met:
	21	*
	22	* Redistributions of source code must retain the above copyright notice, this
	23	* list of conditions and the following disclaimer.
	24	*
	25	* Redistributions in binary form must reproduce the above copyright notice,
	26	* this list of conditions and the following disclaimer in the documentation
	27	* and/or other materials
	28	* provided with the distribution.
	29	*
	30	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	31	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	32	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	33	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	34	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	35	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	36	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	37	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
	38	* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	39	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	40	* POSSIBILITY OF SUCH DAMAGE.
	41	*/
	42
	43	#ifndef __EHCA_CLASSES_H__
	44	#define __EHCA_CLASSES_H__
	45
fab97220 HS	46
	47	struct ehca_module;
	48	struct ehca_qp;
	49	struct ehca_cq;
	50	struct ehca_eq;
	51	struct ehca_mr;
	52	struct ehca_mw;
	53	struct ehca_pd;
	54	struct ehca_av;
	55
31726798 HNN	56	#include <linux/wait.h>
31726798 HNN	57
78d8d5f9 HNN	58	#include <rdma/ib_verbs.h>
	59	#include <rdma/ib_user_verbs.h>
	60
fab97220 HS	61	#ifdef CONFIG_PPC64
	62	#include "ehca_classes_pSeries.h"
	63	#endif
78d8d5f9 HNN	64	#include "ipz_pt_fn.h"
	65	#include "ehca_qes.h"
	66	#include "ehca_irq.h"
fab97220	67
78d8d5f9	68	#define EHCA_EQE_CACHE_SIZE 20
fab97220	69
78d8d5f9 HNN	70	struct ehca_eqe_cache_entry {
	71	struct ehca_eqe *eqe;
	72	struct ehca_cq *cq;
	73	};
fab97220 HS	74
	75	struct ehca_eq {
	76	u32 length;
	77	struct ipz_queue ipz_queue;
	78	struct ipz_eq_handle ipz_eq_handle;
	79	struct work_struct work;
	80	struct h_galpas galpas;
	81	int is_initialized;
	82	struct ehca_pfeq pf;
	83	spinlock_t spinlock;
	84	struct tasklet_struct interrupt_task;
	85	u32 ist;
78d8d5f9 HNN	86	spinlock_t irq_spinlock;
78d8d5f9 HNN	87	struct ehca_eqe_cache_entry eqe_cache[EHCA_EQE_CACHE_SIZE];
fab97220 HS	88	};
	89
	90	struct ehca_sport {
	91	struct ib_cq *ibcq_aqp1;
	92	struct ib_qp *ibqp_aqp1;
	93	enum ib_rate rate;
	94	enum ib_port_state port_state;
	95	};
	96
	97	struct ehca_shca {
	98	struct ib_device ib_device;
	99	struct ibmebus_dev *ibmebus_dev;
	100	u8 num_ports;
	101	int hw_level;
	102	struct list_head shca_list;
	103	struct ipz_adapter_handle ipz_hca_handle;
	104	struct ehca_sport sport[2];
	105	struct ehca_eq eq;
	106	struct ehca_eq neq;
	107	struct ehca_mr *maxmr;
	108	struct ehca_pd *pd;
	109	struct h_galpas galpas;
c4ed790d	110	struct mutex modify_mutex;
91f13aa3 JF	111	u64 hca_cap;
91f13aa3 JF	112	int max_mtu;
fab97220 HS	113	};
	114
	115	struct ehca_pd {
	116	struct ib_pd ib_pd;
	117	struct ipz_pd fw_pd;
	118	u32 ownpid;
	119	};
	120
a6a12947 JF	121	enum ehca_ext_qp_type {
	122	EQPT_NORMAL = 0,
	123	EQPT_LLQP = 1,
	124	EQPT_SRQBASE = 2,
	125	EQPT_SRQ = 3,
	126	};
	127
fab97220	128	struct ehca_qp {
a6a12947 JF	129	union {
	130	struct ib_qp ib_qp;
	131	struct ib_srq ib_srq;
	132	};
fab97220	133	u32 qp_type;
a6a12947	134	enum ehca_ext_qp_type ext_type;
fab97220 HS	135	struct ipz_queue ipz_squeue;
	136	struct ipz_queue ipz_rqueue;
	137	struct h_galpas galpas;
	138	u32 qkey;
	139	u32 real_qp_num;
	140	u32 token;
	141	spinlock_t spinlock_s;
	142	spinlock_t spinlock_r;
	143	u32 sq_max_inline_data_size;
	144	struct ipz_qp_handle ipz_qp_handle;
	145	struct ehca_pfqp pf;
	146	struct ib_qp_init_attr init_attr;
fab97220 HS	147	struct ehca_cq *send_cq;
	148	struct ehca_cq *recv_cq;
	149	unsigned int sqerr_purgeflag;
	150	struct hlist_node list_entries;
4c34bdf5 HNN	151	/* mmap counter for resources mapped into user space */
	152	u32 mm_count_squeue;
	153	u32 mm_count_rqueue;
	154	u32 mm_count_galpa;
fab97220 HS	155	};
fab97220 HS	156
a6a12947 JF	157	#define IS_SRQ(qp) (qp->ext_type == EQPT_SRQ)
	158	#define HAS_SQ(qp) (qp->ext_type != EQPT_SRQ)
	159	#define HAS_RQ(qp) (qp->ext_type != EQPT_SRQBASE)
	160
fab97220 HS	161	/* must be power of 2 */
	162	#define QP_HASHTAB_LEN 8
	163
	164	struct ehca_cq {
	165	struct ib_cq ib_cq;
	166	struct ipz_queue ipz_queue;
	167	struct h_galpas galpas;
	168	spinlock_t spinlock;
	169	u32 cq_number;
	170	u32 token;
	171	u32 nr_of_entries;
	172	struct ipz_cq_handle ipz_cq_handle;
	173	struct ehca_pfcq pf;
	174	spinlock_t cb_lock;
fab97220 HS	175	struct hlist_head qp_hashtab[QP_HASHTAB_LEN];
fab97220 HS	176	struct list_head entry;
31726798 HNN	177	u32 nr_callbacks; /* #events assigned to cpu by scaling code */
	178	u32 nr_events; /* #events seen */
	179	wait_queue_head_t wait_completion;
fab97220 HS	180	spinlock_t task_lock;
fab97220 HS	181	u32 ownpid;
4c34bdf5 HNN	182	/* mmap counter for resources mapped into user space */
	183	u32 mm_count_queue;
	184	u32 mm_count_galpa;
fab97220 HS	185	};
	186
	187	enum ehca_mr_flag {
	188	EHCA_MR_FLAG_FMR = 0x80000000, /* FMR, created with ehca_alloc_fmr */
	189	EHCA_MR_FLAG_MAXMR = 0x40000000, /* max-MR */
	190	};
	191
	192	struct ehca_mr {
	193	union {
	194	struct ib_mr ib_mr; /* must always be first in ehca_mr */
	195	struct ib_fmr ib_fmr; /* must always be first in ehca_mr */
	196	} ib;
f7c6a7b5	197	struct ib_umem *umem;
fab97220 HS	198	spinlock_t mrlock;
	199
	200	enum ehca_mr_flag flags;
	201	u32 num_pages; /* number of MR pages */
	202	u32 num_4k; /* number of 4k "page" portions to form MR */
	203	int acl; /* ACL (stored here for usage in reregister) */
	204	u64 start; / virtual start address (stored here for */
	205	/* usage in reregister) */
	206	u64 size; /* size (stored here for usage in reregister) */
	207	u32 fmr_page_size; /* page size for FMR */
	208	u32 fmr_max_pages; /* max pages for FMR */
	209	u32 fmr_max_maps; /* max outstanding maps for FMR */
	210	u32 fmr_map_cnt; /* map counter for FMR */
	211	/* fw specific data */
	212	struct ipz_mrmw_handle ipz_mr_handle; /* MR handle for h-calls */
	213	struct h_galpas galpas;
	214	/* data for userspace bridge */
	215	u32 nr_of_pages;
	216	void *pagearray;
	217	};
	218
	219	struct ehca_mw {
	220	struct ib_mw ib_mw; /* gen2 mw, must always be first in ehca_mw */
	221	spinlock_t mwlock;
	222
	223	u8 never_bound; /* indication MW was never bound */
	224	struct ipz_mrmw_handle ipz_mw_handle; /* MW handle for h-calls */
	225	struct h_galpas galpas;
	226	};
	227
	228	enum ehca_mr_pgi_type {
	229	EHCA_MR_PGI_PHYS = 1, /* type of ehca_reg_phys_mr,
	230	* ehca_rereg_phys_mr,
	231	* ehca_reg_internal_maxmr */
	232	EHCA_MR_PGI_USER = 2, /* type of ehca_reg_user_mr */
	233	EHCA_MR_PGI_FMR = 3 /* type of ehca_map_phys_fmr */
	234	};
	235
	236	struct ehca_mr_pginfo {
	237	enum ehca_mr_pgi_type type;
	238	u64 num_pages;
	239	u64 page_cnt;
	240	u64 num_4k; /* number of 4k "page" portions */
	241	u64 page_4k_cnt; /* counter for 4k "page" portions */
	242	u64 next_4k; /* next 4k "page" portion in buffer/chunk/listelem */
	243
	244	/* type EHCA_MR_PGI_PHYS section */
	245	int num_phys_buf;
	246	struct ib_phys_buf *phys_buf_array;
	247	u64 next_buf;
	248
	249	/* type EHCA_MR_PGI_USER section */
	250	struct ib_umem *region;
	251	struct ib_umem_chunk *next_chunk;
	252	u64 next_nmap;
	253
	254	/* type EHCA_MR_PGI_FMR section */
	255	u64 *page_list;
	256	u64 next_listelem;
	257	/* next_4k also used within EHCA_MR_PGI_FMR */
	258	};
	259
	260	/* output parameters for MR/FMR hipz calls */
	261	struct ehca_mr_hipzout_parms {
262	struct ipz_mrmw_handle handle;
263	u32 lkey;
264	u32 rkey;
265	u64 len;
266	u64 vaddr;
267	u32 acl;
268	};
269
270	/* output parameters for MW hipz calls */
271	struct ehca_mw_hipzout_parms {
272	struct ipz_mrmw_handle handle;
273	u32 rkey;
274	};
275
276	struct ehca_av {
277	struct ib_ah ib_ah;
278	struct ehca_ud_av av;
279	};
280
281	struct ehca_ucontext {
282	struct ib_ucontext ib_ucontext;
283	};
284
fab97220 HS	285	int ehca_init_pd_cache(void);
	286	void ehca_cleanup_pd_cache(void);
	287	int ehca_init_cq_cache(void);
	288	void ehca_cleanup_cq_cache(void);
	289	int ehca_init_qp_cache(void);
	290	void ehca_cleanup_qp_cache(void);
	291	int ehca_init_av_cache(void);
	292	void ehca_cleanup_av_cache(void);
	293	int ehca_init_mrmw_cache(void);
	294	void ehca_cleanup_mrmw_cache(void);
	295
	296	extern spinlock_t ehca_qp_idr_lock;
	297	extern spinlock_t ehca_cq_idr_lock;
	298	extern struct idr ehca_qp_idr;
	299	extern struct idr ehca_cq_idr;
	300
	301	extern int ehca_static_rate;
	302	extern int ehca_port_act_time;
	303	extern int ehca_use_hp_mr;
4fd30060	304	extern int ehca_scaling_code;
fab97220 HS	305
fab97220 HS	306	struct ipzu_queue_resp {
fab97220 HS	307	u32 qe_size; /* queue entry size */
	308	u32 act_nr_of_sg;
	309	u32 queue_length; /* queue length allocated in bytes */
	310	u32 pagesize;
	311	u32 toggle_state;
	312	u32 dummy; /* padding for 8 byte alignment */
	313	};
	314
	315	struct ehca_create_cq_resp {
	316	u32 cq_number;
	317	u32 token;
	318	struct ipzu_queue_resp ipz_queue;
fab97220 HS	319	};
	320
	321	struct ehca_create_qp_resp {
	322	u32 qp_num;
	323	u32 token;
	324	u32 qp_type;
a6a12947	325	u32 ext_type;
fab97220 HS	326	u32 qkey;
	327	/* qp_num assigned by ehca: sqp0/1 may have got different numbers */
	328	u32 real_qp_num;
	329	u32 dummy; /* padding for 8 byte alignment */
	330	struct ipzu_queue_resp ipz_squeue;
	331	struct ipzu_queue_resp ipz_rqueue;
fab97220 HS	332	};
	333
	334	struct ehca_alloc_cq_parms {
	335	u32 nr_cqe;
	336	u32 act_nr_of_entries;
	337	u32 act_pages;
	338	struct ipz_eq_handle eq_handle;
	339	};
	340
9a79fc0a JF	341	enum ehca_service_type {
	342	ST_RC = 0,
	343	ST_UC = 1,
	344	ST_RD = 2,
	345	ST_UD = 3,
	346	};
	347
9a79fc0a JF	348	enum ehca_ll_comp_flags {
	349	LLQP_SEND_COMP = 0x20,
	350	LLQP_RECV_COMP = 0x40,
	351	LLQP_COMP_MASK = 0x60,
	352	};
	353
fab97220	354	struct ehca_alloc_qp_parms {
9a79fc0a JF	355	/* input parameters */
9a79fc0a JF	356	enum ehca_service_type servicetype;
fab97220	357	int sigtype;
9a79fc0a JF	358	enum ehca_ext_qp_type ext_type;
	359	enum ehca_ll_comp_flags ll_comp_flags;
	360
	361	int max_send_wr, max_recv_wr;
	362	int max_send_sge, max_recv_sge;
fab97220 HS	363	int ud_av_l_key_ctl;
fab97220 HS	364
9a79fc0a JF	365	u32 token;
	366	struct ipz_eq_handle eq_handle;
	367	struct ipz_pd pd;
	368	struct ipz_cq_handle send_cq_handle, recv_cq_handle;
	369
	370	u32 srq_qpn, srq_token, srq_limit;
	371
	372	/* output parameters */
	373	u32 real_qp_num;
	374	struct ipz_qp_handle qp_handle;
	375	struct h_galpas galpas;
	376
fab97220 HS	377	u16 act_nr_send_wqes;
	378	u16 act_nr_recv_wqes;
	379	u8 act_nr_recv_sges;
	380	u8 act_nr_send_sges;
	381
	382	u32 nr_rq_pages;
	383	u32 nr_sq_pages;
fab97220 HS	384	};
	385
	386	int ehca_cq_assign_qp(struct ehca_cq cq, struct ehca_qp qp);
	387	int ehca_cq_unassign_qp(struct ehca_cq *cq, unsigned int qp_num);
	388	struct ehca_qp* ehca_cq_get_qp(struct ehca_cq *cq, int qp_num);
	389
	390	#endif