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