[linux-2.6-block.git] / drivers / infiniband / hw / amso1100 / c2_cm.c

/*
 * Copyright (c) 2005 Ammasso, Inc.  All rights reserved.
 * Copyright (c) 2005 Open Grid Computing, Inc. 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.
 *
 */
#include "c2.h"
#include "c2_wr.h"
#include "c2_vq.h"
#include <rdma/iw_cm.h>

int c2_llp_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
{
	struct c2_dev *c2dev = to_c2dev(cm_id->device);
	struct ib_qp *ibqp;
	struct c2_qp *qp;
	struct c2wr_qp_connect_req *wr;	/* variable size needs a malloc. */
	struct c2_vq_req *vq_req;
	int err;

	ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
	if (!ibqp)
		return -EINVAL;
	qp = to_c2qp(ibqp);

	/* Associate QP <--> CM_ID */
	cm_id->provider_data = qp;
	cm_id->add_ref(cm_id);
	qp->cm_id = cm_id;

	/*
	 * only support the max private_data length
	 */
	if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
		err = -EINVAL;
		goto bail0;
	}
	/*
	 * Set the rdma read limits
	 */
	err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
	if (err)
		goto bail0;

	/*
	 * Create and send a WR_QP_CONNECT...
	 */
	wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
	if (!wr) {
		err = -ENOMEM;
		goto bail0;
	}

	vq_req = vq_req_alloc(c2dev);
	if (!vq_req) {
		err = -ENOMEM;
		goto bail1;
	}

	c2_wr_set_id(wr, CCWR_QP_CONNECT);
	wr->hdr.context = 0;
	wr->rnic_handle = c2dev->adapter_handle;
	wr->qp_handle = qp->adapter_handle;

	wr->remote_addr = cm_id->remote_addr.sin_addr.s_addr;
	wr->remote_port = cm_id->remote_addr.sin_port;

	/*
	 * Move any private data from the callers's buf into
	 * the WR.
	 */
	if (iw_param->private_data) {
		wr->private_data_length =
			cpu_to_be32(iw_param->private_data_len);
		memcpy(&wr->private_data[0], iw_param->private_data,
		       iw_param->private_data_len);
	} else
		wr->private_data_length = 0;

	/*
	 * Send WR to adapter.  NOTE: There is no synch reply from
	 * the adapter.
	 */
	err = vq_send_wr(c2dev, (union c2wr *) wr);
	vq_req_free(c2dev, vq_req);

 bail1:
	kfree(wr);
 bail0:
	if (err) {
		/*
		 * If we fail, release reference on QP and
		 * disassociate QP from CM_ID
		 */
		cm_id->provider_data = NULL;
		qp->cm_id = NULL;
		cm_id->rem_ref(cm_id);
	}
	return err;
}

int c2_llp_service_create(struct iw_cm_id *cm_id, int backlog)
{
	struct c2_dev *c2dev;
	struct c2wr_ep_listen_create_req wr;
	struct c2wr_ep_listen_create_rep *reply;
	struct c2_vq_req *vq_req;
	int err;

	c2dev = to_c2dev(cm_id->device);
	if (c2dev == NULL)
		return -EINVAL;

	/*
	 * Allocate verbs request.
	 */
	vq_req = vq_req_alloc(c2dev);
	if (!vq_req)
		return -ENOMEM;

	/*
	 * Build the WR
	 */
	c2_wr_set_id(&wr, CCWR_EP_LISTEN_CREATE);
	wr.hdr.context = (u64) (unsigned long) vq_req;
	wr.rnic_handle = c2dev->adapter_handle;
	wr.local_addr = cm_id->local_addr.sin_addr.s_addr;
	wr.local_port = cm_id->local_addr.sin_port;
	wr.backlog = cpu_to_be32(backlog);
	wr.user_context = (u64) (unsigned long) cm_id;

	/*
	 * Reference the request struct.  Dereferenced in the int handler.
	 */
	vq_req_get(c2dev, vq_req);

	/*
	 * Send WR to adapter
	 */
	err = vq_send_wr(c2dev, (union c2wr *) & wr);
	if (err) {
		vq_req_put(c2dev, vq_req);
		goto bail0;
	}

	/*
	 * Wait for reply from adapter
	 */
	err = vq_wait_for_reply(c2dev, vq_req);
	if (err)
		goto bail0;

	/*
	 * Process reply
	 */
	reply =
	    (struct c2wr_ep_listen_create_rep *) (unsigned long) vq_req->reply_msg;
	if (!reply) {
		err = -ENOMEM;
		goto bail1;
	}

	if ((err = c2_errno(reply)) != 0)
		goto bail1;

	/*
	 * Keep the adapter handle. Used in subsequent destroy
	 */
	cm_id->provider_data = (void*)(unsigned long) reply->ep_handle;

	/*
	 * free vq stuff
	 */
	vq_repbuf_free(c2dev, reply);
	vq_req_free(c2dev, vq_req);

	return 0;

 bail1:
	vq_repbuf_free(c2dev, reply);
 bail0:
	vq_req_free(c2dev, vq_req);
	return err;
}


