9cf8444931e68b6f3c9288e07dc294db199812af
[mirror/winof/.git] / core / al / kernel / al_proxy_ndi.c
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. \r
4  * Portions Copyright (c) 2008 Microsoft Corporation.  All rights reserved.\r
5  *\r
6  * This software is available to you under the OpenIB.org BSD license\r
7  * below:\r
8  *\r
9  *     Redistribution and use in source and binary forms, with or\r
10  *     without modification, are permitted provided that the following\r
11  *     conditions are met:\r
12  *\r
13  *      - Redistributions of source code must retain the above\r
14  *        copyright notice, this list of conditions and the following\r
15  *        disclaimer.\r
16  *\r
17  *      - Redistributions in binary form must reproduce the above\r
18  *        copyright notice, this list of conditions and the following\r
19  *        disclaimer in the documentation and/or other materials\r
20  *        provided with the distribution.\r
21  *\r
22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
25  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
26  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
27  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
28  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
29  * SOFTWARE.\r
30  *\r
31  * $Id: al_proxy_verbs.c 548 2006-11-27 20:03:51Z leonidk $\r
32  */\r
33 \r
34 \r
35 #include <complib/comp_lib.h>\r
36 #include <iba/ib_al.h>\r
37 #include <iba/ib_al_ioctl.h>\r
38 #include "al.h"\r
39 #include "al_qp.h"\r
40 #include "al_debug.h"\r
41 #include "al_cm_cep.h"\r
42 \r
43 #if defined(EVENT_TRACING)\r
44 #ifdef offsetof\r
45 #undef offsetof\r
46 #endif\r
47 #include "al_proxy_ndi.tmh"\r
48 #endif\r
49 \r
50 #include "al_dev.h"\r
51 /* Get the internal definitions of apis for the proxy */\r
52 #include "al_ca.h"\r
53 #include "ib_common.h"\r
54 #include "al_proxy_ndi.h"\r
55 #include "al_ndi_cm.h"\r
56 \r
57 /*******************************************************************\r
58  *\r
59  * IOCTLS\r
60  *\r
61  ******************************************************************/\r
62 \r
63 /*\r
64  * Process the ioctl UAL_NDI_CREATE_CQ:\r
65  */\r
66 static cl_status_t\r
67 __ndi_create_cq(\r
68         IN              void                                    *p_open_context,\r
69         IN              cl_ioctl_handle_t               h_ioctl,\r
70                 OUT     size_t                                  *p_ret_bytes )\r
71 {\r
72         ual_create_cq_ioctl_t   *p_ioctl =\r
73                 (ual_create_cq_ioctl_t *)cl_ioctl_in_buf( h_ioctl );\r
74         al_dev_open_context_t   *p_context =\r
75                 (al_dev_open_context_t *)p_open_context;\r
76         ib_ca_handle_t                  h_ca;\r
77         ib_cq_handle_t                  h_cq;\r
78         ib_cq_create_t                  cq_create;\r
79         ci_umv_buf_t                    *p_umv_buf = NULL;\r
80         ib_api_status_t                 status;\r
81         ib_pfn_event_cb_t               pfn_ev;\r
82 \r
83         AL_ENTER( AL_DBG_NDI );\r
84 \r
85         /* Validate input buffers. */\r
86         if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
87                 cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
88                 cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
89         {\r
90                 status = CL_INVALID_PARAMETER;\r
91                 goto exit;\r
92         }\r
93 \r
94         /* Validate CA handle */\r
95         h_ca = (ib_ca_handle_t)\r
96                 al_hdl_ref( p_context->h_al, p_ioctl->in.h_ca, AL_OBJ_TYPE_H_CA );\r
97         if( !h_ca )\r
98         {\r
99                 status = IB_INVALID_CA_HANDLE;\r
100                 goto proxy_create_cq_err1;\r
101         }\r
102 \r
103         cq_create.size = p_ioctl->in.size;\r
104 \r
105         /* Override with proxy's cq callback */\r
106         cq_create.pfn_comp_cb = ndi_cq_compl_cb;\r
107         cq_create.h_wait_obj = NULL;\r
108         pfn_ev = ndi_cq_error_cb;\r
109 \r
110         status = cpyin_umvbuf( &p_ioctl->in.umv_buf, &p_umv_buf );\r
111         if( status != IB_SUCCESS )\r
112                 goto proxy_create_cq_err2;\r
113 \r
114         status = create_cq( h_ca, &cq_create,\r
115                 (void*)(ULONG_PTR)p_ioctl->in.context, pfn_ev, &h_cq, p_umv_buf );\r
116 \r
117         if( status != IB_SUCCESS )\r
118                 goto proxy_create_cq_err2;\r
119 \r
120         status = cpyout_umvbuf( &p_ioctl->out.umv_buf, p_umv_buf );\r
121         if( status == IB_SUCCESS )\r
122         {\r
123                 p_ioctl->out.size = cq_create.size;\r
124                 p_ioctl->out.h_cq = h_cq->obj.hdl;\r
125                 h_cq->obj.hdl_valid = TRUE;\r
126                 deref_al_obj( &h_cq->obj );\r
127         }\r
128         else\r
129         {\r
130                 h_cq->obj.pfn_destroy( &h_cq->obj, NULL );\r
131 \r
132 proxy_create_cq_err2:\r
133                 cl_waitobj_deref( cq_create.h_wait_obj );\r
134 \r
135 proxy_create_cq_err1:\r
136                 p_ioctl->out.umv_buf = p_ioctl->in.umv_buf;\r
137                 p_ioctl->out.h_cq = AL_INVALID_HANDLE;\r
138                 p_ioctl->out.size = 0;\r
139         }\r
140         free_umvbuf( p_umv_buf );\r
141 \r
142         if( h_ca )\r
143                 deref_al_obj( &h_ca->obj );\r
144 \r
145         p_ioctl->out.status = status;\r
146         *p_ret_bytes = sizeof(p_ioctl->out);\r
147 \r
148 exit:\r
149         AL_EXIT( AL_DBG_NDI );\r
150         return CL_SUCCESS;\r
151 }\r
152 \r
153 \r
154 static cl_status_t\r
155 __ndi_notify_cq(\r
156         IN              void                                    *p_open_context,\r
157         IN              cl_ioctl_handle_t               h_ioctl,\r
158                 OUT     size_t                                  *p_ret_bytes )\r
159 {\r
160         cl_status_t cl_status;\r
161         ual_ndi_notify_cq_ioctl_in_t *p_ioctl;\r
162         al_dev_open_context_t *p_context;\r
163         ib_cq_handle_t h_cq;\r
164         UNUSED_PARAM(p_ret_bytes);\r
165         \r
166         AL_ENTER( AL_DBG_NDI );\r
167 \r
168         p_context = (al_dev_open_context_t*)p_open_context;\r
169         p_ioctl = (ual_ndi_notify_cq_ioctl_in_t*)cl_ioctl_in_buf( h_ioctl );\r
170 \r
171         /* Validate user parameters. */\r
172         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_ndi_notify_cq_ioctl_in_t) )\r
173         {\r
174                 cl_status = CL_INVALID_PARAMETER;\r
175                 goto exit;\r
176         }\r
177 \r
178         /* Validate CQ handle */\r
179         h_cq = (ib_cq_handle_t)\r
180                 al_hdl_ref( p_context->h_al, p_ioctl->h_cq, AL_OBJ_TYPE_H_CQ );\r
181         if( !h_cq )\r
182         {\r
183                 cl_status = CL_INVALID_HANDLE;\r
184                 goto exit;\r
185         }\r
186 \r
187         /* enqueue the IRP (h_cq is referenced in al_hdl_ref) */\r
188         if (p_ioctl->notify_comps)\r
189                 IoCsqInsertIrp( &h_cq->compl.csq, h_ioctl, NULL );\r
190         else\r
191                 IoCsqInsertIrp( &h_cq->error.csq, h_ioctl, NULL );\r
192 \r
193         cl_status = CL_PENDING;\r
194 \r
195 exit:\r
196         AL_EXIT( AL_DBG_NDI );\r
197         return cl_status;\r
198 }\r
199 \r
200 static cl_status_t\r
201 __ndi_cancel_cq(\r
202         IN              void                                    *p_open_context,\r
203         IN              cl_ioctl_handle_t               h_ioctl,\r
204                 OUT     size_t                                  *p_ret_bytes )\r
205 {\r
206         cl_status_t cl_status;\r
207         ib_cq_handle_t h_cq = NULL;\r
208         al_dev_open_context_t *p_context;\r
209         UNUSED_PARAM(p_ret_bytes);\r
210         \r
211         AL_ENTER( AL_DBG_NDI );\r
212 \r
213         p_context = (al_dev_open_context_t*)p_open_context;\r
214 \r
215         /* Validate user parameters. */\r
216         if( cl_ioctl_in_size( h_ioctl ) != sizeof(uint64_t) )\r
217         {\r
218                 cl_status = CL_INVALID_PARAMETER;\r
219                 goto exit;\r
220         }\r
221 \r
222         /* Validate CQ handle */\r
223         h_cq = (ib_cq_handle_t)\r
224                 al_hdl_ref( p_context->h_al, \r
225                         *(uint64_t*)cl_ioctl_in_buf( h_ioctl ), AL_OBJ_TYPE_H_CQ );\r
226         if( !h_cq )\r
227         {\r
228                 cl_status = CL_INVALID_HANDLE;\r
229                 goto exit;\r
230         }\r
231 \r
232         /* flush IRP queues */\r
233         ndi_cq_flush_ques( h_cq );\r
234 \r
235         cl_status = CL_SUCCESS;\r
236         deref_al_obj( &h_cq->obj );\r
237 \r
238 exit:\r
239         AL_EXIT( AL_DBG_NDI );\r
240         return cl_status;\r
241 }\r
242 \r
243 static cl_status_t\r
244 __ndi_modify_qp(\r
245         IN              void                                    *p_open_context,\r
246         IN              cl_ioctl_handle_t               h_ioctl,\r
247                 OUT     size_t                                  *p_ret_bytes )\r
248 {\r
249         cl_status_t cl_status;\r
250         ib_api_status_t status;\r
251         ib_qp_handle_t h_qp = NULL;\r
252         al_dev_open_context_t *p_context;\r
253         ual_ndi_modify_qp_ioctl_in_t *p_req = \r
254                 (ual_ndi_modify_qp_ioctl_in_t*)cl_ioctl_in_buf( h_ioctl );\r
255 \r
256         UNUSED_PARAM(p_ret_bytes);\r
257         \r
258         AL_ENTER( AL_DBG_NDI );\r
259 \r
260         p_context = (al_dev_open_context_t*)p_open_context;\r
261 \r
262         /* Validate user parameters. */\r
263         if( cl_ioctl_in_size( h_ioctl ) < sizeof(ual_ndi_modify_qp_ioctl_in_t))\r
264         {\r
265                 cl_status = CL_INVALID_PARAMETER;\r
266                 goto exit;\r
267         }\r
268 \r
269         /* Validate QP handle */\r
270         h_qp = (ib_qp_handle_t)al_hdl_ref( p_context->h_al, p_req->h_qp, AL_OBJ_TYPE_H_QP );\r
271         if( !h_qp )\r
272         {\r
273                 cl_status = CL_INVALID_HANDLE;\r
274                 goto exit;\r
275         }\r
276 \r
277         /* Check QP type */\r
278         if( h_qp->type != IB_QPT_RELIABLE_CONN )\r
279         {\r
280                 cl_status = CL_INVALID_HANDLE;\r
281                 goto err;\r
282         }\r
283 \r
284         /* perform the ioctl */\r
285         status = ndi_modify_qp( h_qp, &p_req->qp_mod, \r
286                 cl_ioctl_out_size( h_ioctl ), cl_ioctl_out_buf( h_ioctl ) );\r
287         if ( status != IB_SUCCESS )\r
288         {\r
289                 AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
290                         ("ndi_modify_qp returned %s.\n", ib_get_err_str(status) ) );\r
291                 cl_status = CL_ERROR;\r
292         }\r
293         else\r
294         {\r
295                 cl_status = CL_SUCCESS;\r
296                 *p_ret_bytes = cl_ioctl_out_size( h_ioctl );\r
297         }\r
298 \r
299 err:\r
300         deref_al_obj( &h_qp->obj );\r
301 \r
302 exit:\r
303         AL_EXIT( AL_DBG_NDI );\r
304         return cl_status;\r
305 }\r
306 \r
307 static cl_status_t\r
308 __ndi_req_cm(\r
309         IN              void                                    *p_open_context,\r
310         IN              cl_ioctl_handle_t               h_ioctl,\r
311                 OUT     size_t                                  *p_ret_bytes )\r
312 {\r
313         cl_status_t cl_status;\r
314         ib_qp_handle_t h_qp = NULL;\r
315         al_dev_open_context_t *p_context;\r
316         ual_ndi_req_cm_ioctl_in_t *p_req = \r
317                 (ual_ndi_req_cm_ioctl_in_t*)cl_ioctl_in_buf( h_ioctl );\r
318         UNUSED_PARAM(p_ret_bytes);\r
319         \r
320         AL_ENTER( AL_DBG_NDI );\r
321 \r
322         p_context = (al_dev_open_context_t*)p_open_context;\r
323 \r
324         /* Validate user parameters. */\r
325         if( cl_ioctl_in_size( h_ioctl ) < sizeof(ual_ndi_req_cm_ioctl_in_t))\r
326         {\r
327                 cl_status = CL_INVALID_PARAMETER;\r
328                 goto exit;\r
329         }\r
330 \r
331         /* Validate QP handle */\r
332         h_qp = (ib_qp_handle_t)al_hdl_ref( p_context->h_al, p_req->h_qp, AL_OBJ_TYPE_H_QP );\r
333         if( !h_qp )\r
334         {\r
335                 cl_status = CL_INVALID_HANDLE;\r
336                 goto exit;\r
337         }\r
338 \r
339         /* Check QP type */\r
340         if( h_qp->type != IB_QPT_RELIABLE_CONN )\r
341         {\r
342                 cl_status = CL_INVALID_HANDLE;\r
343                 goto err;\r
344         }\r
345 \r
346         /* Check psize */\r
347         if ( p_req->pdata_size > sizeof(p_req->pdata) )\r
348         {\r
349                 cl_status = CL_INVALID_PARAMETER;\r
350                 goto err;\r
351         }\r
352 \r
353         /* perform the ioctl */\r
354         cl_status = ndi_req_cm( h_qp, h_ioctl );\r
355 \r
356 err:\r
357         deref_al_obj( &h_qp->obj );\r
358 \r
359 exit:\r
360         AL_EXIT( AL_DBG_NDI );\r
361         return cl_status;\r
362 }\r
363 \r
364 static cl_status_t\r
365 __ndi_rep_cm(\r
366         IN              void                                    *p_open_context,\r
367         IN              cl_ioctl_handle_t               h_ioctl,\r
368                 OUT     size_t                                  *p_ret_bytes )\r
369 {\r
370         cl_status_t cl_status;\r
371         ib_qp_handle_t h_qp = NULL;\r
372         al_dev_open_context_t *p_context;\r
373         net32_t cid;\r
374         ual_ndi_rep_cm_ioctl_in_t *p_rep = \r
375                 (ual_ndi_rep_cm_ioctl_in_t*)cl_ioctl_in_buf( h_ioctl );\r
376         UNUSED_PARAM(p_ret_bytes);\r
377 \r
378         AL_ENTER( AL_DBG_NDI );\r
379 \r
380         p_context = (al_dev_open_context_t*)p_open_context;\r
381 \r
382         /* Validate user parameters. */\r
383         if( (cl_ioctl_in_size( h_ioctl ) < sizeof(ual_ndi_rep_cm_ioctl_in_t)) )\r
384         {\r
385                 cl_status = CL_INVALID_PARAMETER;\r
386                 goto exit;\r
387         }\r
388 \r
389         /* Get and validate QP handle */\r
390         h_qp = (ib_qp_handle_t)al_hdl_ref( p_context->h_al, p_rep->h_qp, AL_OBJ_TYPE_H_QP );\r
391         if( !h_qp )\r
392         {\r
393                 cl_status = CL_INVALID_HANDLE;\r
394                 goto exit;\r
395         }\r
396 \r
397         if( h_qp->type != IB_QPT_RELIABLE_CONN )\r
398         {\r
399                 cl_status = CL_INVALID_HANDLE;\r
400                 goto err;\r
401         }\r
402 \r
403         /* Check psize */\r
404         if ( p_rep->pdata_size >= sizeof(p_rep->pdata) )\r
405         {\r
406                 cl_status = CL_INVALID_PARAMETER;\r
407                 goto err;\r
408         }\r
409         \r
410         /* Get and validate CID */\r
411         cid = p_rep->cid;\r
412 \r
413         /* perform the ioctls */\r
414         cl_status = ndi_rep_cm( h_qp, h_ioctl );\r
415 \r
416 err:\r
417         deref_al_obj( &h_qp->obj );\r
418 \r
419 exit:\r
420         AL_EXIT( AL_DBG_NDI );\r
421         return cl_status;\r
422 }\r
423 \r
424 \r
425 static cl_status_t\r
426 __ndi_rej_cm(\r
427         IN              void                                    *p_open_context,\r
428         IN              cl_ioctl_handle_t               h_ioctl,\r
429                 OUT     size_t                                  *p_ret_bytes )\r
430 {\r
431         al_dev_open_context_t *p_context;\r
432         ib_api_status_t status;\r
433         ual_ndi_rej_cm_ioctl_in_t *p_rej = \r
434                 (ual_ndi_rej_cm_ioctl_in_t*)cl_ioctl_in_buf( h_ioctl );\r
435         NTSTATUS ntstatus;\r
436         UNUSED_PARAM(p_ret_bytes);\r
437 \r
438         AL_ENTER( AL_DBG_NDI );\r
439 \r
440         p_context = (al_dev_open_context_t*)p_open_context;\r
441 \r
442         /* Check psize */\r
443         if ( p_rej->pdata_size >= sizeof(p_rej->pdata) )\r
444         {\r
445                 ntstatus = CL_INVALID_PARAMETER;\r
446                 goto exit;\r
447         }\r
448 \r
449         /* perform the ioctl */\r
450         status = al_cep_rej( p_context->h_al, p_rej->cid, IB_REJ_USER_DEFINED,\r
451                 NULL, 0, p_rej->pdata, p_rej->pdata_size);\r
452         if (status != IB_SUCCESS)\r
453         {\r
454                 ntstatus = CL_INVALID_HANDLE;\r
455                 goto exit;\r
456         }\r
457 \r
458         al_destroy_cep( p_context->h_al, &p_rej->cid, FALSE );\r
459         ntstatus = STATUS_SUCCESS;\r
460 \r
461 exit:\r
462         AL_EXIT( AL_DBG_NDI );\r
463         return ntstatus;\r
464 }\r
465 \r
466 static cl_status_t\r
467 __ndi_rtu_cm(\r
468         IN              void                                    *p_open_context,\r
469         IN              cl_ioctl_handle_t               h_ioctl,\r
470                 OUT     size_t                                  *p_ret_bytes )\r
471 {\r
472         cl_status_t cl_status;\r
473         ib_qp_handle_t h_qp = NULL;\r
474         al_dev_open_context_t *p_context;\r
475         ual_ndi_rtu_cm_ioctl_in_t *p_rtu = \r
476                 (ual_ndi_rtu_cm_ioctl_in_t*)cl_ioctl_in_buf( h_ioctl );\r
477 \r
478         UNUSED_PARAM(p_ret_bytes);\r
479         \r
480         AL_ENTER( AL_DBG_NDI );\r
481 \r
482         p_context = (al_dev_open_context_t*)p_open_context;\r
483 \r
484         /* Validate user parameters. */\r
485         if( cl_ioctl_in_size( h_ioctl ) < sizeof(ual_ndi_rtu_cm_ioctl_in_t))\r
486         {\r
487                 cl_status = CL_INVALID_PARAMETER;\r
488                 goto exit;\r
489         }\r
490 \r
491         /* Validate QP handle */\r
492         h_qp = (ib_qp_handle_t)al_hdl_ref( p_context->h_al, p_rtu->h_qp, AL_OBJ_TYPE_H_QP );\r
493         if( !h_qp )\r
494         {\r
495                 cl_status = CL_INVALID_HANDLE;\r
496                 goto exit;\r
497         }\r
498 \r
499         /* Check QP type */\r
500         if( h_qp->type != IB_QPT_RELIABLE_CONN )\r
501         {\r
502                 cl_status = CL_INVALID_HANDLE;\r
503                 goto err;\r
504         }\r
505 \r
506         /* perform the ioctl */\r
507         cl_status = ndi_rtu_cm( h_qp, h_ioctl );\r
508 \r
509 err:\r
510         deref_al_obj( &h_qp->obj );\r
511 \r
512 exit:\r
513         AL_EXIT( AL_DBG_NDI );\r
514         return cl_status;\r
515 }\r
516 \r
517 static cl_status_t\r
518 __ndi_dreq_cm(\r
519         IN              void                                    *p_open_context,\r
520         IN              cl_ioctl_handle_t               h_ioctl,\r
521                 OUT     size_t                                  *p_ret_bytes )\r
522 {\r
523         cl_status_t cl_status;\r
524         ib_qp_handle_t h_qp = NULL;\r
525         al_dev_open_context_t *p_context;\r
526 \r
527         UNUSED_PARAM(p_ret_bytes);\r
528         \r
529         AL_ENTER( AL_DBG_NDI );\r
530 \r
531         p_context = (al_dev_open_context_t*)p_open_context;\r
532 \r
533         /* Validate user parameters. */\r
534         if( cl_ioctl_in_size( h_ioctl ) < sizeof(uint64_t))\r
535         {\r
536                 cl_status = CL_INVALID_PARAMETER;\r
537                 goto exit;\r
538         }\r
539 \r
540         /* Validate QP handle */\r
541         h_qp = (ib_qp_handle_t)al_hdl_ref( p_context->h_al, \r
542                 *(uint64_t*)cl_ioctl_in_buf( h_ioctl ), AL_OBJ_TYPE_H_QP );\r
543         if( !h_qp )\r
544         {\r
545                 cl_status = CL_CONNECTION_INVALID;\r
546                 goto exit;\r
547         }\r
548 \r
549         /* Check QP type */\r
550         if( h_qp->type != IB_QPT_RELIABLE_CONN )\r
551         {\r
552                 cl_status = CL_CONNECTION_INVALID;\r
553                 goto err;\r
554         }\r
555 \r
556         /* perform the ioctl */\r
557         cl_status = ndi_dreq_cm( h_qp, h_ioctl );\r
558 \r
559 err:\r
560         deref_al_obj( &h_qp->obj );\r
561 \r
562 exit:\r
563         AL_EXIT( AL_DBG_NDI );\r
564         return cl_status;\r
565 }\r
566 \r
567 cl_status_t\r
568 ndi_ioctl(\r
569         IN              cl_ioctl_handle_t               h_ioctl,\r
570                 OUT     size_t                                  *p_ret_bytes )\r
571 {\r
572         cl_status_t                             cl_status;\r
573         IO_STACK_LOCATION               *p_io_stack;\r
574         void                                    *p_context;\r
575 \r
576         AL_ENTER( AL_DBG_NDI );\r
577 \r
578         p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
579         p_context = p_io_stack->FileObject->FsContext;\r
580 \r
581         if( !p_context )\r
582         {\r
583                 AL_EXIT( AL_DBG_DEV );\r
584                 return CL_INVALID_PARAMETER;\r
585         }\r
586 \r
587         switch( cl_ioctl_ctl_code( h_ioctl ) )\r
588         {\r
589         case UAL_NDI_CREATE_CQ:\r
590                 cl_status = __ndi_create_cq( p_context, h_ioctl, p_ret_bytes );\r
591                 break;\r
592         case UAL_NDI_NOTIFY_CQ:\r
593                 cl_status = __ndi_notify_cq( p_context, h_ioctl, p_ret_bytes );\r
594                 break;\r
595         case UAL_NDI_CANCEL_CQ:\r
596                 cl_status = __ndi_cancel_cq( p_context, h_ioctl, p_ret_bytes );\r
597                 break;\r
598         case UAL_NDI_MODIFY_QP:\r
599                 cl_status = __ndi_modify_qp( p_context, h_ioctl, p_ret_bytes );\r
600                 break;\r
601         case UAL_NDI_REQ_CM:\r
602                 cl_status = __ndi_req_cm( p_context, h_ioctl, p_ret_bytes );\r
603                 break;\r
604         case UAL_NDI_REP_CM:\r
605                 cl_status = __ndi_rep_cm( p_context, h_ioctl, p_ret_bytes );\r
606                 break;\r
607         case UAL_NDI_RTU_CM:\r
608                 cl_status = __ndi_rtu_cm( p_context, h_ioctl, p_ret_bytes );\r
609                 break;\r
610         case UAL_NDI_REJ_CM:\r
611                 cl_status = __ndi_rej_cm( p_context, h_ioctl, p_ret_bytes );\r
612                 break;\r
613         case UAL_NDI_DREQ_CM:\r
614                 cl_status = __ndi_dreq_cm( p_context, h_ioctl, p_ret_bytes );\r
615                 break;\r
616     case UAL_NDI_NOOP:\r
617         if( cl_ioctl_in_size( h_ioctl ) != 0 )\r
618             cl_status = STATUS_TIMEOUT;\r
619         else\r
620             cl_status = CL_SUCCESS;\r
621         break;\r
622         default:\r
623                 cl_status = CL_INVALID_PARAMETER;\r
624                 break;\r
625         }\r
626 \r
627         AL_EXIT( AL_DBG_NDI );\r
628         return cl_status;\r
629 }\r
630 \r