[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 <linux/slab.h>

#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;
	struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr;

	if (cm_id->remote_addr.ss_family != AF_INET)
		return -ENOSYS;

	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 = raddr->sin_addr.s_addr;
	wr->remote_port = raddr->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;
	struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr;

	if (cm_id->local_addr.ss_family != AF_INET)
		return -ENOSYS;

	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 = laddr->sin_addr.s_addr;
	wr.local_port = laddr->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	*/
5a0e3ad6 TH	34	#include <linux/slab.h>
5a0e3ad6 TH	35
f94b533d TT	36	#include "c2.h"
	37	#include "c2_wr.h"
	38	#include "c2_vq.h"
	39	#include <rdma/iw_cm.h>
	40
	41	int c2_llp_connect(struct iw_cm_id cm_id, struct iw_cm_conn_param iw_param)
	42	{
	43	struct c2_dev *c2dev = to_c2dev(cm_id->device);
	44	struct ib_qp *ibqp;
	45	struct c2_qp *qp;
	46	struct c2wr_qp_connect_req wr; / variable size needs a malloc. */
	47	struct c2_vq_req *vq_req;
	48	int err;
24d44a39 SW	49	struct sockaddr_in raddr = (struct sockaddr_in )&cm_id->remote_addr;
	50
	51	if (cm_id->remote_addr.ss_family != AF_INET)
	52	return -ENOSYS;
f94b533d TT	53
	54	ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
	55	if (!ibqp)
	56	return -EINVAL;
	57	qp = to_c2qp(ibqp);
	58
	59	/* Associate QP <--> CM_ID */
	60	cm_id->provider_data = qp;
	61	cm_id->add_ref(cm_id);
	62	qp->cm_id = cm_id;
	63
	64	/*
	65	* only support the max private_data length
	66	*/
	67	if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
	68	err = -EINVAL;
	69	goto bail0;
	70	}
	71	/*
	72	* Set the rdma read limits
	73	*/
	74	err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
	75	if (err)
	76	goto bail0;
	77
	78	/*
	79	* Create and send a WR_QP_CONNECT...
	80	*/
	81	wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
	82	if (!wr) {
	83	err = -ENOMEM;
	84	goto bail0;
	85	}
	86
	87	vq_req = vq_req_alloc(c2dev);
	88	if (!vq_req) {
	89	err = -ENOMEM;
	90	goto bail1;
	91	}
	92
	93	c2_wr_set_id(wr, CCWR_QP_CONNECT);
	94	wr->hdr.context = 0;
	95	wr->rnic_handle = c2dev->adapter_handle;
	96	wr->qp_handle = qp->adapter_handle;
	97
24d44a39 SW	98	wr->remote_addr = raddr->sin_addr.s_addr;
24d44a39 SW	99	wr->remote_port = raddr->sin_port;
f94b533d TT	100
	101	/*
	102	* Move any private data from the callers's buf into
	103	* the WR.
	104	*/
	105	if (iw_param->private_data) {
	106	wr->private_data_length =
	107	cpu_to_be32(iw_param->private_data_len);
	108	memcpy(&wr->private_data[0], iw_param->private_data,
	109	iw_param->private_data_len);
	110	} else
	111	wr->private_data_length = 0;
	112
	113	/*
	114	* Send WR to adapter. NOTE: There is no synch reply from
	115	* the adapter.
	116	*/
	117	err = vq_send_wr(c2dev, (union c2wr *) wr);
	118	vq_req_free(c2dev, vq_req);
	119
	120	bail1:
	121	kfree(wr);
	122	bail0:
	123	if (err) {
	124	/*
	125	* If we fail, release reference on QP and
	126	* disassociate QP from CM_ID
	127	*/
	128	cm_id->provider_data = NULL;
	129	qp->cm_id = NULL;
	130	cm_id->rem_ref(cm_id);
	131	}
	132	return err;
	133	}
	134
	135	int c2_llp_service_create(struct iw_cm_id *cm_id, int backlog)
	136	{
	137	struct c2_dev *c2dev;
	138	struct c2wr_ep_listen_create_req wr;
	139	struct c2wr_ep_listen_create_rep *reply;
	140	struct c2_vq_req *vq_req;
	141	int err;
24d44a39 SW	142	struct sockaddr_in laddr = (struct sockaddr_in )&cm_id->local_addr;
	143
	144	if (cm_id->local_addr.ss_family != AF_INET)
	145	return -ENOSYS;
f94b533d TT	146
	147	c2dev = to_c2dev(cm_id->device);
	148	if (c2dev == NULL)
	149	return -EINVAL;
	150
	151	/*
	152	* Allocate verbs request.
	153	*/
	154	vq_req = vq_req_alloc(c2dev);
	155	if (!vq_req)
	156	return -ENOMEM;
	157
	158	/*
	159	* Build the WR
	160	*/
	161	c2_wr_set_id(&wr, CCWR_EP_LISTEN_CREATE);
	162	wr.hdr.context = (u64) (unsigned long) vq_req;
	163	wr.rnic_handle = c2dev->adapter_handle;
24d44a39 SW	164	wr.local_addr = laddr->sin_addr.s_addr;
24d44a39 SW	165	wr.local_port = laddr->sin_port;
f94b533d TT	166	wr.backlog = cpu_to_be32(backlog);
	167	wr.user_context = (u64) (unsigned long) cm_id;
	168
	169	/*
	170	* Reference the request struct. Dereferenced in the int handler.
	171	*/
	172	vq_req_get(c2dev, vq_req);
	173
	174	/*
	175	* Send WR to adapter
	176	*/
	177	err = vq_send_wr(c2dev, (union c2wr *) & wr);
	178	if (err) {
	179	vq_req_put(c2dev, vq_req);
	180	goto bail0;
	181	}
	182
	183	/*
	184	* Wait for reply from adapter
	185	*/
	186	err = vq_wait_for_reply(c2dev, vq_req);
	187	if (err)
	188	goto bail0;
	189
	190	/*
	191	* Process reply
	192	*/
	193	reply =
	194	(struct c2wr_ep_listen_create_rep *) (unsigned long) vq_req->reply_msg;
	195	if (!reply) {
	196	err = -ENOMEM;
	197	goto bail1;
	198	}
	199
	200	if ((err = c2_errno(reply)) != 0)
	201	goto bail1;
	202
	203	/*
	204	* Keep the adapter handle. Used in subsequent destroy
	205	*/
	206	cm_id->provider_data = (void*)(unsigned long) reply->ep_handle;
	207
	208	/*
	209	* free vq stuff
	210	*/
	211	vq_repbuf_free(c2dev, reply);
	212	vq_req_free(c2dev, vq_req);
	213
	214	return 0;
	215
	216	bail1:
	217	vq_repbuf_free(c2dev, reply);
	218	bail0:
	219	vq_req_free(c2dev, vq_req);
	220	return err;
	221	}
	222
	223
	224	int c2_llp_service_destroy(struct iw_cm_id *cm_id)
	225	{
	226
	227	struct c2_dev *c2dev;
	228	struct c2wr_ep_listen_destroy_req wr;
	229	struct c2wr_ep_listen_destroy_rep *reply;
230	struct c2_vq_req *vq_req;
231	int err;
232
233	c2dev = to_c2dev(cm_id->device);
234	if (c2dev == NULL)
235	return -EINVAL;
236
237	/*
238	* Allocate verbs request.
239	*/
240	vq_req = vq_req_alloc(c2dev);
241	if (!vq_req)
242	return -ENOMEM;
243
244	/*
245	* Build the WR
246	*/
247	c2_wr_set_id(&wr, CCWR_EP_LISTEN_DESTROY);
248	wr.hdr.context = (unsigned long) vq_req;
249	wr.rnic_handle = c2dev->adapter_handle;
250	wr.ep_handle = (u32)(unsigned long)cm_id->provider_data;
251
252	/*
253	* reference the request struct. dereferenced in the int handler.
254	*/
255	vq_req_get(c2dev, vq_req);
256
257	/*
258	* Send WR to adapter
259	*/
260	err = vq_send_wr(c2dev, (union c2wr *) & wr);
261	if (err) {
262	vq_req_put(c2dev, vq_req);
263	goto bail0;
264	}
265
266	/*
267	* Wait for reply from adapter
268	*/
269	err = vq_wait_for_reply(c2dev, vq_req);
270	if (err)
271	goto bail0;
272
273	/*
274	* Process reply
275	*/
276	reply=(struct c2wr_ep_listen_destroy_rep *)(unsigned long)vq_req->reply_msg;
277	if (!reply) {
278	err = -ENOMEM;
279	goto bail0;
280	}
281	if ((err = c2_errno(reply)) != 0)
282	goto bail1;
283
284	bail1:
285	vq_repbuf_free(c2dev, reply);
286	bail0:
287	vq_req_free(c2dev, vq_req);
288	return err;
289	}
290
291	int c2_llp_accept(struct iw_cm_id cm_id, struct iw_cm_conn_param iw_param)
292	{
293	struct c2_dev *c2dev = to_c2dev(cm_id->device);
294	struct c2_qp *qp;
295	struct ib_qp *ibqp;
296	struct c2wr_cr_accept_req wr; / variable length WR */
297	struct c2_vq_req *vq_req;
298	struct c2wr_cr_accept_rep reply; / VQ Reply msg ptr. */
299	int err;
300
301	ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
302	if (!ibqp)
303	return -EINVAL;
304	qp = to_c2qp(ibqp);
305
306	/* Set the RDMA read limits */
307	err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
308	if (err)
309	goto bail0;
310
311	/* Allocate verbs request. */
312	vq_req = vq_req_alloc(c2dev);
313	if (!vq_req) {
314	err = -ENOMEM;
44334bd9	315	goto bail0;
f94b533d TT	316	}
	317	vq_req->qp = qp;
	318	vq_req->cm_id = cm_id;
	319	vq_req->event = IW_CM_EVENT_ESTABLISHED;
	320
	321	wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
	322	if (!wr) {
	323	err = -ENOMEM;
44334bd9	324	goto bail1;
f94b533d TT	325	}
	326
	327	/* Build the WR */
	328	c2_wr_set_id(wr, CCWR_CR_ACCEPT);
	329	wr->hdr.context = (unsigned long) vq_req;
	330	wr->rnic_handle = c2dev->adapter_handle;
	331	wr->ep_handle = (u32) (unsigned long) cm_id->provider_data;
	332	wr->qp_handle = qp->adapter_handle;
	333
	334	/* Replace the cr_handle with the QP after accept */
	335	cm_id->provider_data = qp;
	336	cm_id->add_ref(cm_id);
	337	qp->cm_id = cm_id;
	338
	339	cm_id->provider_data = qp;
	340
	341	/* Validate private_data length */
	342	if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
	343	err = -EINVAL;
44334bd9	344	goto bail1;
f94b533d TT	345	}
	346
	347	if (iw_param->private_data) {
	348	wr->private_data_length = cpu_to_be32(iw_param->private_data_len);
	349	memcpy(&wr->private_data[0],
	350	iw_param->private_data, iw_param->private_data_len);
	351	} else
	352	wr->private_data_length = 0;
	353
	354	/* Reference the request struct. Dereferenced in the int handler. */
	355	vq_req_get(c2dev, vq_req);
	356
	357	/* Send WR to adapter */
	358	err = vq_send_wr(c2dev, (union c2wr *) wr);
	359	if (err) {
	360	vq_req_put(c2dev, vq_req);
44334bd9	361	goto bail1;
f94b533d TT	362	}
	363
	364	/* Wait for reply from adapter */
	365	err = vq_wait_for_reply(c2dev, vq_req);
	366	if (err)