int c2_llp_service_destroy(struct iw_cm_id *cm_id)
{

	struct c2_dev *c2dev;
	struct c2wr_ep_listen_destroy_req wr;
	struct c2wr_ep_listen_destroy_rep *reply;
	struct c2_vq_req *vq_req;
	int err;

	c2dev = to_c2dev(cm_id->device);
	if (c2dev == NULL)
		return -EINVAL;

	/*
	 * Allocate verbs request.
	 */
	vq_req = vq_req_alloc(c2dev);
	if (!vq_req)
		return -ENOMEM;

	/*
	 * Build the WR
	 */
	c2_wr_set_id(&wr, CCWR_EP_LISTEN_DESTROY);
	wr.hdr.context = (unsigned long) vq_req;
	wr.rnic_handle = c2dev->adapter_handle;
	wr.ep_handle = (u32)(unsigned long)cm_id->provider_data;

	/*
	 * reference the request struct.  dereferenced in the int handler.
	 */
	vq_req_get(c2dev, vq_req);

	/*
	 * Send WR to adapter
	 */
	err = vq_send_wr(c2dev, (union c2wr *) & wr);
	if (err) {
		vq_req_put(c2dev, vq_req);
		goto bail0;
	}

	/*
	 * Wait for reply from adapter
	 */
	err = vq_wait_for_reply(c2dev, vq_req);
	if (err)
		goto bail0;

	/*
	 * Process reply
	 */
	reply=(struct c2wr_ep_listen_destroy_rep *)(unsigned long)vq_req->reply_msg;
	if (!reply) {
		err = -ENOMEM;
		goto bail0;
	}
	if ((err = c2_errno(reply)) != 0)
		goto bail1;

 bail1:
	vq_repbuf_free(c2dev, reply);
 bail0:
	vq_req_free(c2dev, vq_req);
	return err;
}

int c2_llp_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
{
	struct c2_dev *c2dev = to_c2dev(cm_id->device);
	struct c2_qp *qp;
	struct ib_qp *ibqp;
	struct c2wr_cr_accept_req *wr;	/* variable length WR */
	struct c2_vq_req *vq_req;
	struct c2wr_cr_accept_rep *reply;	/* VQ Reply msg ptr. */
	int err;

	ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
	if (!ibqp)
		return -EINVAL;
	qp = to_c2qp(ibqp);

	/* Set the RDMA read limits */
	err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
	if (err)
		goto bail0;

	/* Allocate verbs request. */
	vq_req = vq_req_alloc(c2dev);
	if (!vq_req) {
		err = -ENOMEM;
		goto bail0;
	}
	vq_req->qp = qp;
	vq_req->cm_id = cm_id;
	vq_req->event = IW_CM_EVENT_ESTABLISHED;

	wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
	if (!wr) {
		err = -ENOMEM;
		goto bail1;
	}

	/* Build the WR */
	c2_wr_set_id(wr, CCWR_CR_ACCEPT);
	wr->hdr.context = (unsigned long) vq_req;
	wr->rnic_handle = c2dev->adapter_handle;
	wr->ep_handle = (u32) (unsigned long) cm_id->provider_data;
	wr->qp_handle = qp->adapter_handle;

	/* Replace the cr_handle with the QP after accept */
	cm_id->provider_data = qp;
	cm_id->add_ref(cm_id);
	qp->cm_id = cm_id;

	cm_id->provider_data = qp;

	/* Validate private_data length */
	if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
		err = -EINVAL;
		goto bail1;
	}

	if (iw_param->private_data) {
		wr->private_data_length = cpu_to_be32(iw_param->private_data_len);
		memcpy(&wr->private_data[0],
		       iw_param->private_data, iw_param->private_data_len);
	} else
		wr->private_data_length = 0;

	/* Reference the request struct.  Dereferenced in the int handler. */
	vq_req_get(c2dev, vq_req);

	/* Send WR to adapter */
	err = vq_send_wr(c2dev, (union c2wr *) wr);
	if (err) {
		vq_req_put(c2dev, vq_req);
		goto bail1;
	}

	/* Wait for reply from adapter */
	err = vq_wait_for_reply(c2dev, vq_req);
	if (err)
		goto bail1;

	/* Check that reply is present */
	reply = (struct c2wr_cr_accept_rep *) (unsigned long) vq_req->reply_msg;
	if (!reply) {
		err = -ENOMEM;
		goto bail1;
	}

	err = c2_errno(reply);
	vq_repbuf_free(c2dev, reply);

	if (!err)
		c2_set_qp_state(qp, C2_QP_STATE_RTS);
 bail1:
	kfree(wr);
	vq_req_free(c2dev, vq_req);
 bail0:
	if (err) {
		/*
		 * If we fail, release reference on QP and
		 * disassociate QP from CM_ID
		 */
		cm_id->provider_data = NULL;
		qp->cm_id = NULL;
		cm_id->rem_ref(cm_id);
	}
	return err;
}

