1 files changed, 251 insertions, 0 deletions
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.h b/drivers/infiniband/hw/mthca/mthca_provider.h
new file mode 100644
index 000000000000..0598f3905d9a
--- /dev/null
+++ b/drivers/infiniband/hw/mthca/mthca_provider.h
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2004 Topspin Communications.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     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.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * $Id: mthca_provider.h 1349 2004-12-16 21:09:43Z roland $
+ */
+#ifndef MTHCA_PROVIDER_H
+#define MTHCA_PROVIDER_H
+#include <ib_verbs.h>
+#include <ib_pack.h>
+#define MTHCA_MPT_FLAG_ATOMIC        (1 << 14)
+#define MTHCA_MPT_FLAG_REMOTE_WRITE  (1 << 13)
+#define MTHCA_MPT_FLAG_REMOTE_READ   (1 << 12)
+#define MTHCA_MPT_FLAG_LOCAL_WRITE   (1 << 11)
+#define MTHCA_MPT_FLAG_LOCAL_READ    (1 << 10)
+struct mthca_buf_list {
+        void *buf;
+        DECLARE_PCI_UNMAP_ADDR(mapping)
+};
+struct mthca_uar {
+        unsigned long pfn;
+        int           index;
+};
+struct mthca_mr {
+        struct ib_mr ibmr;
+        int order;
+        u32 first_seg;
+};
+struct mthca_pd {
+        struct ib_pd    ibpd;
+        u32             pd_num;
+        atomic_t        sqp_count;
+        struct mthca_mr ntmr;
+};
+struct mthca_eq {
+        struct mthca_dev      *dev;
+        int                    eqn;
+        u32                    eqn_mask;
+        u32                    cons_index;
+        u16                    msi_x_vector;
+        u16                    msi_x_entry;
+        int                    have_irq;
+        int                    nent;
+        struct mthca_buf_list *page_list;
+        struct mthca_mr        mr;
+};
+struct mthca_av;
+enum mthca_ah_type {
+        MTHCA_AH_ON_HCA,
+        MTHCA_AH_PCI_POOL,
+        MTHCA_AH_KMALLOC
+};
+struct mthca_ah {
+        struct ib_ah       ibah;
+        enum mthca_ah_type type;
+        u32                key;
+        struct mthca_av   *av;
+        dma_addr_t         avdma;
+};
+/*
+ * Quick description of our CQ/QP locking scheme:
+ *
+ * We have one global lock that protects dev->cq/qp_table.  Each
+ * struct mthca_cq/qp also has its own lock.  An individual qp lock
+ * may be taken inside of an individual cq lock.  Both cqs attached to
+ * a qp may be locked, with the send cq locked first.  No other
+ * nesting should be done.
+ *
+ * Each struct mthca_cq/qp also has an atomic_t ref count.  The
+ * pointer from the cq/qp_table to the struct counts as one reference.
+ * This reference also is good for access through the consumer API, so
+ * modifying the CQ/QP etc doesn't need to take another reference.
+ * Access because of a completion being polled does need a reference.
+ *
+ * Finally, each struct mthca_cq/qp has a wait_queue_head_t for the
+ * destroy function to sleep on.
+ *
+ * This means that access from the consumer API requires nothing but
+ * taking the struct's lock.
+ *
+ * Access because of a completion event should go as follows:
+ * - lock cq/qp_table and look up struct
+ * - increment ref count in struct
+ * - drop cq/qp_table lock
+ * - lock struct, do your thing, and unlock struct
+ * - decrement ref count; if zero, wake up waiters
+ *
+ * To destroy a CQ/QP, we can do the following:
+ * - lock cq/qp_table, remove pointer, unlock cq/qp_table lock
+ * - decrement ref count
+ * - wait_event until ref count is zero
+ *
+ * It is the consumer's responsibilty to make sure that no QP
+ * operations (WQE posting or state modification) are pending when the
+ * QP is destroyed.  Also, the consumer must make sure that calls to
+ * qp_modify are serialized.
+ *
+ * Possible optimizations (wait for profile data to see if/where we
+ * have locks bouncing between CPUs):
+ * - split cq/qp table lock into n separate (cache-aligned) locks,
+ *   indexed (say) by the page in the table
+ * - split QP struct lock into three (one for common info, one for the
+ *   send queue and one for the receive queue)
+ */
+struct mthca_cq {
+        struct ib_cq           ibcq;
+        spinlock_t             lock;
+        atomic_t               refcount;
+        int                    cqn;
+        u32                    cons_index;
+        int                    is_direct;
+        /* Next fields are Arbel only */
+        int                    set_ci_db_index;
+        u32                   *set_ci_db;
+        int                    arm_db_index;
+        u32                   *arm_db;
+        int                    arm_sn;
+        union {
+                struct mthca_buf_list direct;
+                struct mthca_buf_list *page_list;
+        }                      queue;
+        struct mthca_mr        mr;
+        wait_queue_head_t      wait;
+};
+struct mthca_wq {
+        spinlock_t lock;
+        int        max;
+        unsigned   next_ind;
+        unsigned   last_comp;
+        unsigned   head;
+        unsigned   tail;
+        void      *last;
+        int        max_gs;
+        int        wqe_shift;
+        int        db_index;    /* Arbel only */
+        u32       *db;
+};
+struct mthca_qp {
+        struct ib_qp           ibqp;
+        atomic_t               refcount;
+        u32                    qpn;
+        int                    is_direct;
+        u8                     transport;
+        u8                     state;
+        u8                     atomic_rd_en;
+        u8                     resp_depth;
+        struct mthca_mr        mr;
+        struct mthca_wq        rq;
+        struct mthca_wq        sq;
+        enum ib_sig_type       sq_policy;
+        int                    send_wqe_offset;
+        u64                   *wrid;
+        union {
+                struct mthca_buf_list direct;
+                struct mthca_buf_list *page_list;
+        }                      queue;
+        wait_queue_head_t      wait;
+};
+struct mthca_sqp {
+        struct mthca_qp qp;
+        int             port;
+        int             pkey_index;
+        u32             qkey;
+        u32             send_psn;
+        struct ib_ud_header ud_header;
+        int             header_buf_size;
+        void           *header_buf;
+        dma_addr_t      header_dma;
+};
+static inline struct mthca_mr *to_mmr(struct ib_mr *ibmr)
+{
+        return container_of(ibmr, struct mthca_mr, ibmr);
+}
+static inline struct mthca_pd *to_mpd(struct ib_pd *ibpd)
+{
+        return container_of(ibpd, struct mthca_pd, ibpd);
+}
+static inline struct mthca_ah *to_mah(struct ib_ah *ibah)
+{
+        return container_of(ibah, struct mthca_ah, ibah);
+}
+static inline struct mthca_cq *to_mcq(struct ib_cq *ibcq)
+{
+        return container_of(ibcq, struct mthca_cq, ibcq);
+}
+static inline struct mthca_qp *to_mqp(struct ib_qp *ibqp)
+{
+        return container_of(ibqp, struct mthca_qp, ibqp);
+}
+static inline struct mthca_sqp *to_msqp(struct mthca_qp *qp)
+{
+        return container_of(qp, struct mthca_sqp, qp);
+}
+#endif /* MTHCA_PROVIDER_H */