44334bd9	367	goto bail1;
f94b533d TT	368
	369	/* Check that reply is present */
	370	reply = (struct c2wr_cr_accept_rep *) (unsigned long) vq_req->reply_msg;
	371	if (!reply) {
	372	err = -ENOMEM;
44334bd9	373	goto bail1;
f94b533d TT	374	}
	375
	376	err = c2_errno(reply);
	377	vq_repbuf_free(c2dev, reply);
	378
	379	if (!err)
	380	c2_set_qp_state(qp, C2_QP_STATE_RTS);
f94b533d	381	bail1:
44334bd9	382	kfree(wr);
f94b533d TT	383	vq_req_free(c2dev, vq_req);
	384	bail0:
	385	if (err) {
	386	/*
	387	* If we fail, release reference on QP and
	388	* disassociate QP from CM_ID
	389	*/
	390	cm_id->provider_data = NULL;
	391	qp->cm_id = NULL;
	392	cm_id->rem_ref(cm_id);
	393	}
	394	return err;
	395	}
	396
	397	int c2_llp_reject(struct iw_cm_id cm_id, const void pdata, u8 pdata_len)
	398	{
	399	struct c2_dev *c2dev;
	400	struct c2wr_cr_reject_req wr;
	401	struct c2_vq_req *vq_req;
	402	struct c2wr_cr_reject_rep *reply;
	403	int err;
	404
	405	c2dev = to_c2dev(cm_id->device);
	406
	407	/*
	408	* Allocate verbs request.
	409	*/
	410	vq_req = vq_req_alloc(c2dev);
	411	if (!vq_req)
	412	return -ENOMEM;
	413
	414	/*
	415	* Build the WR
	416	*/
	417	c2_wr_set_id(&wr, CCWR_CR_REJECT);
	418	wr.hdr.context = (unsigned long) vq_req;
	419	wr.rnic_handle = c2dev->adapter_handle;
	420	wr.ep_handle = (u32) (unsigned long) cm_id->provider_data;
	421
	422	/*
	423	* reference the request struct. dereferenced in the int handler.
	424	*/
	425	vq_req_get(c2dev, vq_req);
	426
	427	/*
	428	* Send WR to adapter
	429	*/
	430	err = vq_send_wr(c2dev, (union c2wr *) & wr);
	431	if (err) {
	432	vq_req_put(c2dev, vq_req);
	433	goto bail0;
	434	}
	435
	436	/*
	437	* Wait for reply from adapter
	438	*/
	439	err = vq_wait_for_reply(c2dev, vq_req);
	440	if (err)
	441	goto bail0;
	442
	443	/*
	444	* Process reply
	445	*/
	446	reply = (struct c2wr_cr_reject_rep *) (unsigned long)
447	vq_req->reply_msg;
448	if (!reply) {
449	err = -ENOMEM;
450	goto bail0;
451	}
452	err = c2_errno(reply);
453	/*
454	* free vq stuff
455	*/
456	vq_repbuf_free(c2dev, reply);
457
458	bail0:
459	vq_req_free(c2dev, vq_req);
460	return err;
461	}