int c2_llp_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
{
	struct c2_dev *c2dev;
	struct c2wr_cr_reject_req wr;
	struct c2_vq_req *vq_req;
	struct c2wr_cr_reject_rep *reply;
	int err;

	c2dev = to_c2dev(cm_id->device);

	/*
	 * Allocate verbs request.
	 */
	vq_req = vq_req_alloc(c2dev);
	if (!vq_req)
		return -ENOMEM;

	/*
	 * Build the WR
	 */
	c2_wr_set_id(&wr, CCWR_CR_REJECT);
	wr.hdr.context = (unsigned long) vq_req;
	wr.rnic_handle = c2dev->adapter_handle;
	wr.ep_handle = (u32) (unsigned long) cm_id->provider_data;

	/*
	 * reference the request struct.  dereferenced in the int handler.
	 */
	vq_req_get(c2dev, vq_req);

	/*
	 * Send WR to adapter
	 */
	err = vq_send_wr(c2dev, (union c2wr *) & wr);
	if (err) {
		vq_req_put(c2dev, vq_req);
		goto bail0;
	}

	/*
	 * Wait for reply from adapter
	 */
	err = vq_wait_for_reply(c2dev, vq_req);
	if (err)
		goto bail0;

	/*
	 * Process reply
	 */
	reply = (struct c2wr_cr_reject_rep *) (unsigned long)
		vq_req->reply_msg;
	if (!reply) {
		err = -ENOMEM;
		goto bail0;
	}
	err = c2_errno(reply);
	/*
	 * free vq stuff
	 */
	vq_repbuf_free(c2dev, reply);

 bail0:
	vq_req_free(c2dev, vq_req);
	return err;
}
Commit	Line	Data
f94b533d TT	1	/*
	2	* Copyright (c) 2005 Ammasso, Inc. All rights reserved.
	3	* Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
	4	*
	5	* This software is available to you under a choice of one of two
	6	* licenses. You may choose to be licensed under the terms of the GNU
	7	* General Public License (GPL) Version 2, available from the file
	8	* COPYING in the main directory of this source tree, or the
	9	* OpenIB.org BSD license below:
	10	*
	11	* Redistribution and use in source and binary forms, with or
	12	* without modification, are permitted provided that the following
	13	* conditions are met:
	14	*
	15	* - Redistributions of source code must retain the above
	16	* copyright notice, this list of conditions and the following
	17	* disclaimer.
	18	*
	19	* - Redistributions in binary form must reproduce the above
	20	* copyright notice, this list of conditions and the following
	21	* disclaimer in the documentation and/or other materials
	22	* provided with the distribution.
	23	*
	24	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	25	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	26	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	27	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	28	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	29	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	30	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	31	* SOFTWARE.
	32	*
	33	*/
	34	#include "c2.h"
	35	#include "c2_wr.h"
	36	#include "c2_vq.h"
	37	#include <rdma/iw_cm.h>
	38
	39	int c2_llp_connect(struct iw_cm_id cm_id, struct iw_cm_conn_param iw_param)
	40	{
	41	struct c2_dev *c2dev = to_c2dev(cm_id->device);
	42	struct ib_qp *ibqp;
	43	struct c2_qp *qp;
	44	struct c2wr_qp_connect_req wr; / variable size needs a malloc. */
	45	struct c2_vq_req *vq_req;
	46	int err;
	47
	48	ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
	49	if (!ibqp)
	50	return -EINVAL;
	51	qp = to_c2qp(ibqp);
	52
	53	/* Associate QP <--> CM_ID */
	54	cm_id->provider_data = qp;
	55	cm_id->add_ref(cm_id);
	56	qp->cm_id = cm_id;
	57
	58	/*
	59	* only support the max private_data length
	60	*/
	61	if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
	62	err = -EINVAL;
	63	goto bail0;
	64	}