diff --git a/drivers/infiniband/hw/mthca/mthca_provider.h b/drivers/infiniband/hw/mthca/mthca_provider.h new file mode 100644 index 000000000000..0598f3905d9a --- /dev/null +++ b/drivers/infiniband/hw/mthca/mthca_provider.h
@@ -0,0 +1,251 @@
	1	/*
	2	* Copyright (c) 2004 Topspin Communications. All rights reserved.
	3	*
	4	* This software is available to you under a choice of one of two
	5	* licenses. You may choose to be licensed under the terms of the GNU
	6	* General Public License (GPL) Version 2, available from the file
	7	* COPYING in the main directory of this source tree, or the
	8	* OpenIB.org BSD license below:
	9	*
	10	* Redistribution and use in source and binary forms, with or
	11	* without modification, are permitted provided that the following
	12	* conditions are met:
	13	*
	14	* - Redistributions of source code must retain the above
	15	* copyright notice, this list of conditions and the following
	16	* disclaimer.
	17	*
	18	* - Redistributions in binary form must reproduce the above
	19	* copyright notice, this list of conditions and the following
	20	* disclaimer in the documentation and/or other materials
	21	* provided with the distribution.
	22	*
	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	25	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	26	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	27	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	28	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	29	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	30	* SOFTWARE.
	31	*
	32	* $Id: mthca_provider.h 1349 2004-12-16 21:09:43Z roland $
	33	*/
	34
	35	#ifndef MTHCA_PROVIDER_H
	36	#define MTHCA_PROVIDER_H
	37
	38	#include <ib_verbs.h>
	39	#include <ib_pack.h>
	40
	41	#define MTHCA_MPT_FLAG_ATOMIC (1 << 14)
	42	#define MTHCA_MPT_FLAG_REMOTE_WRITE (1 << 13)
	43	#define MTHCA_MPT_FLAG_REMOTE_READ (1 << 12)
	44	#define MTHCA_MPT_FLAG_LOCAL_WRITE (1 << 11)
	45	#define MTHCA_MPT_FLAG_LOCAL_READ (1 << 10)
	46
	47	struct mthca_buf_list {
	48	void *buf;
	49	DECLARE_PCI_UNMAP_ADDR(mapping)
	50	};
	51
	52	struct mthca_uar {
	53	unsigned long pfn;
	54	int index;
	55	};
	56
	57	struct mthca_mr {
	58	struct ib_mr ibmr;
	59	int order;
	60	u32 first_seg;
	61	};
	62
	63	struct mthca_pd {
	64	struct ib_pd ibpd;
	65	u32 pd_num;
	66	atomic_t sqp_count;
	67	struct mthca_mr ntmr;
	68	};
	69
	70	struct mthca_eq {
	71	struct mthca_dev *dev;
	72	int eqn;
	73	u32 eqn_mask;
	74	u32 cons_index;
	75	u16 msi_x_vector;
	76	u16 msi_x_entry;
	77	int have_irq;
	78	int nent;
	79	struct mthca_buf_list *page_list;
	80	struct mthca_mr mr;
	81	};
	82
	83	struct mthca_av;
	84
	85	enum mthca_ah_type {
	86	MTHCA_AH_ON_HCA,
	87	MTHCA_AH_PCI_POOL,
	88	MTHCA_AH_KMALLOC
	89	};
	90
	91	struct mthca_ah {
	92	struct ib_ah ibah;
	93	enum mthca_ah_type type;
	94	u32 key;
	95	struct mthca_av *av;
	96	dma_addr_t avdma;
	97	};
	98
	99	/*
	100	* Quick description of our CQ/QP locking scheme:
	101	*
	102	* We have one global lock that protects dev->cq/qp_table. Each
	103	* struct mthca_cq/qp also has its own lock. An individual qp lock
	104	* may be taken inside of an individual cq lock. Both cqs attached to
	105	* a qp may be locked, with the send cq locked first. No other
	106	* nesting should be done.
	107	*
	108	* Each struct mthca_cq/qp also has an atomic_t ref count. The
	109	* pointer from the cq/qp_table to the struct counts as one reference.
	110	* This reference also is good for access through the consumer API, so
	111	* modifying the CQ/QP etc doesn't need to take another reference.
	112	* Access because of a completion being polled does need a reference.
	113	*
	114	* Finally, each struct mthca_cq/qp has a wait_queue_head_t for the
	115	* destroy function to sleep on.
	116	*
	117	* This means that access from the consumer API requires nothing but
	118	* taking the struct's lock.
	119	*
	120	* Access because of a completion event should go as follows:
	121	* - lock cq/qp_table and look up struct
	122	* - increment ref count in struct
	123	* - drop cq/qp_table lock
	124	* - lock struct, do your thing, and unlock struct
	125	* - decrement ref count; if zero, wake up waiters
	126	*
	127	* To destroy a CQ/QP, we can do the following:
	128	* - lock cq/qp_table, remove pointer, unlock cq/qp_table lock
	129	* - decrement ref count
	130	* - wait_event until ref count is zero
	131	*
	132	* It is the consumer's responsibilty to make sure that no QP
	133	* operations (WQE posting or state modification) are pending when the
	134	* QP is destroyed. Also, the consumer must make sure that calls to
	135	* qp_modify are serialized.
	136	*
	137	* Possible optimizations (wait for profile data to see if/where we
	138	* have locks bouncing between CPUs):
	139	* - split cq/qp table lock into n separate (cache-aligned) locks,
	140	* indexed (say) by the page in the table
	141	* - split QP struct lock into three (one for common info, one for the
	142	* send queue and one for the receive queue)
	143	*/
	144
	145	struct mthca_cq {
	146	struct ib_cq ibcq;
	147	spinlock_t lock;
	148	atomic_t refcount;
	149	int cqn;
	150	u32 cons_index;
	151	int is_direct;
	152
	153	/* Next fields are Arbel only */
	154	int set_ci_db_index;
	155	u32 *set_ci_db;
	156	int arm_db_index;
	157	u32 *arm_db;
	158	int arm_sn;
	159
	160	union {
	161	struct mthca_buf_list direct;
	162	struct mthca_buf_list *page_list;
	163	} queue;
	164	struct mthca_mr mr;
	165	wait_queue_head_t wait;
	166	};
	167
	168	struct mthca_wq {
	169	spinlock_t lock;
	170	int max;
	171	unsigned next_ind;
	172	unsigned last_comp;
	173	unsigned head;
	174	unsigned tail;
	175	void *last;
	176	int max_gs;
	177	int wqe_shift;
	178
	179	int db_index; /* Arbel only */
	180	u32 *db;
	181	};
	182
	183	struct mthca_qp {
	184	struct ib_qp ibqp;
	185	atomic_t refcount;
	186	u32 qpn;
	187	int is_direct;
	188	u8 transport;
	189	u8 state;
	190	u8 atomic_rd_en;
	191	u8 resp_depth;
	192
	193	struct mthca_mr mr;
	194
	195	struct mthca_wq rq;
	196	struct mthca_wq sq;
	197	enum ib_sig_type sq_policy;
	198	int send_wqe_offset;
	199
	200	u64 *wrid;
	201	union {
	202	struct mthca_buf_list direct;
	203	struct mthca_buf_list *page_list;
	204	} queue;
	205
	206	wait_queue_head_t wait;
	207	};
	208
	209	struct mthca_sqp {
	210	struct mthca_qp qp;
	211	int port;
	212	int pkey_index;
	213	u32 qkey;
	214	u32 send_psn;
	215	struct ib_ud_header ud_header;
	216	int header_buf_size;
	217	void *header_buf;
	218	dma_addr_t header_dma;
	219	};
	220
	221	static inline struct mthca_mr to_mmr(struct ib_mr ibmr)
	222	{
	223	return container_of(ibmr, struct mthca_mr, ibmr);
	224	}
	225
	226	static inline struct mthca_pd to_mpd(struct ib_pd ibpd)
	227	{
	228	return container_of(ibpd, struct mthca_pd, ibpd);
	229	}
	230
	231	static inline struct mthca_ah to_mah(struct ib_ah ibah)
	232	{
	233	return container_of(ibah, struct mthca_ah, ibah);
	234	}
	235
	236	static inline struct mthca_cq to_mcq(struct ib_cq ibcq)
	237	{
	238	return container_of(ibcq, struct mthca_cq, ibcq);
	239	}
	240
	241	static inline struct mthca_qp to_mqp(struct ib_qp ibqp)
	242	{
	243	return container_of(ibqp, struct mthca_qp, ibqp);
	244	}
	245
	246	static inline struct mthca_sqp to_msqp(struct mthca_qp qp)
	247	{
	248	return container_of(qp, struct mthca_sqp, qp);
	249	}
	250
	251	#endif /* MTHCA_PROVIDER_H */