[IBAL] Change CEP DREP API
[mirror/winof/.git] / core / al / kernel / al_proxy_cep.c
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Portions Copyright (c) 2008 Microsoft Corporation.  All rights reserved.\r
4  *\r
5  * This software is available to you under the OpenIB.org BSD license\r
6  * below:\r
7  *\r
8  *     Redistribution and use in source and binary forms, with or\r
9  *     without modification, are permitted provided that the following\r
10  *     conditions are met:\r
11  *\r
12  *      - Redistributions of source code must retain the above\r
13  *        copyright notice, this list of conditions and the following\r
14  *        disclaimer.\r
15  *\r
16  *      - Redistributions in binary form must reproduce the above\r
17  *        copyright notice, this list of conditions and the following\r
18  *        disclaimer in the documentation and/or other materials\r
19  *        provided with the distribution.\r
20  *\r
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
25  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
26  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
28  * SOFTWARE.\r
29  *\r
30  * $Id$\r
31  */\r
32 \r
33 \r
34 #include "al_debug.h"\r
35 #if defined(EVENT_TRACING)\r
36 #ifdef offsetof\r
37 #undef offsetof\r
38 #endif\r
39 #include "al_proxy_cep.tmh"\r
40 #endif\r
41 #include "al_cm_cep.h"\r
42 #include "al_dev.h"\r
43 #include <iba/ib_al_ioctl.h>\r
44 #include "al_proxy.h"\r
45 #include "al.h"\r
46 #include "al_qp.h"\r
47 \r
48 \r
49 static cl_status_t\r
50 proxy_create_cep(\r
51         IN              void                                    *p_open_context,\r
52         IN              cl_ioctl_handle_t               h_ioctl,\r
53                 OUT     size_t                                  *p_ret_bytes )\r
54 {\r
55         al_dev_open_context_t           *p_context;\r
56         void*                                           user_context;\r
57         ual_create_cep_ioctl_t          *p_ioctl;\r
58 \r
59         AL_ENTER( AL_DBG_CM );\r
60 \r
61         p_context = (al_dev_open_context_t*)p_open_context;\r
62         p_ioctl = (ual_create_cep_ioctl_t*)cl_ioctl_out_buf( h_ioctl );\r
63 \r
64         /* Validate user parameters. */\r
65         if( cl_ioctl_in_size( h_ioctl ) != sizeof(uint64_t) ||\r
66                 cl_ioctl_out_size( h_ioctl ) != sizeof(ual_create_cep_ioctl_t) )\r
67         {\r
68                 AL_EXIT( AL_DBG_CM );\r
69                 return CL_INVALID_PARAMETER;\r
70         }\r
71 \r
72         user_context = *(void**)cl_ioctl_in_buf( h_ioctl );\r
73 \r
74         /* We use IRPs as notification mechanism so the callback is NULL. */\r
75         p_ioctl->cid = AL_INVALID_CID;\r
76         p_ioctl->status = al_create_cep( p_context->h_al, NULL,\r
77                 user_context, NULL, &p_ioctl->cid );\r
78 \r
79         *p_ret_bytes = sizeof(ual_create_cep_ioctl_t);\r
80 \r
81         AL_EXIT( AL_DBG_CM );\r
82         return CL_SUCCESS;\r
83 }\r
84 \r
85 \r
86 static inline void\r
87 __complete_get_event_ioctl(\r
88         IN                              ib_al_handle_t                          h_al,\r
89         IN                              IRP* const                                      p_irp,\r
90         IN                              NTSTATUS                                        status )\r
91 {\r
92 #pragma warning(push, 3)\r
93         IoSetCancelRoutine( p_irp, NULL );\r
94 #pragma warning(pop)\r
95 \r
96         /* Complete the IRP. */\r
97         p_irp->IoStatus.Status = status;\r
98         p_irp->IoStatus.Information = 0;\r
99         IoCompleteRequest( p_irp, IO_NETWORK_INCREMENT );\r
100 \r
101         deref_al_obj( &h_al->obj );\r
102 }\r
103 \r
104 \r
105 static cl_status_t\r
106 proxy_destroy_cep(\r
107         IN              void                                    *p_open_context,\r
108         IN              cl_ioctl_handle_t               h_ioctl,\r
109                 OUT     size_t                                  *p_ret_bytes )\r
110 {\r
111         al_dev_open_context_t           *p_context;\r
112 \r
113         AL_ENTER( AL_DBG_CM );\r
114 \r
115         UNUSED_PARAM( p_ret_bytes );\r
116 \r
117         p_context = (al_dev_open_context_t*)p_open_context;\r
118 \r
119         /* Validate user parameters. */\r
120         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) )\r
121         {\r
122                 AL_EXIT( AL_DBG_CM );\r
123                 return CL_INVALID_PARAMETER;\r
124         }\r
125 \r
126         al_destroy_cep( p_context->h_al,\r
127                 (net32_t*)cl_ioctl_in_buf( h_ioctl ), TRUE );\r
128 \r
129         AL_EXIT( AL_DBG_CM );\r
130         return CL_SUCCESS;\r
131 }\r
132 \r
133 \r
134 static cl_status_t\r
135 proxy_cep_listen(\r
136         IN              void                                    *p_open_context,\r
137         IN              cl_ioctl_handle_t               h_ioctl,\r
138                 OUT     size_t                                  *p_ret_bytes )\r
139 {\r
140         al_dev_open_context_t           *p_context;\r
141         ual_cep_listen_ioctl_t          *p_ioctl;\r
142         ib_api_status_t                         status;\r
143 \r
144         AL_ENTER( AL_DBG_CM );\r
145 \r
146         p_context = (al_dev_open_context_t*)p_open_context;\r
147         p_ioctl = (ual_cep_listen_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
148 \r
149         /* Validate user parameters. */\r
150         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_listen_ioctl_t) ||\r
151                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
152         {\r
153                 AL_EXIT( AL_DBG_CM );\r
154                 return CL_INVALID_PARAMETER;\r
155         }\r
156 \r
157         /* Set the private data compare buffer to our kernel copy. */\r
158         if( p_ioctl->cep_listen.p_cmp_buf )\r
159                 p_ioctl->cep_listen.p_cmp_buf = p_ioctl->compare;\r
160 \r
161         status =\r
162                 al_cep_listen( p_context->h_al, p_ioctl->cid, &p_ioctl->cep_listen );\r
163 \r
164         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = status;\r
165 \r
166         *p_ret_bytes = sizeof(ib_api_status_t);\r
167 \r
168         AL_EXIT( AL_DBG_CM );\r
169         return CL_SUCCESS;\r
170 }\r
171 \r
172 \r
173 static cl_status_t\r
174 proxy_cep_pre_req(\r
175         IN              void                                    *p_open_context,\r
176         IN              cl_ioctl_handle_t               h_ioctl,\r
177                 OUT     size_t                                  *p_ret_bytes )\r
178 {\r
179         al_dev_open_context_t           *p_context;\r
180         ual_cep_req_ioctl_t                     *p_ioctl;\r
181         ib_qp_handle_t                          h_qp;\r
182 \r
183         AL_ENTER( AL_DBG_CM );\r
184 \r
185         p_context = (al_dev_open_context_t*)p_open_context;\r
186         p_ioctl = (ual_cep_req_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
187 \r
188         /* Validate user parameters. */\r
189         if( cl_ioctl_in_size( h_ioctl ) != sizeof(struct _ual_cep_req_ioctl_in) ||\r
190                 cl_ioctl_out_size( h_ioctl ) != sizeof(struct _ual_cep_req_ioctl_out) )\r
191         {\r
192                 AL_EXIT( AL_DBG_CM );\r
193                 return CL_INVALID_PARAMETER;\r
194         }\r
195 \r
196         *p_ret_bytes = sizeof(struct _ual_cep_req_ioctl_out);\r
197 \r
198         p_ioctl->in.cm_req.h_al = p_context->h_al;\r
199         p_ioctl->in.cm_req.p_primary_path = &p_ioctl->in.paths[0];\r
200         if( p_ioctl->in.cm_req.p_alt_path )\r
201                 p_ioctl->in.cm_req.p_alt_path = &p_ioctl->in.paths[1];\r
202         if( p_ioctl->in.cm_req.p_compare_buffer )\r
203                 p_ioctl->in.cm_req.p_compare_buffer = p_ioctl->in.compare;\r
204         if( p_ioctl->in.cm_req.p_req_pdata )\r
205                 p_ioctl->in.cm_req.p_req_pdata = p_ioctl->in.pdata;\r
206 \r
207         /* Get the kernel QP handle. */\r
208         h_qp = (ib_qp_handle_t)al_hdl_ref(\r
209                 p_context->h_al, (uint64_t)p_ioctl->in.cm_req.h_qp, AL_OBJ_TYPE_H_QP );\r
210         if( !h_qp )\r
211         {\r
212                 p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
213                 goto done;\r
214         }\r
215 \r
216         p_ioctl->in.cm_req.h_qp = h_qp;\r
217 \r
218         p_ioctl->out.status = al_cep_pre_req( p_context->h_al, p_ioctl->in.cid,\r
219                 &p_ioctl->in.cm_req, &p_ioctl->out.init );\r
220 \r
221         deref_al_obj( &h_qp->obj );\r
222 \r
223         if( p_ioctl->out.status != IB_SUCCESS )\r
224         {\r
225 done:\r
226                 cl_memclr( &p_ioctl->out.init, sizeof(ib_qp_mod_t) );\r
227         }\r
228 \r
229         AL_EXIT( AL_DBG_CM );\r
230         return CL_SUCCESS;\r
231 }\r
232 \r
233 \r
234 static cl_status_t\r
235 proxy_cep_send_req(\r
236         IN              void                                    *p_open_context,\r
237         IN              cl_ioctl_handle_t               h_ioctl,\r
238                 OUT     size_t                                  *p_ret_bytes )\r
239 {\r
240         al_dev_open_context_t           *p_context;\r
241 \r
242         AL_ENTER( AL_DBG_CM );\r
243 \r
244         p_context = (al_dev_open_context_t*)p_open_context;\r
245 \r
246         /* Validate user parameters. */\r
247         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
248                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
249         {\r
250                 AL_EXIT( AL_DBG_CM );\r
251                 return CL_INVALID_PARAMETER;\r
252         }\r
253 \r
254         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = al_cep_send_req(\r
255                 p_context->h_al, *(net32_t*)cl_ioctl_in_buf( h_ioctl ) );\r
256 \r
257         *p_ret_bytes = sizeof(ib_api_status_t);\r
258 \r
259         AL_EXIT( AL_DBG_CM );\r
260         return CL_SUCCESS;\r
261 }\r
262 \r
263 \r
264 static cl_status_t\r
265 proxy_cep_pre_rep(\r
266         IN              void                                    *p_open_context,\r
267         IN              cl_ioctl_handle_t               h_ioctl,\r
268                 OUT     size_t                                  *p_ret_bytes )\r
269 {\r
270         al_dev_open_context_t           *p_context;\r
271         ual_cep_rep_ioctl_t                     *p_ioctl;\r
272         ib_qp_handle_t                          h_qp;\r
273         net32_t                                         cid;\r
274 \r
275         AL_ENTER( AL_DBG_CM );\r
276 \r
277         p_context = (al_dev_open_context_t*)p_open_context;\r
278         p_ioctl = (ual_cep_rep_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
279 \r
280         /* Validate user parameters. */\r
281         if( cl_ioctl_in_size( h_ioctl ) != sizeof(struct _ual_cep_rep_ioctl_in) ||\r
282                 cl_ioctl_out_size( h_ioctl ) != sizeof(struct _ual_cep_rep_ioctl_out) )\r
283         {\r
284                 AL_EXIT( AL_DBG_CM );\r
285                 return CL_INVALID_PARAMETER;\r
286         }\r
287 \r
288         *p_ret_bytes = sizeof(struct _ual_cep_rep_ioctl_out);\r
289 \r
290         if( p_ioctl->in.cm_rep.p_rep_pdata )\r
291                 p_ioctl->in.cm_rep.p_rep_pdata = p_ioctl->in.pdata;\r
292 \r
293         /* Get the kernel QP handle. */\r
294         h_qp = (ib_qp_handle_t)al_hdl_ref(\r
295                 p_context->h_al, (uint64_t)p_ioctl->in.cm_rep.h_qp, AL_OBJ_TYPE_H_QP );\r
296         if( !h_qp )\r
297         {\r
298                 p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
299                 goto done;\r
300         }\r
301 \r
302         p_ioctl->in.cm_rep.h_qp = h_qp;\r
303 \r
304         cid = AL_INVALID_CID;\r
305         p_ioctl->out.status = al_cep_pre_rep( p_context->h_al, p_ioctl->in.cid,\r
306                 p_ioctl->in.context, NULL, &p_ioctl->in.cm_rep, &cid, &p_ioctl->out.init );\r
307 \r
308         deref_al_obj( &h_qp->obj );\r
309 \r
310         if( p_ioctl->out.status != IB_SUCCESS )\r
311         {\r
312 done:\r
313                 cl_memclr( &p_ioctl->out.init, sizeof(ib_qp_mod_t) );\r
314         }\r
315 \r
316         AL_EXIT( AL_DBG_CM );\r
317         return CL_SUCCESS;\r
318 }\r
319 \r
320 \r
321 static cl_status_t\r
322 proxy_cep_send_rep(\r
323         IN              void                                    *p_open_context,\r
324         IN              cl_ioctl_handle_t               h_ioctl,\r
325                 OUT     size_t                                  *p_ret_bytes )\r
326 {\r
327         al_dev_open_context_t           *p_context;\r
328 \r
329         AL_ENTER( AL_DBG_CM );\r
330 \r
331         p_context = (al_dev_open_context_t*)p_open_context;\r
332 \r
333         /* Validate user parameters. */\r
334         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
335                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
336         {\r
337                 AL_EXIT( AL_DBG_CM );\r
338                 return CL_INVALID_PARAMETER;\r
339         }\r
340 \r
341         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = al_cep_send_rep(\r
342                 p_context->h_al, *(net32_t*)cl_ioctl_in_buf( h_ioctl ) );\r
343 \r
344         *p_ret_bytes = sizeof(ib_api_status_t);\r
345 \r
346         AL_EXIT( AL_DBG_CM );\r
347         return CL_SUCCESS;\r
348 }\r
349 \r
350 \r
351 static cl_status_t\r
352 proxy_cep_get_rtr(\r
353         IN              void                                    *p_open_context,\r
354         IN              cl_ioctl_handle_t               h_ioctl,\r
355                 OUT     size_t                                  *p_ret_bytes )\r
356 {\r
357         al_dev_open_context_t           *p_context;\r
358         ual_cep_get_rtr_ioctl_t         *p_ioctl;\r
359 \r
360         AL_ENTER( AL_DBG_CM );\r
361 \r
362         p_context = (al_dev_open_context_t*)p_open_context;\r
363         p_ioctl = (ual_cep_get_rtr_ioctl_t*)cl_ioctl_out_buf( h_ioctl );\r
364 \r
365         /* Validate user parameters. */\r
366         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
367                 cl_ioctl_out_size( h_ioctl ) != sizeof(ual_cep_get_rtr_ioctl_t) )\r
368         {\r
369                 AL_EXIT( AL_DBG_CM );\r
370                 return CL_INVALID_PARAMETER;\r
371         }\r
372 \r
373         *p_ret_bytes = sizeof(ual_cep_get_rtr_ioctl_t);\r
374 \r
375         p_ioctl->status = al_cep_get_rtr_attr( p_context->h_al,\r
376                 *(net32_t*)cl_ioctl_in_buf( h_ioctl ), &p_ioctl->rtr );\r
377 \r
378         if( p_ioctl->status != IB_SUCCESS )\r
379                 cl_memclr( &p_ioctl->rtr, sizeof(ib_qp_mod_t) );\r
380 \r
381         AL_EXIT( AL_DBG_CM );\r
382         return CL_SUCCESS;\r
383 }\r
384 \r
385 \r
386 static cl_status_t\r
387 proxy_cep_get_rts(\r
388         IN              void                                    *p_open_context,\r
389         IN              cl_ioctl_handle_t               h_ioctl,\r
390                 OUT     size_t                                  *p_ret_bytes )\r
391 {\r
392         al_dev_open_context_t           *p_context;\r
393         ual_cep_get_rts_ioctl_t         *p_ioctl;\r
394 \r
395         AL_ENTER( AL_DBG_CM );\r
396 \r
397         p_context = (al_dev_open_context_t*)p_open_context;\r
398         p_ioctl = (ual_cep_get_rts_ioctl_t*)cl_ioctl_out_buf( h_ioctl );\r
399 \r
400         /* Validate user parameters. */\r
401         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
402                 cl_ioctl_out_size( h_ioctl ) != sizeof(ual_cep_get_rts_ioctl_t) )\r
403         {\r
404                 AL_EXIT( AL_DBG_CM );\r
405                 return CL_INVALID_PARAMETER;\r
406         }\r
407 \r
408         *p_ret_bytes = sizeof(ual_cep_get_rts_ioctl_t);\r
409 \r
410         p_ioctl->status = al_cep_get_rts_attr( p_context->h_al,\r
411                 *(net32_t*)cl_ioctl_in_buf( h_ioctl ), &p_ioctl->rts );\r
412 \r
413         if( p_ioctl->status != IB_SUCCESS )\r
414                 cl_memclr( &p_ioctl->rts, sizeof(ib_qp_mod_t) );\r
415 \r
416         AL_EXIT( AL_DBG_CM );\r
417         return CL_SUCCESS;\r
418 }\r
419 \r
420 \r
421 static cl_status_t\r
422 proxy_cep_rtu(\r
423         IN              void                                    *p_open_context,\r
424         IN              cl_ioctl_handle_t               h_ioctl,\r
425                 OUT     size_t                                  *p_ret_bytes )\r
426 {\r
427         al_dev_open_context_t           *p_context;\r
428         ual_cep_rtu_ioctl_t                     *p_ioctl;\r
429         ib_api_status_t                         status;\r
430 \r
431         AL_ENTER( AL_DBG_CM );\r
432 \r
433         p_context = (al_dev_open_context_t*)p_open_context;\r
434         p_ioctl = (ual_cep_rtu_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
435 \r
436         /* Validate user parameters. */\r
437         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_rtu_ioctl_t) ||\r
438                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
439         {\r
440                 AL_EXIT( AL_DBG_CM );\r
441                 return CL_INVALID_PARAMETER;\r
442         }\r
443 \r
444         status = al_cep_rtu( p_context->h_al,\r
445                 p_ioctl->cid, p_ioctl->pdata, p_ioctl->pdata_len );\r
446 \r
447         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = status;\r
448 \r
449         *p_ret_bytes = sizeof(ib_api_status_t);\r
450 \r
451         AL_EXIT( AL_DBG_CM );\r
452         return CL_SUCCESS;\r
453 }\r
454 \r
455 \r
456 static cl_status_t\r
457 proxy_cep_rej(\r
458         IN              void                                    *p_open_context,\r
459         IN              cl_ioctl_handle_t               h_ioctl,\r
460                 OUT     size_t                                  *p_ret_bytes )\r
461 {\r
462         al_dev_open_context_t           *p_context;\r
463         ual_cep_rej_ioctl_t                     *p_ioctl;\r
464 \r
465         AL_ENTER( AL_DBG_CM );\r
466 \r
467         p_context = (al_dev_open_context_t*)p_open_context;\r
468         p_ioctl = (ual_cep_rej_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
469 \r
470         /* Validate user parameters. */\r
471         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_rej_ioctl_t) ||\r
472                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
473         {\r
474                 AL_EXIT( AL_DBG_CM );\r
475                 return CL_INVALID_PARAMETER;\r
476         }\r
477 \r
478         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = al_cep_rej(\r
479                 p_context->h_al, p_ioctl->cid, p_ioctl->rej_status, p_ioctl->ari,\r
480                 p_ioctl->ari_len, p_ioctl->pdata, p_ioctl->pdata_len );\r
481 \r
482         *p_ret_bytes = sizeof(ib_api_status_t);\r
483 \r
484         AL_EXIT( AL_DBG_CM );\r
485         return CL_SUCCESS;\r
486 }\r
487 \r
488 \r
489 static cl_status_t\r
490 proxy_cep_mra(\r
491         IN              void                                    *p_open_context,\r
492         IN              cl_ioctl_handle_t               h_ioctl,\r
493                 OUT     size_t                                  *p_ret_bytes )\r
494 {\r
495         al_dev_open_context_t           *p_context;\r
496         ual_cep_mra_ioctl_t                     *p_ioctl;\r
497 \r
498         AL_ENTER( AL_DBG_CM );\r
499 \r
500         p_context = (al_dev_open_context_t*)p_open_context;\r
501         p_ioctl = (ual_cep_mra_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
502 \r
503         /* Validate user parameters. */\r
504         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_mra_ioctl_t) ||\r
505                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
506         {\r
507                 AL_EXIT( AL_DBG_CM );\r
508                 return CL_INVALID_PARAMETER;\r
509         }\r
510 \r
511         p_ioctl->cm_mra.p_mra_pdata = p_ioctl->pdata;\r
512 \r
513         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = al_cep_mra(\r
514                 p_context->h_al, p_ioctl->cid, &p_ioctl->cm_mra );\r
515 \r
516         *p_ret_bytes = sizeof(ib_api_status_t);\r
517 \r
518         AL_EXIT( AL_DBG_CM );\r
519         return CL_SUCCESS;\r
520 }\r
521 \r
522 \r
523 static cl_status_t\r
524 proxy_cep_lap(\r
525         IN              void                                    *p_open_context,\r
526         IN              cl_ioctl_handle_t               h_ioctl,\r
527                 OUT     size_t                                  *p_ret_bytes )\r
528 {\r
529         al_dev_open_context_t           *p_context;\r
530         ual_cep_lap_ioctl_t                     *p_ioctl;\r
531         ib_api_status_t                         status;\r
532         ib_qp_handle_t                          h_qp;\r
533 \r
534         AL_ENTER( AL_DBG_CM );\r
535 \r
536         p_context = (al_dev_open_context_t*)p_open_context;\r
537         p_ioctl = (ual_cep_lap_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
538 \r
539         /* Validate user parameters. */\r
540         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_lap_ioctl_t) ||\r
541                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
542         {\r
543                 AL_EXIT( AL_DBG_CM );\r
544                 return CL_INVALID_PARAMETER;\r
545         }\r
546 \r
547         *p_ret_bytes = sizeof(ib_api_status_t);\r
548 \r
549         p_ioctl->cm_lap.p_alt_path = &p_ioctl->alt_path;\r
550         if( p_ioctl->cm_lap.p_lap_pdata )\r
551                 p_ioctl->pdata;\r
552 \r
553         /* Get the kernel QP handle. */\r
554         h_qp = (ib_qp_handle_t)al_hdl_ref(\r
555                 p_context->h_al, (uint64_t)p_ioctl->cm_lap.h_qp, AL_OBJ_TYPE_H_QP );\r
556         if( !h_qp )\r
557         {\r
558                 status = IB_INVALID_QP_HANDLE;\r
559                 goto done;\r
560         }\r
561 \r
562         p_ioctl->cm_lap.h_qp = h_qp;\r
563 \r
564         status = al_cep_lap( p_context->h_al, p_ioctl->cid, &p_ioctl->cm_lap );\r
565 \r
566         deref_al_obj( &h_qp->obj );\r
567 \r
568 done:\r
569         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = status;\r
570 \r
571         AL_EXIT( AL_DBG_CM );\r
572         return CL_SUCCESS;\r
573 }\r
574 \r
575 \r
576 static cl_status_t\r
577 proxy_cep_pre_apr(\r
578         IN              void                                    *p_open_context,\r
579         IN              cl_ioctl_handle_t               h_ioctl,\r
580                 OUT     size_t                                  *p_ret_bytes )\r
581 {\r
582         al_dev_open_context_t           *p_context;\r
583         ual_cep_apr_ioctl_t                     *p_ioctl;\r
584         ib_qp_handle_t                          h_qp;\r
585 \r
586         AL_ENTER( AL_DBG_CM );\r
587 \r
588         p_context = (al_dev_open_context_t*)p_open_context;\r
589         p_ioctl = (ual_cep_apr_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
590 \r
591         /* Validate user parameters. */\r
592         if( cl_ioctl_in_size( h_ioctl ) != sizeof(struct _ual_cep_apr_ioctl_in) ||\r
593                 cl_ioctl_out_size( h_ioctl ) != sizeof(struct _ual_cep_apr_ioctl_out) )\r
594         {\r
595                 AL_EXIT( AL_DBG_CM );\r
596                 return CL_INVALID_PARAMETER;\r
597         }\r
598 \r
599         *p_ret_bytes = sizeof(struct _ual_cep_apr_ioctl_out);\r
600 \r
601         if( p_ioctl->in.cm_apr.p_info )\r
602                 p_ioctl->in.cm_apr.p_info = (ib_apr_info_t*)p_ioctl->in.apr_info;\r
603         if( p_ioctl->in.cm_apr.p_apr_pdata )\r
604                 p_ioctl->in.cm_apr.p_apr_pdata = p_ioctl->in.pdata;\r
605 \r
606         /* Get the kernel QP handle. */\r
607         h_qp = (ib_qp_handle_t)al_hdl_ref(\r
608                 p_context->h_al, (uint64_t)p_ioctl->in.cm_apr.h_qp, AL_OBJ_TYPE_H_QP );\r
609         if( !h_qp )\r
610         {\r
611                 p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
612                 goto done;\r
613         }\r
614 \r
615         p_ioctl->in.cm_apr.h_qp = h_qp;\r
616 \r
617         p_ioctl->out.status = al_cep_pre_apr( p_context->h_al, p_ioctl->in.cid,\r
618                 &p_ioctl->in.cm_apr, &p_ioctl->out.apr );\r
619 \r
620         deref_al_obj( &h_qp->obj );\r
621 \r
622         if( p_ioctl->out.status != IB_SUCCESS )\r
623         {\r
624 done:\r
625                 cl_memclr( &p_ioctl->out.apr, sizeof(ib_qp_mod_t) );\r
626         }\r
627 \r
628         AL_EXIT( AL_DBG_CM );\r
629         return CL_SUCCESS;\r
630 }\r
631 \r
632 \r
633 static cl_status_t\r
634 proxy_cep_send_apr(\r
635         IN              void                                    *p_open_context,\r
636         IN              cl_ioctl_handle_t               h_ioctl,\r
637                 OUT     size_t                                  *p_ret_bytes )\r
638 {\r
639         al_dev_open_context_t           *p_context;\r
640 \r
641         AL_ENTER( AL_DBG_CM );\r
642 \r
643         UNUSED_PARAM( p_ret_bytes );\r
644 \r
645         p_context = (al_dev_open_context_t*)p_open_context;\r
646 \r
647         /* Validate user parameters. */\r
648         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
649                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
650         {\r
651                 AL_EXIT( AL_DBG_CM );\r
652                 return CL_INVALID_PARAMETER;\r
653         }\r
654 \r
655         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = al_cep_send_apr(\r
656                 p_context->h_al, *(net32_t*)cl_ioctl_in_buf( h_ioctl ) );\r
657 \r
658         AL_EXIT( AL_DBG_CM );\r
659         return CL_SUCCESS;\r
660 }\r
661 \r
662 \r
663 static cl_status_t\r
664 proxy_cep_dreq(\r
665         IN              void                                    *p_open_context,\r
666         IN              cl_ioctl_handle_t               h_ioctl,\r
667                 OUT     size_t                                  *p_ret_bytes )\r
668 {\r
669         al_dev_open_context_t           *p_context;\r
670         ual_cep_dreq_ioctl_t                    *p_ioctl;\r
671         ib_api_status_t                         status;\r
672 \r
673         AL_ENTER( AL_DBG_CM );\r
674 \r
675         p_context = (al_dev_open_context_t*)p_open_context;\r
676         p_ioctl = (ual_cep_dreq_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
677 \r
678         /* Validate user parameters. */\r
679         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_dreq_ioctl_t) ||\r
680                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
681         {\r
682                 AL_EXIT( AL_DBG_CM );\r
683                 return CL_INVALID_PARAMETER;\r
684         }\r
685 \r
686         /* Set the private data compare buffer to our kernel copy. */\r
687         status = al_cep_dreq( p_context->h_al,\r
688                 p_ioctl->cid, p_ioctl->pdata, p_ioctl->pdata_len );\r
689 \r
690         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = status;\r
691 \r
692         *p_ret_bytes = sizeof(ib_api_status_t);\r
693 \r
694         AL_EXIT( AL_DBG_CM );\r
695         return CL_SUCCESS;\r
696 }\r
697 \r
698 \r
699 static cl_status_t\r
700 proxy_cep_drep(\r
701         IN              void                                    *p_open_context,\r
702         IN              cl_ioctl_handle_t               h_ioctl,\r
703                 OUT     size_t                                  *p_ret_bytes )\r
704 {\r
705         al_dev_open_context_t           *p_context;\r
706         ual_cep_drep_ioctl_t            *p_ioctl;\r
707 \r
708         AL_ENTER( AL_DBG_CM );\r
709 \r
710         p_context = (al_dev_open_context_t*)p_open_context;\r
711         p_ioctl = (ual_cep_drep_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
712 \r
713         /* Validate user parameters. */\r
714         if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cep_drep_ioctl_t) ||\r
715                 cl_ioctl_out_size( h_ioctl ) != sizeof(ib_api_status_t) )\r
716         {\r
717                 AL_EXIT( AL_DBG_CM );\r
718                 return CL_INVALID_PARAMETER;\r
719         }\r
720 \r
721         (*(ib_api_status_t*)cl_ioctl_out_buf( h_ioctl )) = al_cep_drep(\r
722                 p_context->h_al, p_ioctl->cid, p_ioctl->pdata, p_ioctl->pdata_len );\r
723 \r
724         *p_ret_bytes = sizeof(ib_api_status_t);\r
725 \r
726         AL_EXIT( AL_DBG_CM );\r
727         return CL_SUCCESS;\r
728 }\r
729 \r
730 \r
731 static cl_status_t\r
732 proxy_cep_get_timewait(\r
733         IN              void                                    *p_open_context,\r
734         IN              cl_ioctl_handle_t               h_ioctl,\r
735                 OUT     size_t                                  *p_ret_bytes )\r
736 {\r
737         al_dev_open_context_t                   *p_context;\r
738         ual_cep_get_timewait_ioctl_t    *p_ioctl;\r
739 \r
740         AL_ENTER( AL_DBG_CM );\r
741 \r
742         p_context = (al_dev_open_context_t*)p_open_context;\r
743         p_ioctl = (ual_cep_get_timewait_ioctl_t*)cl_ioctl_out_buf( h_ioctl );\r
744 \r
745         /* Validate user parameters. */\r
746         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
747                 cl_ioctl_out_size( h_ioctl ) != sizeof(ual_cep_get_timewait_ioctl_t) )\r
748         {\r
749                 AL_EXIT( AL_DBG_CM );\r
750                 return CL_INVALID_PARAMETER;\r
751         }\r
752 \r
753         p_ioctl->status = al_cep_get_timewait( p_context->h_al,\r
754                 *(net32_t*)cl_ioctl_in_buf( h_ioctl ), &p_ioctl->timewait_us );\r
755 \r
756         *p_ret_bytes = sizeof(ual_cep_get_timewait_ioctl_t);\r
757 \r
758         AL_EXIT( AL_DBG_CM );\r
759         return CL_SUCCESS;\r
760 }\r
761 \r
762 \r
763 static cl_status_t\r
764 proxy_cep_poll(\r
765         IN              void                                    *p_open_context,\r
766         IN              cl_ioctl_handle_t               h_ioctl,\r
767                 OUT     size_t                                  *p_ret_bytes )\r
768 {\r
769         al_dev_open_context_t           *p_context;\r
770         ual_cep_poll_ioctl_t            *p_ioctl;\r
771         ib_mad_element_t                        *p_mad = NULL;\r
772 \r
773         AL_ENTER( AL_DBG_CM );\r
774 \r
775         p_context = (al_dev_open_context_t*)p_open_context;\r
776         p_ioctl = (ual_cep_poll_ioctl_t*)cl_ioctl_out_buf( h_ioctl );\r
777 \r
778         /* Validate user parameters. */\r
779         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) ||\r
780                 cl_ioctl_out_size( h_ioctl ) != sizeof(ual_cep_poll_ioctl_t) )\r
781         {\r
782                 AL_EXIT( AL_DBG_CM );\r
783                 return CL_INVALID_PARAMETER;\r
784         }\r
785 \r
786         *p_ret_bytes = sizeof(ual_cep_poll_ioctl_t);\r
787 \r
788         p_ioctl->status = al_cep_poll( p_context->h_al,\r
789                 *(net32_t*)cl_ioctl_in_buf( h_ioctl ), &p_ioctl->context,\r
790                 &p_ioctl->new_cid, &p_mad );\r
791 \r
792         if( p_ioctl->status == IB_SUCCESS )\r
793         {\r
794                 /* Copy the MAD for user consumption and free the it. */\r
795                 CL_ASSERT( p_mad );\r
796                 p_ioctl->element = *p_mad;\r
797                 if( p_mad->grh_valid )\r
798                         p_ioctl->grh = *p_mad->p_grh;\r
799                 else\r
800                         cl_memclr( &p_ioctl->grh, sizeof(ib_grh_t) );\r
801                 cl_memcpy( p_ioctl->mad_buf, p_mad->p_mad_buf, MAD_BLOCK_SIZE );\r
802                 ib_put_mad( p_mad );\r
803         }\r
804         else\r
805         {\r
806                 cl_memclr( &p_ioctl->mad_buf, sizeof(MAD_BLOCK_SIZE) );\r
807                 p_ioctl->new_cid = AL_INVALID_CID;\r
808         }\r
809 \r
810         AL_EXIT( AL_DBG_CM );\r
811         return CL_SUCCESS;\r
812 }\r
813 \r
814 \r
815 static cl_status_t\r
816 proxy_cep_get_event(\r
817         IN              void                                    *p_open_context,\r
818         IN              cl_ioctl_handle_t               h_ioctl,\r
819                 OUT     size_t                                  *p_ret_bytes )\r
820 {\r
821         NTSTATUS                                status;\r
822         IO_STACK_LOCATION               *p_io_stack;\r
823         al_dev_open_context_t   *p_context;\r
824         net32_t                                 cid;\r
825 \r
826         AL_ENTER( AL_DBG_CM );\r
827 \r
828         UNUSED_PARAM( p_ret_bytes );\r
829 \r
830         p_context = p_open_context;\r
831 \r
832         p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
833         if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_CM )\r
834         {\r
835                 AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
836                         ("Invalid file object type for request: %016I64x\n",\r
837                         (LONG_PTR)p_io_stack->FileObject->FsContext2) );\r
838                 return CL_INVALID_PARAMETER;\r
839         }\r
840 \r
841         /* Check the size of the ioctl */\r
842         if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) )\r
843         {\r
844                 AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid IOCTL input buffer.\n") );\r
845                 return CL_INVALID_PARAMETER;\r
846         }\r
847 \r
848         cid = *(net32_t*)cl_ioctl_in_buf( h_ioctl );\r
849 \r
850         status = al_cep_queue_irp( p_context->h_al, cid, h_ioctl );\r
851         if( status != STATUS_PENDING )\r
852         {\r
853                 /* Invalid CID.  Complete the request. */\r
854                 AL_EXIT( AL_DBG_CM );\r
855                 return CL_INVALID_PARAMETER;\r
856         }\r
857 \r
858         AL_EXIT( AL_DBG_CM );\r
859         return CL_PENDING;\r
860 }\r
861 \r
862 \r
863 static cl_status_t\r
864 proxy_cep_get_req_cid(\r
865         IN              void                                    *p_open_context,\r
866         IN              cl_ioctl_handle_t               h_ioctl,\r
867                 OUT     size_t                                  *p_ret_bytes )\r
868 {\r
869         cl_status_t cl_status;\r
870         al_dev_open_context_t *p_context;\r
871         UNUSED_PARAM(p_ret_bytes);\r
872         \r
873         AL_ENTER( AL_DBG_CM );\r
874 \r
875         p_context = (al_dev_open_context_t*)p_open_context;\r
876 \r
877         /* Validate user parameters. */\r
878         if( cl_ioctl_in_size( h_ioctl ) != sizeof(uint32_t) ||\r
879                 cl_ioctl_out_size( h_ioctl ) != sizeof(uint32_t) )\r
880         {\r
881                 AL_EXIT( AL_DBG_CM );\r
882                 return CL_INVALID_PARAMETER;\r
883         }\r
884 \r
885         /* get CID */\r
886         cl_status = al_cep_get_cid( p_context->h_al, \r
887                 *(uint32_t*)cl_ioctl_in_buf( h_ioctl ), h_ioctl );\r
888 \r
889         AL_EXIT( AL_DBG_CM );\r
890         return cl_status;\r
891 }\r
892 \r
893 \r
894 \r
895 static cl_status_t\r
896 proxy_cep_get_pdata(\r
897         IN              void                                    *p_open_context,\r
898         IN              cl_ioctl_handle_t               h_ioctl,\r
899                 OUT     size_t                                  *p_ret_bytes )\r
900 {\r
901         al_dev_open_context_t           *p_context;\r
902         ual_cep_get_pdata_ioctl_t       *p_ioctl;\r
903         al_conn_qp_t                            *p_qp;\r
904         NTSTATUS                    status;\r
905 \r
906         AL_ENTER( AL_DBG_CM );\r
907 \r
908         p_context = (al_dev_open_context_t*)p_open_context;\r
909         p_ioctl = (ual_cep_get_pdata_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
910 \r
911         /* Validate user parameters. */\r
912         if( cl_ioctl_in_size( h_ioctl ) != sizeof(struct _ual_cep_get_pdata_ioctl_in) ||\r
913                 cl_ioctl_out_size( h_ioctl ) != sizeof(struct _ual_cep_get_pdata_ioctl_out) )\r
914         {\r
915                 AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, \r
916                         ("Incorrect sizes: in %d, out %d (expected - %d, %d)\n",\r
917                         cl_ioctl_in_size( h_ioctl ), cl_ioctl_out_size( h_ioctl ), \r
918                         sizeof(struct _ual_cep_get_pdata_ioctl_in),\r
919                         sizeof(struct _ual_cep_get_pdata_ioctl_out) ) );\r
920                 return CL_INVALID_PARAMETER;\r
921         }\r
922 \r
923         if ( p_ioctl->in.h_qp )\r
924         {\r
925                 /* Get the kernel QP handle. */\r
926                 p_qp = (al_conn_qp_t*)al_hdl_ref(\r
927                         p_context->h_al, p_ioctl->in.h_qp, AL_OBJ_TYPE_H_QP );\r
928                 if( !p_qp )\r
929                 {\r
930                         AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, \r
931                                 ("Invalid QP handle\n"));\r
932                         return CL_CONNECTION_INVALID;\r
933                 }\r
934                 p_ioctl->in.cid = p_qp->cid;\r
935                 deref_al_obj( &p_qp->qp.obj );\r
936         }\r
937 \r
938         p_ioctl->out.pdata_len = sizeof(p_ioctl->out.pdata);\r
939         status = al_cep_get_pdata( p_context->h_al, p_ioctl->in.cid,\r
940         &p_ioctl->out.init_depth, &p_ioctl->out.resp_res,\r
941                 (uint8_t*)&p_ioctl->out.pdata_len, p_ioctl->out.pdata );\r
942 \r
943         if( NT_SUCCESS( status ) )\r
944         {\r
945                 *p_ret_bytes = sizeof(struct _ual_cep_get_pdata_ioctl_out);\r
946                 AL_PRINT(TRACE_LEVEL_INFORMATION ,AL_DBG_CM ,\r
947                         ("proxy_cep_get_pdata: get %d of pdata \n", (int)*p_ret_bytes ));\r
948         }\r
949 \r
950         AL_EXIT( AL_DBG_CM );\r
951         return status;\r
952 }\r
953 \r
954 cl_status_t cep_ioctl(\r
955         IN              cl_ioctl_handle_t               h_ioctl,\r
956                 OUT     size_t                                  *p_ret_bytes )\r
957 {\r
958         cl_status_t                             cl_status;\r
959         IO_STACK_LOCATION               *p_io_stack;\r
960         void                                    *p_context;\r
961 \r
962         AL_ENTER( AL_DBG_DEV );\r
963 \r
964         CL_ASSERT( h_ioctl && p_ret_bytes );\r
965 \r
966         p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
967         p_context = p_io_stack->FileObject->FsContext;\r
968 \r
969         if( !p_context )\r
970         {\r
971                 AL_EXIT( AL_DBG_DEV );\r
972                 return CL_INVALID_PARAMETER;\r
973         }\r
974 \r
975         switch( cl_ioctl_ctl_code( h_ioctl ) )\r
976         {\r
977         case UAL_CREATE_CEP:\r
978                 cl_status = proxy_create_cep( p_context, h_ioctl, p_ret_bytes );\r
979                 break;\r
980         case UAL_DESTROY_CEP:\r
981                 cl_status = proxy_destroy_cep( p_context, h_ioctl, p_ret_bytes );\r
982                 break;\r
983         case UAL_CEP_LISTEN:\r
984                 cl_status = proxy_cep_listen( p_context, h_ioctl, p_ret_bytes );\r
985                 break;\r
986         case UAL_CEP_PRE_REQ:\r
987                 cl_status = proxy_cep_pre_req( p_context, h_ioctl, p_ret_bytes );\r
988                 break;\r
989         case UAL_CEP_SEND_REQ:\r
990                 cl_status = proxy_cep_send_req( p_context, h_ioctl, p_ret_bytes );\r
991                 break;\r
992         case UAL_CEP_PRE_REP:\r
993                 cl_status = proxy_cep_pre_rep( p_context, h_ioctl, p_ret_bytes );\r
994                 break;\r
995         case UAL_CEP_SEND_REP:\r
996                 cl_status = proxy_cep_send_rep( p_context, h_ioctl, p_ret_bytes );\r
997                 break;\r
998         case UAL_CEP_GET_RTR:\r
999                 cl_status = proxy_cep_get_rtr( p_context, h_ioctl, p_ret_bytes );\r
1000                 break;\r
1001         case UAL_CEP_GET_RTS:\r
1002                 cl_status = proxy_cep_get_rts( p_context, h_ioctl, p_ret_bytes );\r
1003                 break;\r
1004         case UAL_CEP_RTU:\r
1005                 cl_status = proxy_cep_rtu( p_context, h_ioctl, p_ret_bytes );\r
1006                 break;\r
1007         case UAL_CEP_REJ:\r
1008                 cl_status = proxy_cep_rej( p_context, h_ioctl, p_ret_bytes );\r
1009                 break;\r
1010         case UAL_CEP_MRA:\r
1011                 cl_status = proxy_cep_mra( p_context, h_ioctl, p_ret_bytes );\r
1012                 break;\r
1013         case UAL_CEP_LAP:\r
1014                 cl_status = proxy_cep_lap( p_context, h_ioctl, p_ret_bytes );\r
1015                 break;\r
1016         case UAL_CEP_PRE_APR:\r
1017                 cl_status = proxy_cep_pre_apr( p_context, h_ioctl, p_ret_bytes );\r
1018                 break;\r
1019         case UAL_CEP_SEND_APR:\r
1020                 cl_status = proxy_cep_send_apr( p_context, h_ioctl, p_ret_bytes );\r
1021                 break;\r
1022         case UAL_CEP_DREQ:\r
1023                 cl_status = proxy_cep_dreq( p_context, h_ioctl, p_ret_bytes );\r
1024                 break;\r
1025         case UAL_CEP_DREP:\r
1026                 cl_status = proxy_cep_drep( p_context, h_ioctl, p_ret_bytes );\r
1027                 break;\r
1028         case UAL_CEP_GET_TIMEWAIT:\r
1029                 cl_status = proxy_cep_get_timewait( p_context, h_ioctl, p_ret_bytes );\r
1030                 break;\r
1031         case UAL_CEP_GET_EVENT:\r
1032                 cl_status = proxy_cep_get_event( p_context, h_ioctl, p_ret_bytes );\r
1033                 break;\r
1034         case UAL_CEP_POLL:\r
1035                 cl_status = proxy_cep_poll( p_context, h_ioctl, p_ret_bytes );\r
1036                 break;\r
1037         case UAL_CEP_GET_REQ_CID:\r
1038                 cl_status = proxy_cep_get_req_cid( p_context, h_ioctl, p_ret_bytes );\r
1039                 break;\r
1040         case UAL_CEP_GET_PDATA:\r
1041                 cl_status = proxy_cep_get_pdata( p_context, h_ioctl, p_ret_bytes );\r
1042                 break;\r
1043         default:\r
1044                 cl_status = CL_INVALID_PARAMETER;\r
1045                 break;\r
1046         }\r
1047 \r
1048         AL_EXIT( AL_DBG_DEV );\r
1049         return cl_status;\r
1050 }\r