65	/*
66	* Set the rdma read limits
67	*/
68	err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
69	if (err)
70	goto bail0;
71
72	/*
73	* Create and send a WR_QP_CONNECT...
74	*/
75	wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
76	if (!wr) {
77	err = -ENOMEM;
78	goto bail0;
79	}
80
81	vq_req = vq_req_alloc(c2dev);
82	if (!vq_req) {
83	err = -ENOMEM;
84	goto bail1;
85	}
86
87	c2_wr_set_id(wr, CCWR_QP_CONNECT);
88	wr->hdr.context = 0;
89	wr->rnic_handle = c2dev->adapter_handle;
90	wr->qp_handle = qp->adapter_handle;
91
92	wr->remote_addr = cm_id->remote_addr.sin_addr.s_addr;
93	wr->remote_port = cm_id->remote_addr.sin_port;
94
95	/*
96	* Move any private data from the callers's buf into
97	* the WR.
98	*/
99	if (iw_param->private_data) {
100	wr->private_data_length =
101	cpu_to_be32(iw_param->private_data_len);
102	memcpy(&wr->private_data[0], iw_param->private_data,
103	iw_param->private_data_len);
104	} else
105	wr->private_data_length = 0;
106
107	/*
108	* Send WR to adapter. NOTE: There is no synch reply from
109	* the adapter.
110	*/
111	err = vq_send_wr(c2dev, (union c2wr *) wr);
112	vq_req_free(c2dev, vq_req);
113
114	bail1:
115	kfree(wr);
116	bail0:
117	if (err) {
118	/*
119	* If we fail, release reference on QP and
120	* disassociate QP from CM_ID
121	*/
122	cm_id->provider_data = NULL;
123	qp->cm_id = NULL;
124	cm_id->rem_ref(cm_id);
125	}
126	return err;
127	}
128
129	int c2_llp_service_create(struct iw_cm_id *cm_id, int backlog)
130	{
131	struct c2_dev *c2dev;
132	struct c2wr_ep_listen_create_req wr;
133	struct c2wr_ep_listen_create_rep *reply;
134	struct c2_vq_req *vq_req;
135	int err;
136
137	c2dev = to_c2dev(cm_id->device);
138	if (c2dev == NULL)
139	return -EINVAL;
140
141	/*
142	* Allocate verbs request.
143	*/
144	vq_req = vq_req_alloc(c2dev);
145	if (!vq_req)
146	return -ENOMEM;
147
148	/*
149	* Build the WR
150	*/
151	c2_wr_set_id(&wr, CCWR_EP_LISTEN_CREATE);
152	wr.hdr.context = (u64) (unsigned long) vq_req;
153	wr.rnic_handle = c2dev->adapter_handle;
154	wr.local_addr = cm_id->local_addr.sin_addr.s_addr;
155	wr.local_port = cm_id->local_addr.sin_port;
156	wr.backlog = cpu_to_be32(backlog);
157	wr.user_context = (u64) (unsigned long) cm_id;
158
159	/*
160	* Reference the request struct. Dereferenced in the int handler.
161	*/
162	vq_req_get(c2dev, vq_req);
163
164	/*
165	* Send WR to adapter
166	*/
167	err = vq_send_wr(c2dev, (union c2wr *) & wr);
168	if (err) {
169	vq_req_put(c2dev, vq_req);
170	goto bail0;
171	}
172
173	/*
174	* Wait for reply from adapter
175	*/
176	err = vq_wait_for_reply(c2dev, vq_req);
177	if (err)
178	goto bail0;
179
180	/*
181	* Process reply
182	*/
183	reply =
184	(struct c2wr_ep_listen_create_rep *) (unsigned long) vq_req->reply_msg;
185	if (!reply) {
186	err = -ENOMEM;
187	goto bail1;
188	}
189
190	if ((err = c2_errno(reply)) != 0)
191	goto bail1;
192
193	/*
194	* Keep the adapter handle. Used in subsequent destroy
195	*/
196	cm_id->provider_data = (void*)(unsigned long) reply->ep_handle;
197
198	/*
199	* free vq stuff
200	*/
201	vq_repbuf_free(c2dev, reply);
202	vq_req_free(c2dev, vq_req);
203
204	return 0;
205
206	bail1:
207	vq_repbuf_free(c2dev, reply);
208	bail0:
209	vq_req_free(c2dev, vq_req);
210	return err;
211	}
212
213
214	int c2_llp_service_destroy(struct iw_cm_id *cm_id)
215	{
216
217	struct c2_dev *c2dev;
218	struct c2wr_ep_listen_destroy_req wr;
219	struct c2wr_ep_listen_destroy_rep *reply;
220	struct c2_vq_req *vq_req;
221	int err;
222
223	c2dev = to_c2dev(cm_id->device);
224	if (c2dev == NULL)
225	return -EINVAL;
226
227	/*
228	* Allocate verbs request.
229	*/
230	vq_req = vq_req_alloc(c2dev);
231	if (!vq_req)
232	return -ENOMEM;
233
234	/*
235	* Build the WR
236	*/
237	c2_wr_set_id(&wr, CCWR_EP_LISTEN_DESTROY);
238	wr.hdr.context = (unsigned long) vq_req;
239	wr.rnic_handle = c2dev->adapter_handle;
240	wr.ep_handle = (u32)(unsigned long)cm_id->provider_data;
241
242	/*
243	* reference the request struct. dereferenced in the int handler.
244	*/
245	vq_req_get(c2dev, vq_req);
246
247	/*
248	* Send WR to adapter
249	*/
250	err = vq_send_wr(c2dev, (union c2wr *) & wr);
251	if (err) {
252	vq_req_put(c2dev, vq_req);
253	goto bail0;
254	}
255
256	/*
257	* Wait for reply from adapter
258	*/
259	err = vq_wait_for_reply(c2dev, vq_req);
260	if (err)
261	goto bail0;
262
263	/*
264	* Process reply
265	*/
266	reply=(struct c2wr_ep_listen_destroy_rep *)(unsigned long)vq_req->reply_msg;
267	if (!reply) {
268	err = -ENOMEM;
269	goto bail0;
270	}
271	if ((err = c2_errno(reply)) != 0)
272	goto bail1;
273
274	bail1:
275	vq_repbuf_free(c2dev, reply);
276	bail0:
277	vq_req_free(c2dev, vq_req);
278	return err;
279	}
280
281	int c2_llp_accept(struct iw_cm_id cm_id, struct iw_cm_conn_param iw_param)
282	{
283	struct c2_dev *c2dev = to_c2dev(cm_id->device);
284	struct c2_qp *qp;
285	struct ib_qp *ibqp;
286	struct c2wr_cr_accept_req wr; / variable length WR */
287	struct c2_vq_req *vq_req;
288	struct c2wr_cr_accept_rep reply; / VQ Reply msg ptr. */
289	int err;
290
291	ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
292	if (!ibqp)
293	return -EINVAL;
294	qp = to_c2qp(ibqp);
295
296	/* Set the RDMA read limits */
297	err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
298	if (err)
299	goto bail0;
300
301	/* Allocate verbs request. */
302	vq_req = vq_req_alloc(c2dev);
303	if (!vq_req) {
304	err = -ENOMEM;
44334bd9	305	goto bail0;
f94b533d TT	306	}
	307	vq_req->qp = qp;
	308	vq_req->cm_id = cm_id;
	309	vq_req->event = IW_CM_EVENT_ESTABLISHED;
	310
	311	wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
	312	if (!wr) {
	313	err = -ENOMEM;
44334bd9	314	goto bail1;
f94b533d TT	315	}
	316
	317	/* Build the WR */
	318	c2_wr_set_id(wr, CCWR_CR_ACCEPT);
	319	wr->hdr.context = (unsigned long) vq_req;
	320	wr->rnic_handle = c2dev->adapter_handle;
	321	wr->ep_handle = (u32) (unsigned long) cm_id->provider_data;
	322	wr->qp_handle = qp->adapter_handle;
	323
	324	/* Replace the cr_handle with the QP after accept */
	325	cm_id->provider_data = qp;
	326	cm_id->add_ref(cm_id);
	327	qp->cm_id = cm_id;
	328
	329	cm_id->provider_data = qp;
	330
	331	/* Validate private_data length */
	332	if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
	333	err = -EINVAL;
44334bd9	334	goto bail1;
f94b533d TT	335	}
	336
	337	if (iw_param->private_data) {
	338	wr->private_data_length = cpu_to_be32(iw_param->private_data_len);
	339	memcpy(&wr->private_data[0],
	340	iw_param->private_data, iw_param->private_data_len);
	341	} else
	342	wr->private_data_length = 0;
	343
	344	/* Reference the request struct. Dereferenced in the int handler. */
	345	vq_req_get(c2dev, vq_req);
	346
	347	/* Send WR to adapter */
	348	err = vq_send_wr(c2dev, (union c2wr *) wr);
	349	if (err) {
	350	vq_req_put(c2dev, vq_req);
44334bd9	351	goto bail1;
f94b533d TT	352	}
	353
	354	/* Wait for reply from adapter */
	355	err = vq_wait_for_reply(c2dev, vq_req);
	356	if (err)
44334bd9	357	goto bail1;
f94b533d TT	358
	359	/* Check that reply is present */
	360	reply = (struct c2wr_cr_accept_rep *) (unsigned long) vq_req->reply_msg;
	361	if (!reply) {
	362	err = -ENOMEM;
44334bd9	363	goto bail1;
f94b533d TT	364	}
	365
	366	err = c2_errno(reply);
	367	vq_repbuf_free(c2dev, reply);
	368
	369	if (!err)
	370	c2_set_qp_state(qp, C2_QP_STATE_RTS);
f94b533d	371	bail1:
44334bd9	372	kfree(wr);
f94b533d TT	373	vq_req_free(c2dev, vq_req);
	374	bail0:
	375	if (err) {
	376	/*
	377	* If we fail, release reference on QP and
	378	* disassociate QP from CM_ID
	379	*/
	380	cm_id->provider_data = NULL;
	381	qp->cm_id = NULL;
	382	cm_id->rem_ref(cm_id);
	383	}
	384	return err;
	385	}
	386
	387	int c2_llp_reject(struct iw_cm_id cm_id, const void pdata, u8 pdata_len)
	388	{
	389	struct c2_dev *c2dev;
	390	struct c2wr_cr_reject_req wr;
	391	struct c2_vq_req *vq_req;
	392	struct c2wr_cr_reject_rep *reply;
	393	int err;
	394
	395	c2dev = to_c2dev(cm_id->device);
	396
	397	/*
	398	* Allocate verbs request.
	399	*/
	400	vq_req = vq_req_alloc(c2dev);
	401	if (!vq_req)
	402	return -ENOMEM;
	403
	404	/*
	405	* Build the WR
	406	*/
	407	c2_wr_set_id(&wr, CCWR_CR_REJECT);
	408	wr.hdr.context = (unsigned long) vq_req;
	409	wr.rnic_handle = c2dev->adapter_handle;
	410	wr.ep_handle = (u32) (unsigned long) cm_id->provider_data;
	411
	412	/*
	413	* reference the request struct. dereferenced in the int handler.
	414	*/
	415	vq_req_get(c2dev, vq_req);
	416
	417	/*
	418	* Send WR to adapter
	419	*/
	420	err = vq_send_wr(c2dev, (union c2wr *) & wr);
	421	if (err) {
	422	vq_req_put(c2dev, vq_req);
	423	goto bail0;
	424	}
	425
	426	/*
	427	* Wait for reply from adapter
	428	*/
	429	err = vq_wait_for_reply(c2dev, vq_req);
	430	if (err)
	431	goto bail0;
	432
	433	/*
	434	* Process reply
	435	*/
	436	reply = (struct c2wr_cr_reject_rep *) (unsigned long)
437	vq_req->reply_msg;
438	if (!reply) {
439	err = -ENOMEM;
440	goto bail0;
441	}
442	err = c2_errno(reply);
443	/*
444	* free vq stuff
445	*/
446	vq_repbuf_free(c2dev, reply);
447
448	bail0:
449	vq_req_free(c2dev, vq_req);
450	return err;
451	}